plugins/Dash/listviewwithpageheader.cpp · unity8

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

453 {

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

455 auto realVisibleListItemY = listItemY;

456 if (m_topSectionItem) {

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

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

459 // the top section sticky item

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

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

462 realVisibleListItemY -= m_topSectionItem->height();

463 }

464 }

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

466 m_contentYAnimation->setTo(to);

467 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

468 m_contentYAnimation->start();

469 }

470 return true;

471 }

472 return false;

473}

474

475qreal ListViewWithPageHeader::minYExtent() const

476{

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

478 return m_minYExtent;

479}

480

481void ListViewWithPageHeader::componentComplete()

482{

483 if (m_delegateModel)

484 m_delegateModel->componentComplete();

485

486 QQuickFlickable::componentComplete();

487

488 polish();

489}

490

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

492{

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

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

495 // For reproduction just inifnite loop testDash or testDashContent

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

497 return;

498

499 QQuickFlickable::viewportMoved(orient);

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

501 const qreal diff = m_previousContentY - contentY();

502 adjustHeader(diff);

503 m_previousContentY = contentY();

504 layout();

505 polish();

506}

507

508void ListViewWithPageHeader::adjustHeader(qreal diff)

509{

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

511 if (m_headerItem) {

512 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

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

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

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

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

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

518 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

522

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

524 m_headerItemShownHeight = 0;

525 m_headerItem->setY(-m_minYExtent);

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

527 if (maximizeVisibleAreaRunning && diff > 0) {

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

529 m_headerItemShownHeight -= diff;

530 } else {

531 m_headerItemShownHeight += diff;

532 }

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

534 m_headerItemShownHeight = 0;

535 } else {

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

537 }

538 if (m_headerItemShownHeight > 0) {

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

540 m_headerItem->setY(contentY());

541 m_headerItemShownHeight = m_headerItem->height();

542 } else {

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

544 }

545 } else {

546 m_headerItem->setY(-m_minYExtent);

547 }

548 }

549 } else {

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

551 m_headerItem->setY(contentY());

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

553 }

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

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

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

557 if (!showHeaderAnimationRunning) {

558 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

559 } else {

560 diff = -diff;

561 }

562 }

563 if (!m_visibleItems.isEmpty()) {

564 updateClipItem();

565 ListItem *firstItem = m_visibleItems.first();

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

567 if (showHeaderAnimationRunning) {

568 adjustMinYExtent();

569 }

570 }

571}

572

573void ListViewWithPageHeader::createDelegateModel()

574{

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

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

577 if (isComponentComplete())

578 m_delegateModel->componentComplete();

579 updateWatchedRoles();

580}

581

582void ListViewWithPageHeader::refill()

583{

584 if (m_inLayout) {

585 return;

586 }

587 if (!isComponentComplete()) {

588 return;

589 }

590

591 const qreal buffer = height() * bufferRatio;

592 const qreal from = contentY();

593 const qreal to = from + height();

594 const qreal bufferFrom = from - buffer;

595 const qreal bufferTo = to + buffer;

596

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

598 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

600

601 if (added || removed) {

602 m_contentHeightDirty = true;

603 }

604}

605

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

607{

608 if (!delegate())

609 return false;

610

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

612 return false;

613

614 ListItem *item;

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

616

617 int modelIndex = 0;

618 qreal pos = 0;

619 if (!m_visibleItems.isEmpty()) {

620 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

621 item = m_visibleItems.last();

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

623 }

624 bool changed = false;

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

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

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

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

629 break;

630 pos += item->height();

631 ++modelIndex;

632 changed = true;

633 }

634

635 modelIndex = 0;

636 pos = 0;

637 if (!m_visibleItems.isEmpty()) {

638 modelIndex = m_firstVisibleIndex - 1;

639 item = m_visibleItems.first();

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

641 }

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

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

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

645 break;

646 pos -= item->height();

647 --modelIndex;

648 changed = true;

649 }

650

651 return changed;

652}

653

654void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

655{

656 QQuickItem *item = listItem->m_item;

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

658 if (flags & QQmlDelegateModel::Destroyed) {

659 item->setParentItem(nullptr);

660 }

661 delete listItem->sectionItem();

662 delete listItem;

663}

664

665void ListViewWithPageHeader::releaseItem(ListItem *listItem)

666{

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

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

669 m_itemsToRelease << listItem;

670}

671

672void ListViewWithPageHeader::updateWatchedRoles()

673{

674 if (m_delegateModel) {

675 QList<QByteArray> roles;

676 if (!m_sectionProperty.isEmpty())

677 roles << m_sectionProperty.toUtf8();

678 m_delegateModel->setWatchedRoles(roles);

679 }

680}

681

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

683{

684 if (!m_sectionDelegate)

685 return nullptr;

686

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

688 if (section.isEmpty())

689 return nullptr;

690

691 if (modelIndex > 0) {

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

693 if (section == prevSection)

694 return nullptr;

695 }

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

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

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

699 if (section == nextSection) {

700 // Steal the section header

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

702 if (nextItem) {

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

704 nextItem->setSectionItem(nullptr);

705 return sectionItem;

706 }

707 }

708 }

709

710 return getSectionItem(section);

711}

712

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

714{

715 QQuickItem *sectionItem = nullptr;

716

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

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

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

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

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

722 if (nobj) {

723 QQml_setParent_noEvent(context, nobj);

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

725 if (!sectionItem) {

726 delete nobj;

727 } else {

728 sectionItem->setZ(2);

729 QQml_setParent_noEvent(sectionItem, m_clipItem);

730 sectionItem->setParentItem(m_clipItem);

731 }

732 } else {

733 delete context;

734 }

735 m_sectionDelegate->completeCreate();

736

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

738

739 return sectionItem;

740}

741

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

743{

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

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

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

747 if (contentY() < -m_minYExtent) {

748 return false;

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

750 return false;

751 }

752 bool changed = false;

753

754 bool foundVisible = false;

755 int i = 0;

756 int removedItems = 0;

757 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

759 ListItem *item = m_visibleItems[i];

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

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

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

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

764 releaseItem(item);

765 m_visibleItems.removeAt(i);

766 changed = true;

767 ++removedItems;

768 } else {

769 if (!foundVisible) {

770 foundVisible = true;

771 const int itemIndex = m_firstVisibleIndex + removedItems + i;

772 m_firstVisibleIndex = itemIndex;

773 }

774 ++i;

775 }

776 }

777 if (!foundVisible) {

778 m_firstVisibleIndex = -1;

779 }

780 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

781 adjustMinYExtent();

782 }

783

784 return changed;

785}

786

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

788{

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

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

791 return nullptr;

792

793 m_asyncRequestedIndex = -1;

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

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

796 if (!item) {

797 if (object) {

798 m_delegateModel->release(object);

799 if (!m_delegateValidated) {

800 m_delegateValidated = true;

801 QObject* delegateObj = delegate();

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

803 }

804 } else {

805 m_asyncRequestedIndex = modelIndex;

806 }

807 return 0;

808 } else {

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

810 ListItem *listItem = new ListItem;

811 listItem->m_item = item;

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

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

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

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

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

817 // nor is the first item

818 if (prevItem) {

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

820 } else {

821 ListItem *currItem = itemAtIndex(modelIndex);

822 if (currItem) {

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

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

825 } else {

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

827 if (nextItem) {

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

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

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

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

832 lostItem = true;

833 }

834 }

835 }

836 if (lostItem) {

837 listItem->setCulled(true);

838 releaseItem(listItem);

839 listItem = nullptr;

840 } else {

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

842 if (m_visibleItems.isEmpty()) {

843 m_visibleItems << listItem;

844 } else {

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

846 }

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

848 m_firstVisibleIndex = modelIndex;

849 polish();

850 }

851 if (listItem->sectionItem()) {

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

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

854 }

855 adjustMinYExtent();

856 m_contentHeightDirty = true;

857 }

858 return listItem;

859 }

860}

861

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

863{

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

865 if (!item) {

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

867 return;

868 }

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

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

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

872 // For reproduction just inifnite loop testDash or testDashContent

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

874 return;

875

876 item->setParentItem(m_clipItem);

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

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

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

880 context->setContextProperty(QLatin1String("hasSectionHeader"), QVariant::fromValue<bool>(false));

881 if (modelIndex == m_asyncRequestedIndex) {

882 createItem(modelIndex, false);

883 refill();

884 }

885}

886

887void ListViewWithPageHeader::updateClipItem()

888{

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

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

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

892}

893

894void ListViewWithPageHeader::onContentHeightChanged()

895{

896 updateClipItem();

897}

898

899void ListViewWithPageHeader::onContentWidthChanged()

900{

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

902}

903

904void ListViewWithPageHeader::onHeightChanged()

905{

906 polish();

907}

908

909

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

911{

912 // TODO Do something with reset

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

914 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

915

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

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

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

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

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

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

922 bool growDown = true;

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

924 const int modelIndex = remove.index + i;

925 ListItem *item = itemAtIndex(modelIndex);

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

927 growDown = false;

928 }

929 }

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

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

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

933 ListItem *item = m_visibleItems[visibleIndex];

934 // Pass the section item down if needed

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

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

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

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

939 item->setSectionItem(nullptr);

940 }

941 }

942 releaseItem(item);

943 m_visibleItems.removeAt(visibleIndex);

944 }

945 }

946 if (growDown) {

947 adjustMinYExtent();

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

949 if (!m_visibleItems.isEmpty()) {

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

951 // position the new first item correctly

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

953 } else {

954 m_firstVisibleIndex = -1;

955 }

956 }

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

958 m_firstVisibleIndex -= remove.count;

959 }

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

961 const int modelIndex = remove.index + i;

962 if (modelIndex == m_asyncRequestedIndex) {

963 m_asyncRequestedIndex = -1;

964 } else if (modelIndex < m_asyncRequestedIndex) {

965 m_asyncRequestedIndex--;

966 }

967 }

968 }

969

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

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

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

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

974 if (insertingInValidIndexes || firstItemWithViewOnTop)

975 {

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

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

978 bool growUp = false;

979 if (!firstItemWithViewOnTop) {

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

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

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

983 growUp = true;

984 }

985 break;

986 }

987 }

988 }

989

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

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

992 const int modelIndex = insert.index + i;

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

994 if (growUp) {

995 ListItem *firstItem = m_visibleItems.first();

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

997 }

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

999 // if we need adding a new section item

1000 if (m_sectionDelegate) {

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

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

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

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

1005 ListItem *firstItem = m_visibleItems.first();

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

1007 }

1008 }

1009 }

1010 }

1011 if (firstItemWithViewOnTop) {

1012 ListItem *firstItem = m_visibleItems.first();

1013 firstItem->setY(oldFirstValidIndexPos);

1014 }

1015 adjustMinYExtent();

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

1017 m_firstVisibleIndex += insert.count;

1018 }

1019

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

1021 const int modelIndex = insert.index + i;

1022 if (modelIndex <= m_asyncRequestedIndex) {

1023 m_asyncRequestedIndex++;

1024 }

1025 }

1026 }

1027

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

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

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

1031 ListItem *item = itemAtIndex(i);

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

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

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

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

1036 }

1037 }

1038 }

1039

1040 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1041 adjustMinYExtent();

1042 }

1043

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

1045 ListItem *item = m_visibleItems[i];

1046 if (item->sectionItem()) {

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

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

1049 }

1050 }

1051

1052 layout();

1053 polish();

1054 m_contentHeightDirty = true;

1055}

1056

1057void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1058{

1059 m_contentHeightDirty = true;

1060 polish();

1061}

1062

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

1064{

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

1066 if (heightDiff != 0) {

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

1068 ListItem *firstItem = m_visibleItems.first();

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

1070 adjustMinYExtent();

1071 layout();

1072 }

1073 refill();

1074 adjustMinYExtent();

1075 polish();

1076 m_contentHeightDirty = true;

1077 }

1078}

1079

1080void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)

1081{

1082 if (item == m_headerItem) {

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

1084 if (diff != 0) {

1085 adjustHeader(diff);

1086 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();

1087 layout();

1088 polish();

1089 m_contentHeightDirty = true;

1090 }

1091 }

1092}

1093

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

1095{

1096 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1097 if (m_headerItemShownHeight > 0) {

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

1099 // Change its size

1100 m_headerItemShownHeight += heightDiff;

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

1102 updateClipItem();

1103 adjustMinYExtent();

1104 } else {

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

1106 // If the header is shown because its position

1107 // Change its size

1108 ListItem *firstItem = m_visibleItems.first();

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

1110 layout();

1111 } else {

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

1113 // so the viewport is not changed

1114 adjustMinYExtent();

1115 }

1116 }

1117}

1118

1119

1120void ListViewWithPageHeader::adjustMinYExtent()

1121{

1122 if (m_visibleItems.isEmpty()) {

1123 m_minYExtent = 0;

1124 } else {

1125 qreal nonCreatedHeight = 0;

1126 if (m_firstVisibleIndex != 0) {

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

1128 const int visibleItems = m_visibleItems.count();

1129 qreal visibleItemsHeight = 0;

1130 Q_FOREACH(ListItem *item, m_visibleItems) {

1131 visibleItemsHeight += item->height();

1132 }

1133 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1135 }

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

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

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

1139 m_minYExtent = 0;

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

1141 }

1142 }

1143}

1144

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

1146{

1147 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1149 return m_visibleItems[visibleIndexedModelIndex];

1150

1151 return nullptr;

1152}

1153

1154void ListViewWithPageHeader::layout()

1155{

1156 if (m_inLayout)

1157 return;

1158

1159 m_inLayout = true;

1160 if (!m_visibleItems.isEmpty()) {

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

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

1163

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

1165

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

1167 int firstReallyVisibleItem = -1;

1168 int modelIndex = m_firstVisibleIndex;

1169 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1171 item->setCulled(cull);

1172 item->setY(pos);

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

1174 firstReallyVisibleItem = modelIndex;

1175 if (m_topSectionItem) {

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

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

1178 // or stick it to the top

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

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

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

1182 bool showStickySectionItem;

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

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

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

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

1187 if (topSectionStickPos > pos) {

1188 showStickySectionItem = true;

1189 } else if (topSectionStickPos == pos) {

1190 showStickySectionItem = !item->sectionItem();

1191 } else {

1192 showStickySectionItem = false;

1193 }

1194 if (!showStickySectionItem) {

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

1196 if (item->sectionItem()) {

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

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

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

1200 // gets shown shortly in the next polish call

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

1202 }

1203 } else {

1204 // Update the top sticky section header

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

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

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

1208

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

1210 m_topSectionItem->setY(topSectionStickPos);

1211 int delegateIndex = modelIndex;

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

1213 while (delegateIndex > 0) {

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

1215 if (prevSection != section)

1216 break;

1217 delegateIndex--;

1218 }

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

1220 if (item->sectionItem()) {

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

1222 }

1223 }

1224 }

1225 }

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

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

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

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

1230 } else {

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

1232 }

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

1234 pos += item->height();

1235 ++modelIndex;

1236 }

1237

1238 // Second step of section sticky item positioning

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

1240 if (m_topSectionItem) {

1241 if (firstReallyVisibleItem >= 0) {

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

1243 ListItem *item = m_visibleItems[i];

1244 if (item->sectionItem()) {

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

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

1247 }

1248 break;

1249 }

1250 }

1251 }

1252 }

1253 }

1254 m_inLayout = false;

1255}

1256

1257void ListViewWithPageHeader::updatePolish()

1258{

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

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

1261 // For reproduction just inifnite loop testDash or testDashContent

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

1263 return;

1264

1265 Q_FOREACH(ListItem *item, m_itemsToRelease)

1266 reallyReleaseItem(item);

1267 m_itemsToRelease.clear();

1268

1269 if (!model())

1270 return;

1271

1272 layout();

1273

1274 refill();

1275

1276 if (m_contentHeightDirty) {

1277 qreal contentHeight;

1278 if (m_visibleItems.isEmpty()) {

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

1280 } else {

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

1282 const int visibleItems = m_visibleItems.count();

1283 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1284 qreal nonCreatedHeight = 0;

1285 if (lastValidIndex != modelCount - 1) {

1286 const int visibleItems = m_visibleItems.count();

1287 qreal visibleItemsHeight = 0;

1288 Q_FOREACH(ListItem *item, m_visibleItems) {

1289 visibleItemsHeight += item->height();

1290 }

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

1292 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1293 }

1294 ListItem *item = m_visibleItems.last();

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

1296 if (m_firstVisibleIndex != 0) {

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

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

1299 }

1300 }

1301

1302 m_contentHeightDirty = false;

1303 adjustMinYExtent();

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

1305 setContentHeight(contentHeight);

1306 m_inContentHeightKeepHeaderShown = false;

1307 }

1308}

1309

1310#include "moc_listviewwithpageheader.cpp"