plugins/Dash/listviewwithpageheader.cpp · unity8

492 (m_topSectionItem && !listItem->sectionItem() && listItemY - m_topSectionItem->height() < contentY() && listItemY + listItemHeight < contentY() + height()))

493 {

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

495 auto realVisibleListItemY = listItemY;

496 if (m_topSectionItem) {

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

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

499 // the top section sticky item

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

501 if (topSectionShown && !listItem->sectionItem()) {

502 realVisibleListItemY -= m_topSectionItem->height();

503 }

504 }

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

506 m_contentYAnimation->setTo(to);

507 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

508 m_contentYAnimation->start();

509 }

510 return true;

511 }

512 return false;

513}

514

515qreal ListViewWithPageHeader::minYExtent() const

516{

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

518 return m_minYExtent;

519}

520

521qreal ListViewWithPageHeader::maxYExtent() const

522{

523 return height() - contentHeight();

524}

525

526void ListViewWithPageHeader::componentComplete()

527{

528 if (m_delegateModel)

529 m_delegateModel->componentComplete();

530

531 QQuickFlickable::componentComplete();

532

533 polish();

534}

535

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

537{

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

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

540 // For reproduction just inifnite loop testDash or testDashContent

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

542 return;

543

544 QQuickFlickable::viewportMoved(orient);

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

546 const qreal diff = m_previousContentY - contentY();

547 adjustHeader(diff);

548 m_previousContentY = contentY();

549 layout();

550 polish();

551}

552

553void ListViewWithPageHeader::adjustHeader(qreal diff)

554{

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

556 if (m_headerItem) {

557 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

558 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {

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

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

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

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

563 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

567

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

569 m_headerItemShownHeight = 0;

570 m_headerItem->setY(-m_minYExtent);

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

572 if (maximizeVisibleAreaRunning && diff > 0) {

573 // If we are maximizing and the header was shown, make sure we hide it

574 m_headerItemShownHeight -= diff;

575 } else {

576 m_headerItemShownHeight += diff;

577 }

578 if (uFuzzyCompare(contentY(), -m_minYExtent)) {

579 m_headerItemShownHeight = 0;

580 } else {

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

582 }

583 if (m_headerItemShownHeight > 0) {

584 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {

585 m_headerItem->setY(contentY());

586 m_headerItemShownHeight = m_headerItem->height();

587 } else {

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

589 }

590 } else {

591 m_headerItem->setY(-m_minYExtent);

592 }

593 }

594 Q_EMIT headerItemShownHeightChanged();

595 } else {

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

597 m_headerItem->setY(contentY());

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

599 }

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

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

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

603 if (!showHeaderAnimationRunning) {

604 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

605 } else {

606 diff = -diff;

607 }

608 }

609 if (!m_visibleItems.isEmpty()) {

610 updateClipItem();

611 ListItem *firstItem = m_visibleItems.first();

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

613 if (showHeaderAnimationRunning) {

614 adjustMinYExtent();

615 }

616 }

617}

618

619void ListViewWithPageHeader::createDelegateModel()

620{

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

622 connect(m_delegateModel, &QQmlDelegateModel::createdItem, this, &ListViewWithPageHeader::itemCreated);

623 if (isComponentComplete())

624 m_delegateModel->componentComplete();

625 updateWatchedRoles();

626}

627

628void ListViewWithPageHeader::refill()

629{

630 if (m_inLayout) {

631 return;

632 }

633 if (!isComponentComplete()) {

634 return;

635 }

636

637 const qreal from = contentY();

638 const qreal to = from + height();

639 const qreal bufferFrom = from - m_cacheBuffer;

640 const qreal bufferTo = to + m_cacheBuffer;

641

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

643 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

645

646 if (added || removed) {

647 m_contentHeightDirty = true;

648 }

649}

650

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

652{

653 if (!delegate())

654 return false;

655

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

657 return false;

658

659 ListItem *item;

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

661

662 int modelIndex = 0;

663 qreal pos = 0;

664 if (!m_visibleItems.isEmpty()) {

665 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

666 item = m_visibleItems.last();

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

668 }

669 bool changed = false;

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

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

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

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

674 break;

675 pos += item->height();

676 ++modelIndex;

677 changed = true;

678 }

679

680 modelIndex = 0;

681 pos = 0;

682 if (!m_visibleItems.isEmpty()) {

683 modelIndex = m_firstVisibleIndex - 1;

684 item = m_visibleItems.first();

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

686 }

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

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

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

690 break;

691 pos -= item->height();

692 --modelIndex;

693 changed = true;

694 }

695

696 return changed;

697}

698

699void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

700{

701 QQuickItem *item = listItem->m_item;

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

703 if (flags & QQmlDelegateModel::Destroyed) {

704 item->setParentItem(nullptr);

705 }

706 listItem->sectionItem()->deleteLater();

707 delete listItem;

708}

709

710void ListViewWithPageHeader::releaseItem(ListItem *listItem)

711{

712 QQuickItemPrivate::get(listItem->m_item)->removeItemChangeListener(this, QQuickItemPrivate::Geometry);

713 if (listItem->sectionItem()) {

714 QQuickItemPrivate::get(listItem->sectionItem())->removeItemChangeListener(this, QQuickItemPrivate::Geometry);

715 }

716 m_itemsToRelease << listItem;

717}

718

719void ListViewWithPageHeader::updateWatchedRoles()

720{

721 if (m_delegateModel) {

722 QList<QByteArray> roles;

723 if (!m_sectionProperty.isEmpty())

724 roles << m_sectionProperty.toUtf8();

725 m_delegateModel->setWatchedRoles(roles);

726 }

727}

728

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

730{

731 if (!m_sectionDelegate)

732 return nullptr;

733

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

735

736 if (modelIndex > 0) {

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

738 if (section == prevSection)

739 return nullptr;

740 }

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

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

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

744 if (section == nextSection) {

745 // Steal the section header

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

747 if (nextItem) {

748 QQuickItem *sectionItem = nextItem->sectionItem();

749 nextItem->setSectionItem(nullptr);

750 return sectionItem;

751 }

752 }

753 }

754

755 return getSectionItem(section);

756}

757

758QQuickItem *ListViewWithPageHeader::getSectionItem(const QString &sectionText, bool watchGeometry)

759{

760 QQuickItem *sectionItem = nullptr;

761

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

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

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

765 if (nobj) {

766 QQml_setParent_noEvent(context, nobj);

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

768 if (!sectionItem) {

769 delete nobj;

770 } else {

771 sectionItem->setProperty("text", sectionText);

772 sectionItem->setProperty("delegateIndex", -1);

773 sectionItem->setZ(2);

774 QQml_setParent_noEvent(sectionItem, m_clipItem);

775 sectionItem->setParentItem(m_clipItem);

776 }

777 } else {

778 delete context;

779 }

780 m_sectionDelegate->completeCreate();

781

782 if (watchGeometry && sectionItem) {

783 QQuickItemPrivate::get(sectionItem)->addItemChangeListener(this, QQuickItemPrivate::Geometry);

784 }

785

786 return sectionItem;

787}

788

789void ListViewWithPageHeader::updateSectionItem(int modelIndex)

790{

791 ListItem *item = itemAtIndex(modelIndex);

792 if (item) {

793 const QString sectionText = m_delegateModel->stringValue(modelIndex, m_sectionProperty);

794

795 bool needSectionHeader = true;

796 // if it is the same section as the previous item need to drop the section

797 if (modelIndex > 0) {

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

799 if (sectionText == prevSection) {

800 needSectionHeader = false;

801 }

802 }

803

804 if (needSectionHeader) {

805 if (!item->sectionItem()) {

806 item->setSectionItem(getSectionItem(sectionText));

807 } else {

808 item->sectionItem()->setProperty("text", sectionText);

809 }

810 } else {

811 if (item->sectionItem()) {

812 item->sectionItem()->deleteLater();

813 item->setSectionItem(nullptr);

814 }

815 }

816 }

817}

818

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

820{

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

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

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

824 if (contentY() < -m_minYExtent) {

825 return false;

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

827 return false;

828 }

829 bool changed = false;

830

831 bool foundVisible = false;

832 int i = 0;

833 int removedItems = 0;

834 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

836 ListItem *item = m_visibleItems[i];

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

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

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

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

841 releaseItem(item);

842 m_visibleItems.removeAt(i);

843 changed = true;

844 ++removedItems;

845 } else {

846 if (!foundVisible) {

847 foundVisible = true;

848 const int itemIndex = m_firstVisibleIndex + removedItems + i;

849 m_firstVisibleIndex = itemIndex;

850 }

851 ++i;

852 }

853 }

854 if (!foundVisible) {

855 initializeValuesForEmptyList();

856 }

857 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

858 adjustMinYExtent();

859 }

860

861 return changed;

862}

863

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

865{

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

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

868 return nullptr;

869

870 m_asyncRequestedIndex = -1;

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

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

873 if (!item) {

874 if (object) {

875 m_delegateModel->release(object);

876 if (!m_delegateValidated) {

877 m_delegateValidated = true;

878 QObject* delegateObj = delegate();

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

880 }

881 } else {

882 m_asyncRequestedIndex = modelIndex;

883 }

884 return 0;

885 } else {

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

887 ListItem *listItem = new ListItem;

888 listItem->m_item = item;

889 listItem->setSectionItem(getSectionItem(modelIndex, false /*Not yet inserted into m_visibleItems*/));

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

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

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

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

894 // nor is the first item

895 if (prevItem) {

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

897 } else {

898 ListItem *currItem = itemAtIndex(modelIndex);

899 if (currItem) {

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

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

902 } else {

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

904 if (nextItem) {

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

906 } else if (modelIndex == 0) {

907 listItem->setY(-m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0));

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

909 lostItem = true;

910 }

911 }

912 }

913 if (lostItem) {

914 listItem->setCulled(true);

915 releaseItem(listItem);

916 listItem = nullptr;

917 } else {

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

919 if (m_visibleItems.isEmpty()) {

920 m_visibleItems << listItem;

921 } else {

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

923 }

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

925 m_firstVisibleIndex = modelIndex;

926 polish();

927 }

928 if (listItem->sectionItem()) {

929 listItem->sectionItem()->setProperty("delegateIndex", modelIndex);

930 }

931 adjustMinYExtent();

932 m_contentHeightDirty = true;

933 }

934 return listItem;

935 }

936}

937

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

939{

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

941 if (!item) {

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

943 return;

944 }

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

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

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

948 // For reproduction just inifnite loop testDash or testDashContent

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

950 return;

951

952 item->setParentItem(m_clipItem);

953 // FIXME Why do we need the refreshExpressions call?

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

955 QQmlContextPrivate::get(context)->data->refreshExpressions();

956 item->setProperty("heightToClip", QVariant::fromValue<int>(0));

957 if (modelIndex == m_asyncRequestedIndex) {

958 createItem(modelIndex, false);

959 refill();

960 }

961}

962

963void ListViewWithPageHeader::updateClipItem()

964{

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

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

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

968}

969

970void ListViewWithPageHeader::onContentHeightChanged()

971{

972 updateClipItem();

973}

974

975void ListViewWithPageHeader::onContentWidthChanged()

976{

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

978}

979

980void ListViewWithPageHeader::onHeightChanged()

981{

982 polish();

983}

984

985

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

987{

988 // TODO Do something with reset

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

990 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

991

992 Q_FOREACH(const QQmlChangeSet::Change remove, changeSet.removes()) {

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

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

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

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

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

998 bool growDown = true;

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

1000 const int modelIndex = remove.index + i;

1001 ListItem *item = itemAtIndex(modelIndex);

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

1003 growDown = false;

1004 }

1005 }

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

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

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

1009 ListItem *item = m_visibleItems[visibleIndex];

1010 // Pass the section item down if needed

1011 if (item->sectionItem() && visibleIndex + 1 < m_visibleItems.count()) {

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

1013 if (!nextItem->sectionItem()) {

1014 nextItem->setSectionItem(item->sectionItem());

1015 item->setSectionItem(nullptr);

1016 }

1017 }

1018 releaseItem(item);

1019 m_visibleItems.removeAt(visibleIndex);

1020 }

1021 }

1022 if (growDown) {

1023 adjustMinYExtent();

1024 } else if (remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {

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

1026 }

1027 if (m_visibleItems.isEmpty()) {

1028 m_firstVisibleIndex = -1;

1029 } else {

1030 m_firstVisibleIndex -= qMax(0, m_firstVisibleIndex - remove.index);

1031 }

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

1033 m_firstVisibleIndex -= remove.count;

1034 }

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

1036 const int modelIndex = remove.index + i;

1037 if (modelIndex == m_asyncRequestedIndex) {

1038 m_asyncRequestedIndex = -1;

1039 } else if (modelIndex < m_asyncRequestedIndex) {

1040 m_asyncRequestedIndex--;

1041 }

1042 }

1043 }

1044

1045 Q_FOREACH(const QQmlChangeSet::Change insert, changeSet.inserts()) {

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

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

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

1049 if (insertingInValidIndexes || firstItemWithViewOnTop)

1050 {

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

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

1053 bool growUp = false;

1054 if (!firstItemWithViewOnTop) {

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

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

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

1058 growUp = true;

1059 }

1060 break;

1061 }

1062 }

1063 }

1064

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

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

1067 const int modelIndex = insert.index + i;

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

1069 if (growUp) {

1070 ListItem *firstItem = m_visibleItems.first();

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

1072 }

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

1074 // if we need adding a new section item

1075 if (m_sectionDelegate) {

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

1077 if (nextItem && !nextItem->sectionItem()) {

1078 nextItem->setSectionItem(getSectionItem(modelIndex + 1, true /* alredy inserted into m_visibleItems*/));

1079 if (growUp && nextItem->sectionItem()) {

1080 ListItem *firstItem = m_visibleItems.first();

1081 firstItem->setY(firstItem->y() - nextItem->sectionItem()->height());

1082 }

1083 }

1084 }

1085 }

1086 if (firstItemWithViewOnTop) {

1087 ListItem *firstItem = m_visibleItems.first();

1088 firstItem->setY(oldFirstValidIndexPos);

1089 }

1090 adjustMinYExtent();

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

1092 m_firstVisibleIndex += insert.count;

1093 }

1094

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

1096 const int modelIndex = insert.index + i;

1097 if (modelIndex <= m_asyncRequestedIndex) {

1098 m_asyncRequestedIndex++;

1099 }

1100 }

1101 }

1102

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

1104 for (int i = change.start(); i < change.end(); ++i) {

1105 updateSectionItem(i);

1106 }

1107 // Also update the section header for the next item after the change since it may be influenced

1108 updateSectionItem(change.end());

1109 }

1110

1111 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1112 if (m_visibleItems.isEmpty()) {

1113 initializeValuesForEmptyList();

1114 } else {

1115 adjustMinYExtent();

1116 }

1117 }

1118

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

1120 ListItem *item = m_visibleItems[i];

1121 if (item->sectionItem()) {

1122 item->sectionItem()->setProperty("delegateIndex", m_firstVisibleIndex + i);

1123 }

1124 }

1125

1126 layout();

1127 polish();

1128 m_contentHeightDirty = true;

1129}

1130

1131void ListViewWithPageHeader::contentYAnimationRunningChanged(bool running)

1132{

1133 setInteractive(!running);

1134 if (!running) {

1135 m_contentHeightDirty = true;

1136 polish();

1137 }

1138}

1139

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

1141{

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

1143 if (heightDiff != 0) {

1144 if (!m_visibleItems.isEmpty()) {

1145 ListItem *firstItem = m_visibleItems.first();

1146 const auto prevFirstItemY = firstItem->y();

1147 if (!m_inContentHeightKeepHeaderShown && oldGeometry.y() + oldGeometry.height() + m_clipItem->y() <= contentY()) {

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

1149 } else if (item == firstItem->sectionItem()) {

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

1151 }

1152

1153 if (firstItem->y() != prevFirstItemY) {

1154 adjustMinYExtent();

1155 layout();

1156 }

1157 }

1158 refill();

1159 adjustMinYExtent();

1160 polish();

1161 m_contentHeightDirty = true;

1162 }

1163}

1164

1165void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)

1166{

1167 if (item == m_headerItem) {

1168 const qreal diff = m_headerItem->implicitHeight() - m_previousHeaderImplicitHeight;

1169 if (diff != 0) {

1170 adjustHeader(diff);

1171 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();

1172 layout();

1173 polish();

1174 m_contentHeightDirty = true;

1175 }

1176 }

1177}

1178

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

1180{

1181 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1182 if (m_headerItemShownHeight > 0) {

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

1184 // Change its size

1185 m_headerItemShownHeight += heightDiff;

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

1187 updateClipItem();

1188 adjustMinYExtent();

1189 Q_EMIT headerItemShownHeightChanged();

1190 } else {

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

1192 // If the header is shown because its position

1193 // Change its size

1194 ListItem *firstItem = m_visibleItems.first();

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

1196 layout();

1197 } else {

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

1199 // so the viewport is not changed

1200 adjustMinYExtent();

1201 }

1202 }

1203}

1204

1205

1206void ListViewWithPageHeader::adjustMinYExtent()

1207{

1208 if (m_visibleItems.isEmpty() || (contentHeight() + m_minYExtent < height())) {

1209 m_minYExtent = 0;

1210 } else {

1211 qreal nonCreatedHeight = 0;

1212 if (m_firstVisibleIndex != 0) {

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

1214 const int visibleItems = m_visibleItems.count();

1215 qreal visibleItemsHeight = 0;

1216 Q_FOREACH(ListItem *item, m_visibleItems) {

1217 visibleItemsHeight += item->height();

1218 }

1219 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1221 }

1222 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);

1223 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;

1224 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {

1225 m_minYExtent = 0;

1226 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);

1227 }

1228 }

1229}

1230

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

1232{

1233 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1235 return m_visibleItems[visibleIndexedModelIndex];

1236

1237 return nullptr;

1238}

1239

1240void ListViewWithPageHeader::layout()

1241{

1242 if (m_inLayout)

1243 return;

1244

1245 m_inLayout = true;

1246 if (!m_visibleItems.isEmpty()) {

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

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

1249

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

1251

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

1253 int firstReallyVisibleItem = -1;

1254 int modelIndex = m_firstVisibleIndex;

1255 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1257 item->setCulled(cull);

1258 item->setY(pos);

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

1260 firstReallyVisibleItem = modelIndex;

1261 if (m_topSectionItem) {

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

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

1264 // or stick it to the top

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

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

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

1268 bool showStickySectionItem;

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

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

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

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

1273 if (topSectionStickPos > pos) {

1274 showStickySectionItem = true;

1275 } else if (topSectionStickPos == pos) {

1276 showStickySectionItem = !item->sectionItem();

1277 } else {

1278 showStickySectionItem = false;

1279 }

1280 if (!showStickySectionItem) {

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

1282 if (item->sectionItem()) {

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

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

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

1286 // gets shown shortly in the next polish call

1287 QQuickItemPrivate::get(item->sectionItem())->setCulled(false);

1288 }

1289 } else {

1290 // Update the top sticky section header

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

1292 m_topSectionItem->setProperty("text", section);

1293

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

1295 m_topSectionItem->setY(topSectionStickPos);

1296 int delegateIndex = modelIndex;

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

1298 while (delegateIndex > 0) {

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

1300 if (prevSection != section)

1301 break;

1302 delegateIndex--;

1303 }

1304 m_topSectionItem->setProperty("delegateIndex", delegateIndex);

1305 if (item->sectionItem()) {

1306 QQuickItemPrivate::get(item->sectionItem())->setCulled(true);

1307 }

1308 }

1309 }

1310 }

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

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

1313 item->m_item->setProperty("heightToClip", clipFrom - pos);

1314 } else {

1315 item->m_item->setProperty("heightToClip", QVariant::fromValue<int>(0));

1316 }

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

1318 pos += item->height();

1319 ++modelIndex;

1320 }

1321

1322 // Second step of section sticky item positioning

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

1324 if (m_topSectionItem) {

1325 if (firstReallyVisibleItem >= 0) {

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

1327 ListItem *item = m_visibleItems[i];

1328 if (item->sectionItem()) {

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

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

1331 }

1332 break;

1333 }

1334 }

1335 }

1336 }

1337 }

1338 if (m_headerItem) {

1339 const bool cullHeader = m_headerItem->y() + m_headerItem->height() < contentY();

1340 QQuickItemPrivate::get(m_headerItem)->setCulled(cullHeader);

1341 }

1342 m_inLayout = false;

1343}

1344

1345void ListViewWithPageHeader::updatePolish()

1346{

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

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

1349 // For reproduction just inifnite loop testDash or testDashContent

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

1351 return;

1352

1353 Q_FOREACH(ListItem *item, m_itemsToRelease)

1354 reallyReleaseItem(item);

1355 m_itemsToRelease.clear();

1356

1357 if (!model())

1358 return;

1359

1360 layout();

1361

1362 refill();

1363

1364 if (m_contentHeightDirty) {

1365 qreal contentHeight;

1366 if (m_visibleItems.isEmpty()) {

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

1368 } else {

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

1370 const int visibleItems = m_visibleItems.count();

1371 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1372 qreal nonCreatedHeight = 0;

1373 if (lastValidIndex != modelCount - 1) {

1374 const int visibleItems = m_visibleItems.count();

1375 qreal visibleItemsHeight = 0;

1376 Q_FOREACH(ListItem *item, m_visibleItems) {

1377 visibleItemsHeight += item->height();

1378 }

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

1380 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1381 }

1382 ListItem *item = m_visibleItems.last();

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

1384 if (m_firstVisibleIndex != 0) {

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

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

1387 }

1388 }

1389

1390 m_contentHeightDirty = false;

1391 adjustMinYExtent();

1392 if (contentHeight + m_minYExtent < height()) {

1393 // need this since in the previous call to adjustMinYExtent contentHeight is not set yet

1394 m_minYExtent = 0;

1395 }

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

1397 setContentHeight(contentHeight);

1398 m_inContentHeightKeepHeaderShown = false;

1399 }

1400}

1401

1402#include "moc_listviewwithpageheader.cpp"