plugins/Dash/listviewwithpageheader.cpp · unity8

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

469 {

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

471 auto realVisibleListItemY = listItemY;

472 if (m_topSectionItem) {

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

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

475 // the top section sticky item

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

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

478 realVisibleListItemY -= m_topSectionItem->height();

479 }

480 }

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

482 m_contentYAnimation->setTo(to);

483 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

484 m_contentYAnimation->start();

485 }

486 return true;

487 }

488 return false;

489}

490

491qreal ListViewWithPageHeader::minYExtent() const

492{

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

494 return m_minYExtent;

495}

496

497void ListViewWithPageHeader::componentComplete()

498{

499 if (m_delegateModel)

500 m_delegateModel->componentComplete();

501

502 QQuickFlickable::componentComplete();

503

504 polish();

505}

506

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

508{

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

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

511 // For reproduction just inifnite loop testDash or testDashContent

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

513 return;

514

515 QQuickFlickable::viewportMoved(orient);

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

517 const qreal diff = m_previousContentY - contentY();

518 adjustHeader(diff);

519 m_previousContentY = contentY();

520 layout();

521 polish();

522}

523

524void ListViewWithPageHeader::adjustHeader(qreal diff)

525{

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

527 if (m_headerItem) {

528 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

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

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

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

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

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

534 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

538

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

540 m_headerItemShownHeight = 0;

541 m_headerItem->setY(-m_minYExtent);

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

543 if (maximizeVisibleAreaRunning && diff > 0) {

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

545 m_headerItemShownHeight -= diff;

546 } else {

547 m_headerItemShownHeight += diff;

548 }

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

550 m_headerItemShownHeight = 0;

551 } else {

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

553 }

554 if (m_headerItemShownHeight > 0) {

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

556 m_headerItem->setY(contentY());

557 m_headerItemShownHeight = m_headerItem->height();

558 } else {

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

560 }

561 } else {

562 m_headerItem->setY(-m_minYExtent);

563 }

564 }

565 Q_EMIT headerItemShownHeightChanged();

566 } else {

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

568 m_headerItem->setY(contentY());

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

570 }

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

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

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

574 if (!showHeaderAnimationRunning) {

575 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

576 } else {

577 diff = -diff;

578 }

579 }

580 if (!m_visibleItems.isEmpty()) {

581 updateClipItem();

582 ListItem *firstItem = m_visibleItems.first();

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

584 if (showHeaderAnimationRunning) {

585 adjustMinYExtent();

586 }

587 }

588}

589

590void ListViewWithPageHeader::createDelegateModel()

591{

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

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

594 if (isComponentComplete())

595 m_delegateModel->componentComplete();

596 updateWatchedRoles();

597}

598

599void ListViewWithPageHeader::refill()

600{

601 if (m_inLayout) {

602 return;

603 }

604 if (!isComponentComplete()) {

605 return;

606 }

607

608 const qreal from = contentY();

609 const qreal to = from + height();

610 const qreal bufferFrom = from - m_cacheBuffer;

611 const qreal bufferTo = to + m_cacheBuffer;

612

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

614 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

616

617 if (added || removed) {

618 m_contentHeightDirty = true;

619 }

620}

621

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

623{

624 if (!delegate())

625 return false;

626

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

628 return false;

629

630 ListItem *item;

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

632

633 int modelIndex = 0;

634 qreal pos = 0;

635 if (!m_visibleItems.isEmpty()) {

636 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

637 item = m_visibleItems.last();

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

639 }

640 bool changed = false;

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

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

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

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

645 break;

646 pos += item->height();

647 ++modelIndex;

648 changed = true;

649 }

650

651 modelIndex = 0;

652 pos = 0;

653 if (!m_visibleItems.isEmpty()) {

654 modelIndex = m_firstVisibleIndex - 1;

655 item = m_visibleItems.first();

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

657 }

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

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

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

661 break;

662 pos -= item->height();

663 --modelIndex;

664 changed = true;

665 }

666

667 return changed;

668}

669

670void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

671{

672 QQuickItem *item = listItem->m_item;

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

674 if (flags & QQmlDelegateModel::Destroyed) {

675 item->setParentItem(nullptr);

676 }

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

678 delete listItem;

679}

680

681void ListViewWithPageHeader::releaseItem(ListItem *listItem)

682{

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

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

685 m_itemsToRelease << listItem;

686}

687

688void ListViewWithPageHeader::updateWatchedRoles()

689{

690 if (m_delegateModel) {

691 QList<QByteArray> roles;

692 if (!m_sectionProperty.isEmpty())

693 roles << m_sectionProperty.toUtf8();

694 m_delegateModel->setWatchedRoles(roles);

695 }

696}

697

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

699{

700 if (!m_sectionDelegate)

701 return nullptr;

702

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

704

705 if (modelIndex > 0) {

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

707 if (section == prevSection)

708 return nullptr;

709 }

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

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

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

713 if (section == nextSection) {

714 // Steal the section header

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

716 if (nextItem) {

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

718 nextItem->setSectionItem(nullptr);

719 return sectionItem;

720 }

721 }

722 }

723

724 return getSectionItem(section);

725}

726

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

728{

729 QQuickItem *sectionItem = nullptr;

730

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

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

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

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

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

736 if (nobj) {

737 QQml_setParent_noEvent(context, nobj);

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

739 if (!sectionItem) {

740 delete nobj;

741 } else {

742 sectionItem->setZ(2);

743 QQml_setParent_noEvent(sectionItem, m_clipItem);

744 sectionItem->setParentItem(m_clipItem);

745 }

746 } else {

747 delete context;

748 }

749 m_sectionDelegate->completeCreate();

750

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

752

753 return sectionItem;

754}

755

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

757{

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

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

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

761 if (contentY() < -m_minYExtent) {

762 return false;

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

764 return false;

765 }

766 bool changed = false;

767

768 bool foundVisible = false;

769 int i = 0;

770 int removedItems = 0;

771 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

773 ListItem *item = m_visibleItems[i];

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

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

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

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

778 releaseItem(item);

779 m_visibleItems.removeAt(i);

780 changed = true;

781 ++removedItems;

782 } else {

783 if (!foundVisible) {

784 foundVisible = true;

785 const int itemIndex = m_firstVisibleIndex + removedItems + i;

786 m_firstVisibleIndex = itemIndex;

787 }

788 ++i;

789 }

790 }

791 if (!foundVisible) {

792 m_firstVisibleIndex = -1;

793 }

794 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

795 adjustMinYExtent();

796 }

797

798 return changed;

799}

800

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

802{

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

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

805 return nullptr;

806

807 m_asyncRequestedIndex = -1;

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

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

810 if (!item) {

811 if (object) {

812 m_delegateModel->release(object);

813 if (!m_delegateValidated) {

814 m_delegateValidated = true;

815 QObject* delegateObj = delegate();

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

817 }

818 } else {

819 m_asyncRequestedIndex = modelIndex;

820 }

821 return 0;

822 } else {

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

824 ListItem *listItem = new ListItem;

825 listItem->m_item = item;

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

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

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

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

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

831 // nor is the first item

832 if (prevItem) {

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

834 } else {

835 ListItem *currItem = itemAtIndex(modelIndex);

836 if (currItem) {

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

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

839 } else {

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

841 if (nextItem) {

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

843 } else if (modelIndex == 0) {

844 listItem->setY(m_headerItem ? m_headerItem->height() : 0);

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

846 lostItem = true;

847 }

848 }

849 }

850 if (lostItem) {

851 listItem->setCulled(true);

852 releaseItem(listItem);

853 listItem = nullptr;

854 } else {

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

856 if (m_visibleItems.isEmpty()) {

857 m_visibleItems << listItem;

858 } else {

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

860 }

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

862 m_firstVisibleIndex = modelIndex;

863 polish();

864 }

865 if (listItem->sectionItem()) {

866 QQmlContext *context = QQmlEngine::contextForObject(listItem->sectionItem())->parentContext();

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

868 }

869 adjustMinYExtent();

870 m_contentHeightDirty = true;

871 }

872 return listItem;

873 }

874}

875

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

877{

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

879 if (!item) {

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

881 return;

882 }

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

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

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

886 // For reproduction just inifnite loop testDash or testDashContent

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

888 return;

889

890 item->setParentItem(m_clipItem);

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

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

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

894 if (modelIndex == m_asyncRequestedIndex) {

895 createItem(modelIndex, false);

896 refill();

897 }

898}

899

900void ListViewWithPageHeader::updateClipItem()

901{

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

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

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

905}

906

907void ListViewWithPageHeader::onContentHeightChanged()

908{

909 updateClipItem();

910}

911

912void ListViewWithPageHeader::onContentWidthChanged()

913{

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

915}

916

917void ListViewWithPageHeader::onHeightChanged()

918{

919 polish();

920}

921

922

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

924{

925 // TODO Do something with reset

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

927 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

928

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

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

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

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

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

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

935 bool growDown = true;

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

937 const int modelIndex = remove.index + i;

938 ListItem *item = itemAtIndex(modelIndex);

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

940 growDown = false;

941 }

942 }

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

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

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

946 ListItem *item = m_visibleItems[visibleIndex];

947 // Pass the section item down if needed

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

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

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

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

952 item->setSectionItem(nullptr);

953 }

954 }

955 releaseItem(item);

956 m_visibleItems.removeAt(visibleIndex);

957 }

958 }

959 if (growDown) {

960 adjustMinYExtent();

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

962 if (!m_visibleItems.isEmpty()) {

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

964 // position the new first item correctly

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

966 } else {

967 m_firstVisibleIndex = -1;

968 }

969 }

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

971 m_firstVisibleIndex -= remove.count;

972 }

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

974 const int modelIndex = remove.index + i;

975 if (modelIndex == m_asyncRequestedIndex) {

976 m_asyncRequestedIndex = -1;

977 } else if (modelIndex < m_asyncRequestedIndex) {

978 m_asyncRequestedIndex--;

979 }

980 }

981 }

982

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

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

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

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

987 if (insertingInValidIndexes || firstItemWithViewOnTop)

988 {

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

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

991 bool growUp = false;

992 if (!firstItemWithViewOnTop) {

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

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

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

996 growUp = true;

997 }

998 break;

999 }

1000 }

1001 }

1002

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

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

1005 const int modelIndex = insert.index + i;

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

1007 if (growUp) {

1008 ListItem *firstItem = m_visibleItems.first();

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

1010 }

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

1012 // if we need adding a new section item

1013 if (m_sectionDelegate) {

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

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

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

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

1018 ListItem *firstItem = m_visibleItems.first();

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

1020 }

1021 }

1022 }

1023 }

1024 if (firstItemWithViewOnTop) {

1025 ListItem *firstItem = m_visibleItems.first();

1026 firstItem->setY(oldFirstValidIndexPos);

1027 }

1028 adjustMinYExtent();

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

1030 m_firstVisibleIndex += insert.count;

1031 }

1032

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

1034 const int modelIndex = insert.index + i;

1035 if (modelIndex <= m_asyncRequestedIndex) {

1036 m_asyncRequestedIndex++;

1037 }

1038 }

1039 }

1040

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

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

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

1044 ListItem *item = itemAtIndex(i);

1045 if (item && item->sectionItem()) {

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

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

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

1049 }

1050 }

1051 }

1052

1053 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1054 adjustMinYExtent();

1055 }

1056

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

1058 ListItem *item = m_visibleItems[i];

1059 if (item->sectionItem()) {

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

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

1062 }

1063 }

1064

1065 layout();

1066 polish();

1067 m_contentHeightDirty = true;

1068}

1069

1070void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1071{

1072 m_contentHeightDirty = true;

1073 polish();

1074}

1075

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

1077{

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

1079 if (heightDiff != 0) {

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

1081 ListItem *firstItem = m_visibleItems.first();

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

1083 adjustMinYExtent();

1084 layout();

1085 }

1086 refill();

1087 adjustMinYExtent();

1088 polish();

1089 m_contentHeightDirty = true;

1090 }

1091}

1092

1093void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)

1094{

1095 if (item == m_headerItem) {

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

1097 if (diff != 0) {

1098 adjustHeader(diff);

1099 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();

1100 layout();

1101 polish();

1102 m_contentHeightDirty = true;

1103 }

1104 }

1105}

1106

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

1108{

1109 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1110 if (m_headerItemShownHeight > 0) {

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

1112 // Change its size

1113 m_headerItemShownHeight += heightDiff;

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

1115 updateClipItem();

1116 adjustMinYExtent();

1117 Q_EMIT headerItemShownHeightChanged();

1118 } else {

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

1120 // If the header is shown because its position

1121 // Change its size

1122 ListItem *firstItem = m_visibleItems.first();

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

1124 layout();

1125 } else {

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

1127 // so the viewport is not changed

1128 adjustMinYExtent();

1129 }

1130 }

1131}

1132

1133

1134void ListViewWithPageHeader::adjustMinYExtent()

1135{

1136 if (m_visibleItems.isEmpty()) {

1137 m_minYExtent = 0;

1138 } else {

1139 qreal nonCreatedHeight = 0;

1140 if (m_firstVisibleIndex != 0) {

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

1142 const int visibleItems = m_visibleItems.count();

1143 qreal visibleItemsHeight = 0;

1144 Q_FOREACH(ListItem *item, m_visibleItems) {

1145 visibleItemsHeight += item->height();

1146 }

1147 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1149 }

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

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

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

1153 m_minYExtent = 0;

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

1155 }

1156 }

1157}

1158

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

1160{

1161 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1163 return m_visibleItems[visibleIndexedModelIndex];

1164

1165 return nullptr;

1166}

1167

1168void ListViewWithPageHeader::layout()

1169{

1170 if (m_inLayout)

1171 return;

1172

1173 m_inLayout = true;

1174 if (!m_visibleItems.isEmpty()) {

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

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

1177

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

1179

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

1181 int firstReallyVisibleItem = -1;

1182 int modelIndex = m_firstVisibleIndex;

1183 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1185 item->setCulled(cull);

1186 item->setY(pos);

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

1188 firstReallyVisibleItem = modelIndex;

1189 if (m_topSectionItem) {

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

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

1192 // or stick it to the top

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

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

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

1196 bool showStickySectionItem;

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

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

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

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

1201 if (topSectionStickPos > pos) {

1202 showStickySectionItem = true;

1203 } else if (topSectionStickPos == pos) {

1204 showStickySectionItem = !item->sectionItem();

1205 } else {

1206 showStickySectionItem = false;

1207 }

1208 if (!showStickySectionItem) {

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

1210 if (item->sectionItem()) {

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

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

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

1214 // gets shown shortly in the next polish call

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

1216 }

1217 } else {

1218 // Update the top sticky section header

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

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

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

1222

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

1224 m_topSectionItem->setY(topSectionStickPos);

1225 int delegateIndex = modelIndex;

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

1227 while (delegateIndex > 0) {

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

1229 if (prevSection != section)

1230 break;

1231 delegateIndex--;

1232 }

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

1234 if (item->sectionItem()) {

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

1236 }

1237 }

1238 }

1239 }

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

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

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

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

1244 } else {

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

1246 }

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

1248 pos += item->height();

1249 ++modelIndex;

1250 }

1251

1252 // Second step of section sticky item positioning

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

1254 if (m_topSectionItem) {

1255 if (firstReallyVisibleItem >= 0) {

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

1257 ListItem *item = m_visibleItems[i];

1258 if (item->sectionItem()) {

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

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

1261 }

1262 break;

1263 }

1264 }

1265 }

1266 }

1267 }

1268 m_inLayout = false;

1269}

1270

1271void ListViewWithPageHeader::updatePolish()

1272{

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

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

1275 // For reproduction just inifnite loop testDash or testDashContent

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

1277 return;

1278

1279 Q_FOREACH(ListItem *item, m_itemsToRelease)

1280 reallyReleaseItem(item);

1281 m_itemsToRelease.clear();

1282

1283 if (!model())

1284 return;

1285

1286 layout();

1287

1288 refill();

1289

1290 if (m_contentHeightDirty) {

1291 qreal contentHeight;

1292 if (m_visibleItems.isEmpty()) {

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

1294 } else {

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

1296 const int visibleItems = m_visibleItems.count();

1297 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1298 qreal nonCreatedHeight = 0;

1299 if (lastValidIndex != modelCount - 1) {

1300 const int visibleItems = m_visibleItems.count();

1301 qreal visibleItemsHeight = 0;

1302 Q_FOREACH(ListItem *item, m_visibleItems) {

1303 visibleItemsHeight += item->height();

1304 }

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

1306 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1307 }

1308 ListItem *item = m_visibleItems.last();

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

1310 if (m_firstVisibleIndex != 0) {

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

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

1313 }

1314 }

1315

1316 m_contentHeightDirty = false;

1317 adjustMinYExtent();

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

1319 setContentHeight(contentHeight);

1320 m_inContentHeightKeepHeaderShown = false;

1321 }

1322}

1323

1324#include "moc_listviewwithpageheader.cpp"