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 qreal diff = m_previousContentY - contentY();

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

501 if (m_headerItem) {

502 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

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

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

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

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

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

508 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

512

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

514 m_headerItemShownHeight = 0;

515 m_headerItem->setY(-m_minYExtent);

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

517 if (maximizeVisibleAreaRunning && diff > 0) {

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

519 m_headerItemShownHeight -= diff;

520 } else {

521 m_headerItemShownHeight += diff;

522 }

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

524 m_headerItemShownHeight = 0;

525 } else {

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

527 }

528 if (m_headerItemShownHeight > 0) {

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

530 m_headerItem->setY(contentY());

531 m_headerItemShownHeight = m_headerItem->height();

532 } else {

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

534 }

535 } else {

536 m_headerItem->setY(-m_minYExtent);

537 }

538 }

539 } else {

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

541 m_headerItem->setY(contentY());

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

543 }

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

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

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

547 if (!showHeaderAnimationRunning) {

548 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

549 } else {

550 diff = -diff;

551 }

552 }

553 if (!m_visibleItems.isEmpty()) {

554 updateClipItem();

555 ListItem *firstItem = m_visibleItems.first();

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

557 if (showHeaderAnimationRunning) {

558 adjustMinYExtent();

559 }

560 }

561

562 m_previousContentY = contentY();

563 layout();

564 polish();

565}

566

567void ListViewWithPageHeader::createDelegateModel()

568{

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

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

571 if (isComponentComplete())

572 m_delegateModel->componentComplete();

573 updateWatchedRoles();

574}

575

576void ListViewWithPageHeader::refill()

577{

578 if (m_inLayout) {

579 return;

580 }

581 if (!isComponentComplete()) {

582 return;

583 }

584

585 const qreal buffer = height() * bufferRatio;

586 const qreal from = contentY();

587 const qreal to = from + height();

588 const qreal bufferFrom = from - buffer;

589 const qreal bufferTo = to + buffer;

590

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

592 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

594

595 if (added || removed) {

596 m_contentHeightDirty = true;

597 }

598}

599

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

601{

602 if (!delegate())

603 return false;

604

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

606 return false;

607

608 ListItem *item;

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

610

611 int modelIndex = 0;

612 qreal pos = 0;

613 if (!m_visibleItems.isEmpty()) {

614 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

615 item = m_visibleItems.last();

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

617 }

618 bool changed = false;

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

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

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

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

623 break;

624 pos += item->height();

625 ++modelIndex;

626 changed = true;

627 }

628

629 modelIndex = 0;

630 pos = 0;

631 if (!m_visibleItems.isEmpty()) {

632 modelIndex = m_firstVisibleIndex - 1;

633 item = m_visibleItems.first();

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

635 }

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

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

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

639 break;

640 pos -= item->height();

641 --modelIndex;

642 changed = true;

643 }

644

645 return changed;

646}

647

648void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

649{

650 QQuickItem *item = listItem->m_item;

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

652 if (flags & QQmlDelegateModel::Destroyed) {

653 item->setParentItem(nullptr);

654 }

655 delete listItem->sectionItem();

656 delete listItem;

657}

658

659void ListViewWithPageHeader::releaseItem(ListItem *listItem)

660{

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

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

663 m_itemsToRelease << listItem;

664}

665

666void ListViewWithPageHeader::updateWatchedRoles()

667{

668 if (m_delegateModel) {

669 QList<QByteArray> roles;

670 if (!m_sectionProperty.isEmpty())

671 roles << m_sectionProperty.toUtf8();

672 m_delegateModel->setWatchedRoles(roles);

673 }

674}

675

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

677{

678 if (!m_sectionDelegate)

679 return nullptr;

680

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

682 if (section.isEmpty())

683 return nullptr;

684

685 if (modelIndex > 0) {

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

687 if (section == prevSection)

688 return nullptr;

689 }

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

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

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

693 if (section == nextSection) {

694 // Steal the section header

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

696 if (nextItem) {

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

698 nextItem->setSectionItem(nullptr);

699 return sectionItem;

700 }

701 }

702 }

703

704 return getSectionItem(section);

705}

706

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

708{

709 QQuickItem *sectionItem = nullptr;

710

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

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

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

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

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

716 if (nobj) {

717 QQml_setParent_noEvent(context, nobj);

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

719 if (!sectionItem) {

720 delete nobj;

721 } else {

722 sectionItem->setZ(2);

723 QQml_setParent_noEvent(sectionItem, m_clipItem);

724 sectionItem->setParentItem(m_clipItem);

725 }

726 } else {

727 delete context;

728 }

729 m_sectionDelegate->completeCreate();

730

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

732

733 return sectionItem;

734}

735

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

737{

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

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

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

741 if (contentY() < -m_minYExtent) {

742 return false;

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

744 return false;

745 }

746 bool changed = false;

747

748 bool foundVisible = false;

749 int i = 0;

750 int removedItems = 0;

751 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

753 ListItem *item = m_visibleItems[i];

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

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

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

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

758 releaseItem(item);

759 m_visibleItems.removeAt(i);

760 changed = true;

761 ++removedItems;

762 } else {

763 if (!foundVisible) {

764 foundVisible = true;

765 const int itemIndex = m_firstVisibleIndex + removedItems + i;

766 m_firstVisibleIndex = itemIndex;

767 }

768 ++i;

769 }

770 }

771 if (!foundVisible) {

772 m_firstVisibleIndex = -1;

773 }

774 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

775 adjustMinYExtent();

776 }

777

778 return changed;

779}

780

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

782{

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

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

785 return nullptr;

786

787 m_asyncRequestedIndex = -1;

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

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

790 if (!item) {

791 if (object) {

792 m_delegateModel->release(object);

793 if (!m_delegateValidated) {

794 m_delegateValidated = true;

795 QObject* delegateObj = delegate();

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

797 }

798 } else {

799 m_asyncRequestedIndex = modelIndex;

800 }

801 return 0;

802 } else {

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

804 ListItem *listItem = new ListItem;

805 listItem->m_item = item;

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

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

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

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

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

811 // nor is the first item

812 if (prevItem) {

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

814 } else {

815 ListItem *currItem = itemAtIndex(modelIndex);

816 if (currItem) {

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

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

819 } else {

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

821 if (nextItem) {

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

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

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

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

826 lostItem = true;

827 }

828 }

829 }

830 if (lostItem) {

831 listItem->setCulled(true);

832 releaseItem(listItem);

833 listItem = nullptr;

834 } else {

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

836 if (m_visibleItems.isEmpty()) {

837 m_visibleItems << listItem;

838 } else {

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

840 }

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

842 m_firstVisibleIndex = modelIndex;

843 polish();

844 }

845 if (listItem->sectionItem()) {

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

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

848 }

849 adjustMinYExtent();

850 m_contentHeightDirty = true;

851 }

852 return listItem;

853 }

854}

855

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

857{

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

859 if (!item) {

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

861 return;

862 }

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

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

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

866 // For reproduction just inifnite loop testDash or testDashContent

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

868 return;

869

870 item->setParentItem(m_clipItem);

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

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

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

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

875 if (modelIndex == m_asyncRequestedIndex) {

876 createItem(modelIndex, false);

877 refill();

878 }

879}

880

881void ListViewWithPageHeader::updateClipItem()

882{

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

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

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

886}

887

888void ListViewWithPageHeader::onContentHeightChanged()

889{

890 updateClipItem();

891}

892

893void ListViewWithPageHeader::onContentWidthChanged()

894{

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

896}

897

898void ListViewWithPageHeader::onHeightChanged()

899{

900 polish();

901}

902

903

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

905{

906 // TODO Do something with reset

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

908 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

909

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

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

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

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

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

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

916 bool growDown = true;

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

918 const int modelIndex = remove.index + i;

919 ListItem *item = itemAtIndex(modelIndex);

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

921 growDown = false;

922 }

923 }

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

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

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

927 ListItem *item = m_visibleItems[visibleIndex];

928 // Pass the section item down if needed

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

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

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

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

933 item->setSectionItem(nullptr);

934 }

935 }

936 releaseItem(item);

937 m_visibleItems.removeAt(visibleIndex);

938 }

939 }

940 if (growDown) {

941 adjustMinYExtent();

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

943 if (!m_visibleItems.isEmpty()) {

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

945 // position the new first item correctly

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

947 } else {

948 m_firstVisibleIndex = -1;

949 }

950 }

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

952 m_firstVisibleIndex -= remove.count;

953 }

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

955 const int modelIndex = remove.index + i;

956 if (modelIndex == m_asyncRequestedIndex) {

957 m_asyncRequestedIndex = -1;

958 } else if (modelIndex < m_asyncRequestedIndex) {

959 m_asyncRequestedIndex--;

960 }

961 }

962 }

963

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

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

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

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

968 if (insertingInValidIndexes || firstItemWithViewOnTop)

969 {

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

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

972 bool growUp = false;

973 if (!firstItemWithViewOnTop) {

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

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

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

977 growUp = true;

978 }

979 break;

980 }

981 }

982 }

983

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

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

986 const int modelIndex = insert.index + i;

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

988 if (growUp) {

989 ListItem *firstItem = m_visibleItems.first();

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

991 }

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

993 // if we need adding a new section item

994 if (m_sectionDelegate) {

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

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

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

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

999 ListItem *firstItem = m_visibleItems.first();

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

1001 }

1002 }

1003 }

1004 }

1005 if (firstItemWithViewOnTop) {

1006 ListItem *firstItem = m_visibleItems.first();

1007 firstItem->setY(oldFirstValidIndexPos);

1008 }

1009 adjustMinYExtent();

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

1011 m_firstVisibleIndex += insert.count;

1012 }

1013

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

1015 const int modelIndex = insert.index + i;

1016 if (modelIndex <= m_asyncRequestedIndex) {

1017 m_asyncRequestedIndex++;

1018 }

1019 }

1020 }

1021

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

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

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

1025 ListItem *item = itemAtIndex(i);

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

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

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

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

1030 }

1031 }

1032 }

1033

1034 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1035 adjustMinYExtent();

1036 }

1037

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

1039 ListItem *item = m_visibleItems[i];

1040 if (item->sectionItem()) {

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

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

1043 }

1044 }

1045

1046 layout();

1047 polish();

1048 m_contentHeightDirty = true;

1049}

1050

1051void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1052{

1053 m_contentHeightDirty = true;

1054 polish();

1055}

1056

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

1058{

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

1060 if (heightDiff != 0) {

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

1062 ListItem *firstItem = m_visibleItems.first();

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

1064 adjustMinYExtent();

1065 layout();

1066 }

1067 refill();

1068 adjustMinYExtent();

1069 polish();

1070 m_contentHeightDirty = true;

1071 }

1072}

1073

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

1075{

1076 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1077 if (m_headerItemShownHeight > 0) {

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

1079 // Change its size

1080 m_headerItemShownHeight += heightDiff;

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

1082 updateClipItem();

1083 adjustMinYExtent();

1084 } else {

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

1086 // If the header is shown because its position

1087 // Change its size

1088 ListItem *firstItem = m_visibleItems.first();

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

1090 layout();

1091 } else {

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

1093 // so the viewport is not changed

1094 adjustMinYExtent();

1095 }

1096 }

1097}

1098

1099

1100void ListViewWithPageHeader::adjustMinYExtent()

1101{

1102 if (m_visibleItems.isEmpty()) {

1103 m_minYExtent = 0;

1104 } else {

1105 qreal nonCreatedHeight = 0;

1106 if (m_firstVisibleIndex != 0) {

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

1108 const int visibleItems = m_visibleItems.count();

1109 qreal visibleItemsHeight = 0;

1110 Q_FOREACH(ListItem *item, m_visibleItems) {

1111 visibleItemsHeight += item->height();

1112 }

1113 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1115 }

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

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

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

1119 m_minYExtent = 0;

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

1121 }

1122 }

1123}

1124

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

1126{

1127 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1129 return m_visibleItems[visibleIndexedModelIndex];

1130

1131 return nullptr;

1132}

1133

1134void ListViewWithPageHeader::layout()

1135{

1136 if (m_inLayout)

1137 return;

1138

1139 m_inLayout = true;

1140 if (!m_visibleItems.isEmpty()) {

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

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

1143

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

1145

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

1147 int firstReallyVisibleItem = -1;

1148 int modelIndex = m_firstVisibleIndex;

1149 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1151 item->setCulled(cull);

1152 item->setY(pos);

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

1154 firstReallyVisibleItem = modelIndex;

1155 if (m_topSectionItem) {

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

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

1158 // or stick it to the top

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

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

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

1162 bool showStickySectionItem;

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

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

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

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

1167 if (topSectionStickPos > pos) {

1168 showStickySectionItem = true;

1169 } else if (topSectionStickPos == pos) {

1170 showStickySectionItem = !item->sectionItem();

1171 } else {

1172 showStickySectionItem = false;

1173 }

1174 if (!showStickySectionItem) {

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

1176 if (item->sectionItem()) {

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

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

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

1180 // gets shown shortly in the next polish call

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

1182 }

1183 } else {

1184 // Update the top sticky section header

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

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

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

1188

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

1190 m_topSectionItem->setY(topSectionStickPos);

1191 int delegateIndex = modelIndex;

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

1193 while (delegateIndex > 0) {

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

1195 if (prevSection != section)

1196 break;

1197 delegateIndex--;

1198 }

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

1200 if (item->sectionItem()) {

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

1202 }

1203 }

1204 }

1205 }

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

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

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

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

1210 } else {

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

1212 }

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

1214 pos += item->height();

1215 ++modelIndex;

1216 }

1217

1218 // Second step of section sticky item positioning

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

1220 if (m_topSectionItem) {

1221 if (firstReallyVisibleItem >= 0) {

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

1223 ListItem *item = m_visibleItems[i];

1224 if (item->sectionItem()) {

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

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

1227 }

1228 break;

1229 }

1230 }

1231 }

1232 }

1233 }

1234 m_inLayout = false;

1235}

1236

1237void ListViewWithPageHeader::updatePolish()

1238{

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

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

1241 // For reproduction just inifnite loop testDash or testDashContent

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

1243 return;

1244

1245 Q_FOREACH(ListItem *item, m_itemsToRelease)

1246 reallyReleaseItem(item);

1247 m_itemsToRelease.clear();

1248

1249 if (!model())

1250 return;

1251

1252 layout();

1253

1254 refill();

1255

1256 if (m_contentHeightDirty) {

1257 qreal contentHeight;

1258 if (m_visibleItems.isEmpty()) {

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

1260 } else {

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

1262 const int visibleItems = m_visibleItems.count();

1263 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1264 qreal nonCreatedHeight = 0;

1265 if (lastValidIndex != modelCount - 1) {

1266 const int visibleItems = m_visibleItems.count();

1267 qreal visibleItemsHeight = 0;

1268 Q_FOREACH(ListItem *item, m_visibleItems) {

1269 visibleItemsHeight += item->height();

1270 }

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

1272 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1273 }

1274 ListItem *item = m_visibleItems.last();

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

1276 if (m_firstVisibleIndex != 0) {

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

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

1279 }

1280 }

1281

1282 m_contentHeightDirty = false;

1283 adjustMinYExtent();

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

1285 setContentHeight(contentHeight);

1286 m_inContentHeightKeepHeaderShown = false;

1287 }

1288}

1289

1290#include "moc_listviewwithpageheader.cpp"