plugins/Dash/listviewwithpageheader.cpp · unity8

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

457 {

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

459 auto realVisibleListItemY = listItemY;

460 if (m_topSectionItem) {

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

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

463 // the top section sticky item

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

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

466 realVisibleListItemY -= m_topSectionItem->height();

467 }

468 }

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

470 m_contentYAnimation->setTo(to);

471 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

472 m_contentYAnimation->start();

473 }

474 return true;

475 }

476 return false;

477}

478

479qreal ListViewWithPageHeader::minYExtent() const

480{

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

482 return m_minYExtent;

483}

484

485void ListViewWithPageHeader::componentComplete()

486{

487 if (m_delegateModel)

488 m_delegateModel->componentComplete();

489

490 QQuickFlickable::componentComplete();

491

492 polish();

493}

494

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

496{

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

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

499 // For reproduction just inifnite loop testDash or testDashContent

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

501 return;

502

503 QQuickFlickable::viewportMoved(orient);

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

505 const qreal diff = m_previousContentY - contentY();

506 adjustHeader(diff);

507 m_previousContentY = contentY();

508 layout();

509 polish();

510}

511

512void ListViewWithPageHeader::adjustHeader(qreal diff)

513{

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

515 if (m_headerItem) {

516 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

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

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

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

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

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

522 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

526

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

528 m_headerItemShownHeight = 0;

529 m_headerItem->setY(-m_minYExtent);

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

531 if (maximizeVisibleAreaRunning && diff > 0) {

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

533 m_headerItemShownHeight -= diff;

534 } else {

535 m_headerItemShownHeight += diff;

536 }

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

538 m_headerItemShownHeight = 0;

539 } else {

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

541 }

542 if (m_headerItemShownHeight > 0) {

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

544 m_headerItem->setY(contentY());

545 m_headerItemShownHeight = m_headerItem->height();

546 } else {

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

548 }

549 } else {

550 m_headerItem->setY(-m_minYExtent);

551 }

552 }

553 Q_EMIT headerItemShownHeightChanged();

554 } else {

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

556 m_headerItem->setY(contentY());

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

558 }

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

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

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

562 if (!showHeaderAnimationRunning) {

563 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

564 } else {

565 diff = -diff;

566 }

567 }

568 if (!m_visibleItems.isEmpty()) {

569 updateClipItem();

570 ListItem *firstItem = m_visibleItems.first();

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

572 if (showHeaderAnimationRunning) {

573 adjustMinYExtent();

574 }

575 }

576}

577

578void ListViewWithPageHeader::createDelegateModel()

579{

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

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

582 if (isComponentComplete())

583 m_delegateModel->componentComplete();

584 updateWatchedRoles();

585}

586

587void ListViewWithPageHeader::refill()

588{

589 if (m_inLayout) {

590 return;

591 }

592 if (!isComponentComplete()) {

593 return;

594 }

595

596 const qreal buffer = height() * bufferRatio;

597 const qreal from = contentY();

598 const qreal to = from + height();

599 const qreal bufferFrom = from - buffer;

600 const qreal bufferTo = to + buffer;

601

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

603 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

605

606 if (added || removed) {

607 m_contentHeightDirty = true;

608 }

609}

610

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

612{

613 if (!delegate())

614 return false;

615

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

617 return false;

618

619 ListItem *item;

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

621

622 int modelIndex = 0;

623 qreal pos = 0;

624 if (!m_visibleItems.isEmpty()) {

625 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

626 item = m_visibleItems.last();

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

628 }

629 bool changed = false;

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

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

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

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

634 break;

635 pos += item->height();

636 ++modelIndex;

637 changed = true;

638 }

639

640 modelIndex = 0;

641 pos = 0;

642 if (!m_visibleItems.isEmpty()) {

643 modelIndex = m_firstVisibleIndex - 1;

644 item = m_visibleItems.first();

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

646 }

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

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

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

650 break;

651 pos -= item->height();

652 --modelIndex;

653 changed = true;

654 }

655

656 return changed;

657}

658

659void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

660{

661 QQuickItem *item = listItem->m_item;

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

663 if (flags & QQmlDelegateModel::Destroyed) {

664 item->setParentItem(nullptr);

665 }

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

667 delete listItem;

668}

669

670void ListViewWithPageHeader::releaseItem(ListItem *listItem)

671{

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

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

674 m_itemsToRelease << listItem;

675}

676

677void ListViewWithPageHeader::updateWatchedRoles()

678{

679 if (m_delegateModel) {

680 QList<QByteArray> roles;

681 if (!m_sectionProperty.isEmpty())

682 roles << m_sectionProperty.toUtf8();

683 m_delegateModel->setWatchedRoles(roles);

684 }

685}

686

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

688{

689 if (!m_sectionDelegate)

690 return nullptr;

691

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

693

694 if (modelIndex > 0) {

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

696 if (section == prevSection)

697 return nullptr;

698 }

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

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

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

702 if (section == nextSection) {

703 // Steal the section header

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

705 if (nextItem) {

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

707 nextItem->setSectionItem(nullptr);

708 return sectionItem;

709 }

710 }

711 }

712

713 return getSectionItem(section);

714}

715

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

717{

718 QQuickItem *sectionItem = nullptr;

719

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

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

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

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

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

725 if (nobj) {

726 QQml_setParent_noEvent(context, nobj);

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

728 if (!sectionItem) {

729 delete nobj;

730 } else {

731 sectionItem->setZ(2);

732 QQml_setParent_noEvent(sectionItem, m_clipItem);

733 sectionItem->setParentItem(m_clipItem);

734 }

735 } else {

736 delete context;

737 }

738 m_sectionDelegate->completeCreate();

739

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

741

742 return sectionItem;

743}

744

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

746{

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

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

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

750 if (contentY() < -m_minYExtent) {

751 return false;

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

753 return false;

754 }

755 bool changed = false;

756

757 bool foundVisible = false;

758 int i = 0;

759 int removedItems = 0;

760 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

762 ListItem *item = m_visibleItems[i];

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

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

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

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

767 releaseItem(item);

768 m_visibleItems.removeAt(i);

769 changed = true;

770 ++removedItems;

771 } else {

772 if (!foundVisible) {

773 foundVisible = true;

774 const int itemIndex = m_firstVisibleIndex + removedItems + i;

775 m_firstVisibleIndex = itemIndex;

776 }

777 ++i;

778 }

779 }

780 if (!foundVisible) {

781 m_firstVisibleIndex = -1;

782 }

783 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

784 adjustMinYExtent();

785 }

786

787 return changed;

788}

789

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

791{

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

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

794 return nullptr;

795

796 m_asyncRequestedIndex = -1;

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

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

799 if (!item) {

800 if (object) {

801 m_delegateModel->release(object);

802 if (!m_delegateValidated) {

803 m_delegateValidated = true;

804 QObject* delegateObj = delegate();

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

806 }

807 } else {

808 m_asyncRequestedIndex = modelIndex;

809 }

810 return 0;

811 } else {

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

813 ListItem *listItem = new ListItem;

814 listItem->m_item = item;

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

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

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

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

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

820 // nor is the first item

821 if (prevItem) {

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

823 } else {

824 ListItem *currItem = itemAtIndex(modelIndex);

825 if (currItem) {

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

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

828 } else {

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

830 if (nextItem) {

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

832 } else if (modelIndex == 0) {

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

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

835 lostItem = true;

836 }

837 }

838 }

839 if (lostItem) {

840 listItem->setCulled(true);

841 releaseItem(listItem);

842 listItem = nullptr;

843 } else {

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

845 if (m_visibleItems.isEmpty()) {

846 m_visibleItems << listItem;

847 } else {

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

849 }

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

851 m_firstVisibleIndex = modelIndex;

852 polish();

853 }

854 if (listItem->sectionItem()) {

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

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

857 }

858 adjustMinYExtent();

859 m_contentHeightDirty = true;

860 }

861 return listItem;

862 }

863}

864

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

866{

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

868 if (!item) {

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

870 return;

871 }

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

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

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

875 // For reproduction just inifnite loop testDash or testDashContent

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

877 return;

878

879 item->setParentItem(m_clipItem);

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

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

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

883 if (modelIndex == m_asyncRequestedIndex) {

884 createItem(modelIndex, false);

885 refill();

886 }

887}

888

889void ListViewWithPageHeader::updateClipItem()

890{

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

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

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

894}

895

896void ListViewWithPageHeader::onContentHeightChanged()

897{

898 updateClipItem();

899}

900

901void ListViewWithPageHeader::onContentWidthChanged()

902{

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

904}

905

906void ListViewWithPageHeader::onHeightChanged()

907{

908 polish();

909}

910

911

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

913{

914 // TODO Do something with reset

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

916 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

917

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

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

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

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

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

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

924 bool growDown = true;

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

926 const int modelIndex = remove.index + i;

927 ListItem *item = itemAtIndex(modelIndex);

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

929 growDown = false;

930 }

931 }

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

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

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

935 ListItem *item = m_visibleItems[visibleIndex];

936 // Pass the section item down if needed

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

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

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

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

941 item->setSectionItem(nullptr);

942 }

943 }

944 releaseItem(item);

945 m_visibleItems.removeAt(visibleIndex);

946 }

947 }

948 if (growDown) {

949 adjustMinYExtent();

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

951 if (!m_visibleItems.isEmpty()) {

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

953 // position the new first item correctly

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

955 } else {

956 m_firstVisibleIndex = -1;

957 }

958 }

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

960 m_firstVisibleIndex -= remove.count;

961 }

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

963 const int modelIndex = remove.index + i;

964 if (modelIndex == m_asyncRequestedIndex) {

965 m_asyncRequestedIndex = -1;

966 } else if (modelIndex < m_asyncRequestedIndex) {

967 m_asyncRequestedIndex--;

968 }

969 }

970 }

971

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

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

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

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

976 if (insertingInValidIndexes || firstItemWithViewOnTop)

977 {

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

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

980 bool growUp = false;

981 if (!firstItemWithViewOnTop) {

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

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

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

985 growUp = true;

986 }

987 break;

988 }

989 }

990 }

991

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

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

994 const int modelIndex = insert.index + i;

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

996 if (growUp) {

997 ListItem *firstItem = m_visibleItems.first();

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

999 }

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

1001 // if we need adding a new section item

1002 if (m_sectionDelegate) {

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

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

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

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

1007 ListItem *firstItem = m_visibleItems.first();

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

1009 }

1010 }

1011 }

1012 }

1013 if (firstItemWithViewOnTop) {

1014 ListItem *firstItem = m_visibleItems.first();

1015 firstItem->setY(oldFirstValidIndexPos);

1016 }

1017 adjustMinYExtent();

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

1019 m_firstVisibleIndex += insert.count;

1020 }

1021

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

1023 const int modelIndex = insert.index + i;

1024 if (modelIndex <= m_asyncRequestedIndex) {

1025 m_asyncRequestedIndex++;

1026 }

1027 }

1028 }

1029

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

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

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

1033 ListItem *item = itemAtIndex(i);

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

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

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

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

1038 }

1039 }

1040 }

1041

1042 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1043 adjustMinYExtent();

1044 }

1045

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

1047 ListItem *item = m_visibleItems[i];

1048 if (item->sectionItem()) {

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

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

1051 }

1052 }

1053

1054 layout();

1055 polish();

1056 m_contentHeightDirty = true;

1057}

1058

1059void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1060{

1061 m_contentHeightDirty = true;

1062 polish();

1063}

1064

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

1066{

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

1068 if (heightDiff != 0) {

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

1070 ListItem *firstItem = m_visibleItems.first();

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

1072 adjustMinYExtent();

1073 layout();

1074 }

1075 refill();

1076 adjustMinYExtent();

1077 polish();

1078 m_contentHeightDirty = true;

1079 }

1080}

1081

1082void ListViewWithPageHeader::itemImplicitHeightChanged(QQuickItem *item)

1083{

1084 if (item == m_headerItem) {

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

1086 if (diff != 0) {

1087 adjustHeader(diff);

1088 m_previousHeaderImplicitHeight = m_headerItem->implicitHeight();

1089 layout();

1090 polish();

1091 m_contentHeightDirty = true;

1092 }

1093 }

1094}

1095

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

1097{

1098 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1099 if (m_headerItemShownHeight > 0) {

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

1101 // Change its size

1102 m_headerItemShownHeight += heightDiff;

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

1104 updateClipItem();

1105 adjustMinYExtent();

1106 Q_EMIT headerItemShownHeightChanged();

1107 } else {

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

1109 // If the header is shown because its position

1110 // Change its size

1111 ListItem *firstItem = m_visibleItems.first();

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

1113 layout();

1114 } else {

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

1116 // so the viewport is not changed

1117 adjustMinYExtent();

1118 }

1119 }

1120}

1121

1122

1123void ListViewWithPageHeader::adjustMinYExtent()

1124{

1125 if (m_visibleItems.isEmpty()) {

1126 m_minYExtent = 0;

1127 } else {

1128 qreal nonCreatedHeight = 0;

1129 if (m_firstVisibleIndex != 0) {

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

1131 const int visibleItems = m_visibleItems.count();

1132 qreal visibleItemsHeight = 0;

1133 Q_FOREACH(ListItem *item, m_visibleItems) {

1134 visibleItemsHeight += item->height();

1135 }

1136 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1138 }

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

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

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

1142 m_minYExtent = 0;

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

1144 }

1145 }

1146}

1147

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

1149{

1150 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1152 return m_visibleItems[visibleIndexedModelIndex];

1153

1154 return nullptr;

1155}

1156

1157void ListViewWithPageHeader::layout()

1158{

1159 if (m_inLayout)

1160 return;

1161

1162 m_inLayout = true;

1163 if (!m_visibleItems.isEmpty()) {

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

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

1166

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

1168

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

1170 int firstReallyVisibleItem = -1;

1171 int modelIndex = m_firstVisibleIndex;

1172 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1174 item->setCulled(cull);

1175 item->setY(pos);

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

1177 firstReallyVisibleItem = modelIndex;

1178 if (m_topSectionItem) {

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

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

1181 // or stick it to the top

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

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

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

1185 bool showStickySectionItem;

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

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

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

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

1190 if (topSectionStickPos > pos) {

1191 showStickySectionItem = true;

1192 } else if (topSectionStickPos == pos) {

1193 showStickySectionItem = !item->sectionItem();

1194 } else {

1195 showStickySectionItem = false;

1196 }

1197 if (!showStickySectionItem) {

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

1199 if (item->sectionItem()) {

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

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

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

1203 // gets shown shortly in the next polish call

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

1205 }

1206 } else {

1207 // Update the top sticky section header

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

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

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

1211

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

1213 m_topSectionItem->setY(topSectionStickPos);

1214 int delegateIndex = modelIndex;

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

1216 while (delegateIndex > 0) {

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

1218 if (prevSection != section)

1219 break;

1220 delegateIndex--;

1221 }

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

1223 if (item->sectionItem()) {

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

1225 }

1226 }

1227 }

1228 }

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

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

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

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

1233 } else {

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

1235 }

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

1237 pos += item->height();

1238 ++modelIndex;

1239 }

1240

1241 // Second step of section sticky item positioning

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

1243 if (m_topSectionItem) {

1244 if (firstReallyVisibleItem >= 0) {

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

1246 ListItem *item = m_visibleItems[i];

1247 if (item->sectionItem()) {

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

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

1250 }

1251 break;

1252 }

1253 }

1254 }

1255 }

1256 }

1257 m_inLayout = false;

1258}

1259

1260void ListViewWithPageHeader::updatePolish()

1261{

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

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

1264 // For reproduction just inifnite loop testDash or testDashContent

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

1266 return;

1267

1268 Q_FOREACH(ListItem *item, m_itemsToRelease)

1269 reallyReleaseItem(item);

1270 m_itemsToRelease.clear();

1271

1272 if (!model())

1273 return;

1274

1275 layout();

1276

1277 refill();

1278

1279 if (m_contentHeightDirty) {

1280 qreal contentHeight;

1281 if (m_visibleItems.isEmpty()) {

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

1283 } else {

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

1285 const int visibleItems = m_visibleItems.count();

1286 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1287 qreal nonCreatedHeight = 0;

1288 if (lastValidIndex != modelCount - 1) {

1289 const int visibleItems = m_visibleItems.count();

1290 qreal visibleItemsHeight = 0;

1291 Q_FOREACH(ListItem *item, m_visibleItems) {

1292 visibleItemsHeight += item->height();

1293 }

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

1295 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1296 }

1297 ListItem *item = m_visibleItems.last();

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

1299 if (m_firstVisibleIndex != 0) {

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

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

1302 }

1303 }

1304

1305 m_contentHeightDirty = false;

1306 adjustMinYExtent();

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

1308 setContentHeight(contentHeight);

1309 m_inContentHeightKeepHeaderShown = false;

1310 }

1311}

1312

1313#include "moc_listviewwithpageheader.cpp"