plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

424 {

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

426 auto realVisibleListItemY = listItemY;

427 if (m_topSectionItem) {

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

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

430 // the top section sticky item

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

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

433 realVisibleListItemY -= m_topSectionItem->height();

434 }

435 }

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

437 m_contentYAnimation->setTo(to);

438 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

439 m_contentYAnimation->start();

440 }

441 return true;

442 }

443 return false;

444}

445

446qreal ListViewWithPageHeader::minYExtent() const

447{

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

449 return m_minYExtent;

450}

451

452void ListViewWithPageHeader::componentComplete()

453{

454 if (m_delegateModel)

455 m_delegateModel->componentComplete();

456

457 QQuickFlickable::componentComplete();

458

459 polish();

460}

461

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

463{

464 QQuickFlickable::viewportMoved(orient);

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

466 qreal diff = m_previousContentY - contentY();

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

468 if (m_headerItem) {

469 auto oldHeaderItemShownHeight = m_headerItemShownHeight;

470 if (contentY() < -m_minYExtent) {

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

472 m_headerItem->setY(contentY());

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

474 } else {

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

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

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

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

479 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

483

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

485 m_headerItemShownHeight = 0;

486 m_headerItem->setY(contentY());

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

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

489 m_headerItemShownHeight -= diff;

490 else

491 m_headerItemShownHeight += diff;

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

493 m_headerItemShownHeight = 0;

494 } else {

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

496 }

497 if (m_headerItemShownHeight > 0) {

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

499 } else {

500 m_headerItem->setY(-m_minYExtent);

501 }

502 }

503 }

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

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

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

507 if (!showHeaderAnimationRunning) {

508 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

509 } else {

510 diff = -diff;

511 }

512 }

513 if (!m_visibleItems.isEmpty()) {

514 updateClipItem();

515 ListItem *firstItem = m_visibleItems.first();

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

517 if (showHeaderAnimationRunning) {

518 adjustMinYExtent();

519 }

520 }

521

522 m_previousContentY = contentY();

523 layout();

524 polish();

525}

526

527void ListViewWithPageHeader::createDelegateModel()

528{

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

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

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

532#else

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

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

535#endif

536 if (isComponentComplete())

537 m_delegateModel->componentComplete();

538 updateWatchedRoles();

539}

540

541void ListViewWithPageHeader::refill()

542{

543 if (m_inLayout) {

544 return;

545 }

546 if (!isComponentComplete()) {

547 return;

548 }

549

550 const qreal buffer = height() * bufferRatio;

551 const qreal from = contentY();

552 const qreal to = from + height();

553 const qreal bufferFrom = from - buffer;

554 const qreal bufferTo = to + buffer;

555

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

557 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

559

560 if (added || removed) {

561 m_contentHeightDirty = true;

562 }

563}

564

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

566{

567 if (!delegate())

568 return false;

569

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

571 return false;

572

573 ListItem *item;

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

575

576 int modelIndex = 0;

577 qreal pos = 0;

578 if (!m_visibleItems.isEmpty()) {

579 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

580 item = m_visibleItems.last();

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

582 }

583 bool changed = false;

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

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

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

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

588 break;

589 pos += item->height();

590 ++modelIndex;

591 changed = true;

592 }

593

594 modelIndex = 0;

595 pos = 0;

596 if (!m_visibleItems.isEmpty()) {

597 modelIndex = m_firstVisibleIndex - 1;

598 item = m_visibleItems.first();

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

600 }

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

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

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

604 break;

605 pos -= item->height();

606 --modelIndex;

607 changed = true;

608 }

609

610 return changed;

611}

612

613void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

614{

615 QQuickItem *item = listItem->m_item;

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

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

618 if (flags & QQuickVisualModel::Destroyed) {

619#else

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

621 if (flags & QQmlDelegateModel::Destroyed) {

622#endif

623 item->setParentItem(nullptr);

624 }

625 delete listItem->m_sectionItem;

626 delete listItem;

627}

628

629void ListViewWithPageHeader::releaseItem(ListItem *listItem)

630{

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

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

633 m_itemsToRelease << listItem;

634}

635

636void ListViewWithPageHeader::updateWatchedRoles()

637{

638 if (m_delegateModel) {

639 QList<QByteArray> roles;

640 if (!m_sectionProperty.isEmpty())

641 roles << m_sectionProperty.toUtf8();

642 m_delegateModel->setWatchedRoles(roles);

643 }

644}

645

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

647{

648 if (!m_sectionDelegate)

649 return nullptr;

650

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

652 if (modelIndex > 0) {

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

654 if (section == prevSection)

655 return nullptr;

656 }

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

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

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

660 if (section == nextSection) {

661 // Steal the section header

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

663 if (nextItem) {

664 QQuickItem *sectionItem = nextItem->m_sectionItem;

665 nextItem->m_sectionItem = nullptr;

666 return sectionItem;

667 }

668 }

669 }

670

671 return getSectionItem(section);

672}

673

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

675{

676 QQuickItem *sectionItem = nullptr;

677

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

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

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

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

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

683 if (nobj) {

684 QQml_setParent_noEvent(context, nobj);

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

686 if (!sectionItem) {

687 delete nobj;

688 } else {

689 sectionItem->setZ(2);

690 QQml_setParent_noEvent(sectionItem, m_clipItem);

691 sectionItem->setParentItem(m_clipItem);

692 }

693 } else {

694 delete context;

695 }

696 m_sectionDelegate->completeCreate();

697

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

699

700 return sectionItem;

701}

702

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

704{

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

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

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

708 if (contentY() < -m_minYExtent) {

709 return false;

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

711 return false;

712 }

713 bool changed = false;

714

715 bool foundVisible = false;

716 int i = 0;

717 int removedItems = 0;

718 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

720 ListItem *item = m_visibleItems[i];

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

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

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

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

725 releaseItem(item);

726 m_visibleItems.removeAt(i);

727 changed = true;

728 ++removedItems;

729 } else {

730 if (!foundVisible) {

731 foundVisible = true;

732 const int itemIndex = m_firstVisibleIndex + removedItems + i;

733 m_firstVisibleIndex = itemIndex;

734 }

735 ++i;

736 }

737 }

738 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

739 adjustMinYExtent();

740 }

741

742 return changed;

743}

744

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

746{

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

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

749 return nullptr;

750

751 m_asyncRequestedIndex = -1;

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

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

754#else

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

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

757#endif

758 if (!item) {

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

760 m_asyncRequestedIndex = modelIndex;

761#else

762 if (object) {

763 m_delegateModel->release(object);

764 if (!m_delegateValidated) {

765 m_delegateValidated = true;

766 QObject* delegateObj = delegate();

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

768 }

769 } else {

770 m_asyncRequestedIndex = modelIndex;

771 }

772#endif

773 return 0;

774 } else {

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

776 ListItem *listItem = new ListItem;

777 listItem->m_item = item;

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

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

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

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

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

783 // nor is the first item

784 if (prevItem) {

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

786 } else {

787 ListItem *currItem = itemAtIndex(modelIndex);

788 if (currItem) {

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

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

791 } else {

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

793 if (nextItem) {

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

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

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

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

798 lostItem = true;

799 }

800 }

801 }

802 if (lostItem) {

803 releaseItem(listItem);

804 listItem = nullptr;

805 } else {

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

807 if (m_visibleItems.isEmpty()) {

808 m_visibleItems << listItem;

809 } else {

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

811 }

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

813 m_firstVisibleIndex = modelIndex;

814 polish();

815 }

816 if (listItem->m_sectionItem) {

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

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

819 }

820 adjustMinYExtent();

821 m_contentHeightDirty = true;

822 }

823 return listItem;

824 }

825}

826

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

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

829{

830#else

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

832{

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

834 if (!item) {

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

836 return;

837 }

838#endif

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

840

841 item->setParentItem(m_clipItem);

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

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

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

845 if (modelIndex == m_asyncRequestedIndex) {

846 createItem(modelIndex, false);

847 refill();

848 }

849}

850

851void ListViewWithPageHeader::updateClipItem()

852{

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

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

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

856}

857

858void ListViewWithPageHeader::onContentHeightChanged()

859{

860 updateClipItem();

861}

862

863void ListViewWithPageHeader::onContentWidthChanged()

864{

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

866}

867

868void ListViewWithPageHeader::onHeightChanged()

869{

870 polish();

871}

872

873

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

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

876#else

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

878#endif

879{

880 // TODO Do something with reset

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

882 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

883

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

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

886#else

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

888#endif

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

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

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

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

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

894 bool growDown = true;

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

896 const int modelIndex = remove.index + i;

897 ListItem *item = itemAtIndex(modelIndex);

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

899 growDown = false;

900 }

901 }

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

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

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

905 ListItem *item = m_visibleItems[visibleIndex];

906 // Pass the section item down if needed

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

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

909 if (!nextItem->m_sectionItem) {

910 nextItem->m_sectionItem = item->m_sectionItem;

911 item->m_sectionItem = nullptr;

912 }

913 }

914 releaseItem(item);

915 m_visibleItems.removeAt(visibleIndex);

916 }

917 }

918 if (growDown) {

919 adjustMinYExtent();

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

921 if (!m_visibleItems.isEmpty()) {

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

923 // position the new first item correctly

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

925 } else {

926 m_firstVisibleIndex = -1;

927 }

928 }

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

930 m_firstVisibleIndex -= remove.count;

931 }

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

933 const int modelIndex = remove.index + i;

934 if (modelIndex == m_asyncRequestedIndex) {

935 m_asyncRequestedIndex = -1;

936 } else if (modelIndex < m_asyncRequestedIndex) {

937 m_asyncRequestedIndex--;

938 }

939 }

940 }

941

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

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

944#else

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

946#endif

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

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

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

950 if (insertingInValidIndexes || firstItemWithViewOnTop)

951 {

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

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

954 bool growUp = false;

955 if (!firstItemWithViewOnTop) {

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

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

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

959 growUp = true;

960 }

961 break;

962 }

963 }

964 }

965

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

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

968 const int modelIndex = insert.index + i;

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

970 if (growUp) {

971 ListItem *firstItem = m_visibleItems.first();

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

973 adjustMinYExtent();

974 }

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

976 // if we need adding a new section item

977 if (m_sectionDelegate) {

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

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

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

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

982 ListItem *firstItem = m_visibleItems.first();

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

984 adjustMinYExtent();

985 }

986 }

987 }

988 }

989 if (firstItemWithViewOnTop) {

990 ListItem *firstItem = m_visibleItems.first();

991 firstItem->setY(oldFirstValidIndexPos);

992 }

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

994 m_firstVisibleIndex += insert.count;

995 }

996

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

998 const int modelIndex = insert.index + i;

999 if (modelIndex <= m_asyncRequestedIndex) {

1000 m_asyncRequestedIndex++;

1001 }

1002 }

1003 }

1004

1005 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1006 adjustMinYExtent();

1007 }

1008

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

1010 ListItem *item = m_visibleItems[i];

1011 if (item->m_sectionItem) {

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

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

1014 }

1015 }

1016

1017 layout();

1018 polish();

1019 m_contentHeightDirty = true;

1020}

1021

1022void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1023{

1024 m_contentHeightDirty = true;

1025 polish();

1026}

1027

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

1029{

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

1031 if (heightDiff != 0) {

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

1033 ListItem *firstItem = m_visibleItems.first();

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

1035 adjustMinYExtent();

1036 layout();

1037 }

1038 refill();

1039 adjustMinYExtent();

1040 polish();

1041 m_contentHeightDirty = true;

1042 }

1043}

1044

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

1046{

1047 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1048 if (m_headerItemShownHeight > 0) {

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

1050 // Change its size

1051 m_headerItemShownHeight += heightDiff;

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

1053 updateClipItem();

1054 adjustMinYExtent();

1055 } else {

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

1057 // If the header is shown because its position

1058 // Change its size

1059 ListItem *firstItem = m_visibleItems.first();

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

1061 layout();

1062 } else {

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

1064 // so the viewport is not changed

1065 adjustMinYExtent();

1066 }

1067 }

1068}

1069

1070

1071void ListViewWithPageHeader::adjustMinYExtent()

1072{

1073 if (m_visibleItems.isEmpty()) {

1074 m_minYExtent = 0;

1075 } else {

1076 qreal nonCreatedHeight = 0;

1077 if (m_firstVisibleIndex != 0) {

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

1079 const int visibleItems = m_visibleItems.count();

1080 qreal visibleItemsHeight = 0;

1081 Q_FOREACH(ListItem *item, m_visibleItems) {

1082 visibleItemsHeight += item->height();

1083 }

1084 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1086 }

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

1088 }

1089}

1090

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

1092{

1093 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1095 return m_visibleItems[visibleIndexedModelIndex];

1096

1097 return nullptr;

1098}

1099

1100void ListViewWithPageHeader::layout()

1101{

1102 if (m_inLayout)

1103 return;

1104

1105 m_inLayout = true;

1106 if (!m_visibleItems.isEmpty()) {

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

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

1109

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

1111

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

1113 int firstReallyVisibleItem = -1;

1114 int modelIndex = m_firstVisibleIndex;

1115 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1117 item->setCulled(cull);

1118 item->setY(pos);

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

1120 firstReallyVisibleItem = modelIndex;

1121 if (m_topSectionItem) {

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

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

1124 // or stick it to the top

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

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

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

1128 bool showStickySectionItem;

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

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

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

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

1133 if (topSectionStickPos > pos) {

1134 showStickySectionItem = true;

1135 } else if (topSectionStickPos == pos) {

1136 showStickySectionItem = !item->m_sectionItem;

1137 } else {

1138 showStickySectionItem = false;

1139 }

1140 if (!showStickySectionItem) {

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

1142 if (item->m_sectionItem) {

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

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

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

1146 // gets shown shortly in the next polish call

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

1148 }

1149 } else {

1150 // Update the top sticky section header

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

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

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

1154

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

1156 m_topSectionItem->setY(topSectionStickPos);

1157 int delegateIndex = modelIndex;

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

1159 while (delegateIndex > 0) {

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

1161 if (prevSection != section)

1162 break;

1163 delegateIndex--;

1164 }

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

1166 if (item->m_sectionItem) {

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

1168 }

1169 }

1170 }

1171 }

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

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

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

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

1176 } else {

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

1178 }

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

1180 pos += item->height();

1181 ++modelIndex;

1182 }

1183

1184 // Second step of section sticky item positioning

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

1186 if (m_topSectionItem) {

1187 if (firstReallyVisibleItem >= 0) {

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

1189 ListItem *item = m_visibleItems[i];

1190 if (item->m_sectionItem) {

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

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

1193 }

1194 break;

1195 }

1196 }

1197 }

1198 }

1199 }

1200 m_inLayout = false;

1201}

1202

1203void ListViewWithPageHeader::updatePolish()

1204{

1205 Q_FOREACH(ListItem *item, m_itemsToRelease)

1206 reallyReleaseItem(item);

1207 m_itemsToRelease.clear();

1208

1209 if (!model())

1210 return;

1211

1212 layout();

1213

1214 refill();

1215

1216 if (m_contentHeightDirty) {

1217 qreal contentHeight;

1218 if (m_visibleItems.isEmpty()) {

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

1220 } else {

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

1222 const int visibleItems = m_visibleItems.count();

1223 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1224 qreal nonCreatedHeight = 0;

1225 if (lastValidIndex != modelCount - 1) {

1226 const int visibleItems = m_visibleItems.count();

1227 qreal visibleItemsHeight = 0;

1228 Q_FOREACH(ListItem *item, m_visibleItems) {

1229 visibleItemsHeight += item->height();

1230 }

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

1232 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1233 }

1234 ListItem *item = m_visibleItems.last();

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

1236 if (m_firstVisibleIndex != 0) {

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

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

1239 }

1240 }

1241

1242 m_contentHeightDirty = false;

1243 setContentHeight(contentHeight);

1244 }

1245}

1246

1247#include "moc_listviewwithpageheader.cpp"