plugins/Dash/listviewwithpageheader.cpp · unity8

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

451 {

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

453 auto realVisibleListItemY = listItemY;

454 if (m_topSectionItem) {

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

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

457 // the top section sticky item

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

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

460 realVisibleListItemY -= m_topSectionItem->height();

461 }

462 }

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

464 m_contentYAnimation->setTo(to);

465 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

466 m_contentYAnimation->start();

467 }

468 return true;

469 }

470 return false;

471}

472

473qreal ListViewWithPageHeader::minYExtent() const

474{

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

476 return m_minYExtent;

477}

478

479void ListViewWithPageHeader::componentComplete()

480{

481 if (m_delegateModel)

482 m_delegateModel->componentComplete();

483

484 QQuickFlickable::componentComplete();

485

486 polish();

487}

488

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

490{

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

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

493 // For reproduction just inifnite loop testDash or testDashContent

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

495 return;

496

497 QQuickFlickable::viewportMoved(orient);

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

499 const qreal diff = m_previousContentY - contentY();

500 adjustHeader(diff);

501 m_previousContentY = contentY();

502 layout();

503 polish();

504}

505

506void ListViewWithPageHeader::adjustHeader(qreal diff)

507{

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

509 if (m_headerItem) {

510 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

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

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

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

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

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

516 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

520

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

522 m_headerItemShownHeight = 0;

523 m_headerItem->setY(-m_minYExtent);

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

525 if (maximizeVisibleAreaRunning && diff > 0) {

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

527 m_headerItemShownHeight -= diff;

528 } else {

529 m_headerItemShownHeight += diff;

530 }

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

532 m_headerItemShownHeight = 0;

533 } else {

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

535 }

536 if (m_headerItemShownHeight > 0) {

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

538 m_headerItem->setY(contentY());

539 m_headerItemShownHeight = m_headerItem->height();

540 } else {

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

542 }

543 } else {

544 m_headerItem->setY(-m_minYExtent);

545 }

546 }

547 } else {

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

549 m_headerItem->setY(contentY());

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

551 }

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

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

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

555 if (!showHeaderAnimationRunning) {

556 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

557 } else {

558 diff = -diff;

559 }

560 }

561 if (!m_visibleItems.isEmpty()) {

562 updateClipItem();

563 ListItem *firstItem = m_visibleItems.first();

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

565 if (showHeaderAnimationRunning) {

566 adjustMinYExtent();

567 }

568 }

569}

570

571void ListViewWithPageHeader::createDelegateModel()

572{

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

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

575 if (isComponentComplete())

576 m_delegateModel->componentComplete();

577 updateWatchedRoles();

578}

579

580void ListViewWithPageHeader::refill()

581{

582 if (m_inLayout) {

583 return;

584 }

585 if (!isComponentComplete()) {

586 return;

587 }

588

589 const qreal buffer = height() * bufferRatio;

590 const qreal from = contentY();

591 const qreal to = from + height();

592 const qreal bufferFrom = from - buffer;

593 const qreal bufferTo = to + buffer;

594

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

596 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

598

599 if (added || removed) {

600 m_contentHeightDirty = true;

601 }

602}

603

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

605{

606 if (!delegate())

607 return false;

608

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

610 return false;

611

612 ListItem *item;

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

614

615 int modelIndex = 0;

616 qreal pos = 0;

617 if (!m_visibleItems.isEmpty()) {

618 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

619 item = m_visibleItems.last();

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

621 }

622 bool changed = false;

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

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

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

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

627 break;

628 pos += item->height();

629 ++modelIndex;

630 changed = true;

631 }

632

633 modelIndex = 0;

634 pos = 0;

635 if (!m_visibleItems.isEmpty()) {

636 modelIndex = m_firstVisibleIndex - 1;

637 item = m_visibleItems.first();

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

639 }

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

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

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

643 break;

644 pos -= item->height();

645 --modelIndex;

646 changed = true;

647 }

648

649 return changed;

650}

651

652void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

653{

654 QQuickItem *item = listItem->m_item;

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

656 if (flags & QQmlDelegateModel::Destroyed) {

657 item->setParentItem(nullptr);

658 }

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

660 delete listItem;

661}

662

663void ListViewWithPageHeader::releaseItem(ListItem *listItem)

664{

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

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

667 m_itemsToRelease << listItem;

668}

669

670void ListViewWithPageHeader::updateWatchedRoles()

671{

672 if (m_delegateModel) {

673 QList<QByteArray> roles;

674 if (!m_sectionProperty.isEmpty())

675 roles << m_sectionProperty.toUtf8();

676 m_delegateModel->setWatchedRoles(roles);

677 }

678}

679

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

681{

682 if (!m_sectionDelegate)

683 return nullptr;

684

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

686

687 if (modelIndex > 0) {

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

689 if (section == prevSection)

690 return nullptr;

691 }

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

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

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

695 if (section == nextSection) {

696 // Steal the section header

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

698 if (nextItem) {

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

700 nextItem->setSectionItem(nullptr);

701 return sectionItem;

702 }

703 }

704 }

705

706 return getSectionItem(section);

707}

708

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

710{

711 QQuickItem *sectionItem = nullptr;

712

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

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

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

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

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

718 if (nobj) {

719 QQml_setParent_noEvent(context, nobj);

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

721 if (!sectionItem) {

722 delete nobj;

723 } else {

724 sectionItem->setZ(2);

725 QQml_setParent_noEvent(sectionItem, m_clipItem);

726 sectionItem->setParentItem(m_clipItem);

727 }

728 } else {

729 delete context;

730 }

731 m_sectionDelegate->completeCreate();

732

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

734

735 return sectionItem;

736}

737

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

739{

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

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

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

743 if (contentY() < -m_minYExtent) {

744 return false;

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

746 return false;

747 }

748 bool changed = false;

749

750 bool foundVisible = false;

751 int i = 0;

752 int removedItems = 0;

753 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

755 ListItem *item = m_visibleItems[i];

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

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

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

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

760 releaseItem(item);

761 m_visibleItems.removeAt(i);

762 changed = true;

763 ++removedItems;

764 } else {

765 if (!foundVisible) {

766 foundVisible = true;

767 const int itemIndex = m_firstVisibleIndex + removedItems + i;

768 m_firstVisibleIndex = itemIndex;

769 }

770 ++i;

771 }

772 }

773 if (!foundVisible) {

774 m_firstVisibleIndex = -1;

775 }

776 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

777 adjustMinYExtent();

778 }

779

780 return changed;

781}

782

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

784{

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

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

787 return nullptr;

788

789 m_asyncRequestedIndex = -1;

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

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

792 if (!item) {

793 if (object) {

794 m_delegateModel->release(object);

795 if (!m_delegateValidated) {

796 m_delegateValidated = true;

797 QObject* delegateObj = delegate();

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

799 }

800 } else {

801 m_asyncRequestedIndex = modelIndex;

802 }

803 return 0;

804 } else {

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

806 ListItem *listItem = new ListItem;

807 listItem->m_item = item;

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

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

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

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

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

813 // nor is the first item

814 if (prevItem) {

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

816 } else {

817 ListItem *currItem = itemAtIndex(modelIndex);

818 if (currItem) {

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

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

821 } else {

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

823 if (nextItem) {

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

825 } else if (modelIndex == 0) {

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

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

828 lostItem = true;

829 }

830 }

831 }

832 if (lostItem) {

833 listItem->setCulled(true);

834 releaseItem(listItem);

835 listItem = nullptr;

836 } else {

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

838 if (m_visibleItems.isEmpty()) {

839 m_visibleItems << listItem;

840 } else {

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

842 }

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

844 m_firstVisibleIndex = modelIndex;

845 polish();

846 }

847 if (listItem->sectionItem()) {

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

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

850 }

851 adjustMinYExtent();

852 m_contentHeightDirty = true;

853 }

854 return listItem;

855 }

856}

857

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

859{

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

861 if (!item) {

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

863 return;

864 }

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

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

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

868 // For reproduction just inifnite loop testDash or testDashContent

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

870 return;

871

872 item->setParentItem(m_clipItem);

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

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

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

876 if (modelIndex == m_asyncRequestedIndex) {

877 createItem(modelIndex, false);

878 refill();

879 }

880}

881

882void ListViewWithPageHeader::updateClipItem()

883{

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

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

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

887}

888

889void ListViewWithPageHeader::onContentHeightChanged()

890{

891 updateClipItem();

892}

893

894void ListViewWithPageHeader::onContentWidthChanged()

895{

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

897}

898

899void ListViewWithPageHeader::onHeightChanged()

900{

901 polish();

902}

903

904

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

906{

907 // TODO Do something with reset

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

909 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

910

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

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

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

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

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

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

917 bool growDown = true;

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

919 const int modelIndex = remove.index + i;

920 ListItem *item = itemAtIndex(modelIndex);

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

922 growDown = false;

923 }

924 }

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

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

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

928 ListItem *item = m_visibleItems[visibleIndex];

929 // Pass the section item down if needed

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

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

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

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

934 item->setSectionItem(nullptr);

935 }

936 }

937 releaseItem(item);

938 m_visibleItems.removeAt(visibleIndex);

939 }

940 }

941 if (growDown) {

942 adjustMinYExtent();

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

944 if (!m_visibleItems.isEmpty()) {

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

946 // position the new first item correctly

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

948 } else {

949 m_firstVisibleIndex = -1;

950 }

951 }

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

953 m_firstVisibleIndex -= remove.count;

954 }

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

956 const int modelIndex = remove.index + i;

957 if (modelIndex == m_asyncRequestedIndex) {

958 m_asyncRequestedIndex = -1;

959 } else if (modelIndex < m_asyncRequestedIndex) {

960 m_asyncRequestedIndex--;

961 }

962 }

963 }

964

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

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

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

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

969 if (insertingInValidIndexes || firstItemWithViewOnTop)

970 {

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

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

973 bool growUp = false;

974 if (!firstItemWithViewOnTop) {

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

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

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

978 growUp = true;

979 }

980 break;

981 }

982 }

983 }

984

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

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

987 const int modelIndex = insert.index + i;

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

989 if (growUp) {

990 ListItem *firstItem = m_visibleItems.first();

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

992 }

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

994 // if we need adding a new section item

995 if (m_sectionDelegate) {

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

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

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

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

1000 ListItem *firstItem = m_visibleItems.first();

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

1002 }

1003 }

1004 }

1005 }

1006 if (firstItemWithViewOnTop) {

1007 ListItem *firstItem = m_visibleItems.first();

1008 firstItem->setY(oldFirstValidIndexPos);

1009 }

1010 adjustMinYExtent();

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

1012 m_firstVisibleIndex += insert.count;

1013 }

1014

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

1016 const int modelIndex = insert.index + i;

1017 if (modelIndex <= m_asyncRequestedIndex) {

1018 m_asyncRequestedIndex++;

1019 }

1020 }

1021 }

1022

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

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

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

1026 ListItem *item = itemAtIndex(i);

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

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

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

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

1031 }

1032 }

1033 }

1034

1035 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1036 adjustMinYExtent();

1037 }

1038

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

1040 ListItem *item = m_visibleItems[i];

1041 if (item->sectionItem()) {

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

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

1044 }

1045 }

1046

1047 layout();

1048 polish();

1049 m_contentHeightDirty = true;

1050}

1051

1052void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1053{

1054 m_contentHeightDirty = true;

1055 polish();

1056}

1057

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

1059{

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

1061 if (heightDiff != 0) {

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

1063 ListItem *firstItem = m_visibleItems.first();

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

1065 adjustMinYExtent();

1066 layout();

1067 }

1068 refill();

1069 adjustMinYExtent();

1070 polish();

1071 m_contentHeightDirty = true;

1072 }

1073}

1074

1075void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)

1076{

1077 if (item == m_headerItem) {

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

1079 if (diff != 0) {

1080 adjustHeader(diff);

1081 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();

1082 layout();

1083 polish();

1084 m_contentHeightDirty = true;

1085 }

1086 }

1087}

1088

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

1090{

1091 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1092 if (m_headerItemShownHeight > 0) {

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

1094 // Change its size

1095 m_headerItemShownHeight += heightDiff;

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

1097 updateClipItem();

1098 adjustMinYExtent();

1099 } else {

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

1101 // If the header is shown because its position

1102 // Change its size

1103 ListItem *firstItem = m_visibleItems.first();

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

1105 layout();

1106 } else {

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

1108 // so the viewport is not changed

1109 adjustMinYExtent();

1110 }

1111 }

1112}

1113

1114

1115void ListViewWithPageHeader::adjustMinYExtent()

1116{

1117 if (m_visibleItems.isEmpty()) {

1118 m_minYExtent = 0;

1119 } else {

1120 qreal nonCreatedHeight = 0;

1121 if (m_firstVisibleIndex != 0) {

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

1123 const int visibleItems = m_visibleItems.count();

1124 qreal visibleItemsHeight = 0;

1125 Q_FOREACH(ListItem *item, m_visibleItems) {

1126 visibleItemsHeight += item->height();

1127 }

1128 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1130 }

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

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

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

1134 m_minYExtent = 0;

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

1136 }

1137 }

1138}

1139

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

1141{

1142 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1144 return m_visibleItems[visibleIndexedModelIndex];

1145

1146 return nullptr;

1147}

1148

1149void ListViewWithPageHeader::layout()

1150{

1151 if (m_inLayout)

1152 return;

1153

1154 m_inLayout = true;

1155 if (!m_visibleItems.isEmpty()) {

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

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

1158

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

1160

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

1162 int firstReallyVisibleItem = -1;

1163 int modelIndex = m_firstVisibleIndex;

1164 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1166 item->setCulled(cull);

1167 item->setY(pos);

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

1169 firstReallyVisibleItem = modelIndex;

1170 if (m_topSectionItem) {

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

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

1173 // or stick it to the top

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

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

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

1177 bool showStickySectionItem;

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

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

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

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

1182 if (topSectionStickPos > pos) {

1183 showStickySectionItem = true;

1184 } else if (topSectionStickPos == pos) {

1185 showStickySectionItem = !item->sectionItem();

1186 } else {

1187 showStickySectionItem = false;

1188 }

1189 if (!showStickySectionItem) {

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

1191 if (item->sectionItem()) {

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

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

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

1195 // gets shown shortly in the next polish call

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

1197 }

1198 } else {

1199 // Update the top sticky section header

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

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

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

1203

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

1205 m_topSectionItem->setY(topSectionStickPos);

1206 int delegateIndex = modelIndex;

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

1208 while (delegateIndex > 0) {

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

1210 if (prevSection != section)

1211 break;

1212 delegateIndex--;

1213 }

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

1215 if (item->sectionItem()) {

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

1217 }

1218 }

1219 }

1220 }

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

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

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

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

1225 } else {

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

1227 }

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

1229 pos += item->height();

1230 ++modelIndex;

1231 }

1232

1233 // Second step of section sticky item positioning

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

1235 if (m_topSectionItem) {

1236 if (firstReallyVisibleItem >= 0) {

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

1238 ListItem *item = m_visibleItems[i];

1239 if (item->sectionItem()) {

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

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

1242 }

1243 break;

1244 }

1245 }

1246 }

1247 }

1248 }

1249 m_inLayout = false;

1250}

1251

1252void ListViewWithPageHeader::updatePolish()

1253{

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

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

1256 // For reproduction just inifnite loop testDash or testDashContent

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

1258 return;

1259

1260 Q_FOREACH(ListItem *item, m_itemsToRelease)

1261 reallyReleaseItem(item);

1262 m_itemsToRelease.clear();

1263

1264 if (!model())

1265 return;

1266

1267 layout();

1268

1269 refill();

1270

1271 if (m_contentHeightDirty) {

1272 qreal contentHeight;

1273 if (m_visibleItems.isEmpty()) {

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

1275 } else {

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

1277 const int visibleItems = m_visibleItems.count();

1278 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1279 qreal nonCreatedHeight = 0;

1280 if (lastValidIndex != modelCount - 1) {

1281 const int visibleItems = m_visibleItems.count();

1282 qreal visibleItemsHeight = 0;

1283 Q_FOREACH(ListItem *item, m_visibleItems) {

1284 visibleItemsHeight += item->height();

1285 }

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

1287 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1288 }

1289 ListItem *item = m_visibleItems.last();

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

1291 if (m_firstVisibleIndex != 0) {

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

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

1294 }

1295 }

1296

1297 m_contentHeightDirty = false;

1298 adjustMinYExtent();

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

1300 setContentHeight(contentHeight);

1301 m_inContentHeightKeepHeaderShown = false;

1302 }

1303}

1304

1305#include "moc_listviewwithpageheader.cpp"