plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

434 {

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

436 auto realVisibleListItemY = listItemY;

437 if (m_topSectionItem) {

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

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

440 // the top section sticky item

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

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

443 realVisibleListItemY -= m_topSectionItem->height();

444 }

445 }

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

447 m_contentYAnimation->setTo(to);

448 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

449 m_contentYAnimation->start();

450 }

451 return true;

452 }

453 return false;

454}

455

456qreal ListViewWithPageHeader::minYExtent() const

457{

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

459 return m_minYExtent;

460}

461

462void ListViewWithPageHeader::componentComplete()

463{

464 if (m_delegateModel)

465 m_delegateModel->componentComplete();

466

467 QQuickFlickable::componentComplete();

468

469 polish();

470}

471

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

473{

474 QQuickFlickable::viewportMoved(orient);

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

476 qreal diff = m_previousContentY - contentY();

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

478 if (m_headerItem) {

479 auto oldHeaderItemShownHeight = m_headerItemShownHeight;

480 if (contentY() < -m_minYExtent) {

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

482 m_headerItem->setY(contentY());

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

484 } else {

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

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

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

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

489 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

493

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

495 m_headerItemShownHeight = 0;

496 m_headerItem->setY(contentY());

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

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

499 m_headerItemShownHeight -= diff;

500 else

501 m_headerItemShownHeight += diff;

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

503 m_headerItemShownHeight = 0;

504 } else {

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

506 }

507 if (m_headerItemShownHeight > 0) {

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

509 } else {

510 m_headerItem->setY(-m_minYExtent);

511 }

512 }

513 }

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

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

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

517 if (!showHeaderAnimationRunning) {

518 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

519 } else {

520 diff = -diff;

521 }

522 }

523 if (!m_visibleItems.isEmpty()) {

524 updateClipItem();

525 ListItem *firstItem = m_visibleItems.first();

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

527 if (showHeaderAnimationRunning) {

528 adjustMinYExtent();

529 }

530 }

531

532 m_previousContentY = contentY();

533 layout();

534 polish();

535}

536

537void ListViewWithPageHeader::createDelegateModel()

538{

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

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

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

542#else

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

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

545#endif

546 if (isComponentComplete())

547 m_delegateModel->componentComplete();

548 updateWatchedRoles();

549}

550

551void ListViewWithPageHeader::refill()

552{

553 if (m_inLayout) {

554 return;

555 }

556 if (!isComponentComplete()) {

557 return;

558 }

559

560 const qreal buffer = height() * bufferRatio;

561 const qreal from = contentY();

562 const qreal to = from + height();

563 const qreal bufferFrom = from - buffer;

564 const qreal bufferTo = to + buffer;

565

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

567 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

569

570 if (added || removed) {

571 m_contentHeightDirty = true;

572 }

573}

574

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

576{

577 if (!delegate())

578 return false;

579

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

581 return false;

582

583 ListItem *item;

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

585

586 int modelIndex = 0;

587 qreal pos = 0;

588 if (!m_visibleItems.isEmpty()) {

589 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

590 item = m_visibleItems.last();

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

592 }

593 bool changed = false;

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

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

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

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

598 break;

599 pos += item->height();

600 ++modelIndex;

601 changed = true;

602 }

603

604 modelIndex = 0;

605 pos = 0;

606 if (!m_visibleItems.isEmpty()) {

607 modelIndex = m_firstVisibleIndex - 1;

608 item = m_visibleItems.first();

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

610 }

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

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

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

614 break;

615 pos -= item->height();

616 --modelIndex;

617 changed = true;

618 }

619

620 return changed;

621}

622

623void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

624{

625 QQuickItem *item = listItem->m_item;

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

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

628 if (flags & QQuickVisualModel::Destroyed) {

629#else

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

631 if (flags & QQmlDelegateModel::Destroyed) {

632#endif

633 item->setParentItem(nullptr);

634 }

635 delete listItem->m_sectionItem;

636 delete listItem;

637}

638

639void ListViewWithPageHeader::releaseItem(ListItem *listItem)

640{

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

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

643 m_itemsToRelease << listItem;

644}

645

646void ListViewWithPageHeader::updateWatchedRoles()

647{

648 if (m_delegateModel) {

649 QList<QByteArray> roles;

650 if (!m_sectionProperty.isEmpty())

651 roles << m_sectionProperty.toUtf8();

652 m_delegateModel->setWatchedRoles(roles);

653 }

654}

655

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

657{

658 if (!m_sectionDelegate)

659 return nullptr;

660

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

662 if (modelIndex > 0) {

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

664 if (section == prevSection)

665 return nullptr;

666 }

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

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

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

670 if (section == nextSection) {

671 // Steal the section header

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

673 if (nextItem) {

674 QQuickItem *sectionItem = nextItem->m_sectionItem;

675 nextItem->m_sectionItem = nullptr;

676 return sectionItem;

677 }

678 }

679 }

680

681 return getSectionItem(section);

682}

683

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

685{

686 QQuickItem *sectionItem = nullptr;

687

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

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

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

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

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

693 if (nobj) {

694 QQml_setParent_noEvent(context, nobj);

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

696 if (!sectionItem) {

697 delete nobj;

698 } else {

699 sectionItem->setZ(2);

700 QQml_setParent_noEvent(sectionItem, m_clipItem);

701 sectionItem->setParentItem(m_clipItem);

702 }

703 } else {

704 delete context;

705 }

706 m_sectionDelegate->completeCreate();

707

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

709

710 return sectionItem;

711}

712

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

714{

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

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

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

718 if (contentY() < -m_minYExtent) {

719 return false;

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

721 return false;

722 }

723 bool changed = false;

724

725 bool foundVisible = false;

726 int i = 0;

727 int removedItems = 0;

728 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

730 ListItem *item = m_visibleItems[i];

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

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

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

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

735 releaseItem(item);

736 m_visibleItems.removeAt(i);

737 changed = true;

738 ++removedItems;

739 } else {

740 if (!foundVisible) {

741 foundVisible = true;

742 const int itemIndex = m_firstVisibleIndex + removedItems + i;

743 m_firstVisibleIndex = itemIndex;

744 }

745 ++i;

746 }

747 }

748 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

749 adjustMinYExtent();

750 }

751

752 return changed;

753}

754

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

756{

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

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

759 return nullptr;

760

761 m_asyncRequestedIndex = -1;

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

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

764#else

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

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

767#endif

768 if (!item) {

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

770 m_asyncRequestedIndex = modelIndex;

771#else

772 if (object) {

773 m_delegateModel->release(object);

774 if (!m_delegateValidated) {

775 m_delegateValidated = true;

776 QObject* delegateObj = delegate();

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

778 }

779 } else {

780 m_asyncRequestedIndex = modelIndex;

781 }

782#endif

783 return 0;

784 } else {

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

786 ListItem *listItem = new ListItem;

787 listItem->m_item = item;

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

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

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

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

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

793 // nor is the first item

794 if (prevItem) {

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

796 } else {

797 ListItem *currItem = itemAtIndex(modelIndex);

798 if (currItem) {

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

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

801 } else {

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

803 if (nextItem) {

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

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

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

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

808 lostItem = true;

809 }

810 }

811 }

812 if (lostItem) {

813 releaseItem(listItem);

814 listItem = nullptr;

815 } else {

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

817 if (m_visibleItems.isEmpty()) {

818 m_visibleItems << listItem;

819 } else {

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

821 }

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

823 m_firstVisibleIndex = modelIndex;

824 polish();

825 }

826 if (listItem->m_sectionItem) {

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

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

829 }

830 adjustMinYExtent();

831 m_contentHeightDirty = true;

832 }

833 return listItem;

834 }

835}

836

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

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

839{

840#else

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

842{

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

844 if (!item) {

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

846 return;

847 }

848#endif

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

850

851 item->setParentItem(m_clipItem);

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

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

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

855 if (modelIndex == m_asyncRequestedIndex) {

856 createItem(modelIndex, false);

857 refill();

858 }

859}

860

861void ListViewWithPageHeader::updateClipItem()

862{

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

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

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

866}

867

868void ListViewWithPageHeader::onContentHeightChanged()

869{

870 updateClipItem();

871}

872

873void ListViewWithPageHeader::onContentWidthChanged()

874{

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

876}

877

878void ListViewWithPageHeader::onHeightChanged()

879{

880 polish();

881}

882

883

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

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

886#else

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

888#endif

889{

890 // TODO Do something with reset

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

892 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

893

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

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

896#else

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

898#endif

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

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

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

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

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

904 bool growDown = true;

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

906 const int modelIndex = remove.index + i;

907 ListItem *item = itemAtIndex(modelIndex);

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

909 growDown = false;

910 }

911 }

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

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

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

915 ListItem *item = m_visibleItems[visibleIndex];

916 // Pass the section item down if needed

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

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

919 if (!nextItem->m_sectionItem) {

920 nextItem->m_sectionItem = item->m_sectionItem;

921 item->m_sectionItem = nullptr;

922 }

923 }

924 releaseItem(item);

925 m_visibleItems.removeAt(visibleIndex);

926 }

927 }

928 if (growDown) {

929 adjustMinYExtent();

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

931 if (!m_visibleItems.isEmpty()) {

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

933 // position the new first item correctly

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

935 } else {

936 m_firstVisibleIndex = -1;

937 }

938 }

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

940 m_firstVisibleIndex -= remove.count;

941 }

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

943 const int modelIndex = remove.index + i;

944 if (modelIndex == m_asyncRequestedIndex) {

945 m_asyncRequestedIndex = -1;

946 } else if (modelIndex < m_asyncRequestedIndex) {

947 m_asyncRequestedIndex--;

948 }

949 }

950 }

951

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

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

954#else

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

956#endif

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

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

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

960 if (insertingInValidIndexes || firstItemWithViewOnTop)

961 {

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

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

964 bool growUp = false;

965 if (!firstItemWithViewOnTop) {

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

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

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

969 growUp = true;

970 }

971 break;

972 }

973 }

974 }

975

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

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

978 const int modelIndex = insert.index + i;

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

980 if (growUp) {

981 ListItem *firstItem = m_visibleItems.first();

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

983 adjustMinYExtent();

984 }

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

986 // if we need adding a new section item

987 if (m_sectionDelegate) {

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

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

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

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

992 ListItem *firstItem = m_visibleItems.first();

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

994 adjustMinYExtent();

995 }

996 }

997 }

998 }

999 if (firstItemWithViewOnTop) {

1000 ListItem *firstItem = m_visibleItems.first();

1001 firstItem->setY(oldFirstValidIndexPos);

1002 }

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

1004 m_firstVisibleIndex += insert.count;

1005 }

1006

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

1008 const int modelIndex = insert.index + i;

1009 if (modelIndex <= m_asyncRequestedIndex) {

1010 m_asyncRequestedIndex++;

1011 }

1012 }

1013 }

1014

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

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

1017#else

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

1019#endif

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

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

1022 ListItem *item = itemAtIndex(i);

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

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

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

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

1027 }

1028 }

1029 }

1030

1031 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1032 adjustMinYExtent();

1033 }

1034

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

1036 ListItem *item = m_visibleItems[i];

1037 if (item->m_sectionItem) {

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

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

1040 }

1041 }

1042

1043 layout();

1044 polish();

1045 m_contentHeightDirty = true;

1046}

1047

1048void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1049{

1050 m_contentHeightDirty = true;

1051 polish();

1052}

1053

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

1055{

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

1057 if (heightDiff != 0) {

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

1059 ListItem *firstItem = m_visibleItems.first();

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

1061 adjustMinYExtent();

1062 layout();

1063 }

1064 refill();

1065 adjustMinYExtent();

1066 polish();

1067 m_contentHeightDirty = true;

1068 }

1069}

1070

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

1072{

1073 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1074 if (m_headerItemShownHeight > 0) {

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

1076 // Change its size

1077 m_headerItemShownHeight += heightDiff;

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

1079 updateClipItem();

1080 adjustMinYExtent();

1081 } else {

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

1083 // If the header is shown because its position

1084 // Change its size

1085 ListItem *firstItem = m_visibleItems.first();

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

1087 layout();

1088 } else {

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

1090 // so the viewport is not changed

1091 adjustMinYExtent();

1092 }

1093 }

1094}

1095

1096

1097void ListViewWithPageHeader::adjustMinYExtent()

1098{

1099 if (m_visibleItems.isEmpty()) {

1100 m_minYExtent = 0;

1101 } else {

1102 qreal nonCreatedHeight = 0;

1103 if (m_firstVisibleIndex != 0) {

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

1105 const int visibleItems = m_visibleItems.count();

1106 qreal visibleItemsHeight = 0;

1107 Q_FOREACH(ListItem *item, m_visibleItems) {

1108 visibleItemsHeight += item->height();

1109 }

1110 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1112 }

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

1114 }

1115}

1116

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

1118{

1119 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1121 return m_visibleItems[visibleIndexedModelIndex];

1122

1123 return nullptr;

1124}

1125

1126void ListViewWithPageHeader::layout()

1127{

1128 if (m_inLayout)

1129 return;

1130

1131 m_inLayout = true;

1132 if (!m_visibleItems.isEmpty()) {

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

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

1135

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

1137

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

1139 int firstReallyVisibleItem = -1;

1140 int modelIndex = m_firstVisibleIndex;

1141 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1143 item->setCulled(cull);

1144 item->setY(pos);

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

1146 firstReallyVisibleItem = modelIndex;

1147 if (m_topSectionItem) {

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

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

1150 // or stick it to the top

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

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

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

1154 bool showStickySectionItem;

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

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

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

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

1159 if (topSectionStickPos > pos) {

1160 showStickySectionItem = true;

1161 } else if (topSectionStickPos == pos) {

1162 showStickySectionItem = !item->m_sectionItem;

1163 } else {

1164 showStickySectionItem = false;

1165 }

1166 if (!showStickySectionItem) {

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

1168 if (item->m_sectionItem) {

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

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

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

1172 // gets shown shortly in the next polish call

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

1174 }

1175 } else {

1176 // Update the top sticky section header

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

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

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

1180

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

1182 m_topSectionItem->setY(topSectionStickPos);

1183 int delegateIndex = modelIndex;

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

1185 while (delegateIndex > 0) {

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

1187 if (prevSection != section)

1188 break;

1189 delegateIndex--;

1190 }

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

1192 if (item->m_sectionItem) {

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

1194 }

1195 }

1196 }

1197 }

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

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

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

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

1202 } else {

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

1204 }

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

1206 pos += item->height();

1207 ++modelIndex;

1208 }

1209

1210 // Second step of section sticky item positioning

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

1212 if (m_topSectionItem) {

1213 if (firstReallyVisibleItem >= 0) {

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

1215 ListItem *item = m_visibleItems[i];

1216 if (item->m_sectionItem) {

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

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

1219 }

1220 break;

1221 }

1222 }

1223 }

1224 }

1225 }

1226 m_inLayout = false;

1227}

1228

1229void ListViewWithPageHeader::updatePolish()

1230{

1231 Q_FOREACH(ListItem *item, m_itemsToRelease)

1232 reallyReleaseItem(item);

1233 m_itemsToRelease.clear();

1234

1235 if (!model())

1236 return;

1237

1238 layout();

1239

1240 refill();

1241

1242 if (m_contentHeightDirty) {

1243 qreal contentHeight;

1244 if (m_visibleItems.isEmpty()) {

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

1246 } else {

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

1248 const int visibleItems = m_visibleItems.count();

1249 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1250 qreal nonCreatedHeight = 0;

1251 if (lastValidIndex != modelCount - 1) {

1252 const int visibleItems = m_visibleItems.count();

1253 qreal visibleItemsHeight = 0;

1254 Q_FOREACH(ListItem *item, m_visibleItems) {

1255 visibleItemsHeight += item->height();

1256 }

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

1258 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1259 }

1260 ListItem *item = m_visibleItems.last();

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

1262 if (m_firstVisibleIndex != 0) {

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

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

1265 }

1266 }

1267

1268 m_contentHeightDirty = false;

1269 adjustMinYExtent();

1270 setContentHeight(contentHeight);

1271 }

1272}

1273

1274#include "moc_listviewwithpageheader.cpp"