plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

421 {

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

423 auto realVisibleListItemY = listItemY;

424 if (m_topSectionItem) {

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

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

427 // the top section sticky item

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

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

430 realVisibleListItemY -= m_topSectionItem->height();

431 }

432 }

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

434 m_contentYAnimation->setTo(to);

435 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

436 m_contentYAnimation->start();

437 }

438 return true;

439 }

440 return false;

441}

442

443qreal ListViewWithPageHeader::minYExtent() const

444{

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

446 return m_minYExtent;

447}

448

449void ListViewWithPageHeader::componentComplete()

450{

451 if (m_delegateModel)

452 m_delegateModel->componentComplete();

453

454 QQuickFlickable::componentComplete();

455

456 polish();

457}

458

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

460{

461 QQuickFlickable::viewportMoved(orient);

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

463 qreal diff = m_previousContentY - contentY();

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

465 if (m_headerItem) {

466 auto oldHeaderItemShownHeight = m_headerItemShownHeight;

467 if (contentY() < -m_minYExtent) {

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

469 m_headerItem->setY(contentY());

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

471 } else {

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

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

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

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

476 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

480

481 if (!scrolledUp && contentY() == -m_minYExtent) {

482 m_headerItemShownHeight = 0;

483 m_headerItem->setY(contentY());

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

485 if (maximizeVisibleAreaRunning && diff > 0) // If we are maximizing and the header was shown, make sure we hide it

486 m_headerItemShownHeight -= diff;

487 else

488 m_headerItemShownHeight += diff;

489 if (contentY() == -m_minYExtent) {

490 m_headerItemShownHeight = 0;

491 } else {

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

493 }

494 if (m_headerItemShownHeight > 0) {

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

496 } else {

497 m_headerItem->setY(-m_minYExtent);

498 }

499 }

500 }

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

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

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

504 if (!showHeaderAnimationRunning) {

505 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

506 } else {

507 diff = -diff;

508 }

509 }

510 if (!m_visibleItems.isEmpty()) {

511 updateClipItem();

512 ListItem *firstItem = m_visibleItems.first();

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

514 if (showHeaderAnimationRunning) {

515 adjustMinYExtent();

516 }

517 }

518

519 m_previousContentY = contentY();

520 layout();

521 polish();

522}

523

524void ListViewWithPageHeader::createDelegateModel()

525{

526#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

527 m_delegateModel = new QQuickVisualDataModel(qmlContext(this), this);

528 connect(m_delegateModel, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(itemCreated(int,QQuickItem*)));

529#else

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

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

532#endif

533 if (isComponentComplete())

534 m_delegateModel->componentComplete();

535 updateWatchedRoles();

536}

537

538void ListViewWithPageHeader::refill()

539{

540 if (m_inLayout) {

541 return;

542 }

543 if (!isComponentComplete()) {

544 return;

545 }

546

547 const qreal buffer = height() * bufferRatio;

548 const qreal from = contentY();

549 const qreal to = from + height();

550 const qreal bufferFrom = from - buffer;

551 const qreal bufferTo = to + buffer;

552

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

554 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

556

557 if (added || removed) {

558 m_contentHeightDirty = true;

559 }

560}

561

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

563{

564 if (!delegate())

565 return false;

566

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

568 return false;

569

570 ListItem *item;

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

572

573 int modelIndex = 0;

574 qreal pos = 0;

575 if (!m_visibleItems.isEmpty()) {

576 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

577 item = m_visibleItems.last();

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

579 }

580 bool changed = false;

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

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

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

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

585 break;

586 pos += item->height();

587 ++modelIndex;

588 changed = true;

589 }

590

591 modelIndex = 0;

592 pos = 0;

593 if (!m_visibleItems.isEmpty()) {

594 modelIndex = m_firstVisibleIndex - 1;

595 item = m_visibleItems.first();

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

597 }

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

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

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

601 break;

602 pos -= item->height();

603 --modelIndex;

604 changed = true;

605 }

606

607 return changed;

608}

609

610void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

611{

612 QQuickItem *item = listItem->m_item;

613#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

614 QQuickVisualModel::ReleaseFlags flags = m_delegateModel->release(item);

615 if (flags & QQuickVisualModel::Destroyed) {

616#else

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

618 if (flags & QQmlDelegateModel::Destroyed) {

619#endif

620 item->setParentItem(nullptr);

621 }

622 delete listItem->m_sectionItem;

623 delete listItem;

624}

625

626void ListViewWithPageHeader::releaseItem(ListItem *listItem)

627{

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

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

630 m_itemsToRelease << listItem;

631}

632

633void ListViewWithPageHeader::updateWatchedRoles()

634{

635 if (m_delegateModel) {

636 QList<QByteArray> roles;

637 if (!m_sectionProperty.isEmpty())

638 roles << m_sectionProperty.toUtf8();

639 m_delegateModel->setWatchedRoles(roles);

640 }

641}

642

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

644{

645 if (!m_sectionDelegate)

646 return nullptr;

647

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

649 if (modelIndex > 0) {

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

651 if (section == prevSection)

652 return nullptr;

653 }

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

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

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

657 if (section == nextSection) {

658 // Steal the section header

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

660 if (nextItem) {

661 QQuickItem *sectionItem = nextItem->m_sectionItem;

662 nextItem->m_sectionItem = nullptr;

663 return sectionItem;

664 }

665 }

666 }

667

668 return getSectionItem(section);

669}

670

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

672{

673 QQuickItem *sectionItem = nullptr;

674

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

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

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

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

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

680 if (nobj) {

681 QQml_setParent_noEvent(context, nobj);

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

683 if (!sectionItem) {

684 delete nobj;

685 } else {

686 sectionItem->setZ(2);

687 QQml_setParent_noEvent(sectionItem, m_clipItem);

688 sectionItem->setParentItem(m_clipItem);

689 }

690 } else {

691 delete context;

692 }

693 m_sectionDelegate->completeCreate();

694

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

696

697 return sectionItem;

698}

699

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

701{

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

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

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

705 if (contentY() < -m_minYExtent) {

706 return false;

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

708 return false;

709 }

710 bool changed = false;

711

712 bool foundVisible = false;

713 int i = 0;

714 int removedItems = 0;

715 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

717 ListItem *item = m_visibleItems[i];

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

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

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

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

722 releaseItem(item);

723 m_visibleItems.removeAt(i);

724 changed = true;

725 ++removedItems;

726 } else {

727 if (!foundVisible) {

728 foundVisible = true;

729 const int itemIndex = m_firstVisibleIndex + removedItems + i;

730 m_firstVisibleIndex = itemIndex;

731 }

732 ++i;

733 }

734 }

735 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

736 adjustMinYExtent();

737 }

738

739 return changed;

740}

741

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

743{

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

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

746 return nullptr;

747

748 m_asyncRequestedIndex = -1;

749#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

750 QQuickItem *item = m_delegateModel->item(modelIndex, asynchronous);

751#else

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

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

754#endif

755 if (!item) {

756#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

757 m_asyncRequestedIndex = modelIndex;

758#else

759 if (object) {

760 m_delegateModel->release(object);

761 if (!m_delegateValidated) {

762 m_delegateValidated = true;

763 QObject* delegateObj = delegate();

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

765 }

766 } else {

767 m_asyncRequestedIndex = modelIndex;

768 }

769#endif

770 return 0;

771 } else {

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

773 ListItem *listItem = new ListItem;

774 listItem->m_item = item;

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

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

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

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

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

780 // nor is the first item

781 if (prevItem) {

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

783 } else {

784 ListItem *currItem = itemAtIndex(modelIndex);

785 if (currItem) {

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

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

788 } else {

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

790 if (nextItem) {

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

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

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

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

795 lostItem = true;

796 }

797 }

798 }

799 if (lostItem) {

800 releaseItem(listItem);

801 listItem = nullptr;

802 } else {

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

804 if (m_visibleItems.isEmpty()) {

805 m_visibleItems << listItem;

806 } else {

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

808 }

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

810 m_firstVisibleIndex = modelIndex;

811 polish();

812 }

813 if (listItem->m_sectionItem) {

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

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

816 }

817 adjustMinYExtent();

818 m_contentHeightDirty = true;

819 }

820 return listItem;

821 }

822}

823

824#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

825void ListViewWithPageHeader::itemCreated(int modelIndex, QQuickItem *item)

826{

827#else

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

829{

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

831 if (!item) {

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

833 return;

834 }

835#endif

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

837

838 item->setParentItem(m_clipItem);

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

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

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

842 if (modelIndex == m_asyncRequestedIndex) {

843 createItem(modelIndex, false);

844 refill();

845 }

846}

847

848void ListViewWithPageHeader::updateClipItem()

849{

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

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

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

853}

854

855void ListViewWithPageHeader::onContentHeightChanged()

856{

857 updateClipItem();

858}

859

860void ListViewWithPageHeader::onContentWidthChanged()

861{

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

863}

864

865void ListViewWithPageHeader::onHeightChanged()

866{

867 polish();

868}

869

870

871#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

872void ListViewWithPageHeader::onModelUpdated(const QQuickChangeSet &changeSet, bool /*reset*/)

873#else

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

875#endif

876{

877 // TODO Do something with reset

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

879 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

880

881#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

882 Q_FOREACH(const QQuickChangeSet::Remove &remove, changeSet.removes()) {

883#else

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

885#endif

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

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

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

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

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

891 bool growDown = true;

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

893 const int modelIndex = remove.index + i;

894 ListItem *item = itemAtIndex(modelIndex);

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

896 growDown = false;

897 }

898 }

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

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

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

902 ListItem *item = m_visibleItems[visibleIndex];

903 // Pass the section item down if needed

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

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

906 if (!nextItem->m_sectionItem) {

907 nextItem->m_sectionItem = item->m_sectionItem;

908 item->m_sectionItem = nullptr;

909 }

910 }

911 releaseItem(item);

912 m_visibleItems.removeAt(visibleIndex);

913 }

914 }

915 if (growDown) {

916 adjustMinYExtent();

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

918 if (!m_visibleItems.isEmpty()) {

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

920 // position the new first item correctly

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

922 } else {

923 m_firstVisibleIndex = -1;

924 }

925 }

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

927 m_firstVisibleIndex -= remove.count;

928 }

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

930 const int modelIndex = remove.index + i;

931 if (modelIndex == m_asyncRequestedIndex) {

932 m_asyncRequestedIndex = -1;

933 } else if (modelIndex < m_asyncRequestedIndex) {

934 m_asyncRequestedIndex--;

935 }

936 }

937 }

938

939#if (QT_VERSION < QT_VERSION_CHECK(5, 1, 0))

940 Q_FOREACH(const QQuickChangeSet::Insert &insert, changeSet.inserts()) {

941#else

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

943#endif

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

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

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

947 if (insertingInValidIndexes || firstItemWithViewOnTop)

948 {

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

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

951 bool growUp = false;

952 if (!firstItemWithViewOnTop) {

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

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

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

956 growUp = true;

957 }

958 break;

959 }

960 }

961 }

962

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

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

965 const int modelIndex = insert.index + i;

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

967 if (growUp) {

968 ListItem *firstItem = m_visibleItems.first();

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

970 adjustMinYExtent();

971 }

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

973 // if we need adding a new section item

974 if (m_sectionDelegate) {

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

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

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

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

979 ListItem *firstItem = m_visibleItems.first();

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

981 adjustMinYExtent();

982 }

983 }

984 }

985 }

986 if (firstItemWithViewOnTop) {

987 ListItem *firstItem = m_visibleItems.first();

988 firstItem->setY(oldFirstValidIndexPos);

989 }

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

991 m_firstVisibleIndex += insert.count;

992 }

993

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

995 const int modelIndex = insert.index + i;

996 if (modelIndex <= m_asyncRequestedIndex) {

997 m_asyncRequestedIndex++;

998 }

999 }

1000 }

1001

1002 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1003 adjustMinYExtent();

1004 }

1005

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

1007 ListItem *item = m_visibleItems[i];

1008 if (item->m_sectionItem) {

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

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

1011 }

1012 }

1013

1014 layout();

1015 polish();

1016 m_contentHeightDirty = true;

1017}

1018

1019void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1020{

1021 m_contentHeightDirty = true;

1022 polish();

1023}

1024

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

1026{

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

1028 if (heightDiff != 0) {

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

1030 ListItem *firstItem = m_visibleItems.first();

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

1032 adjustMinYExtent();

1033 layout();

1034 }

1035 refill();

1036 adjustMinYExtent();

1037 polish();

1038 m_contentHeightDirty = true;

1039 }

1040}

1041

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

1043{

1044 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1045 if (m_headerItemShownHeight > 0) {

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

1047 // Change its size

1048 m_headerItemShownHeight += heightDiff;

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

1050 updateClipItem();

1051 adjustMinYExtent();

1052 } else {

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

1054 // If the header is shown because its position

1055 // Change its size

1056 ListItem *firstItem = m_visibleItems.first();

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

1058 layout();

1059 } else {

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

1061 // so the viewport is not changed

1062 adjustMinYExtent();

1063 }

1064 }

1065}

1066

1067

1068void ListViewWithPageHeader::adjustMinYExtent()

1069{

1070 if (m_visibleItems.isEmpty()) {

1071 m_minYExtent = 0;

1072 } else {

1073 qreal nonCreatedHeight = 0;

1074 if (m_firstVisibleIndex != 0) {

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

1076 const int visibleItems = m_visibleItems.count();

1077 qreal visibleItemsHeight = 0;

1078 Q_FOREACH(ListItem *item, m_visibleItems) {

1079 visibleItemsHeight += item->height();

1080 }

1081 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1083 }

1084 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + (m_headerItem ? m_headerItem->implicitHeight() : 0);

1085 }

1086}

1087

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

1089{

1090 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1092 return m_visibleItems[visibleIndexedModelIndex];

1093

1094 return nullptr;

1095}

1096

1097void ListViewWithPageHeader::layout()

1098{

1099 if (m_inLayout)

1100 return;

1101

1102 m_inLayout = true;

1103 if (!m_visibleItems.isEmpty()) {

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

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

1106

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

1108

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

1110 int firstReallyVisibleItem = -1;

1111 int modelIndex = m_firstVisibleIndex;

1112 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1114 item->setCulled(cull);

1115 item->setY(pos);

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

1117 firstReallyVisibleItem = modelIndex;

1118 if (m_topSectionItem) {

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

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

1121 // or stick it to the top

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

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

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

1125 bool showStickySectionItem;

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

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

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

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

1130 if (topSectionStickPos > pos) {

1131 showStickySectionItem = true;

1132 } else if (topSectionStickPos == pos) {

1133 showStickySectionItem = !item->m_sectionItem;

1134 } else {

1135 showStickySectionItem = false;

1136 }

1137 if (!showStickySectionItem) {

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

1139 if (item->m_sectionItem) {

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

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

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

1143 // gets shown shortly in the next polish call

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

1145 }

1146 } else {

1147 // Update the top sticky section header

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

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

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

1151

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

1153 m_topSectionItem->setY(topSectionStickPos);

1154 int delegateIndex = modelIndex;

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

1156 while (delegateIndex > 0) {

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

1158 if (prevSection != section)

1159 break;

1160 delegateIndex--;

1161 }

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

1163 if (item->m_sectionItem) {

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

1165 }

1166 }

1167 }

1168 }

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

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

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

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

1173 } else {

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

1175 }

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

1177 pos += item->height();

1178 ++modelIndex;

1179 }

1180

1181 // Second step of section sticky item positioning

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

1183 if (m_topSectionItem) {

1184 if (firstReallyVisibleItem >= 0) {

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

1186 ListItem *item = m_visibleItems[i];

1187 if (item->m_sectionItem) {

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

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

1190 }

1191 break;

1192 }

1193 }

1194 }

1195 }

1196 }

1197 m_inLayout = false;

1198}

1199

1200void ListViewWithPageHeader::updatePolish()

1201{

1202 Q_FOREACH(ListItem *item, m_itemsToRelease)

1203 reallyReleaseItem(item);

1204 m_itemsToRelease.clear();

1205

1206 if (!model())

1207 return;

1208

1209 layout();

1210

1211 refill();

1212

1213 if (m_contentHeightDirty) {

1214 qreal contentHeight;

1215 if (m_visibleItems.isEmpty()) {

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

1217 } else {

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

1219 const int visibleItems = m_visibleItems.count();

1220 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1221 qreal nonCreatedHeight = 0;

1222 if (lastValidIndex != modelCount - 1) {

1223 const int visibleItems = m_visibleItems.count();

1224 qreal visibleItemsHeight = 0;

1225 Q_FOREACH(ListItem *item, m_visibleItems) {

1226 visibleItemsHeight += item->height();

1227 }

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

1229 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1230 }

1231 ListItem *item = m_visibleItems.last();

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

1233 if (m_firstVisibleIndex != 0) {

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

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

1236 }

1237 }

1238

1239 m_contentHeightDirty = false;

1240 setContentHeight(contentHeight);

1241 }

1242}

1243

1244#include "moc_listviewwithpageheader.cpp"