plugins/Dash/listviewwithpageheader.cpp · unity8

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

446 {

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

448 auto realVisibleListItemY = listItemY;

449 if (m_topSectionItem) {

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

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

452 // the top section sticky item

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

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

455 realVisibleListItemY -= m_topSectionItem->height();

456 }

457 }

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

459 m_contentYAnimation->setTo(to);

460 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

461 m_contentYAnimation->start();

462 }

463 return true;

464 }

465 return false;

466}

467

468qreal ListViewWithPageHeader::minYExtent() const

469{

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

471 return m_minYExtent;

472}

473

474void ListViewWithPageHeader::componentComplete()

475{

476 if (m_delegateModel)

477 m_delegateModel->componentComplete();

478

479 QQuickFlickable::componentComplete();

480

481 polish();

482}

483

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

485{

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

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

488 // For reproduction just inifnite loop testDash or testDashContent

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

490 return;

491

492 QQuickFlickable::viewportMoved(orient);

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

494 const qreal diff = m_previousContentY - contentY();

495 adjustHeader(diff);

496 m_previousContentY = contentY();

497 layout();

498 polish();

499}

500

501void ListViewWithPageHeader::adjustHeader(qreal diff)

502{

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

504 if (m_headerItem) {

505 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

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

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

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

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

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

511 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

515

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

517 m_headerItemShownHeight = 0;

518 m_headerItem->setY(-m_minYExtent);

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

520 if (maximizeVisibleAreaRunning && diff > 0) {

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

522 m_headerItemShownHeight -= diff;

523 } else {

524 m_headerItemShownHeight += diff;

525 }

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

527 m_headerItemShownHeight = 0;

528 } else {

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

530 }

531 if (m_headerItemShownHeight > 0) {

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

533 m_headerItem->setY(contentY());

534 m_headerItemShownHeight = m_headerItem->height();

535 } else {

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

537 }

538 } else {

539 m_headerItem->setY(-m_minYExtent);

540 }

541 }

542 } else {

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

544 m_headerItem->setY(contentY());

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

546 }

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

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

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

550 if (!showHeaderAnimationRunning) {

551 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

552 } else {

553 diff = -diff;

554 }

555 }

556 if (!m_visibleItems.isEmpty()) {

557 updateClipItem();

558 ListItem *firstItem = m_visibleItems.first();

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

560 if (showHeaderAnimationRunning) {

561 adjustMinYExtent();

562 }

563 }

564}

565

566void ListViewWithPageHeader::createDelegateModel()

567{

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

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

570 if (isComponentComplete())

571 m_delegateModel->componentComplete();

572 updateWatchedRoles();

573}

574

575void ListViewWithPageHeader::refill()

576{

577 if (m_inLayout) {

578 return;

579 }

580 if (!isComponentComplete()) {

581 return;

582 }

583

584 const qreal buffer = height() * bufferRatio;

585 const qreal from = contentY();

586 const qreal to = from + height();

587 const qreal bufferFrom = from - buffer;

588 const qreal bufferTo = to + buffer;

589

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

591 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

593

594 if (added || removed) {

595 m_contentHeightDirty = true;

596 }

597}

598

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

600{

601 if (!delegate())

602 return false;

603

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

605 return false;

606

607 ListItem *item;

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

609

610 int modelIndex = 0;

611 qreal pos = 0;

612 if (!m_visibleItems.isEmpty()) {

613 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

614 item = m_visibleItems.last();

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

616 }

617 bool changed = false;

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

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

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

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

622 break;

623 pos += item->height();

624 ++modelIndex;

625 changed = true;

626 }

627

628 modelIndex = 0;

629 pos = 0;

630 if (!m_visibleItems.isEmpty()) {

631 modelIndex = m_firstVisibleIndex - 1;

632 item = m_visibleItems.first();

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

634 }

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

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

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

638 break;

639 pos -= item->height();

640 --modelIndex;

641 changed = true;

642 }

643

644 return changed;

645}

646

647void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

648{

649 QQuickItem *item = listItem->m_item;

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

651 if (flags & QQmlDelegateModel::Destroyed) {

652 item->setParentItem(nullptr);

653 }

654 delete listItem->m_sectionItem;

655 delete listItem;

656}

657

658void ListViewWithPageHeader::releaseItem(ListItem *listItem)

659{

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

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

662 m_itemsToRelease << listItem;

663}

664

665void ListViewWithPageHeader::updateWatchedRoles()

666{

667 if (m_delegateModel) {

668 QList<QByteArray> roles;

669 if (!m_sectionProperty.isEmpty())

670 roles << m_sectionProperty.toUtf8();

671 m_delegateModel->setWatchedRoles(roles);

672 }

673}

674

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

676{

677 if (!m_sectionDelegate)

678 return nullptr;

679

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

681 if (modelIndex > 0) {

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

683 if (section == prevSection)

684 return nullptr;

685 }

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

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

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

689 if (section == nextSection) {

690 // Steal the section header

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

692 if (nextItem) {

693 QQuickItem *sectionItem = nextItem->m_sectionItem;

694 nextItem->m_sectionItem = nullptr;

695 return sectionItem;

696 }

697 }

698 }

699

700 return getSectionItem(section);

701}

702

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

704{

705 QQuickItem *sectionItem = nullptr;

706

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

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

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

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

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

712 if (nobj) {

713 QQml_setParent_noEvent(context, nobj);

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

715 if (!sectionItem) {

716 delete nobj;

717 } else {

718 sectionItem->setZ(2);

719 QQml_setParent_noEvent(sectionItem, m_clipItem);

720 sectionItem->setParentItem(m_clipItem);

721 }

722 } else {

723 delete context;

724 }

725 m_sectionDelegate->completeCreate();

726

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

728

729 return sectionItem;

730}

731

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

733{

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

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

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

737 if (contentY() < -m_minYExtent) {

738 return false;

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

740 return false;

741 }

742 bool changed = false;

743

744 bool foundVisible = false;

745 int i = 0;

746 int removedItems = 0;

747 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

749 ListItem *item = m_visibleItems[i];

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

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

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

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

754 releaseItem(item);

755 m_visibleItems.removeAt(i);

756 changed = true;

757 ++removedItems;

758 } else {

759 if (!foundVisible) {

760 foundVisible = true;

761 const int itemIndex = m_firstVisibleIndex + removedItems + i;

762 m_firstVisibleIndex = itemIndex;

763 }

764 ++i;

765 }

766 }

767 if (!foundVisible) {

768 m_firstVisibleIndex = -1;

769 }

770 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

771 adjustMinYExtent();

772 }

773

774 return changed;

775}

776

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

778{

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

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

781 return nullptr;

782

783 m_asyncRequestedIndex = -1;

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

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

786 if (!item) {

787 if (object) {

788 m_delegateModel->release(object);

789 if (!m_delegateValidated) {

790 m_delegateValidated = true;

791 QObject* delegateObj = delegate();

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

793 }

794 } else {

795 m_asyncRequestedIndex = modelIndex;

796 }

797 return 0;

798 } else {

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

800 ListItem *listItem = new ListItem;

801 listItem->m_item = item;

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

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

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

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

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

807 // nor is the first item

808 if (prevItem) {

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

810 } else {

811 ListItem *currItem = itemAtIndex(modelIndex);

812 if (currItem) {

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

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

815 } else {

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

817 if (nextItem) {

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

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

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

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

822 lostItem = true;

823 }

824 }

825 }

826 if (lostItem) {

827 listItem->setCulled(true);

828 releaseItem(listItem);

829 listItem = nullptr;

830 } else {

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

832 if (m_visibleItems.isEmpty()) {

833 m_visibleItems << listItem;

834 } else {

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

836 }

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

838 m_firstVisibleIndex = modelIndex;

839 polish();

840 }

841 if (listItem->m_sectionItem) {

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

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

844 }

845 adjustMinYExtent();

846 m_contentHeightDirty = true;

847 }

848 return listItem;

849 }

850}

851

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

853{

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

855 if (!item) {

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

857 return;

858 }

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

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

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

862 // For reproduction just inifnite loop testDash or testDashContent

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

864 return;

865

866 item->setParentItem(m_clipItem);

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

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

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

870 if (modelIndex == m_asyncRequestedIndex) {

871 createItem(modelIndex, false);

872 refill();

873 }

874}

875

876void ListViewWithPageHeader::updateClipItem()

877{

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

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

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

881}

882

883void ListViewWithPageHeader::onContentHeightChanged()

884{

885 updateClipItem();

886}

887

888void ListViewWithPageHeader::onContentWidthChanged()

889{

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

891}

892

893void ListViewWithPageHeader::onHeightChanged()

894{

895 polish();

896}

897

898

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

900{

901 // TODO Do something with reset

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

903 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

904

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

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

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

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

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

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

911 bool growDown = true;

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

913 const int modelIndex = remove.index + i;

914 ListItem *item = itemAtIndex(modelIndex);

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

916 growDown = false;

917 }

918 }

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

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

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

922 ListItem *item = m_visibleItems[visibleIndex];

923 // Pass the section item down if needed

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

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

926 if (!nextItem->m_sectionItem) {

927 nextItem->m_sectionItem = item->m_sectionItem;

928 item->m_sectionItem = nullptr;

929 }

930 }

931 releaseItem(item);

932 m_visibleItems.removeAt(visibleIndex);

933 }

934 }

935 if (growDown) {

936 adjustMinYExtent();

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

938 if (!m_visibleItems.isEmpty()) {

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

940 // position the new first item correctly

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

942 } else {

943 m_firstVisibleIndex = -1;

944 }

945 }

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

947 m_firstVisibleIndex -= remove.count;

948 }

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

950 const int modelIndex = remove.index + i;

951 if (modelIndex == m_asyncRequestedIndex) {

952 m_asyncRequestedIndex = -1;

953 } else if (modelIndex < m_asyncRequestedIndex) {

954 m_asyncRequestedIndex--;

955 }

956 }

957 }

958

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

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

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

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

963 if (insertingInValidIndexes || firstItemWithViewOnTop)

964 {

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

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

967 bool growUp = false;

968 if (!firstItemWithViewOnTop) {

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

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

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

972 growUp = true;

973 }

974 break;

975 }

976 }

977 }

978

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

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

981 const int modelIndex = insert.index + i;

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

983 if (growUp) {

984 ListItem *firstItem = m_visibleItems.first();

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

986 }

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

988 // if we need adding a new section item

989 if (m_sectionDelegate) {

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

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

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

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

994 ListItem *firstItem = m_visibleItems.first();

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

996 }

997 }

998 }

999 }

1000 if (firstItemWithViewOnTop) {

1001 ListItem *firstItem = m_visibleItems.first();

1002 firstItem->setY(oldFirstValidIndexPos);

1003 }

1004 adjustMinYExtent();

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

1006 m_firstVisibleIndex += insert.count;

1007 }

1008

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

1010 const int modelIndex = insert.index + i;

1011 if (modelIndex <= m_asyncRequestedIndex) {

1012 m_asyncRequestedIndex++;

1013 }

1014 }

1015 }

1016

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

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

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

1020 ListItem *item = itemAtIndex(i);

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

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

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

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

1025 }

1026 }

1027 }

1028

1029 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1030 adjustMinYExtent();

1031 }

1032

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

1034 ListItem *item = m_visibleItems[i];

1035 if (item->m_sectionItem) {

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

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

1038 }

1039 }

1040

1041 layout();

1042 polish();

1043 m_contentHeightDirty = true;

1044}

1045

1046void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1047{

1048 m_contentHeightDirty = true;

1049 polish();

1050}

1051

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

1053{

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

1055 if (heightDiff != 0) {

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

1057 ListItem *firstItem = m_visibleItems.first();

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

1059 adjustMinYExtent();

1060 layout();

1061 }

1062 refill();

1063 adjustMinYExtent();

1064 polish();

1065 m_contentHeightDirty = true;

1066 }

1067}

1068

1069void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)

1070{

1071 if (item == m_headerItem) {

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

1073 if (diff != 0) {

1074 adjustHeader(diff);

1075 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();

1076 layout();

1077 polish();

1078 m_contentHeightDirty = true;

1079 }

1080 }

1081}

1082

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

1084{

1085 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1086 if (m_headerItemShownHeight > 0) {

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

1088 // Change its size

1089 m_headerItemShownHeight += heightDiff;

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

1091 updateClipItem();

1092 adjustMinYExtent();

1093 } else {

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

1095 // If the header is shown because its position

1096 // Change its size

1097 ListItem *firstItem = m_visibleItems.first();

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

1099 layout();

1100 } else {

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

1102 // so the viewport is not changed

1103 adjustMinYExtent();

1104 }

1105 }

1106}

1107

1108

1109void ListViewWithPageHeader::adjustMinYExtent()

1110{

1111 if (m_visibleItems.isEmpty()) {

1112 m_minYExtent = 0;

1113 } else {

1114 qreal nonCreatedHeight = 0;

1115 if (m_firstVisibleIndex != 0) {

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

1117 const int visibleItems = m_visibleItems.count();

1118 qreal visibleItemsHeight = 0;

1119 Q_FOREACH(ListItem *item, m_visibleItems) {

1120 visibleItemsHeight += item->height();

1121 }

1122 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1124 }

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

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

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

1128 m_minYExtent = 0;

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

1130 }

1131 }

1132}

1133

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

1135{

1136 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1138 return m_visibleItems[visibleIndexedModelIndex];

1139

1140 return nullptr;

1141}

1142

1143void ListViewWithPageHeader::layout()

1144{

1145 if (m_inLayout)

1146 return;

1147

1148 m_inLayout = true;

1149 if (!m_visibleItems.isEmpty()) {

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

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

1152

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

1154

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

1156 int firstReallyVisibleItem = -1;

1157 int modelIndex = m_firstVisibleIndex;

1158 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1160 item->setCulled(cull);

1161 item->setY(pos);

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

1163 firstReallyVisibleItem = modelIndex;

1164 if (m_topSectionItem) {

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

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

1167 // or stick it to the top

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

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

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

1171 bool showStickySectionItem;

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

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

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

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

1176 if (topSectionStickPos > pos) {

1177 showStickySectionItem = true;

1178 } else if (topSectionStickPos == pos) {

1179 showStickySectionItem = !item->m_sectionItem;

1180 } else {

1181 showStickySectionItem = false;

1182 }

1183 if (!showStickySectionItem) {

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

1185 if (item->m_sectionItem) {

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

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

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

1189 // gets shown shortly in the next polish call

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

1191 }

1192 } else {

1193 // Update the top sticky section header

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

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

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

1197

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

1199 m_topSectionItem->setY(topSectionStickPos);

1200 int delegateIndex = modelIndex;

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

1202 while (delegateIndex > 0) {

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

1204 if (prevSection != section)

1205 break;

1206 delegateIndex--;

1207 }

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

1209 if (item->m_sectionItem) {

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

1211 }

1212 }

1213 }

1214 }

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

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

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

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

1219 } else {

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

1221 }

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

1223 pos += item->height();

1224 ++modelIndex;

1225 }

1226

1227 // Second step of section sticky item positioning

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

1229 if (m_topSectionItem) {

1230 if (firstReallyVisibleItem >= 0) {

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

1232 ListItem *item = m_visibleItems[i];

1233 if (item->m_sectionItem) {

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

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

1236 }

1237 break;

1238 }

1239 }

1240 }

1241 }

1242 }

1243 m_inLayout = false;

1244}

1245

1246void ListViewWithPageHeader::updatePolish()

1247{

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

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

1250 // For reproduction just inifnite loop testDash or testDashContent

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

1252 return;

1253

1254 Q_FOREACH(ListItem *item, m_itemsToRelease)

1255 reallyReleaseItem(item);

1256 m_itemsToRelease.clear();

1257

1258 if (!model())

1259 return;

1260

1261 layout();

1262

1263 refill();

1264

1265 if (m_contentHeightDirty) {

1266 qreal contentHeight;

1267 if (m_visibleItems.isEmpty()) {

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

1269 } else {

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

1271 const int visibleItems = m_visibleItems.count();

1272 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1273 qreal nonCreatedHeight = 0;

1274 if (lastValidIndex != modelCount - 1) {

1275 const int visibleItems = m_visibleItems.count();

1276 qreal visibleItemsHeight = 0;

1277 Q_FOREACH(ListItem *item, m_visibleItems) {

1278 visibleItemsHeight += item->height();

1279 }

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

1281 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1282 }

1283 ListItem *item = m_visibleItems.last();

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

1285 if (m_firstVisibleIndex != 0) {

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

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

1288 }

1289 }

1290

1291 m_contentHeightDirty = false;

1292 adjustMinYExtent();

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

1294 setContentHeight(contentHeight);

1295 m_inContentHeightKeepHeaderShown = false;

1296 }

1297}

1298

1299#include "moc_listviewwithpageheader.cpp"