plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

435 {

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

437 auto realVisibleListItemY = listItemY;

438 if (m_topSectionItem) {

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

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

441 // the top section sticky item

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

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

444 realVisibleListItemY -= m_topSectionItem->height();

445 }

446 }

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

448 m_contentYAnimation->setTo(to);

449 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

450 m_contentYAnimation->start();

451 }

452 return true;

453 }

454 return false;

455}

456

457qreal ListViewWithPageHeader::minYExtent() const

458{

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

460 return m_minYExtent;

461}

462

463void ListViewWithPageHeader::componentComplete()

464{

465 if (m_delegateModel)

466 m_delegateModel->componentComplete();

467

468 QQuickFlickable::componentComplete();

469

470 polish();

471}

472

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

474{

475 QQuickFlickable::viewportMoved(orient);

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

477 qreal diff = m_previousContentY - contentY();

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

479 if (m_headerItem) {

480 auto oldHeaderItemShownHeight = m_headerItemShownHeight;

481 if (contentY() < -m_minYExtent) {

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

483 m_headerItem->setY(contentY());

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

485 } else {

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

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

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

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

490 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

494

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

496 m_headerItemShownHeight = 0;

497 m_headerItem->setY(contentY());

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

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

500 m_headerItemShownHeight -= diff;

501 else

502 m_headerItemShownHeight += diff;

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

504 m_headerItemShownHeight = 0;

505 } else {

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

507 }

508 if (m_headerItemShownHeight > 0) {

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

510 } else {

511 m_headerItem->setY(-m_minYExtent);

512 }

513 }

514 }

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

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

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

518 if (!showHeaderAnimationRunning) {

519 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

520 } else {

521 diff = -diff;

522 }

523 }

524 if (!m_visibleItems.isEmpty()) {

525 updateClipItem();

526 ListItem *firstItem = m_visibleItems.first();

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

528 if (showHeaderAnimationRunning) {

529 adjustMinYExtent();

530 }

531 }

532

533 m_previousContentY = contentY();

534 layout();

535 polish();

536}

537

538void ListViewWithPageHeader::createDelegateModel()

539{

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

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

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

543#else

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

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

546#endif

547 if (isComponentComplete())

548 m_delegateModel->componentComplete();

549 updateWatchedRoles();

550}

551

552void ListViewWithPageHeader::refill()

553{

554 if (m_inLayout) {

555 return;

556 }

557 if (!isComponentComplete()) {

558 return;

559 }

560

561 const qreal buffer = height() * bufferRatio;

562 const qreal from = contentY();

563 const qreal to = from + height();

564 const qreal bufferFrom = from - buffer;

565 const qreal bufferTo = to + buffer;

566

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

568 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

570

571 if (added || removed) {

572 m_contentHeightDirty = true;

573 }

574}

575

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

577{

578 if (!delegate())

579 return false;

580

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

582 return false;

583

584 ListItem *item;

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

586

587 int modelIndex = 0;

588 qreal pos = 0;

589 if (!m_visibleItems.isEmpty()) {

590 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

591 item = m_visibleItems.last();

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

593 }

594 bool changed = false;

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

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

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

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

599 break;

600 pos += item->height();

601 ++modelIndex;

602 changed = true;

603 }

604

605 modelIndex = 0;

606 pos = 0;

607 if (!m_visibleItems.isEmpty()) {

608 modelIndex = m_firstVisibleIndex - 1;

609 item = m_visibleItems.first();

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

611 }

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

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

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

615 break;

616 pos -= item->height();

617 --modelIndex;

618 changed = true;

619 }

620

621 return changed;

622}

623

624void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

625{

626 QQuickItem *item = listItem->m_item;

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

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

629 if (flags & QQuickVisualModel::Destroyed) {

630#else

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

632 if (flags & QQmlDelegateModel::Destroyed) {

633#endif

634 item->setParentItem(nullptr);

635 }

636 delete listItem->m_sectionItem;

637 delete listItem;

638}

639

640void ListViewWithPageHeader::releaseItem(ListItem *listItem)

641{

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

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

644 m_itemsToRelease << listItem;

645}

646

647void ListViewWithPageHeader::updateWatchedRoles()

648{

649 if (m_delegateModel) {

650 QList<QByteArray> roles;

651 if (!m_sectionProperty.isEmpty())

652 roles << m_sectionProperty.toUtf8();

653 m_delegateModel->setWatchedRoles(roles);

654 }

655}

656

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

658{

659 if (!m_sectionDelegate)

660 return nullptr;

661

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

663 if (modelIndex > 0) {

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

665 if (section == prevSection)

666 return nullptr;

667 }

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

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

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

671 if (section == nextSection) {

672 // Steal the section header

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

674 if (nextItem) {

675 QQuickItem *sectionItem = nextItem->m_sectionItem;

676 nextItem->m_sectionItem = nullptr;

677 return sectionItem;

678 }

679 }

680 }

681

682 return getSectionItem(section);

683}

684

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

686{

687 QQuickItem *sectionItem = nullptr;

688

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

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

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

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

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

694 if (nobj) {

695 QQml_setParent_noEvent(context, nobj);

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

697 if (!sectionItem) {

698 delete nobj;

699 } else {

700 sectionItem->setZ(2);

701 QQml_setParent_noEvent(sectionItem, m_clipItem);

702 sectionItem->setParentItem(m_clipItem);

703 }

704 } else {

705 delete context;

706 }

707 m_sectionDelegate->completeCreate();

708

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

710

711 return sectionItem;

712}

713

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

715{

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

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

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

719 if (contentY() < -m_minYExtent) {

720 return false;

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

722 return false;

723 }

724 bool changed = false;

725

726 bool foundVisible = false;

727 int i = 0;

728 int removedItems = 0;

729 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

731 ListItem *item = m_visibleItems[i];

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

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

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

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

736 releaseItem(item);

737 m_visibleItems.removeAt(i);

738 changed = true;

739 ++removedItems;

740 } else {

741 if (!foundVisible) {

742 foundVisible = true;

743 const int itemIndex = m_firstVisibleIndex + removedItems + i;

744 m_firstVisibleIndex = itemIndex;

745 }

746 ++i;

747 }

748 }

749 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

750 adjustMinYExtent();

751 }

752

753 return changed;

754}

755

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

757{

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

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

760 return nullptr;

761

762 m_asyncRequestedIndex = -1;

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

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

765#else

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

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

768#endif

769 if (!item) {

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

771 m_asyncRequestedIndex = modelIndex;

772#else

773 if (object) {

774 m_delegateModel->release(object);

775 if (!m_delegateValidated) {

776 m_delegateValidated = true;

777 QObject* delegateObj = delegate();

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

779 }

780 } else {

781 m_asyncRequestedIndex = modelIndex;

782 }

783#endif

784 return 0;

785 } else {

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

787 ListItem *listItem = new ListItem;

788 listItem->m_item = item;

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

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

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

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

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

794 // nor is the first item

795 if (prevItem) {

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

797 } else {

798 ListItem *currItem = itemAtIndex(modelIndex);

799 if (currItem) {

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

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

802 } else {

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

804 if (nextItem) {

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

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

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

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

809 lostItem = true;

810 }

811 }

812 }

813 if (lostItem) {

814 releaseItem(listItem);

815 listItem = nullptr;

816 } else {

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

818 if (m_visibleItems.isEmpty()) {

819 m_visibleItems << listItem;

820 } else {

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

822 }

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

824 m_firstVisibleIndex = modelIndex;

825 polish();

826 }

827 if (listItem->m_sectionItem) {

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

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

830 }

831 adjustMinYExtent();

832 m_contentHeightDirty = true;

833 }

834 return listItem;

835 }

836}

837

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

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

840{

841#else

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

843{

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

845 if (!item) {

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

847 return;

848 }

849#endif

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

851

852 item->setParentItem(m_clipItem);

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

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

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

856 if (modelIndex == m_asyncRequestedIndex) {

857 createItem(modelIndex, false);

858 refill();

859 }

860}

861

862void ListViewWithPageHeader::updateClipItem()

863{

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

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

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

867}

868

869void ListViewWithPageHeader::onContentHeightChanged()

870{

871 updateClipItem();

872}

873

874void ListViewWithPageHeader::onContentWidthChanged()

875{

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

877}

878

879void ListViewWithPageHeader::onHeightChanged()

880{

881 polish();

882}

883

884

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

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

887#else

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

889#endif

890{

891 // TODO Do something with reset

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

893 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

894

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

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

897#else

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

899#endif

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

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

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

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

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

905 bool growDown = true;

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

907 const int modelIndex = remove.index + i;

908 ListItem *item = itemAtIndex(modelIndex);

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

910 growDown = false;

911 }

912 }

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

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

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

916 ListItem *item = m_visibleItems[visibleIndex];

917 // Pass the section item down if needed

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

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

920 if (!nextItem->m_sectionItem) {

921 nextItem->m_sectionItem = item->m_sectionItem;

922 item->m_sectionItem = nullptr;

923 }

924 }

925 releaseItem(item);

926 m_visibleItems.removeAt(visibleIndex);

927 }

928 }

929 if (growDown) {

930 adjustMinYExtent();

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

932 if (!m_visibleItems.isEmpty()) {

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

934 // position the new first item correctly

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

936 } else {

937 m_firstVisibleIndex = -1;

938 }

939 }

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

941 m_firstVisibleIndex -= remove.count;

942 }

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

944 const int modelIndex = remove.index + i;

945 if (modelIndex == m_asyncRequestedIndex) {

946 m_asyncRequestedIndex = -1;

947 } else if (modelIndex < m_asyncRequestedIndex) {

948 m_asyncRequestedIndex--;

949 }

950 }

951 }

952

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

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

955#else

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

957#endif

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

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

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

961 if (insertingInValidIndexes || firstItemWithViewOnTop)

962 {

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

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

965 bool growUp = false;

966 if (!firstItemWithViewOnTop) {

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

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

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

970 growUp = true;

971 }

972 break;

973 }

974 }

975 }

976

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

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

979 const int modelIndex = insert.index + i;

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

981 if (growUp) {

982 ListItem *firstItem = m_visibleItems.first();

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

984 adjustMinYExtent();

985 }

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

987 // if we need adding a new section item

988 if (m_sectionDelegate) {

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

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

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

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

993 ListItem *firstItem = m_visibleItems.first();

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

995 adjustMinYExtent();

996 }

997 }

998 }

999 }

1000 if (firstItemWithViewOnTop) {

1001 ListItem *firstItem = m_visibleItems.first();

1002 firstItem->setY(oldFirstValidIndexPos);

1003 }

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

1005 m_firstVisibleIndex += insert.count;

1006 }

1007

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

1009 const int modelIndex = insert.index + i;

1010 if (modelIndex <= m_asyncRequestedIndex) {

1011 m_asyncRequestedIndex++;

1012 }

1013 }

1014 }

1015

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

1017 Q_FOREACH(const QQuickChangeSet::Change &change, changeSet.changes()) {

1018#else

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

1020#endif

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

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

1023 ListItem *item = itemAtIndex(i);

1024 if (item && item->m_sectionItem) {

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

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

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

1028 }

1029 }

1030 }

1031

1032 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1033 adjustMinYExtent();

1034 }

1035

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

1037 ListItem *item = m_visibleItems[i];

1038 if (item->m_sectionItem) {

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

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

1041 }

1042 }

1043

1044 layout();

1045 polish();

1046 m_contentHeightDirty = true;

1047}

1048

1049void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1050{

1051 m_contentHeightDirty = true;

1052 polish();

1053}

1054

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

1056{

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

1058 if (heightDiff != 0) {

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

1060 ListItem *firstItem = m_visibleItems.first();

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

1062 adjustMinYExtent();

1063 layout();

1064 }

1065 refill();

1066 adjustMinYExtent();

1067 polish();

1068 m_contentHeightDirty = true;

1069 }

1070}

1071

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

1073{

1074 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1075 if (m_headerItemShownHeight > 0) {

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

1077 // Change its size

1078 m_headerItemShownHeight += heightDiff;

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

1080 updateClipItem();

1081 adjustMinYExtent();

1082 } else {

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

1084 // If the header is shown because its position

1085 // Change its size

1086 ListItem *firstItem = m_visibleItems.first();

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

1088 layout();

1089 } else {

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

1091 // so the viewport is not changed

1092 adjustMinYExtent();

1093 }

1094 }

1095}

1096

1097

1098void ListViewWithPageHeader::adjustMinYExtent()

1099{

1100 if (m_visibleItems.isEmpty()) {

1101 m_minYExtent = 0;

1102 } else {

1103 qreal nonCreatedHeight = 0;

1104 if (m_firstVisibleIndex != 0) {

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

1106 const int visibleItems = m_visibleItems.count();

1107 qreal visibleItemsHeight = 0;

1108 Q_FOREACH(ListItem *item, m_visibleItems) {

1109 visibleItemsHeight += item->height();

1110 }

1111 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1113 }

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

1115 }

1116}

1117

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

1119{

1120 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1122 return m_visibleItems[visibleIndexedModelIndex];

1123

1124 return nullptr;

1125}

1126

1127void ListViewWithPageHeader::layout()

1128{

1129 if (m_inLayout)

1130 return;

1131

1132 m_inLayout = true;

1133 if (!m_visibleItems.isEmpty()) {

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

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

1136

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

1138

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

1140 int firstReallyVisibleItem = -1;

1141 int modelIndex = m_firstVisibleIndex;

1142 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1144 item->setCulled(cull);

1145 item->setY(pos);

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

1147 firstReallyVisibleItem = modelIndex;

1148 if (m_topSectionItem) {

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

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

1151 // or stick it to the top

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

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

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

1155 bool showStickySectionItem;

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

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

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

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

1160 if (topSectionStickPos > pos) {

1161 showStickySectionItem = true;

1162 } else if (topSectionStickPos == pos) {

1163 showStickySectionItem = !item->m_sectionItem;

1164 } else {

1165 showStickySectionItem = false;

1166 }

1167 if (!showStickySectionItem) {

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

1169 if (item->m_sectionItem) {

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

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

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

1173 // gets shown shortly in the next polish call

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

1175 }

1176 } else {

1177 // Update the top sticky section header

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

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

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

1181

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

1183 m_topSectionItem->setY(topSectionStickPos);

1184 int delegateIndex = modelIndex;

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

1186 while (delegateIndex > 0) {

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

1188 if (prevSection != section)

1189 break;

1190 delegateIndex--;

1191 }

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

1193 if (item->m_sectionItem) {

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

1195 }

1196 }

1197 }

1198 }

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

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

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

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

1203 } else {

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

1205 }

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

1207 pos += item->height();

1208 ++modelIndex;

1209 }

1210

1211 // Second step of section sticky item positioning

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

1213 if (m_topSectionItem) {

1214 if (firstReallyVisibleItem >= 0) {

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

1216 ListItem *item = m_visibleItems[i];

1217 if (item->m_sectionItem) {

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

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

1220 }

1221 break;

1222 }

1223 }

1224 }

1225 }

1226 }

1227 m_inLayout = false;

1228}

1229

1230void ListViewWithPageHeader::updatePolish()

1231{

1232 Q_FOREACH(ListItem *item, m_itemsToRelease)

1233 reallyReleaseItem(item);

1234 m_itemsToRelease.clear();

1235

1236 if (!model())

1237 return;

1238

1239 layout();

1240

1241 refill();

1242

1243 if (m_contentHeightDirty) {

1244 qreal contentHeight;

1245 if (m_visibleItems.isEmpty()) {

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

1247 } else {

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

1249 const int visibleItems = m_visibleItems.count();

1250 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1251 qreal nonCreatedHeight = 0;

1252 if (lastValidIndex != modelCount - 1) {

1253 const int visibleItems = m_visibleItems.count();

1254 qreal visibleItemsHeight = 0;

1255 Q_FOREACH(ListItem *item, m_visibleItems) {

1256 visibleItemsHeight += item->height();

1257 }

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

1259 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1260 }

1261 ListItem *item = m_visibleItems.last();

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

1263 if (m_firstVisibleIndex != 0) {

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

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

1266 }

1267 }

1268

1269 m_contentHeightDirty = false;

1270 adjustMinYExtent();

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

1272 setContentHeight(contentHeight);

1273 m_inContentHeightKeepHeaderShown = false;

1274 }

1275}

1276

1277#include "moc_listviewwithpageheader.cpp"