plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

430 (m_topSectionItem && !listItem->m_sectionItem && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))

431 {

432 // we can scroll the list down to show more stuff

433 auto realVisibleListItemY = listItemY;

434 if (m_topSectionItem) {

435 // If we are showing the top section sticky item and this item doesn't have a section

436 // item we have to make sure to scroll it a bit more so that it is not underlapping

437 // the top section sticky item

438 bool topSectionShown = !QQuickItemPrivate::get(m_topSectionItem)->culled;

439 if (topSectionShown && !listItem->m_sectionItem) {

440 realVisibleListItemY -= m_topSectionItem->height();

441 }

442 }

443 const auto to = qMax(realVisibleListItemY, listItemY + listItemHeight - height());

444 m_contentYAnimation->setTo(to);

445 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

446 m_contentYAnimation->start();

447 }

448 return true;

449 }

450 return false;

451}

452

453qreal ListViewWithPageHeader::minYExtent() const

454{

455// qDebug() << "ListViewWithPageHeader::minYExtent" << m_minYExtent;

456 return m_minYExtent;

457}

458

459void ListViewWithPageHeader::componentComplete()

460{

461 if (m_delegateModel)

462 m_delegateModel->componentComplete();

463

464 QQuickFlickable::componentComplete();

465

466 polish();

467}

468

469void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)

470{

471 QQuickFlickable::viewportMoved(orient);

472// qDebug() << "ListViewWithPageHeader::viewportMoved" << contentY();

473 qreal diff = m_previousContentY - contentY();

474 const bool showHeaderAnimationRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationShowHeader;

475 if (m_headerItem) {

476 auto oldHeaderItemShownHeight = m_headerItemShownHeight;

477 if (contentY() < -m_minYExtent) {

478 // Stick the header item to the top when dragging down

479 m_headerItem->setY(contentY());

480 m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));

481 } else {

482 m_headerItem->setHeight(m_headerItem->implicitHeight());

483 // We are going down (but it's not because of the rebound at the end)

484 // (but the header was not shown by it's own position)

485 // or the header is partially shown and we are not doing a maximizeVisibleArea either

486 const bool scrolledUp = m_previousContentY > contentY();

487 const bool notRebounding = contentY() + height() < contentHeight();

488 const bool notShownByItsOwn = contentY() + diff >= m_headerItem->y() + m_headerItem->height();

489 const bool maximizeVisibleAreaRunning = m_contentYAnimation->isRunning() && contentYAnimationType == ContentYAnimationMaximizeVisibleArea;

490

491 if (!scrolledUp && contentY() == -m_minYExtent) {

492 m_headerItemShownHeight = 0;

493 m_headerItem->setY(contentY());

494 } else if ((scrolledUp && notRebounding && notShownByItsOwn && !maximizeVisibleAreaRunning) || (m_headerItemShownHeight > 0)) {

495 if (maximizeVisibleAreaRunning && diff > 0) // If we are maximizing and the header was shown, make sure we hide it

496 m_headerItemShownHeight -= diff;

497 else

498 m_headerItemShownHeight += diff;

499 if (contentY() == -m_minYExtent) {

500 m_headerItemShownHeight = 0;

501 } else {

502 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());

503 }

504 if (m_headerItemShownHeight > 0) {

505 m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);

506 } else {

507 m_headerItem->setY(-m_minYExtent);

508 }

509 }

510 }

511 // We will be changing the clip item, need to accomadate for it

512 // otherwise we move the firstItem down/up twice (unless the

513 // show header animation is running, where we want to keep the viewport stable)

514 if (!showHeaderAnimationRunning) {

515 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

516 } else {

517 diff = -diff;

518 }

519 }

520 if (!m_visibleItems.isEmpty()) {

521 updateClipItem();

522 ListItem *firstItem = m_visibleItems.first();

523 firstItem->setY(firstItem->y() + diff);

524 if (showHeaderAnimationRunning) {

525 adjustMinYExtent();

526 }

527 }

528

529 m_previousContentY = contentY();

530 layout();

531 polish();

532}

533

534void ListViewWithPageHeader::createDelegateModel()

535{

536#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

537 m_delegateModel = new QQuickVisualDataModel(qmlContext(this), this);

538 connect(m_delegateModel, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(itemCreated(int,QQuickItem*)));

539#else

540 m_delegateModel = new QQmlDelegateModel(qmlContext(this), this);

541 connect(m_delegateModel, SIGNAL(createdItem(int,QObject*)), this, SLOT(itemCreated(int,QObject*)));

542#endif

543 if (isComponentComplete())

544 m_delegateModel->componentComplete();

545 updateWatchedRoles();

546}

547

548void ListViewWithPageHeader::refill()

549{

550 if (m_inLayout) {

551 return;

552 }

553 if (!isComponentComplete()) {

554 return;

555 }

556

557 const qreal buffer = height() * bufferRatio;

558 const qreal from = contentY();

559 const qreal to = from + height();

560 const qreal bufferFrom = from - buffer;

561 const qreal bufferTo = to + buffer;

562

563 bool added = addVisibleItems(from, to, false);

564 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

565 added |= addVisibleItems(bufferFrom, bufferTo, true);

566

567 if (added || removed) {

568 m_contentHeightDirty = true;

569 }

570}

571

572bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous)

573{

574 if (!delegate())

575 return false;

576

577 if (m_delegateModel->count() == 0)

578 return false;

579

580 ListItem *item;

581// qDebug() << "ListViewWithPageHeader::addVisibleItems" << fillFrom << fillTo << asynchronous;

582

583 int modelIndex = 0;

584 qreal pos = 0;

585 if (!m_visibleItems.isEmpty()) {

586 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

587 item = m_visibleItems.last();

588 pos = item->y() + item->height() + m_clipItem->y();

589 }

590 bool changed = false;

591// qDebug() << (modelIndex < m_delegateModel->count()) << pos << fillTo;

592 while (modelIndex < m_delegateModel->count() && pos <= fillTo) {

593// qDebug() << "refill: append item" << modelIndex << "pos" << pos << "asynchronous" << asynchronous;

594 if (!(item = createItem(modelIndex, asynchronous)))

595 break;

596 pos += item->height();

597 ++modelIndex;

598 changed = true;

599 }

600

601 modelIndex = 0;

602 pos = 0;

603 if (!m_visibleItems.isEmpty()) {

604 modelIndex = m_firstVisibleIndex - 1;

605 item = m_visibleItems.first();

606 pos = item->y() + m_clipItem->y();

607 }

608 while (modelIndex >= 0 && pos > fillFrom) {

609// qDebug() << "refill: prepend item" << modelIndex << "pos" << pos << "fillFrom" << fillFrom << "asynchronous" << asynchronous;

610 if (!(item = createItem(modelIndex, asynchronous)))

611 break;

612 pos -= item->height();

613 --modelIndex;

614 changed = true;

615 }

616

617 return changed;

618}

619

620void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

621{

622 QQuickItem *item = listItem->m_item;

623#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

624 QQuickVisualModel::ReleaseFlags flags = m_delegateModel->release(item);

625 if (flags & QQuickVisualModel::Destroyed) {

626#else

627 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);

628 if (flags & QQmlDelegateModel::Destroyed) {

629#endif

630 item->setParentItem(nullptr);

631 }

632 delete listItem->m_sectionItem;

633 delete listItem;

634}

635

636void ListViewWithPageHeader::releaseItem(ListItem *listItem)

637{

638 QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);

639 itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);

640 m_itemsToRelease << listItem;

641}

642

643void ListViewWithPageHeader::updateWatchedRoles()

644{

645 if (m_delegateModel) {

646 QList<QByteArray> roles;

647 if (!m_sectionProperty.isEmpty())

648 roles << m_sectionProperty.toUtf8();

649 m_delegateModel->setWatchedRoles(roles);

650 }

651}

652

653QQuickItem *ListViewWithPageHeader::getSectionItem(int modelIndex, bool alreadyInserted)

654{

655 if (!m_sectionDelegate)

656 return nullptr;

657

658 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);

659 if (modelIndex > 0) {

660 const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);

661 if (section == prevSection)

662 return nullptr;

663 }

664 if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {

665 // Already inserted items can't steal next section header

666 const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);

667 if (section == nextSection) {

668 // Steal the section header

669 ListItem *nextItem = itemAtIndex(modelIndex); // Not +1 since not yet inserted into m_visibleItems

670 if (nextItem) {

671 QQuickItem *sectionItem = nextItem->m_sectionItem;

672 nextItem->m_sectionItem = nullptr;

673 return sectionItem;

674 }

675 }

676 }

677

678 return getSectionItem(section);

679}

680

681QQuickItem *ListViewWithPageHeader::getSectionItem(const QString &sectionText)

682{

683 QQuickItem *sectionItem = nullptr;

684

685 QQmlContext *creationContext = m_sectionDelegate->creationContext();

686 QQmlContext *context = new QQmlContext(creationContext ? creationContext : qmlContext(this));

687 context->setContextProperty(QLatin1String("section"), sectionText);

688 context->setContextProperty(QLatin1String("delegateIndex"), -1);

689 QObject *nobj = m_sectionDelegate->beginCreate(context);

690 if (nobj) {

691 QQml_setParent_noEvent(context, nobj);

692 sectionItem = qobject_cast<QQuickItem *>(nobj);

693 if (!sectionItem) {

694 delete nobj;

695 } else {

696 sectionItem->setZ(2);

697 QQml_setParent_noEvent(sectionItem, m_clipItem);

698 sectionItem->setParentItem(m_clipItem);

699 }

700 } else {

701 delete context;

702 }

703 m_sectionDelegate->completeCreate();

704

705 // TODO attach to sectionItem so we can accomodate to it changing its height

706

707 return sectionItem;

708}

709

710bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)

711{

712// qDebug() << "ListViewWithPageHeader::removeNonVisibleItems" << bufferFrom << bufferTo;

713 // Do not remove items if we are overshooting up or down, since we'll come back

714 // to the "stable" position and delete/create items without any reason

715 if (contentY() < -m_minYExtent) {

716 return false;

717 } else if (contentY() + height() > contentHeight()) {

718 return false;

719 }

720 bool changed = false;

721

722 bool foundVisible = false;

723 int i = 0;

724 int removedItems = 0;

725 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

726 while (i < m_visibleItems.count()) {

727 ListItem *item = m_visibleItems[i];

728 const qreal pos = item->y() + m_clipItem->y();

729// qDebug() << i << pos << (pos + item->height()) << bufferFrom << bufferTo;

730 if (pos + item->height() < bufferFrom || pos > bufferTo) {

731// qDebug() << "Releasing" << i << (pos + item->height() < bufferFrom) << pos + item->height() << bufferFrom << (pos > bufferTo) << pos << bufferTo;

732 releaseItem(item);

733 m_visibleItems.removeAt(i);

734 changed = true;

735 ++removedItems;

736 } else {

737 if (!foundVisible) {

738 foundVisible = true;

739 const int itemIndex = m_firstVisibleIndex + removedItems + i;

740 m_firstVisibleIndex = itemIndex;

741 }

742 ++i;

743 }

744 }

745 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

746 adjustMinYExtent();

747 }

748

749 return changed;

750}

751

752ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(int modelIndex, bool asynchronous)

753{

754// qDebug() << "CREATE ITEM" << modelIndex;

755 if (asynchronous && m_asyncRequestedIndex != -1)

756 return nullptr;

757

758 m_asyncRequestedIndex = -1;

759#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

760 QQuickItem *item = m_delegateModel->item(modelIndex, asynchronous);

761#else

762 QObject* object = m_delegateModel->object(modelIndex, asynchronous);

763 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);

764#endif

765 if (!item) {

766#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

767 m_asyncRequestedIndex = modelIndex;

768#else

769 if (object) {

770 m_delegateModel->release(object);

771 if (!m_delegateValidated) {

772 m_delegateValidated = true;

773 QObject* delegateObj = delegate();

774 qmlInfo(delegateObj ? delegateObj : this) << "Delegate must be of Item type";

775 }

776 } else {

777 m_asyncRequestedIndex = modelIndex;

778 }

779#endif

780 return 0;

781 } else {

782// qDebug() << "ListViewWithPageHeader::createItem::We have the item" << modelIndex << item;

783 ListItem *listItem = new ListItem;

784 listItem->m_item = item;

785 listItem->m_sectionItem = getSectionItem(modelIndex, false /*Not yet inserted into m_visibleItems*/);

786 QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Geometry);

787 ListItem *prevItem = itemAtIndex(modelIndex - 1);

788 bool lostItem = false; // Is an item that we requested async but because of model changes

789 // it is no longer attached to any of the existing items (has no prev nor next item)

790 // nor is the first item

791 if (prevItem) {

792 listItem->setY(prevItem->y() + prevItem->height());

793 } else {

794 ListItem *currItem = itemAtIndex(modelIndex);

795 if (currItem) {

796 // There's something already in m_visibleItems at out index, meaning this is an insert, so attach to its top

797 listItem->setY(currItem->y() - listItem->height());

798 } else {

799 ListItem *nextItem = itemAtIndex(modelIndex + 1);

800 if (nextItem) {

801 listItem->setY(nextItem->y() - listItem->height());

802 } else if (modelIndex == 0 && m_headerItem) {

803 listItem->setY(m_headerItem->height());

804 } else if (!m_visibleItems.isEmpty()) {

805 lostItem = true;

806 }

807 }

808 }

809 if (lostItem) {

810 releaseItem(listItem);

811 listItem = nullptr;

812 } else {

813 listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() <= contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());

814 if (m_visibleItems.isEmpty()) {

815 m_visibleItems << listItem;

816 } else {

817 m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);

818 }

819 if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {

820 m_firstVisibleIndex = modelIndex;

821 polish();

822 }

823 if (listItem->m_sectionItem) {

824 QQmlContext *context = QQmlEngine::contextForObject(listItem->m_sectionItem)->parentContext();

825 context->setContextProperty(QLatin1String("delegateIndex"), modelIndex);

826 }

827 adjustMinYExtent();

828 m_contentHeightDirty = true;

829 }

830 return listItem;

831 }

832}

833

834#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

835void ListViewWithPageHeader::itemCreated(int modelIndex, QQuickItem *item)

836{

837#else

838void ListViewWithPageHeader::itemCreated(int modelIndex, QObject *object)

839{

840 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);

841 if (!item) {

842 qWarning() << "ListViewWithPageHeader::itemCreated got a non item for index" << modelIndex;

843 return;

844 }

845#endif

846// qDebug() << "ListViewWithPageHeader::itemCreated" << modelIndex << item;

847

848 item->setParentItem(m_clipItem);

849 QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();

850 context->setContextProperty(QLatin1String("ListViewWithPageHeader"), this);

851 context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));

852 if (modelIndex == m_asyncRequestedIndex) {

853 createItem(modelIndex, false);

854 refill();

855 }

856}

857

858void ListViewWithPageHeader::updateClipItem()

859{

860 m_clipItem->setHeight(height() - m_headerItemShownHeight);

861 m_clipItem->setY(contentY() + m_headerItemShownHeight);

862 m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);

863}

864

865void ListViewWithPageHeader::onContentHeightChanged()

866{

867 updateClipItem();

868}

869

870void ListViewWithPageHeader::onContentWidthChanged()

871{

872 m_clipItem->setWidth(contentItem()->width());

873}

874

875void ListViewWithPageHeader::onHeightChanged()

876{

877 polish();

878}

879

880

881#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

882void ListViewWithPageHeader::onModelUpdated(const QQuickChangeSet &changeSet, bool /*reset*/)

883#else

884void ListViewWithPageHeader::onModelUpdated(const QQmlChangeSet &changeSet, bool /*reset*/)

885#endif

886{

887 // TODO Do something with reset

888// qDebug() << "ListViewWithPageHeader::onModelUpdated" << changeSet << reset;

889 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

890

891#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

892 Q_FOREACH(const QQuickChangeSet::Remove &remove, changeSet.removes()) {

893#else

894 Q_FOREACH(const QQmlChangeSet::Remove &remove, changeSet.removes()) {

895#endif

896// qDebug() << "ListViewWithPageHeader::onModelUpdated Remove" << remove.index << remove.count;

897 if (remove.index + remove.count > m_firstVisibleIndex && remove.index < m_firstVisibleIndex + m_visibleItems.count()) {

898 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();

899 // If all the items we are removing are either not created or culled

900 // we have to grow down to avoid viewport changing

901 bool growDown = true;

902 for (int i = 0; growDown && i < remove.count; ++i) {

903 const int modelIndex = remove.index + i;

904 ListItem *item = itemAtIndex(modelIndex);

905 if (item && !item->culled()) {

906 growDown = false;

907 }

908 }

909 for (int i = remove.count - 1; i >= 0; --i) {

910 const int visibleIndex = remove.index + i - m_firstVisibleIndex;

911 if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {

912 ListItem *item = m_visibleItems[visibleIndex];

913 // Pass the section item down if needed

914 if (item->m_sectionItem && visibleIndex + 1 < m_visibleItems.count()) {

915 ListItem *nextItem = m_visibleItems[visibleIndex + 1];

916 if (!nextItem->m_sectionItem) {

917 nextItem->m_sectionItem = item->m_sectionItem;

918 item->m_sectionItem = nullptr;

919 }

920 }

921 releaseItem(item);

922 m_visibleItems.removeAt(visibleIndex);

923 }

924 }

925 if (growDown) {

926 adjustMinYExtent();

927 } else if (remove.index <= m_firstVisibleIndex) {

928 if (!m_visibleItems.isEmpty()) {

929 // We removed the first item that is the one that positions the rest

930 // position the new first item correctly

931 m_visibleItems.first()->setY(oldFirstValidIndexPos);

932 } else {

933 m_firstVisibleIndex = -1;

934 }

935 }

936 } else if (remove.index + remove.count <= m_firstVisibleIndex) {

937 m_firstVisibleIndex -= remove.count;

938 }

939 for (int i = remove.count - 1; i >= 0; --i) {

940 const int modelIndex = remove.index + i;

941 if (modelIndex == m_asyncRequestedIndex) {

942 m_asyncRequestedIndex = -1;

943 } else if (modelIndex < m_asyncRequestedIndex) {

944 m_asyncRequestedIndex--;

945 }

946 }

947 }

948

949#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

950 Q_FOREACH(const QQuickChangeSet::Insert &insert, changeSet.inserts()) {

951#else

952 Q_FOREACH(const QQmlChangeSet::Insert &insert, changeSet.inserts()) {

953#endif

954// qDebug() << "ListViewWithPageHeader::onModelUpdated Insert" << insert.index << insert.count;

955 const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();

956 const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();

957 if (insertingInValidIndexes || firstItemWithViewOnTop)

958 {

959 // If the items we are adding won't be really visible

960 // we grow up instead of down to not change the viewport

961 bool growUp = false;

962 if (!firstItemWithViewOnTop) {

963 for (int i = 0; i < m_visibleItems.count(); ++i) {

964 if (!m_visibleItems[i]->culled()) {

965 if (insert.index <= m_firstVisibleIndex + i) {

966 growUp = true;

967 }

968 break;

969 }

970 }

971 }

972

973 const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();

974 for (int i = insert.count - 1; i >= 0; --i) {

975 const int modelIndex = insert.index + i;

976 ListItem *item = createItem(modelIndex, false);

977 if (growUp) {

978 ListItem *firstItem = m_visibleItems.first();

979 firstItem->setY(firstItem->y() - item->height());

980 adjustMinYExtent();

981 }

982 // Adding an item may break a "same section" chain, so check

983 // if we need adding a new section item

984 if (m_sectionDelegate) {

985 ListItem *nextItem = itemAtIndex(modelIndex + 1);

986 if (nextItem && !nextItem->m_sectionItem) {

987 nextItem->m_sectionItem = getSectionItem(modelIndex + 1, true /* alredy inserted into m_visibleItems*/);

988 if (growUp && nextItem->m_sectionItem) {

989 ListItem *firstItem = m_visibleItems.first();

990 firstItem->setY(firstItem->y() - nextItem->m_sectionItem->height());

991 adjustMinYExtent();

992 }

993 }

994 }

995 }

996 if (firstItemWithViewOnTop) {

997 ListItem *firstItem = m_visibleItems.first();

998 firstItem->setY(oldFirstValidIndexPos);

999 }

1000 } else if (insert.index <= m_firstVisibleIndex) {

1001 m_firstVisibleIndex += insert.count;

1002 }

1003

1004 for (int i = insert.count - 1; i >= 0; --i) {

1005 const int modelIndex = insert.index + i;

1006 if (modelIndex <= m_asyncRequestedIndex) {

1007 m_asyncRequestedIndex++;

1008 }

1009 }

1010 }

1011

1012#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

1013 Q_FOREACH(const QQuickChangeSet::Change &change, changeSet.changes()) {

1014#else

1015 Q_FOREACH(const QQmlChangeSet::Change &change, changeSet.changes()) {

1016#endif

1017// qDebug() << "ListViewWithPageHeader::onModelUpdated Change" << change.index << change.count;

1018 for (int i = change.index; i < change.count; ++i) {

1019 ListItem *item = itemAtIndex(i);

1020 if (item && item->m_sectionItem) {

1021 QQmlContext *context = QQmlEngine::contextForObject(item->m_sectionItem)->parentContext();

1022 const QString sectionText = m_delegateModel->stringValue(i, m_sectionProperty);

1023 context->setContextProperty(QLatin1String("section"), sectionText);

1024 }

1025 }

1026 }

1027

1028 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1029 adjustMinYExtent();

1030 }

1031

1032 for (int i = 0; i < m_visibleItems.count(); ++i) {

1033 ListItem *item = m_visibleItems[i];

1034 if (item->m_sectionItem) {

1035 QQmlContext *context = QQmlEngine::contextForObject(item->m_sectionItem)->parentContext();

1036 context->setContextProperty(QLatin1String("delegateIndex"), m_firstVisibleIndex + i);

1037 }

1038 }

1039

1040 layout();

1041 polish();

1042 m_contentHeightDirty = true;

1043}

1044

1045void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1046{

1047 m_contentHeightDirty = true;

1048 polish();

1049}

1050

1051void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * /*item*/, const QRectF &newGeometry, const QRectF &oldGeometry)

1052{

1053 const qreal heightDiff = newGeometry.height() - oldGeometry.height();

1054 if (heightDiff != 0) {

1055 if (oldGeometry.y() + oldGeometry.height() + m_clipItem->y() < contentY() && !m_visibleItems.isEmpty()) {

1056 ListItem *firstItem = m_visibleItems.first();

1057 firstItem->setY(firstItem->y() - heightDiff);

1058 adjustMinYExtent();

1059 layout();

1060 }

1061 refill();

1062 adjustMinYExtent();

1063 polish();

1064 m_contentHeightDirty = true;

1065 }

1066}

1067

1068void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)

1069{

1070 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1071 if (m_headerItemShownHeight > 0) {

1072 // If the header is shown because of the clip

1073 // Change its size

1074 m_headerItemShownHeight += heightDiff;

1075 m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);

1076 updateClipItem();

1077 adjustMinYExtent();

1078 } else {

1079 if (oldHeaderY + oldHeaderHeight > contentY()) {

1080 // If the header is shown because its position

1081 // Change its size

1082 ListItem *firstItem = m_visibleItems.first();

1083 firstItem->setY(firstItem->y() + heightDiff);

1084 layout();

1085 } else {

1086 // If the header is not on screen, just change the start of the list

1087 // so the viewport is not changed

1088 adjustMinYExtent();

1089 }

1090 }

1091}

1092

1093

1094void ListViewWithPageHeader::adjustMinYExtent()

1095{

1096 if (m_visibleItems.isEmpty()) {

1097 m_minYExtent = 0;

1098 } else {

1099 qreal nonCreatedHeight = 0;

1100 if (m_firstVisibleIndex != 0) {

1101 // Calculate the average height of items to estimate the position of the list start

1102 const int visibleItems = m_visibleItems.count();

1103 qreal visibleItemsHeight = 0;

1104 Q_FOREACH(ListItem *item, m_visibleItems) {

1105 visibleItemsHeight += item->height();

1106 }

1107 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

1108// qDebug() << m_firstVisibleIndex << visibleItemsHeight << visibleItems << nonCreatedHeight;

1109 }

1110 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + (m_headerItem ? m_headerItem->implicitHeight() : 0);

1111 }

1112}

1113

1114ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(int modelIndex) const

1115{

1116 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

1117 if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())

1118 return m_visibleItems[visibleIndexedModelIndex];

1119

1120 return nullptr;

1121}

1122

1123void ListViewWithPageHeader::layout()

1124{

1125 if (m_inLayout)

1126 return;

1127

1128 m_inLayout = true;

1129 if (!m_visibleItems.isEmpty()) {

1130 const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;

1131 const qreal visibleTo = contentY() + height() - m_clipItem->y();

1132

1133 qreal pos = m_visibleItems.first()->y();

1134

1135// qDebug() << "ListViewWithPageHeader::layout Updating positions and heights. contentY" << contentY() << "minYExtent" << minYExtent();

1136 int firstReallyVisibleItem = -1;

1137 int modelIndex = m_firstVisibleIndex;

1138 Q_FOREACH(ListItem *item, m_visibleItems) {

1139 const bool cull = pos + item->height() <= visibleFrom || pos >= visibleTo;

1140 item->setCulled(cull);

1141 item->setY(pos);

1142 if (!cull && firstReallyVisibleItem == -1) {

1143 firstReallyVisibleItem = modelIndex;

1144 if (m_topSectionItem) {

1145 // Positing the top section sticky item is a two step process

1146 // First we set it either we cull it (because it doesn't need to be sticked to the top)

1147 // or stick it to the top

1148 // Then after the loop we'll make sure that if there's another section just below it

1149 // pushed the sticky section up to make it disappear

1150 const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();

1151 bool showStickySectionItem;

1152 // We need to show the "top section sticky item" when the position at the "top" of the

1153 // viewport is bigger than the start of the position of the first visible item

1154 // i.e. the first visible item starts before the viewport, or when the first

1155 // visible item starts just at the viewport start and it does not have its own section item

1156 if (topSectionStickPos > pos) {

1157 showStickySectionItem = true;

1158 } else if (topSectionStickPos == pos) {

1159 showStickySectionItem = !item->m_sectionItem;

1160 } else {

1161 showStickySectionItem = false;

1162 }

1163 if (!showStickySectionItem) {

1164 QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);

1165 if (item->m_sectionItem) {

1166 // This seems it should happen since why would we cull the top section

1167 // if the first visible item has no section header? This only happens briefly

1168 // when increasing the height of a list that is at the bottom, the m_topSectionItem

1169 // gets shown shortly in the next polish call

1170 QQuickItemPrivate::get(item->m_sectionItem)->setCulled(false);

1171 }

1172 } else {

1173 // Update the top sticky section header

1174 const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);

1175 QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();

1176 context->setContextProperty(QLatin1String("section"), section);

1177

1178 QQuickItemPrivate::get(m_topSectionItem)->setCulled(false);

1179 m_topSectionItem->setY(topSectionStickPos);

1180 int delegateIndex = modelIndex;

1181 // Look for the first index with this section text

1182 while (delegateIndex > 0) {

1183 const QString prevSection = m_delegateModel->stringValue(delegateIndex - 1, m_sectionProperty);

1184 if (prevSection != section)

1185 break;

1186 delegateIndex--;

1187 }

1188 context->setContextProperty(QLatin1String("delegateIndex"), delegateIndex);

1189 if (item->m_sectionItem) {

1190 QQuickItemPrivate::get(item->m_sectionItem)->setCulled(true);

1191 }

1192 }

1193 }

1194 }

1195 QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();

1196 const qreal clipFrom = visibleFrom + (!item->m_sectionItem && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);

1197 if (!cull && pos < clipFrom) {

1198 context->setContextProperty(QLatin1String("heightToClip"), clipFrom - pos);

1199 } else {

1200 context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));

1201 }

1202// qDebug() << "ListViewWithPageHeader::layout" << item->m_item;

1203 pos += item->height();

1204 ++modelIndex;

1205 }

1206

1207 // Second step of section sticky item positioning

1208 // Look at the next section header, check if it's pushing up the sticky one

1209 if (m_topSectionItem) {

1210 if (firstReallyVisibleItem >= 0) {

1211 for (int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {

1212 ListItem *item = m_visibleItems[i];

1213 if (item->m_sectionItem) {

1214 if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {

1215 m_topSectionItem->setY(item->y() - m_topSectionItem->height());

1216 }

1217 break;

1218 }

1219 }

1220 }

1221 }

1222 }

1223 m_inLayout = false;

1224}

1225

1226void ListViewWithPageHeader::updatePolish()

1227{

1228 Q_FOREACH(ListItem *item, m_itemsToRelease)

1229 reallyReleaseItem(item);

1230 m_itemsToRelease.clear();

1231

1232 if (!model())

1233 return;

1234

1235 layout();

1236

1237 refill();

1238

1239 if (m_contentHeightDirty) {

1240 qreal contentHeight;

1241 if (m_visibleItems.isEmpty()) {

1242 contentHeight = m_headerItem ? m_headerItem->height() : 0;

1243 } else {

1244 const int modelCount = model()->rowCount();

1245 const int visibleItems = m_visibleItems.count();

1246 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1247 qreal nonCreatedHeight = 0;

1248 if (lastValidIndex != modelCount - 1) {

1249 const int visibleItems = m_visibleItems.count();

1250 qreal visibleItemsHeight = 0;

1251 Q_FOREACH(ListItem *item, m_visibleItems) {

1252 visibleItemsHeight += item->height();

1253 }

1254 const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);

1255 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1256 }

1257 ListItem *item = m_visibleItems.last();

1258 contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();

1259 if (m_firstVisibleIndex != 0) {

1260 // Make sure that if we are shrinking we tell the view we still fit

1261 m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));

1262 }

1263 }

1264

1265 m_contentHeightDirty = false;

1266 adjustMinYExtent();

1267 setContentHeight(contentHeight);

1268 }

1269}

1270

1271#include "moc_listviewwithpageheader.cpp"