Unity 8
listviewwithpageheader.cpp
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  */
16 
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  */
91 
92 #include "listviewwithpageheader.h"
93 
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>
106 
107 qreal ListViewWithPageHeader::ListItem::height() const
108 {
109  return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
110 }
111 
112 qreal ListViewWithPageHeader::ListItem::y() const
113 {
114  return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
115 }
116 
117 void ListViewWithPageHeader::ListItem::setY(qreal newY)
118 {
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  }
125 }
126 
127 bool ListViewWithPageHeader::ListItem::culled() const
128 {
129  return QQuickItemPrivate::get(m_item)->culled;
130 }
131 
132 void ListViewWithPageHeader::ListItem::setCulled(bool culled)
133 {
134  QQuickItemPrivate::get(m_item)->setCulled(culled);
135  if (m_sectionItem)
136  QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
137 }
138 
139 void ListViewWithPageHeader::ListItem::setSectionItem(QQuickItem *sectionItem)
140 {
141  m_sectionItem = sectionItem;
142 }
143 
144 ListViewWithPageHeader::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)
160 {
161  m_clipItem = new QQuickItem(contentItem());
162 // m_clipItem = new QQuickRectangle(contentItem());
163 // ((QQuickRectangle*)m_clipItem)->setColor(Qt::gray);
164 
165  m_contentYAnimation = new QQuickNumberAnimation(this);
166  m_contentYAnimation->setEasing(QEasingCurve::OutQuad);
167  m_contentYAnimation->setProperty(QStringLiteral("contentY"));
168  m_contentYAnimation->setDuration(200);
169  m_contentYAnimation->setTargetObject(this);
170 
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);
175 
176  setFlickableDirection(VerticalFlick);
177 }
178 
179 ListViewWithPageHeader::~ListViewWithPageHeader()
180 {
181 }
182 
183 QAbstractItemModel *ListViewWithPageHeader::model() const
184 {
185  return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() : nullptr;
186 }
187 
188 void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
189 {
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  }
204 }
205 
206 QQmlComponent *ListViewWithPageHeader::delegate() const
207 {
208  return m_delegateModel ? m_delegateModel->delegate() : nullptr;
209 }
210 
211 void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
212 {
213  if (delegate != this->delegate()) {
214  if (!m_delegateModel) {
215  createDelegateModel();
216  }
217 
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  }
229 
230  m_delegateModel->setDelegate(delegate);
231 
232  Q_EMIT delegateChanged();
233  m_delegateValidated = false;
234  m_contentHeightDirty = true;
235  polish();
236  }
237 }
238 
239 QQuickItem *ListViewWithPageHeader::header() const
240 {
241  return m_headerItem;
242 }
243 
244 void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
245 {
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  }
269 }
270 
271 QQmlComponent *ListViewWithPageHeader::sectionDelegate() const
272 {
273  return m_sectionDelegate;
274 }
275 
276 void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
277 {
278  if (delegate != m_sectionDelegate) {
279  // TODO clean existing sections
280 
281  m_sectionDelegate = delegate;
282 
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);
287 
288  // TODO create sections for existing items
289 
290  Q_EMIT sectionDelegateChanged();
291  Q_EMIT stickyHeaderHeightChanged();
292  }
293 }
294 
295 QString ListViewWithPageHeader::sectionProperty() const
296 {
297  return m_sectionProperty;
298 }
299 
300 void ListViewWithPageHeader::setSectionProperty(const QString &property)
301 {
302  if (property != m_sectionProperty) {
303  m_sectionProperty = property;
304 
305  updateWatchedRoles();
306 
307  // TODO recreate sections
308 
309  Q_EMIT sectionPropertyChanged();
310  }
311 }
312 
313 bool ListViewWithPageHeader::forceNoClip() const
314 {
315  return m_forceNoClip;
316 }
317 
318 void ListViewWithPageHeader::setForceNoClip(bool noClip)
319 {
320  if (noClip != m_forceNoClip) {
321  m_forceNoClip = noClip;
322  updateClipItem();
323  Q_EMIT forceNoClipChanged();
324  }
325 }
326 
327 int ListViewWithPageHeader::stickyHeaderHeight() const
328 {
329  return m_topSectionItem ? m_topSectionItem->height() : 0;
330 }
331 
332 qreal ListViewWithPageHeader::headerItemShownHeight() const
333 {
334  return m_headerItemShownHeight;
335 }
336 
337 int ListViewWithPageHeader::cacheBuffer() const
338 {
339  return m_cacheBuffer;
340 }
341 
342 void ListViewWithPageHeader::setCacheBuffer(int cacheBuffer)
343 {
344  if (cacheBuffer < 0) {
345  qmlInfo(this) << "Cannot set a negative cache buffer";
346  return;
347  }
348 
349  if (cacheBuffer != m_cacheBuffer) {
350  m_cacheBuffer = cacheBuffer;
351  Q_EMIT cacheBufferChanged();
352  polish();
353  }
354 }
355 
356 void ListViewWithPageHeader::positionAtBeginning()
357 {
358  if (m_delegateModel->count() <= 0)
359  return;
360 
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;
370 
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  }
384 
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  }
395 }
396 
397 static inline bool uFuzzyCompare(qreal r1, qreal r2)
398 {
399  return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
400 }
401 
402 void ListViewWithPageHeader::showHeader()
403 {
404  if (!m_headerItem)
405  return;
406 
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  }
427 }
428 
429 int ListViewWithPageHeader::firstCreatedIndex() const
430 {
431  return m_firstVisibleIndex;
432 }
433 
434 int ListViewWithPageHeader::createdItemCount() const
435 {
436  return m_visibleItems.count();
437 }
438 
439 QQuickItem *ListViewWithPageHeader::item(int modelIndex) const
440 {
441  ListItem *item = itemAtIndex(modelIndex);
442  if (item)
443  return item->m_item;
444  else
445  return nullptr;
446 }
447 
448 bool ListViewWithPageHeader::maximizeVisibleArea(int modelIndex)
449 {
450  ListItem *listItem = itemAtIndex(modelIndex);
451  if (listItem) {
452  return maximizeVisibleArea(listItem, listItem->height());
453  }
454 
455  return false;
456 }
457 
458 bool ListViewWithPageHeader::maximizeVisibleArea(int modelIndex, int itemHeight)
459 {
460  if (itemHeight < 0)
461  return false;
462 
463  ListItem *listItem = itemAtIndex(modelIndex);
464  if (listItem) {
465  return maximizeVisibleArea(listItem, itemHeight + (listItem->sectionItem() ? listItem->sectionItem()->height() : 0));
466  }
467 
468  return false;
469 }
470 
471 bool ListViewWithPageHeader::maximizeVisibleArea(ListItem *listItem, int listItemHeight)
472 {
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;
504 }
505 
506 qreal ListViewWithPageHeader::minYExtent() const
507 {
508 // qDebug() << "ListViewWithPageHeader::minYExtent" << m_minYExtent;
509  return m_minYExtent;
510 }
511 
512 void ListViewWithPageHeader::componentComplete()
513 {
514  if (m_delegateModel)
515  m_delegateModel->componentComplete();
516 
517  QQuickFlickable::componentComplete();
518 
519  polish();
520 }
521 
522 void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
523 {
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;
529 
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();
537 }
538 
539 void ListViewWithPageHeader::adjustHeader(qreal diff)
540 {
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;
553 
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  }
603 }
604 
605 void ListViewWithPageHeader::createDelegateModel()
606 {
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();
612 }
613 
614 void ListViewWithPageHeader::refill()
615 {
616  if (m_inLayout) {
617  return;
618  }
619  if (!isComponentComplete()) {
620  return;
621  }
622 
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;
627 
628  bool added = addVisibleItems(from, to, false);
629  bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
630  added |= addVisibleItems(bufferFrom, bufferTo, true);
631 
632  if (added || removed) {
633  m_contentHeightDirty = true;
634  }
635 }
636 
637 bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous)
638 {
639  if (!delegate())
640  return false;
641 
642  if (m_delegateModel->count() == 0)
643  return false;
644 
645  ListItem *item;
646 // qDebug() << "ListViewWithPageHeader::addVisibleItems" << fillFrom << fillTo << asynchronous;
647 
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  }
665 
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  }
681 
682  return changed;
683 }
684 
685 void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
686 {
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;
694 }
695 
696 void ListViewWithPageHeader::releaseItem(ListItem *listItem)
697 {
698  QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
699  itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
700  m_itemsToRelease << listItem;
701 }
702 
703 void ListViewWithPageHeader::updateWatchedRoles()
704 {
705  if (m_delegateModel) {
706  QList<QByteArray> roles;
707  if (!m_sectionProperty.isEmpty())
708  roles << m_sectionProperty.toUtf8();
709  m_delegateModel->setWatchedRoles(roles);
710  }
711 }
712 
713 QQuickItem *ListViewWithPageHeader::getSectionItem(int modelIndex, bool alreadyInserted)
714 {
715  if (!m_sectionDelegate)
716  return nullptr;
717 
718  const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
719 
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  }
738 
739  return getSectionItem(section);
740 }
741 
742 QQuickItem *ListViewWithPageHeader::getSectionItem(const QString &sectionText)
743 {
744  QQuickItem *sectionItem = nullptr;
745 
746  QQmlContext *creationContext = m_sectionDelegate->creationContext();
747  QQmlContext *context = new QQmlContext(creationContext ? creationContext : qmlContext(this));
748  context->setContextProperty(QStringLiteral("section"), sectionText);
749  context->setContextProperty(QStringLiteral("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();
765 
766  // TODO attach to sectionItem so we can accomodate to it changing its height
767 
768  return sectionItem;
769 }
770 
771 bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
772 {
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;
782 
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  }
812 
813  return changed;
814 }
815 
816 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(int modelIndex, bool asynchronous)
817 {
818 // qDebug() << "CREATE ITEM" << modelIndex;
819  if (asynchronous && m_asyncRequestedIndex != -1)
820  return nullptr;
821 
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(QStringLiteral("delegateIndex"), modelIndex);
883  }
884  adjustMinYExtent();
885  m_contentHeightDirty = true;
886  }
887  return listItem;
888  }
889 }
890 
891 void ListViewWithPageHeader::itemCreated(int modelIndex, QObject *object)
892 {
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;
904 
905  item->setParentItem(m_clipItem);
906  QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
907  context->setContextProperty(QStringLiteral("ListViewWithPageHeader"), this);
908  context->setContextProperty(QStringLiteral("heightToClip"), QVariant::fromValue<int>(0));
909  if (modelIndex == m_asyncRequestedIndex) {
910  createItem(modelIndex, false);
911  refill();
912  }
913 }
914 
915 void ListViewWithPageHeader::updateClipItem()
916 {
917  m_clipItem->setHeight(height() - m_headerItemShownHeight);
918  m_clipItem->setY(contentY() + m_headerItemShownHeight);
919  m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
920 }
921 
922 void ListViewWithPageHeader::onContentHeightChanged()
923 {
924  updateClipItem();
925 }
926 
927 void ListViewWithPageHeader::onContentWidthChanged()
928 {
929  m_clipItem->setWidth(contentItem()->width());
930 }
931 
932 void ListViewWithPageHeader::onHeightChanged()
933 {
934  polish();
935 }
936 
937 
938 void ListViewWithPageHeader::onModelUpdated(const QQmlChangeSet &changeSet, bool /*reset*/)
939 {
940  // TODO Do something with reset
941 // qDebug() << "ListViewWithPageHeader::onModelUpdated" << changeSet << reset;
942  const auto oldFirstVisibleIndex = m_firstVisibleIndex;
943 
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  }
996 
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)
1002  {
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;
1011  }
1012  break;
1013  }
1014  }
1015  }
1016 
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());
1024  }
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());
1034  }
1035  }
1036  }
1037  }
1038  if (firstItemWithViewOnTop) {
1039  ListItem *firstItem = m_visibleItems.first();
1040  firstItem->setY(oldFirstValidIndexPos);
1041  }
1042  adjustMinYExtent();
1043  } else if (insert.index <= m_firstVisibleIndex) {
1044  m_firstVisibleIndex += insert.count;
1045  }
1046 
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++;
1051  }
1052  }
1053  }
1054 
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(QStringLiteral("section"), sectionText);
1063  }
1064  }
1065  }
1066 
1067  if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1068  adjustMinYExtent();
1069  }
1070 
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(QStringLiteral("delegateIndex"), m_firstVisibleIndex + i);
1076  }
1077  }
1078 
1079  layout();
1080  polish();
1081  m_contentHeightDirty = true;
1082 }
1083 
1084 void ListViewWithPageHeader::contentYAnimationRunningChanged(bool running)
1085 {
1086  setInteractive(!running);
1087  if (!running) {
1088  m_contentHeightDirty = true;
1089  polish();
1090  }
1091 }
1092 
1093 void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * /*item*/, const QRectF &newGeometry, const QRectF &oldGeometry)
1094 {
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();
1102  }
1103  refill();
1104  adjustMinYExtent();
1105  polish();
1106  m_contentHeightDirty = true;
1107  }
1108 }
1109 
1110 void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)
1111 {
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;
1120  }
1121  }
1122 }
1123 
1124 void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1125 {
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();
1146  }
1147  }
1148 }
1149 
1150 
1151 void ListViewWithPageHeader::adjustMinYExtent()
1152 {
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();
1163  }
1164  nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1165 // qDebug() << m_firstVisibleIndex << visibleItemsHeight << visibleItems << nonCreatedHeight;
1166  }
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);
1172  }
1173  }
1174 }
1175 
1176 ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(int modelIndex) const
1177 {
1178  const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1179  if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1180  return m_visibleItems[visibleIndexedModelIndex];
1181 
1182  return nullptr;
1183 }
1184 
1185 void ListViewWithPageHeader::layout()
1186 {
1187  if (m_inLayout)
1188  return;
1189 
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();
1194 
1195  qreal pos = m_visibleItems.first()->y();
1196 
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;
1224  }
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);
1233  }
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(QStringLiteral("section"), section);
1239 
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--;
1249  }
1250  context->setContextProperty(QStringLiteral("delegateIndex"), delegateIndex);
1251  if (item->sectionItem()) {
1252  QQuickItemPrivate::get(item->sectionItem())->setCulled(true);
1253  }
1254  }
1255  }
1256  }
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(QStringLiteral("heightToClip"), clipFrom - pos);
1261  } else {
1262  context->setContextProperty(QStringLiteral("heightToClip"), QVariant::fromValue<int>(0));
1263  }
1264 // qDebug() << "ListViewWithPageHeader::layout" << item->m_item;
1265  pos += item->height();
1266  ++modelIndex;
1267  }
1268 
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());
1278  }
1279  break;
1280  }
1281  }
1282  }
1283  }
1284  }
1285  m_inLayout = false;
1286 }
1287 
1288 void ListViewWithPageHeader::updatePolish()
1289 {
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;
1295 
1296  Q_FOREACH(ListItem *item, m_itemsToRelease)
1297  reallyReleaseItem(item);
1298  m_itemsToRelease.clear();
1299 
1300  if (!model())
1301  return;
1302 
1303  layout();
1304 
1305  refill();
1306 
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();
1321  }
1322  const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1323  nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1324  }
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()));
1330  }
1331  }
1332 
1333  m_contentHeightDirty = false;
1334  adjustMinYExtent();
1335  m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();
1336  setContentHeight(contentHeight);
1337  m_inContentHeightKeepHeaderShown = false;
1338  }
1339 }
1340 
1341 #include "moc_listviewwithpageheader.cpp"