plugins/DashViews/listviewwithpageheader.cpp · unity8

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

449 {

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

451 auto realVisibleListItemY = listItemY;

452 if (m_topSectionItem) {

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

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

455 // the top section sticky item

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

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

458 realVisibleListItemY -= m_topSectionItem->height();

459 }

460 }

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

462 m_contentYAnimation->setTo(to);

463 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

464 m_contentYAnimation->start();

465 }

466 return true;

467 }

468 return false;

469}

470

471qreal ListViewWithPageHeader::minYExtent() const

472{

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

474 return m_minYExtent;

475}

476

477void ListViewWithPageHeader::componentComplete()

478{

479 if (m_delegateModel)

480 m_delegateModel->componentComplete();

481

482 QQuickFlickable::componentComplete();

483

484 polish();

485}

486

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

488{

489 // Check we are not being taken down and don't paint anything

490 // TODO Check if we still need this in 5.2

491 // For reproduction just inifnite loop testDash or testDashContent

492 if (!QQmlEngine::contextForObject(this)->parentContext())

493 return;

494

495 QQuickFlickable::viewportMoved(orient);

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

497 qreal diff = m_previousContentY - contentY();

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

499 if (m_headerItem) {

500 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

501 if (contentY() < -m_minYExtent) {

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

503 m_headerItem->setY(contentY());

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

505 } else {

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

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

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

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

510 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

514

515 if (!scrolledUp && (contentY() == -m_minYExtent || (m_headerItemShownHeight == 0 && m_previousContentY == m_headerItem->y()))) {

516 m_headerItemShownHeight = 0;

517 m_headerItem->setY(-m_minYExtent);

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

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

520 m_headerItemShownHeight -= diff;

521 else

522 m_headerItemShownHeight += diff;

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

524 m_headerItemShownHeight = 0;

525 } else {

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

527 }

528 if (m_headerItemShownHeight > 0) {

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

530 } else {

531 m_headerItem->setY(-m_minYExtent);

532 }

533 }

534 }

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

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

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

538 if (!showHeaderAnimationRunning) {

539 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

540 } else {

541 diff = -diff;

542 }

543 }

544 if (!m_visibleItems.isEmpty()) {

545 updateClipItem();

546 ListItem *firstItem = m_visibleItems.first();

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

548 if (showHeaderAnimationRunning) {

549 adjustMinYExtent();

550 }

551 }

552

553 m_previousContentY = contentY();

554 layout();

555 polish();

556}

557

558void ListViewWithPageHeader::createDelegateModel()

559{

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

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

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

563#else

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

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

566#endif

567 if (isComponentComplete())

568 m_delegateModel->componentComplete();

569 updateWatchedRoles();

570}

571

572void ListViewWithPageHeader::refill()

573{

574 if (m_inLayout) {

575 return;

576 }

577 if (!isComponentComplete()) {

578 return;

579 }

580

581 const qreal buffer = height() * bufferRatio;

582 const qreal from = contentY();

583 const qreal to = from + height();

584 const qreal bufferFrom = from - buffer;

585 const qreal bufferTo = to + buffer;

586

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

588 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

590

591 if (added || removed) {

592 m_contentHeightDirty = true;

593 }

594}

595

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

597{

598 if (!delegate())

599 return false;

600

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

602 return false;

603

604 ListItem *item;

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

606

607 int modelIndex = 0;

608 qreal pos = 0;

609 if (!m_visibleItems.isEmpty()) {

610 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

611 item = m_visibleItems.last();

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

613 }

614 bool changed = false;

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

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

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

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

619 break;

620 pos += item->height();

621 ++modelIndex;

622 changed = true;

623 }

624

625 modelIndex = 0;

626 pos = 0;

627 if (!m_visibleItems.isEmpty()) {

628 modelIndex = m_firstVisibleIndex - 1;

629 item = m_visibleItems.first();

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

631 }

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

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

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

635 break;

636 pos -= item->height();

637 --modelIndex;

638 changed = true;

639 }

640

641 return changed;

642}

643

644void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

645{

646 QQuickItem *item = listItem->m_item;

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

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

649 if (flags & QQuickVisualModel::Destroyed) {

650#else

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

652 if (flags & QQmlDelegateModel::Destroyed) {

653#endif

654 item->setParentItem(nullptr);

655 }

656 delete listItem->m_sectionItem;

657 delete listItem;

658}

659

660void ListViewWithPageHeader::releaseItem(ListItem *listItem)

661{

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

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

664 m_itemsToRelease << listItem;

665}

666

667void ListViewWithPageHeader::updateWatchedRoles()

668{

669 if (m_delegateModel) {

670 QList<QByteArray> roles;

671 if (!m_sectionProperty.isEmpty())

672 roles << m_sectionProperty.toUtf8();

673 m_delegateModel->setWatchedRoles(roles);

674 }

675}

676

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

678{

679 if (!m_sectionDelegate)

680 return nullptr;

681

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

683 if (modelIndex > 0) {

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

685 if (section == prevSection)

686 return nullptr;

687 }

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

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

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

691 if (section == nextSection) {

692 // Steal the section header

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

694 if (nextItem) {

695 QQuickItem *sectionItem = nextItem->m_sectionItem;

696 nextItem->m_sectionItem = nullptr;

697 return sectionItem;

698 }

699 }

700 }

701

702 return getSectionItem(section);

703}

704

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

706{

707 QQuickItem *sectionItem = nullptr;

708

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

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

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

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

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

714 if (nobj) {

715 QQml_setParent_noEvent(context, nobj);

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

717 if (!sectionItem) {

718 delete nobj;

719 } else {

720 sectionItem->setZ(2);

721 QQml_setParent_noEvent(sectionItem, m_clipItem);

722 sectionItem->setParentItem(m_clipItem);

723 }

724 } else {

725 delete context;

726 }

727 m_sectionDelegate->completeCreate();

728

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

730

731 return sectionItem;

732}

733

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

735{

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

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

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

739 if (contentY() < -m_minYExtent) {

740 return false;

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

742 return false;

743 }

744 bool changed = false;

745

746 bool foundVisible = false;

747 int i = 0;

748 int removedItems = 0;

749 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

751 ListItem *item = m_visibleItems[i];

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

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

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

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

756 releaseItem(item);

757 m_visibleItems.removeAt(i);

758 changed = true;

759 ++removedItems;

760 } else {

761 if (!foundVisible) {

762 foundVisible = true;

763 const int itemIndex = m_firstVisibleIndex + removedItems + i;

764 m_firstVisibleIndex = itemIndex;

765 }

766 ++i;

767 }

768 }

769 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

770 adjustMinYExtent();

771 }

772

773 return changed;

774}

775

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

777{

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

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

780 return nullptr;

781

782 m_asyncRequestedIndex = -1;

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

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

785#else

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

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

788#endif

789 if (!item) {

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

791 m_asyncRequestedIndex = modelIndex;

792#else

793 if (object) {

794 m_delegateModel->release(object);

795 if (!m_delegateValidated) {

796 m_delegateValidated = true;

797 QObject* delegateObj = delegate();

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

799 }

800 } else {

801 m_asyncRequestedIndex = modelIndex;

802 }

803#endif

804 return 0;

805 } else {

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

807 ListItem *listItem = new ListItem;

808 listItem->m_item = item;

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

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

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

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

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

814 // nor is the first item

815 if (prevItem) {

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

817 } else {

818 ListItem *currItem = itemAtIndex(modelIndex);

819 if (currItem) {

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

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

822 } else {

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

824 if (nextItem) {

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

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

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

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

829 lostItem = true;

830 }

831 }

832 }

833 if (lostItem) {

834 releaseItem(listItem);

835 listItem = nullptr;

836 } else {

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

838 if (m_visibleItems.isEmpty()) {

839 m_visibleItems << listItem;

840 } else {

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

842 }

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

844 m_firstVisibleIndex = modelIndex;

845 polish();

846 }

847 if (listItem->m_sectionItem) {

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

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

850 }

851 adjustMinYExtent();

852 m_contentHeightDirty = true;

853 }

854 return listItem;

855 }

856}

857

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

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

860{

861#else

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

863{

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

865 if (!item) {

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

867 return;

868 }

869#endif

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

871 // Check we are not being taken down and don't paint anything

872 // TODO Check if we still need this in 5.2

873 // For reproduction just inifnite loop testDash or testDashContent

874 if (!QQmlEngine::contextForObject(this)->parentContext())

875 return;

876

877 item->setParentItem(m_clipItem);

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

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

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

881 if (modelIndex == m_asyncRequestedIndex) {

882 createItem(modelIndex, false);

883 refill();

884 }

885}

886

887void ListViewWithPageHeader::updateClipItem()

888{

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

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

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

892}

893

894void ListViewWithPageHeader::onContentHeightChanged()

895{

896 updateClipItem();

897}

898

899void ListViewWithPageHeader::onContentWidthChanged()

900{

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

902}

903

904void ListViewWithPageHeader::onHeightChanged()

905{

906 polish();

907}

908

909

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

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

912#else

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

914#endif

915{

916 // TODO Do something with reset

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

918 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

919

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

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

922#else

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

924#endif

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

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

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

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

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

930 bool growDown = true;

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

932 const int modelIndex = remove.index + i;

933 ListItem *item = itemAtIndex(modelIndex);

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

935 growDown = false;

936 }

937 }

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

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

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

941 ListItem *item = m_visibleItems[visibleIndex];

942 // Pass the section item down if needed

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

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

945 if (!nextItem->m_sectionItem) {

946 nextItem->m_sectionItem = item->m_sectionItem;

947 item->m_sectionItem = nullptr;

948 }

949 }

950 releaseItem(item);

951 m_visibleItems.removeAt(visibleIndex);

952 }

953 }

954 if (growDown) {

955 adjustMinYExtent();

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

957 if (!m_visibleItems.isEmpty()) {

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

959 // position the new first item correctly

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

961 } else {

962 m_firstVisibleIndex = -1;

963 }

964 }

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

966 m_firstVisibleIndex -= remove.count;

967 }

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

969 const int modelIndex = remove.index + i;

970 if (modelIndex == m_asyncRequestedIndex) {

971 m_asyncRequestedIndex = -1;

972 } else if (modelIndex < m_asyncRequestedIndex) {

973 m_asyncRequestedIndex--;

974 }

975 }

976 }

977

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

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

980#else

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

982#endif

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

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

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

986 if (insertingInValidIndexes || firstItemWithViewOnTop)

987 {

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

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

990 bool growUp = false;

991 if (!firstItemWithViewOnTop) {

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

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

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

995 growUp = true;

996 }

997 break;

998 }

999 }

1000 }

1001

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

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

1004 const int modelIndex = insert.index + i;

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

1006 if (growUp) {

1007 ListItem *firstItem = m_visibleItems.first();

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

1009 }

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

1011 // if we need adding a new section item

1012 if (m_sectionDelegate) {

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

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

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

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

1017 ListItem *firstItem = m_visibleItems.first();

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

1019 }

1020 }

1021 }

1022 }

1023 if (firstItemWithViewOnTop) {

1024 ListItem *firstItem = m_visibleItems.first();

1025 firstItem->setY(oldFirstValidIndexPos);

1026 }

1027 adjustMinYExtent();

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

1029 m_firstVisibleIndex += insert.count;

1030 }

1031

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

1033 const int modelIndex = insert.index + i;

1034 if (modelIndex <= m_asyncRequestedIndex) {

1035 m_asyncRequestedIndex++;

1036 }

1037 }

1038 }

1039

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

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

1042#else

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

1044#endif

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

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

1047 ListItem *item = itemAtIndex(i);

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

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

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

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

1052 }

1053 }

1054 }

1055

1056 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1057 adjustMinYExtent();

1058 }

1059

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

1061 ListItem *item = m_visibleItems[i];

1062 if (item->m_sectionItem) {

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

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

1065 }

1066 }

1067

1068 layout();

1069 polish();

1070 m_contentHeightDirty = true;

1071}

1072

1073void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1074{

1075 m_contentHeightDirty = true;

1076 polish();

1077}

1078

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

1080{

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

1082 if (heightDiff != 0) {

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

1084 ListItem *firstItem = m_visibleItems.first();

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

1086 adjustMinYExtent();

1087 layout();

1088 }

1089 refill();

1090 adjustMinYExtent();

1091 polish();

1092 m_contentHeightDirty = true;

1093 }

1094}

1095

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

1097{

1098 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1099 if (m_headerItemShownHeight > 0) {

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

1101 // Change its size

1102 m_headerItemShownHeight += heightDiff;

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

1104 updateClipItem();

1105 adjustMinYExtent();

1106 } else {

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

1108 // If the header is shown because its position

1109 // Change its size

1110 ListItem *firstItem = m_visibleItems.first();

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

1112 layout();

1113 } else {

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

1115 // so the viewport is not changed

1116 adjustMinYExtent();

1117 }

1118 }

1119}

1120

1121

1122void ListViewWithPageHeader::adjustMinYExtent()

1123{

1124 if (m_visibleItems.isEmpty()) {

1125 m_minYExtent = 0;

1126 } else {

1127 qreal nonCreatedHeight = 0;

1128 if (m_firstVisibleIndex != 0) {

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

1130 const int visibleItems = m_visibleItems.count();

1131 qreal visibleItemsHeight = 0;

1132 Q_FOREACH(ListItem *item, m_visibleItems) {

1133 visibleItemsHeight += item->height();

1134 }

1135 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1137 }

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

1139 }

1140}

1141

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

1143{

1144 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1146 return m_visibleItems[visibleIndexedModelIndex];

1147

1148 return nullptr;

1149}

1150

1151void ListViewWithPageHeader::layout()

1152{

1153 if (m_inLayout)

1154 return;

1155

1156 m_inLayout = true;

1157 if (!m_visibleItems.isEmpty()) {

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

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

1160

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

1162

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

1164 int firstReallyVisibleItem = -1;

1165 int modelIndex = m_firstVisibleIndex;

1166 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1168 item->setCulled(cull);

1169 item->setY(pos);

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

1171 firstReallyVisibleItem = modelIndex;

1172 if (m_topSectionItem) {

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

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

1175 // or stick it to the top

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

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

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

1179 bool showStickySectionItem;

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

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

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

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

1184 if (topSectionStickPos > pos) {

1185 showStickySectionItem = true;

1186 } else if (topSectionStickPos == pos) {

1187 showStickySectionItem = !item->m_sectionItem;

1188 } else {

1189 showStickySectionItem = false;

1190 }

1191 if (!showStickySectionItem) {

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

1193 if (item->m_sectionItem) {

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

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

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

1197 // gets shown shortly in the next polish call

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

1199 }

1200 } else {

1201 // Update the top sticky section header

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

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

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

1205

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

1207 m_topSectionItem->setY(topSectionStickPos);

1208 int delegateIndex = modelIndex;

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

1210 while (delegateIndex > 0) {

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

1212 if (prevSection != section)

1213 break;

1214 delegateIndex--;

1215 }

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

1217 if (item->m_sectionItem) {

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

1219 }

1220 }

1221 }

1222 }

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

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

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

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

1227 } else {

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

1229 }

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

1231 pos += item->height();

1232 ++modelIndex;

1233 }

1234

1235 // Second step of section sticky item positioning

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

1237 if (m_topSectionItem) {

1238 if (firstReallyVisibleItem >= 0) {

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

1240 ListItem *item = m_visibleItems[i];

1241 if (item->m_sectionItem) {

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

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

1244 }

1245 break;

1246 }

1247 }

1248 }

1249 }

1250 }

1251 m_inLayout = false;

1252}

1253

1254void ListViewWithPageHeader::updatePolish()

1255{

1256 // Check we are not being taken down and don't paint anything

1257 // TODO Check if we still need this in 5.2

1258 // For reproduction just inifnite loop testDash or testDashContent

1259 if (!QQmlEngine::contextForObject(this)->parentContext())

1260 return;

1261

1262 Q_FOREACH(ListItem *item, m_itemsToRelease)

1263 reallyReleaseItem(item);

1264 m_itemsToRelease.clear();

1265

1266 if (!model())

1267 return;

1268

1269 layout();

1270

1271 refill();

1272

1273 if (m_contentHeightDirty) {

1274 qreal contentHeight;

1275 if (m_visibleItems.isEmpty()) {

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

1277 } else {

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

1279 const int visibleItems = m_visibleItems.count();

1280 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1281 qreal nonCreatedHeight = 0;

1282 if (lastValidIndex != modelCount - 1) {

1283 const int visibleItems = m_visibleItems.count();

1284 qreal visibleItemsHeight = 0;

1285 Q_FOREACH(ListItem *item, m_visibleItems) {

1286 visibleItemsHeight += item->height();

1287 }

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

1289 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1290 }

1291 ListItem *item = m_visibleItems.last();

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

1293 if (m_firstVisibleIndex != 0) {

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

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

1296 }

1297 }

1298

1299 m_contentHeightDirty = false;

1300 adjustMinYExtent();

1301 m_inContentHeightKeepHeaderShown = m_headerItem && m_headerItem->y() == contentY();

1302 setContentHeight(contentHeight);

1303 m_inContentHeightKeepHeaderShown = false;

1304 }

1305}

1306

1307#include "moc_listviewwithpageheader.cpp"