plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

428 {

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

430 auto realVisibleListItemY = listItemY;

431 if (m_topSectionItem) {

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

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

434 // the top section sticky item

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

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

437 realVisibleListItemY -= m_topSectionItem->height();

438 }

439 }

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

441 m_contentYAnimation->setTo(to);

442 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

443 m_contentYAnimation->start();

444 }

445 return true;

446 }

447 return false;

448}

449

450qreal ListViewWithPageHeader::minYExtent() const

451{

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

453 return m_minYExtent;

454}

455

456void ListViewWithPageHeader::componentComplete()

457{

458 if (m_delegateModel)

459 m_delegateModel->componentComplete();

460

461 QQuickFlickable::componentComplete();

462

463 polish();

464}

465

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

467{

468 QQuickFlickable::viewportMoved(orient);

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

470 qreal diff = m_previousContentY - contentY();

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

472 if (m_headerItem) {

473 auto oldHeaderItemShownHeight = m_headerItemShownHeight;

474 if (contentY() < -m_minYExtent) {

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

476 m_headerItem->setY(contentY());

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

478 } else {

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

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

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

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

483 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

487

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

489 m_headerItemShownHeight = 0;

490 m_headerItem->setY(contentY());

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

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

493 m_headerItemShownHeight -= diff;

494 else

495 m_headerItemShownHeight += diff;

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

497 m_headerItemShownHeight = 0;

498 } else {

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

500 }

501 if (m_headerItemShownHeight > 0) {

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

503 } else {

504 m_headerItem->setY(-m_minYExtent);

505 }

506 }

507 }

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

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

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

511 if (!showHeaderAnimationRunning) {

512 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

513 } else {

514 diff = -diff;

515 }

516 }

517 if (!m_visibleItems.isEmpty()) {

518 updateClipItem();

519 ListItem *firstItem = m_visibleItems.first();

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

521 if (showHeaderAnimationRunning) {

522 adjustMinYExtent();

523 }

524 }

525

526 m_previousContentY = contentY();

527 layout();

528 polish();

529}

530

531void ListViewWithPageHeader::createDelegateModel()

532{

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

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

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

536#else

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

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

539#endif

540 if (isComponentComplete())

541 m_delegateModel->componentComplete();

542 updateWatchedRoles();

543}

544

545void ListViewWithPageHeader::refill()

546{

547 if (m_inLayout) {

548 return;

549 }

550 if (!isComponentComplete()) {

551 return;

552 }

553

554 const qreal buffer = height() * bufferRatio;

555 const qreal from = contentY();

556 const qreal to = from + height();

557 const qreal bufferFrom = from - buffer;

558 const qreal bufferTo = to + buffer;

559

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

561 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

563

564 if (added || removed) {

565 m_contentHeightDirty = true;

566 }

567}

568

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

570{

571 if (!delegate())

572 return false;

573

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

575 return false;

576

577 ListItem *item;

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

579

580 int modelIndex = 0;

581 qreal pos = 0;

582 if (!m_visibleItems.isEmpty()) {

583 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

584 item = m_visibleItems.last();

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

586 }

587 bool changed = false;

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

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

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

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

592 break;

593 pos += item->height();

594 ++modelIndex;

595 changed = true;

596 }

597

598 modelIndex = 0;

599 pos = 0;

600 if (!m_visibleItems.isEmpty()) {

601 modelIndex = m_firstVisibleIndex - 1;

602 item = m_visibleItems.first();

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

604 }

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

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

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

608 break;

609 pos -= item->height();

610 --modelIndex;

611 changed = true;

612 }

613

614 return changed;

615}

616

617void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

618{

619 QQuickItem *item = listItem->m_item;

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

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

622 if (flags & QQuickVisualModel::Destroyed) {

623#else

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

625 if (flags & QQmlDelegateModel::Destroyed) {

626#endif

627 item->setParentItem(nullptr);

628 }

629 delete listItem->m_sectionItem;

630 delete listItem;

631}

632

633void ListViewWithPageHeader::releaseItem(ListItem *listItem)

634{

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

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

637 m_itemsToRelease << listItem;

638}

639

640void ListViewWithPageHeader::updateWatchedRoles()

641{

642 if (m_delegateModel) {

643 QList<QByteArray> roles;

644 if (!m_sectionProperty.isEmpty())

645 roles << m_sectionProperty.toUtf8();

646 m_delegateModel->setWatchedRoles(roles);

647 }

648}

649

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

651{

652 if (!m_sectionDelegate)

653 return nullptr;

654

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

656 if (modelIndex > 0) {

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

658 if (section == prevSection)

659 return nullptr;

660 }

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

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

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

664 if (section == nextSection) {

665 // Steal the section header

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

667 if (nextItem) {

668 QQuickItem *sectionItem = nextItem->m_sectionItem;

669 nextItem->m_sectionItem = nullptr;

670 return sectionItem;

671 }

672 }

673 }

674

675 return getSectionItem(section);

676}

677

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

679{

680 QQuickItem *sectionItem = nullptr;

681

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

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

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

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

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

687 if (nobj) {

688 QQml_setParent_noEvent(context, nobj);

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

690 if (!sectionItem) {

691 delete nobj;

692 } else {

693 sectionItem->setZ(2);

694 QQml_setParent_noEvent(sectionItem, m_clipItem);

695 sectionItem->setParentItem(m_clipItem);

696 }

697 } else {

698 delete context;

699 }

700 m_sectionDelegate->completeCreate();

701

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

703

704 return sectionItem;

705}

706

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

708{

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

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

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

712 if (contentY() < -m_minYExtent) {

713 return false;

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

715 return false;

716 }

717 bool changed = false;

718

719 bool foundVisible = false;

720 int i = 0;

721 int removedItems = 0;

722 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

724 ListItem *item = m_visibleItems[i];

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

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

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

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

729 releaseItem(item);

730 m_visibleItems.removeAt(i);

731 changed = true;

732 ++removedItems;

733 } else {

734 if (!foundVisible) {

735 foundVisible = true;

736 const int itemIndex = m_firstVisibleIndex + removedItems + i;

737 m_firstVisibleIndex = itemIndex;

738 }

739 ++i;

740 }

741 }

742 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

743 adjustMinYExtent();

744 }

745

746 return changed;

747}

748

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

750{

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

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

753 return nullptr;

754

755 m_asyncRequestedIndex = -1;

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

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

758#else

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

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

761#endif

762 if (!item) {

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

764 m_asyncRequestedIndex = modelIndex;

765#else

766 if (object) {

767 m_delegateModel->release(object);

768 if (!m_delegateValidated) {

769 m_delegateValidated = true;

770 QObject* delegateObj = delegate();

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

772 }

773 } else {

774 m_asyncRequestedIndex = modelIndex;

775 }

776#endif

777 return 0;

778 } else {

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

780 ListItem *listItem = new ListItem;

781 listItem->m_item = item;

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

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

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

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

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

787 // nor is the first item

788 if (prevItem) {

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

790 } else {

791 ListItem *currItem = itemAtIndex(modelIndex);

792 if (currItem) {

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

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

795 } else {

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

797 if (nextItem) {

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

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

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

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

802 lostItem = true;

803 }

804 }

805 }

806 if (lostItem) {

807 releaseItem(listItem);

808 listItem = nullptr;

809 } else {

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

811 if (m_visibleItems.isEmpty()) {

812 m_visibleItems << listItem;

813 } else {

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

815 }

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

817 m_firstVisibleIndex = modelIndex;

818 polish();

819 }

820 if (listItem->m_sectionItem) {

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

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

823 }

824 adjustMinYExtent();

825 m_contentHeightDirty = true;

826 }

827 return listItem;

828 }

829}

830

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

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

833{

834#else

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

836{

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

838 if (!item) {

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

840 return;

841 }

842#endif

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

844

845 item->setParentItem(m_clipItem);

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

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

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

849 if (modelIndex == m_asyncRequestedIndex) {

850 createItem(modelIndex, false);

851 refill();

852 }

853}

854

855void ListViewWithPageHeader::updateClipItem()

856{

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

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

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

860}

861

862void ListViewWithPageHeader::onContentHeightChanged()

863{

864 updateClipItem();

865}

866

867void ListViewWithPageHeader::onContentWidthChanged()

868{

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

870}

871

872void ListViewWithPageHeader::onHeightChanged()

873{

874 polish();

875}

876

877

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

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

880#else

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

882#endif

883{

884 // TODO Do something with reset

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

886 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

887

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

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

890#else

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

892#endif

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

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

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

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

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

898 bool growDown = true;

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

900 const int modelIndex = remove.index + i;

901 ListItem *item = itemAtIndex(modelIndex);

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

903 growDown = false;

904 }

905 }

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

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

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

909 ListItem *item = m_visibleItems[visibleIndex];

910 // Pass the section item down if needed

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

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

913 if (!nextItem->m_sectionItem) {

914 nextItem->m_sectionItem = item->m_sectionItem;

915 item->m_sectionItem = nullptr;

916 }

917 }

918 releaseItem(item);

919 m_visibleItems.removeAt(visibleIndex);

920 }

921 }

922 if (growDown) {

923 adjustMinYExtent();

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

925 if (!m_visibleItems.isEmpty()) {

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

927 // position the new first item correctly

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

929 } else {

930 m_firstVisibleIndex = -1;

931 }

932 }

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

934 m_firstVisibleIndex -= remove.count;

935 }

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

937 const int modelIndex = remove.index + i;

938 if (modelIndex == m_asyncRequestedIndex) {

939 m_asyncRequestedIndex = -1;

940 } else if (modelIndex < m_asyncRequestedIndex) {

941 m_asyncRequestedIndex--;

942 }

943 }

944 }

945

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

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

948#else

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

950#endif

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

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

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

954 if (insertingInValidIndexes || firstItemWithViewOnTop)

955 {

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

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

958 bool growUp = false;

959 if (!firstItemWithViewOnTop) {

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

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

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

963 growUp = true;

964 }

965 break;

966 }

967 }

968 }

969

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

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

972 const int modelIndex = insert.index + i;

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

974 if (growUp) {

975 ListItem *firstItem = m_visibleItems.first();

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

977 adjustMinYExtent();

978 }

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

980 // if we need adding a new section item

981 if (m_sectionDelegate) {

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

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

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

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

986 ListItem *firstItem = m_visibleItems.first();

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

988 adjustMinYExtent();

989 }

990 }

991 }

992 }

993 if (firstItemWithViewOnTop) {

994 ListItem *firstItem = m_visibleItems.first();

995 firstItem->setY(oldFirstValidIndexPos);

996 }

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

998 m_firstVisibleIndex += insert.count;

999 }

1000

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

1002 const int modelIndex = insert.index + i;

1003 if (modelIndex <= m_asyncRequestedIndex) {

1004 m_asyncRequestedIndex++;

1005 }

1006 }

1007 }

1008

1009 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1010 adjustMinYExtent();

1011 }

1012

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

1014 ListItem *item = m_visibleItems[i];

1015 if (item->m_sectionItem) {

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

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

1018 }

1019 }

1020

1021 layout();

1022 polish();

1023 m_contentHeightDirty = true;

1024}

1025

1026void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1027{

1028 m_contentHeightDirty = true;

1029 polish();

1030}

1031

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

1033{

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

1035 if (heightDiff != 0) {

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

1037 ListItem *firstItem = m_visibleItems.first();

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

1039 adjustMinYExtent();

1040 layout();

1041 }

1042 refill();

1043 adjustMinYExtent();

1044 polish();

1045 m_contentHeightDirty = true;

1046 }

1047}

1048

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

1050{

1051 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1052 if (m_headerItemShownHeight > 0) {

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

1054 // Change its size

1055 m_headerItemShownHeight += heightDiff;

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

1057 updateClipItem();

1058 adjustMinYExtent();

1059 } else {

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

1061 // If the header is shown because its position

1062 // Change its size

1063 ListItem *firstItem = m_visibleItems.first();

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

1065 layout();

1066 } else {

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

1068 // so the viewport is not changed

1069 adjustMinYExtent();

1070 }

1071 }

1072}

1073

1074

1075void ListViewWithPageHeader::adjustMinYExtent()

1076{

1077 if (m_visibleItems.isEmpty()) {

1078 m_minYExtent = 0;

1079 } else {

1080 qreal nonCreatedHeight = 0;

1081 if (m_firstVisibleIndex != 0) {

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

1083 const int visibleItems = m_visibleItems.count();

1084 qreal visibleItemsHeight = 0;

1085 Q_FOREACH(ListItem *item, m_visibleItems) {

1086 visibleItemsHeight += item->height();

1087 }

1088 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1090 }

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

1092 }

1093}

1094

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

1096{

1097 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1099 return m_visibleItems[visibleIndexedModelIndex];

1100

1101 return nullptr;

1102}

1103

1104void ListViewWithPageHeader::layout()

1105{

1106 if (m_inLayout)

1107 return;

1108

1109 m_inLayout = true;

1110 if (!m_visibleItems.isEmpty()) {

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

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

1113

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

1115

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

1117 int firstReallyVisibleItem = -1;

1118 int modelIndex = m_firstVisibleIndex;

1119 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1121 item->setCulled(cull);

1122 item->setY(pos);

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

1124 firstReallyVisibleItem = modelIndex;

1125 if (m_topSectionItem) {

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

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

1128 // or stick it to the top

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

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

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

1132 bool showStickySectionItem;

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

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

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

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

1137 if (topSectionStickPos > pos) {

1138 showStickySectionItem = true;

1139 } else if (topSectionStickPos == pos) {

1140 showStickySectionItem = !item->m_sectionItem;

1141 } else {

1142 showStickySectionItem = false;

1143 }

1144 if (!showStickySectionItem) {

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

1146 if (item->m_sectionItem) {

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

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

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

1150 // gets shown shortly in the next polish call

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

1152 }

1153 } else {

1154 // Update the top sticky section header

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

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

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

1158

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

1160 m_topSectionItem->setY(topSectionStickPos);

1161 int delegateIndex = modelIndex;

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

1163 while (delegateIndex > 0) {

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

1165 if (prevSection != section)

1166 break;

1167 delegateIndex--;

1168 }

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

1170 if (item->m_sectionItem) {

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

1172 }

1173 }

1174 }

1175 }

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

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

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

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

1180 } else {

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

1182 }

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

1184 pos += item->height();

1185 ++modelIndex;

1186 }

1187

1188 // Second step of section sticky item positioning

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

1190 if (m_topSectionItem) {

1191 if (firstReallyVisibleItem >= 0) {

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

1193 ListItem *item = m_visibleItems[i];

1194 if (item->m_sectionItem) {

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

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

1197 }

1198 break;

1199 }

1200 }

1201 }

1202 }

1203 }

1204 m_inLayout = false;

1205}

1206

1207void ListViewWithPageHeader::updatePolish()

1208{

1209 Q_FOREACH(ListItem *item, m_itemsToRelease)

1210 reallyReleaseItem(item);

1211 m_itemsToRelease.clear();

1212

1213 if (!model())

1214 return;

1215

1216 layout();

1217

1218 refill();

1219

1220 if (m_contentHeightDirty) {

1221 qreal contentHeight;

1222 if (m_visibleItems.isEmpty()) {

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

1224 } else {

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

1226 const int visibleItems = m_visibleItems.count();

1227 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1228 qreal nonCreatedHeight = 0;

1229 if (lastValidIndex != modelCount - 1) {

1230 const int visibleItems = m_visibleItems.count();

1231 qreal visibleItemsHeight = 0;

1232 Q_FOREACH(ListItem *item, m_visibleItems) {

1233 visibleItemsHeight += item->height();

1234 }

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

1236 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1237 }

1238 ListItem *item = m_visibleItems.last();

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

1240 if (m_firstVisibleIndex != 0) {

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

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

1243 }

1244 }

1245

1246 m_contentHeightDirty = false;

1247 adjustMinYExtent();

1248 setContentHeight(contentHeight);

1249 }

1250}

1251

1252#include "moc_listviewwithpageheader.cpp"