git.iko.soy/unity8
on 52f8f32 help sign in
unity8/plugins/ListViewWithPageHeader/listviewwithpageheader.cpp
801 lines 30 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#include "listviewwithpageheader.h"
19#include <QDebug>
20#include <qqmlinfo.h>
21#include <qqmlengine.h>
22#include <private/qquickvisualdatamodel_p.h>
23#include <private/qqmlglobal_p.h>
24#include <private/qquickitem_p.h>
25// #include <private/qquickrectangle_p.h>
27qreal ListViewWithPageHeader::ListItem::height() const
29 return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
32qreal ListViewWithPageHeader::ListItem::y() const
34 return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
37void ListViewWithPageHeader::ListItem::setY(qreal newY)
39 if (m_sectionItem) {
40 m_sectionItem->setY(newY);
41 m_item->setY(newY + m_sectionItem->height());
42 } else {
43 m_item->setY(newY);
44 }
47bool ListViewWithPageHeader::ListItem::culled() const
49 return QQuickItemPrivate::get(m_item)->culled;
52void ListViewWithPageHeader::ListItem::setCulled(bool culled)
54 QQuickItemPrivate::get(m_item)->setCulled(culled);
55 if (m_sectionItem)
56 QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
59ListViewWithPageHeader::ListViewWithPageHeader()
60 : m_delegateModel(nullptr)
61 , m_delegateValidated(false)
62 , m_firstVisibleIndex(-1)
63 , m_minYExtent(0)
64 , m_contentHeightDirty(false)
65 , m_headerItem(nullptr)
66 , m_previousContentY(0)
67 , m_headerItemShownHeight(0)
68 , m_sectionDelegate(nullptr)
69 , m_topSectionItem(nullptr)
71 m_clipItem = new QQuickItem(contentItem());
72// m_clipItem = new QQuickRectangle(contentItem());
73// ((QQuickRectangle*)m_clipItem)->setColor(Qt::gray);
75 connect(this, SIGNAL(contentWidthChanged()), this, SLOT(onContentWidthChanged()));
76 connect(this, SIGNAL(contentHeightChanged()), this, SLOT(onContentHeightChanged()));
79ListViewWithPageHeader::~ListViewWithPageHeader()
83QAbstractItemModel *ListViewWithPageHeader::model() const
85 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() : nullptr;
88void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
90 if (model != this->model()) {
91 if (!m_delegateModel) {
92 createDelegateModel();
93 } else {
94 disconnect(m_delegateModel, SIGNAL(modelUpdated(QQuickChangeSet,bool)), this, SLOT(onModelUpdated(QQuickChangeSet,bool)));
95 }
96 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
97 connect(m_delegateModel, SIGNAL(modelUpdated(QQuickChangeSet,bool)), this, SLOT(onModelUpdated(QQuickChangeSet,bool)));
98 Q_EMIT modelChanged();
99 // TODO?
100// Q_EMIT contentHeightChanged();
101// Q_EMIT contentYChanged();
102 }
105QQmlComponent *ListViewWithPageHeader::delegate() const
107 return m_delegateModel ? m_delegateModel->delegate() : nullptr;
110void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
112 if (delegate != this->delegate()) {
113 if (!m_delegateModel) {
114 createDelegateModel();
115 }
117 // Cleanup the existing items
118 foreach(ListItem *item, m_visibleItems)
119 releaseItem(item);
120 m_visibleItems.clear();
121 m_firstVisibleIndex = -1;
122 QQuickFlickable::setContentY(0);
123 m_clipItem->setY(0);
125 m_delegateModel->setDelegate(delegate);
127 Q_EMIT delegateChanged();
128 m_delegateValidated = false;
129 m_contentHeightDirty = true;
130 polish();
131 }
134QQuickItem *ListViewWithPageHeader::header() const
136 return m_headerItem;
139void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
141 if (m_headerItem != headerItem) {
142 qreal oldHeaderHeight = 0;
143 qreal oldHeaderY = 0;
144 if (m_headerItem) {
145 oldHeaderHeight = m_headerItem->height();
146 oldHeaderY = m_headerItem->y();
147 QQuickItemPrivate::get(m_headerItem)->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
148 m_headerItem->setParentItem(nullptr);
149 }
150 m_headerItem = headerItem;
151 if (m_headerItem) {
152 m_headerItem->setParentItem(contentItem());
153 m_headerItem->setZ(1);
154 QQuickItemPrivate::get(m_headerItem)->addItemChangeListener(this, QQuickItemPrivate::Geometry);
155 }
156 qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
157 if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
158 headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
159 polish();
160 m_contentHeightDirty = true;
161 }
162 Q_EMIT headerChanged();
163 }
166QQmlComponent *ListViewWithPageHeader::sectionDelegate() const
168 return m_sectionDelegate;
171void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
173 if (delegate != m_sectionDelegate) {
174 // TODO clean existing sections
176 m_sectionDelegate = delegate;
178 m_topSectionItem = getSectionItem(QString());
179 m_topSectionItem->setZ(3);
180 QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);
182 // TODO create sections for existing items
184 Q_EMIT sectionDelegateChanged();
185 }
188QString ListViewWithPageHeader::sectionProperty() const
190 return m_sectionProperty;
193void ListViewWithPageHeader::setSectionProperty(const QString &property)
195 if (property != m_sectionProperty) {
196 m_sectionProperty = property;
198 updateWatchedRoles();
200 // TODO recreate sections
202 Q_EMIT sectionPropertyChanged();
203 }
206void ListViewWithPageHeader::positionAtBeginning()
208 qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
209 if (m_firstVisibleIndex != 0) {
210 // This could be optimized by trying to reuse the interesection
211 // of items that may end up intersecting between the existing
212 // m_visibleItems and the items we are creating in the next loop
213 foreach(ListItem *item, m_visibleItems)
214 releaseItem(item);
215 m_visibleItems.clear();
216 m_firstVisibleIndex = -1;
218 // Create the item 0, it will be already correctly positioned at createItem()
219 m_clipItem->setY(0);
220 ListItem *item = createItem(0, false);
221 // Create the subsequent items
222 int modelIndex = 1;
223 qreal pos = item->y() + item->height();
224 const qreal buffer = height() / 2;
225 const qreal bufferTo = height() + buffer;
226 while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
227 if (!(item = createItem(modelIndex, false)))
228 break;
229 pos += item->height();
230 ++modelIndex;
231 }
233 m_previousContentY = m_visibleItems.first()->y() - headerHeight;
234 }
235 QQuickFlickable::setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
238void ListViewWithPageHeader::showHeader()
240 // TODO
243qreal ListViewWithPageHeader::minYExtent() const
245// qDebug() << "ListViewWithPageHeader::minYExtent" << m_minYExtent;
246 return m_minYExtent;
249void ListViewWithPageHeader::componentComplete()
251 if (m_delegateModel)
252 m_delegateModel->componentComplete();
254 QQuickFlickable::componentComplete();
256 polish();
259void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
261 QQuickFlickable::viewportMoved(orient);
262// qDebug() << "ListViewWithPageHeader::viewportMoved" << contentY();
263 qreal diff = m_previousContentY - contentY();
264 if (m_headerItem) {
265 auto oldHeaderItemShownHeight = m_headerItemShownHeight;
266 if (contentY() < -m_minYExtent) {
267 // Stick the header item to the top when dragging down
268 m_headerItem->setY(contentY());
269 } else {
270 // We are going down (but it's not because of the rebound at the end)
271 // (but the header was not shown by it's own position)
272 // or the header is partially shown
273 const bool scrolledUp = m_previousContentY > contentY();
274 const bool notRebounding = contentY() + height() < contentHeight();
275 const bool notShownByItsOwn = contentY() + diff > m_headerItem->y() + m_headerItem->height();
277 if (!scrolledUp && contentY() == -m_minYExtent) {
278 m_headerItemShownHeight = 0;
279 m_headerItem->setY(contentY());
280 } else if ((scrolledUp && notRebounding && notShownByItsOwn) || (m_headerItemShownHeight > 0)) {
281 m_headerItemShownHeight += diff;
282 if (contentY() == -m_minYExtent) {
283 m_headerItemShownHeight = 0;
284 } else {
285 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
286 }
287 if (m_headerItemShownHeight > 0) {
288 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
289 } else {
290 m_headerItem->setY(-m_minYExtent);
291 }
292 }
293 }
294 // We will be changing the clip item, need to accomadate for it
295 // otherwise we move the firstItem down/up twice
296 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
297 }
298 if (!m_visibleItems.isEmpty()) {
299 updateClipItem();
300 ListItem *firstItem = m_visibleItems.first();
301 firstItem->setY(firstItem->y() + diff);
302 }
304 m_previousContentY = contentY();
305 polish();
308void ListViewWithPageHeader::setContentY(qreal /*pos*/)
310 qWarning() << "ListViewWithPageHeader::setContentY unsupported feature";
313void ListViewWithPageHeader::createDelegateModel()
315 m_delegateModel = new QQuickVisualDataModel(qmlContext(this), this);
316 connect(m_delegateModel, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(itemCreated(int,QQuickItem*)));
317 if (isComponentComplete())
318 m_delegateModel->componentComplete();
319 updateWatchedRoles();
322void ListViewWithPageHeader::refill()
324 if (!isComponentComplete()) {
325 qWarning() << "Incomplete ListViewWithPageHeader::refill";
326 return;
327 }
329 const qreal buffer = height() / 2;
330 const qreal from = contentY();
331 const qreal to = from + height();
332 const qreal bufferFrom = from - buffer;
333 const qreal bufferTo = to + buffer;
335 bool added = addVisibleItems(from, to, false);
336 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
337 added |= addVisibleItems(bufferFrom, bufferTo, true);
339 if (added || removed) {
340 m_contentHeightDirty = true;
341 }
344bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous)
346 if (!delegate())
347 return false;
349 if (m_delegateModel->count() == 0)
350 return false;
352 ListItem *item;
353// qDebug() << "ListViewWithPageHeader::addVisibleItems" << fillFrom << fillTo << asynchronous;
355 int modelIndex = 0;
356 qreal pos = 0;
357 if (!m_visibleItems.isEmpty()) {
358 modelIndex = m_firstVisibleIndex + m_visibleItems.count();
359 item = m_visibleItems.last();
360 pos = item->y() + item->height() + m_clipItem->y();
361 }
362 bool changed = false;
363// qDebug() << (modelIndex < m_delegateModel->count()) << pos << fillTo;
364 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
365// qDebug() << "refill: append item" << modelIndex << "pos" << pos << "asynchronous" << asynchronous;
366 if (!(item = createItem(modelIndex, asynchronous)))
367 break;
368 pos += item->height();
369 ++modelIndex;
370 changed = true;
371 }
373 modelIndex = 0;
374 pos = 0;
375 if (!m_visibleItems.isEmpty()) {
376 modelIndex = m_firstVisibleIndex - 1;
377 item = m_visibleItems.first();
378 pos = item->y() + m_clipItem->y();
379 }
380 while (modelIndex >= 0 && pos > fillFrom) {
381// qDebug() << "refill: prepend item" << modelIndex << "pos" << pos << "fillFrom" << fillFrom << "asynchronous" << asynchronous;
382 if (!(item = createItem(modelIndex, asynchronous)))
383 break;
384 pos -= item->height();
385 --modelIndex;
386 changed = true;
387 }
389 return changed;
392void ListViewWithPageHeader::releaseItem(ListItem *listItem)
394 QQuickItem *item = listItem->m_item;
395 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
396 itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
397 QQuickVisualModel::ReleaseFlags flags = m_delegateModel->release(item);
398 if (flags & QQuickVisualModel::Destroyed) {
399 item->setParentItem(nullptr);
400 }
401 delete listItem->m_sectionItem;
402 delete listItem;
405void ListViewWithPageHeader::updateWatchedRoles()
407 if (m_delegateModel) {
408 QList<QByteArray> roles;
409 if (!m_sectionProperty.isEmpty())
410 roles << m_sectionProperty.toUtf8();
411 m_delegateModel->setWatchedRoles(roles);
412 }
415QQuickItem *ListViewWithPageHeader::getSectionItem(int modelIndex)
417 if (!m_sectionDelegate)
418 return nullptr;
420 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
421 if (modelIndex > 0) {
422 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
423 if (section == prevSection)
424 return nullptr;
425 }
427 return getSectionItem(section);
430QQuickItem *ListViewWithPageHeader::getSectionItem(const QString &sectionText)
432 QQuickItem *sectionItem = nullptr;
434 QQmlContext *creationContext = m_sectionDelegate->creationContext();
435 QQmlContext *context = new QQmlContext(creationContext ? creationContext : qmlContext(this));
436 context->setContextProperty(QLatin1String("section"), sectionText);
437 QObject *nobj = m_sectionDelegate->beginCreate(context);
438 if (nobj) {
439 QQml_setParent_noEvent(context, nobj);
440 sectionItem = qobject_cast<QQuickItem *>(nobj);
441 if (!sectionItem) {
442 delete nobj;
443 } else {
444 sectionItem->setZ(2);
445 QQml_setParent_noEvent(sectionItem, m_clipItem);
446 sectionItem->setParentItem(m_clipItem);
447 }
448 } else {
449 delete context;
450 }
451 m_sectionDelegate->completeCreate();
453 return sectionItem;
456bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
458// qDebug() << "ListViewWithPageHeader::removeNonVisibleItems" << bufferFrom << bufferTo;
459 bool changed = false;
461 bool foundVisible = false;
462 int i = 0;
463 int removedItems = 0;
464 while (i < m_visibleItems.count()) {
465 ListItem *item = m_visibleItems[i];
466 const qreal pos = item->y() + m_clipItem->y();
467// qDebug() << i << pos << (pos + item->height()) << bufferFrom << bufferTo;
468 if (pos + item->height() < bufferFrom || pos > bufferTo) {
469// qDebug() << "Releasing" << i << (pos + item->height() < bufferFrom) << pos + item->height() << bufferFrom << (pos > bufferTo) << pos << bufferTo;
470 releaseItem(item);
471 m_visibleItems.removeAt(i);
472 changed = true;
473 ++removedItems;
474 } else {
475 if (!foundVisible) {
476 foundVisible = true;
477 const int itemIndex = m_firstVisibleIndex + removedItems + i;
478 m_firstVisibleIndex = itemIndex;
479 }
480 ++i;
481 }
482 }
484 return changed;
487ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(int modelIndex, bool asynchronous)
489// qDebug() << "CREATE ITEM" << modelIndex;
490 if (asynchronous && m_asyncRequestedIndexes.contains(modelIndex))
491 return nullptr;
493 m_asyncRequestedIndexes.remove(modelIndex);
494 QQuickItem *item = m_delegateModel->item(modelIndex, asynchronous);
495 if (!item) {
496 m_asyncRequestedIndexes << modelIndex;
497 return 0;
498 } else {
499// qDebug() << "ListViewWithPageHeader::createItem::We have the item" << modelIndex << item;
500 ListItem *listItem = new ListItem;
501 listItem->m_item = item;
502 listItem->m_sectionItem = getSectionItem(modelIndex);
503 QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Geometry);
504 ListItem *prevItem = itemAtIndex(modelIndex - 1);
505 if (prevItem) {
506 listItem->setY(prevItem->y() + prevItem->height());
507 } else {
508 ListItem *nextItem = itemAtIndex(modelIndex + 1);
509 if (nextItem) {
510 listItem->setY(nextItem->y() - listItem ->height());
511 } else if (modelIndex == 0 && m_headerItem) {
512 listItem->setY(m_headerItem->height());
513 }
514 }
515 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() < contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
516 if (m_visibleItems.isEmpty()) {
517 m_visibleItems << listItem;
518 } else {
519 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
520 }
521 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
522 m_firstVisibleIndex = modelIndex;
523 adjustMinYExtent();
524 }
525 return listItem;
526 }
529void ListViewWithPageHeader::itemCreated(int modelIndex, QQuickItem *item)
531// qDebug() << "ListViewWithPageHeader::itemCreated" << modelIndex << item;
533 item->setParentItem(m_clipItem);
534 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
535 context->setContextProperty(QLatin1String("ListViewWithPageHeader"), this);
536 if (m_asyncRequestedIndexes.remove(modelIndex)) {
537 createItem(modelIndex, false);
538 }
541void ListViewWithPageHeader::updateClipItem()
543 m_clipItem->setHeight(height() - m_headerItemShownHeight);
544 m_clipItem->setY(contentY() + m_headerItemShownHeight);
545 m_clipItem->setClip(m_headerItemShownHeight > 0);
548void ListViewWithPageHeader::onContentHeightChanged()
550 updateClipItem();
553void ListViewWithPageHeader::onContentWidthChanged()
555 m_clipItem->setWidth(contentItem()->width());
558void ListViewWithPageHeader::onModelUpdated(const QQuickChangeSet &changeSet, bool /*reset*/)
560 // TODO Do something with reset
561// qDebug() << "ListViewWithPageHeader::onModelUpdated" << changeSet << reset;
562 foreach(const QQuickChangeSet::Remove &remove, changeSet.removes()) {
563// qDebug() << "ListViewWithPageHeader::onModelUpdated Remove" << remove;
564 if (remove.index + remove.count > m_firstVisibleIndex && remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
565 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
566 // If all the items we are removing are either not created or culled
567 // we have to grow down to avoid viewport changing
568 bool growDown = true;
569 for (int i = 0; growDown && i < remove.count; ++i) {
570 const int modelIndex = remove.index + i;
571 ListItem *item = itemAtIndex(modelIndex);
572 if (item && !item->culled()) {
573 growDown = false;
574 }
575 }
576 for (int i = remove.count - 1; i >= 0; --i) {
577 const int visibleIndex = remove.index + i - m_firstVisibleIndex;
578 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
579 ListItem *item = m_visibleItems[visibleIndex];
580 releaseItem(item);
581 m_visibleItems.removeAt(visibleIndex);
582 }
583 }
584 if (growDown) {
585 adjustMinYExtent();
586 } else if (remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {
587 // We removed the first item that is the one that positions the rest
588 // position the new first item correctly
589 m_visibleItems.first()->setY(oldFirstValidIndexPos);
590 }
591 } else if (remove.index + remove.count <= m_firstVisibleIndex) {
592 m_firstVisibleIndex -= remove.count;
593 }
594 }
596 foreach(const QQuickChangeSet::Insert &insert, changeSet.inserts()) {
597// qDebug() << "ListViewWithPageHeader::onModelUpdated Insert" << insert;
598 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
599 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
600 if (insertingInValidIndexes || firstItemWithViewOnTop)
601 {
602 // If the items we are adding won't be really visible
603 // we grow up instead of down to not change the viewport
604 bool growUp = false;
605 if (!firstItemWithViewOnTop) {
606 for (int i = 0; i < m_visibleItems.count(); ++i) {
607 if (!m_visibleItems[i]->culled()) {
608 if (insert.index <= m_firstVisibleIndex + i) {
609 growUp = true;
610 }
611 break;
612 }
613 }
614 }
616 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
617 for (int i = insert.count - 1; i >= 0; --i) {
618 const int modelIndex = insert.index + i;
619 ListItem *item = createItem(modelIndex, false);
620 if (growUp) {
621 ListItem *firstItem = m_visibleItems.first();
622 firstItem->setY(firstItem->y() - item->height());
623 adjustMinYExtent();
624 }
625 }
626 if (firstItemWithViewOnTop) {
627 ListItem *firstItem = m_visibleItems.first();
628 firstItem->setY(oldFirstValidIndexPos);
629 }
630 } else if (insert.index <= m_firstVisibleIndex) {
631 m_firstVisibleIndex += insert.count;
632 }
633 }
635 polish();
636 m_contentHeightDirty = true;
639void ListViewWithPageHeader::itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry)
641 const qreal heightDiff = newGeometry.height() - oldGeometry.height();
642 if (heightDiff != 0) {
643 if (item == m_headerItem) {
644 headerHeightChanged(newGeometry.height(), oldGeometry.height(), oldGeometry.y());
645 } else {
646 if (oldGeometry.y() + oldGeometry.height() + m_clipItem->y() < contentY() && !m_visibleItems.isEmpty()) {
647 ListItem *firstItem = m_visibleItems.first();
648 firstItem->setY(firstItem->y() - heightDiff);
649 adjustMinYExtent();
650 }
651 }
652 polish();
653 m_contentHeightDirty = true;
654 }
657void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
659 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
660 if (m_headerItemShownHeight > 0) {
661 // If the header is shown because of the clip
662 // Change its size
663 m_headerItemShownHeight += heightDiff;
664 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
665 updateClipItem();
666 adjustMinYExtent();
667 } else {
668 if (oldHeaderY + oldHeaderHeight > contentY()) {
669 // If the header is shown because its position
670 // Change its size
671 ListItem *firstItem = m_visibleItems.first();
672 firstItem->setY(firstItem->y() + heightDiff);
673 } else {
674 // If the header is not on screen, just change the start of the list
675 // so the viewport is not changed
676 adjustMinYExtent();
677 }
678 }
682void ListViewWithPageHeader::adjustMinYExtent()
684 if (m_visibleItems.isEmpty()) {
685 m_minYExtent = 0;
686 } else {
687 m_minYExtent = -m_visibleItems.first()->y() - m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0);
688 }
691ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(int modelIndex) const
693 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
694 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
695 return m_visibleItems[visibleIndexedModelIndex];
697 return nullptr;
700void ListViewWithPageHeader::updatePolish()
702 if (!model())
703 return;
705 if (!m_visibleItems.isEmpty()) {
706 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
707 const qreal visibleTo = contentY() + height() - m_clipItem->y();
709 qreal pos = m_visibleItems.first()->y();
711// qDebug() << "ListViewWithPageHeader::updatePolish Updating positions and heights. contentY" << contentY() << "minYExtent" << minYExtent();
712 int firstReallyVisibleItem = -1;
713 int modelIndex = m_firstVisibleIndex;
714 foreach(ListItem *item, m_visibleItems) {
715 const bool cull = pos + item->height() < visibleFrom || pos >= visibleTo;
716 item->setCulled(cull);
717 item->setY(pos);
718 if (!cull && firstReallyVisibleItem == -1) {
719 firstReallyVisibleItem = modelIndex;
720 if (m_topSectionItem) {
721 // Update the top sticky section header
722 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
723 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
724 context->setContextProperty(QLatin1String("section"), section);
726 // Positing the top section sticky item is a two step process
727 // First we set it either we cull it (because it doesn't need to be sticked to the top)
728 // or stick it to the top
729 // Then after the loop we'll make sure that if there's another section just below it
730 // pushed the sticky section up to make it disappear
731 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
732 if (topSectionStickPos <= pos) {
733 QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);
734 QQuickItemPrivate::get(item->m_sectionItem)->setCulled(false);
735 } else {
736 QQuickItemPrivate::get(m_topSectionItem)->setCulled(false);
737 m_topSectionItem->setY(topSectionStickPos);
738 if (item->m_sectionItem) {
739 QQuickItemPrivate::get(item->m_sectionItem)->setCulled(true);
740 }
741 }
742 }
743 }
744 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
745 if (!cull && pos < visibleFrom) {
746 context->setContextProperty(QLatin1String("heightToClip"), visibleFrom - pos);
747 } else {
748 context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));
749 }
750// qDebug() << "ListViewWithPageHeader::updatePolish" << /*index << */pos + m_clipItem->y() << /*QQuickItemPrivate::get(item)->culled <<*/ (pos + item->height() < visibleFrom) << (pos > visibleTo);
751 pos += item->height();
752 ++modelIndex;
753 }
755 // Second step of section sticky item positioning
756 // Look at the next section header, check if it's pushing up the sticky one
757 if (m_topSectionItem) {
758 for (int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
759 ListItem *item = m_visibleItems[i];
760 if (item->m_sectionItem) {
761 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
762 m_topSectionItem->setY(item->y() - m_topSectionItem->height());
763 }
764 break;
765 }
766 }
767 }
768 }
770 refill();
772 if (m_contentHeightDirty) {
773 qreal contentHeight;
774 const int modelCount = model()->rowCount();
775 const int visibleItems = m_visibleItems.count();
776 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
777 if (lastValidIndex == modelCount - 1) {
778 ListItem *item = m_visibleItems.last();
779 contentHeight = item->y() + item->height() + m_clipItem->y();
780 if (m_firstVisibleIndex != 0) {
781 // Make sure that if we are shrinking we tell the view we still fit
782 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
783 }
784 } else {
785 contentHeight = m_headerItem ? m_headerItem->height() : 0;
786 if (!m_visibleItems.isEmpty()) {
787 foreach(ListItem *item, m_visibleItems) {
788 contentHeight += item->height();
789 }
790 const int unknownSizes = modelCount - visibleItems;
791 contentHeight += unknownSizes * contentHeight / visibleItems;
792 }
793 }
795 m_contentHeightDirty = false;
796 setContentHeight(contentHeight);
797 }
801#include "moc_listviewwithpageheader.cpp"