plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

442 {

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

444 auto realVisibleListItemY = listItemY;

445 if (m_topSectionItem) {

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

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

448 // the top section sticky item

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

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

451 realVisibleListItemY -= m_topSectionItem->height();

452 }

453 }

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

455 m_contentYAnimation->setTo(to);

456 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

457 m_contentYAnimation->start();

458 }

459 return true;

460 }

461 return false;

462}

463

464qreal ListViewWithPageHeader::minYExtent() const

465{

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

467 return m_minYExtent;

468}

469

470void ListViewWithPageHeader::componentComplete()

471{

472 if (m_delegateModel)

473 m_delegateModel->componentComplete();

474

475 QQuickFlickable::componentComplete();

476

477 polish();

478}

479

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

481{

482 QQuickFlickable::viewportMoved(orient);

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

484 qreal diff = m_previousContentY - contentY();

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

486 if (m_headerItem) {

487 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

488 if (contentY() < -m_minYExtent) {

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

490 m_headerItem->setY(contentY());

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

492 } else {

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

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

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

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

497 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

501

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

503 m_headerItemShownHeight = 0;

504 m_headerItem->setY(-m_minYExtent);

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

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

507 m_headerItemShownHeight -= diff;

508 else

509 m_headerItemShownHeight += diff;

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

511 m_headerItemShownHeight = 0;

512 } else {

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

514 }

515 if (m_headerItemShownHeight > 0) {

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

517 } else {

518 m_headerItem->setY(-m_minYExtent);

519 }

520 }

521 }

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

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

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

525 if (!showHeaderAnimationRunning) {

526 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

527 } else {

528 diff = -diff;

529 }

530 }

531 if (!m_visibleItems.isEmpty()) {

532 updateClipItem();

533 ListItem *firstItem = m_visibleItems.first();

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

535 if (showHeaderAnimationRunning) {

536 adjustMinYExtent();

537 }

538 }

539

540 m_previousContentY = contentY();

541 layout();

542 polish();

543}

544

545void ListViewWithPageHeader::createDelegateModel()

546{

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

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

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

550#else

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

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

553#endif

554 if (isComponentComplete())

555 m_delegateModel->componentComplete();

556 updateWatchedRoles();

557}

558

559void ListViewWithPageHeader::refill()

560{

561 if (m_inLayout) {

562 return;

563 }

564 if (!isComponentComplete()) {

565 return;

566 }

567

568 const qreal buffer = height() * bufferRatio;

569 const qreal from = contentY();

570 const qreal to = from + height();

571 const qreal bufferFrom = from - buffer;

572 const qreal bufferTo = to + buffer;

573

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

575 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

577

578 if (added || removed) {

579 m_contentHeightDirty = true;

580 }

581}

582

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

584{

585 if (!delegate())

586 return false;

587

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

589 return false;

590

591 ListItem *item;

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

593

594 int modelIndex = 0;

595 qreal pos = 0;

596 if (!m_visibleItems.isEmpty()) {

597 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

598 item = m_visibleItems.last();

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

600 }

601 bool changed = false;

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

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

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

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

606 break;

607 pos += item->height();

608 ++modelIndex;

609 changed = true;

610 }

611

612 modelIndex = 0;

613 pos = 0;

614 if (!m_visibleItems.isEmpty()) {

615 modelIndex = m_firstVisibleIndex - 1;

616 item = m_visibleItems.first();

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

618 }

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

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

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

622 break;

623 pos -= item->height();

624 --modelIndex;

625 changed = true;

626 }

627

628 return changed;

629}

630

631void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

632{

633 QQuickItem *item = listItem->m_item;

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

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

636 if (flags & QQuickVisualModel::Destroyed) {

637#else

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

639 if (flags & QQmlDelegateModel::Destroyed) {

640#endif

641 item->setParentItem(nullptr);

642 }

643 delete listItem->m_sectionItem;

644 delete listItem;

645}

646

647void ListViewWithPageHeader::releaseItem(ListItem *listItem)

648{

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

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

651 m_itemsToRelease << listItem;

652}

653

654void ListViewWithPageHeader::updateWatchedRoles()

655{

656 if (m_delegateModel) {

657 QList<QByteArray> roles;

658 if (!m_sectionProperty.isEmpty())

659 roles << m_sectionProperty.toUtf8();

660 m_delegateModel->setWatchedRoles(roles);

661 }

662}

663

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

665{

666 if (!m_sectionDelegate)

667 return nullptr;

668

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

670 if (modelIndex > 0) {

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

672 if (section == prevSection)

673 return nullptr;

674 }

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

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

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

678 if (section == nextSection) {

679 // Steal the section header

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

681 if (nextItem) {

682 QQuickItem *sectionItem = nextItem->m_sectionItem;

683 nextItem->m_sectionItem = nullptr;

684 return sectionItem;

685 }

686 }

687 }

688

689 return getSectionItem(section);

690}

691

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

693{

694 QQuickItem *sectionItem = nullptr;

695

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

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

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

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

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

701 if (nobj) {

702 QQml_setParent_noEvent(context, nobj);

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

704 if (!sectionItem) {

705 delete nobj;

706 } else {

707 sectionItem->setZ(2);

708 QQml_setParent_noEvent(sectionItem, m_clipItem);

709 sectionItem->setParentItem(m_clipItem);

710 }

711 } else {

712 delete context;

713 }

714 m_sectionDelegate->completeCreate();

715

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

717

718 return sectionItem;

719}

720

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

722{

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

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

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

726 if (contentY() < -m_minYExtent) {

727 return false;

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

729 return false;

730 }

731 bool changed = false;

732

733 bool foundVisible = false;

734 int i = 0;

735 int removedItems = 0;

736 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

738 ListItem *item = m_visibleItems[i];

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

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

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

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

743 releaseItem(item);

744 m_visibleItems.removeAt(i);

745 changed = true;

746 ++removedItems;

747 } else {

748 if (!foundVisible) {

749 foundVisible = true;

750 const int itemIndex = m_firstVisibleIndex + removedItems + i;

751 m_firstVisibleIndex = itemIndex;

752 }

753 ++i;

754 }

755 }

756 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

757 adjustMinYExtent();

758 }

759

760 return changed;

761}

762

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

764{

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

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

767 return nullptr;

768

769 m_asyncRequestedIndex = -1;

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

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

772#else

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

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

775#endif

776 if (!item) {

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

778 m_asyncRequestedIndex = modelIndex;

779#else

780 if (object) {

781 m_delegateModel->release(object);

782 if (!m_delegateValidated) {

783 m_delegateValidated = true;

784 QObject* delegateObj = delegate();

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

786 }

787 } else {

788 m_asyncRequestedIndex = modelIndex;

789 }

790#endif

791 return 0;

792 } else {

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

794 ListItem *listItem = new ListItem;

795 listItem->m_item = item;

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

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

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

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

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

801 // nor is the first item

802 if (prevItem) {

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

804 } else {

805 ListItem *currItem = itemAtIndex(modelIndex);

806 if (currItem) {

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

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

809 } else {

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

811 if (nextItem) {

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

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

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

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

816 lostItem = true;

817 }

818 }

819 }

820 if (lostItem) {

821 releaseItem(listItem);

822 listItem = nullptr;

823 } else {

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

825 if (m_visibleItems.isEmpty()) {

826 m_visibleItems << listItem;

827 } else {

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

829 }

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

831 m_firstVisibleIndex = modelIndex;

832 polish();

833 }

834 if (listItem->m_sectionItem) {

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

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

837 }

838 adjustMinYExtent();

839 m_contentHeightDirty = true;

840 }

841 return listItem;

842 }

843}

844

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

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

847{

848#else

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

850{

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

852 if (!item) {

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

854 return;

855 }

856#endif

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

858

859 item->setParentItem(m_clipItem);

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

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

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

863 if (modelIndex == m_asyncRequestedIndex) {

864 createItem(modelIndex, false);

865 refill();

866 }

867}

868

869void ListViewWithPageHeader::updateClipItem()

870{

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

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

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

874}

875

876void ListViewWithPageHeader::onContentHeightChanged()

877{

878 updateClipItem();

879}

880

881void ListViewWithPageHeader::onContentWidthChanged()

882{

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

884}

885

886void ListViewWithPageHeader::onHeightChanged()

887{

888 polish();

889}

890

891

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

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

894#else

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

896#endif

897{

898 // TODO Do something with reset

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

900 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

901

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

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

904#else

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

906#endif

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

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

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

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

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

912 bool growDown = true;

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

914 const int modelIndex = remove.index + i;

915 ListItem *item = itemAtIndex(modelIndex);

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

917 growDown = false;

918 }

919 }

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

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

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

923 ListItem *item = m_visibleItems[visibleIndex];

924 // Pass the section item down if needed

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

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

927 if (!nextItem->m_sectionItem) {

928 nextItem->m_sectionItem = item->m_sectionItem;

929 item->m_sectionItem = nullptr;

930 }

931 }

932 releaseItem(item);

933 m_visibleItems.removeAt(visibleIndex);

934 }

935 }

936 if (growDown) {

937 adjustMinYExtent();

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

939 if (!m_visibleItems.isEmpty()) {

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

941 // position the new first item correctly

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

943 } else {

944 m_firstVisibleIndex = -1;

945 }

946 }

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

948 m_firstVisibleIndex -= remove.count;

949 }

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

951 const int modelIndex = remove.index + i;

952 if (modelIndex == m_asyncRequestedIndex) {

953 m_asyncRequestedIndex = -1;

954 } else if (modelIndex < m_asyncRequestedIndex) {

955 m_asyncRequestedIndex--;

956 }

957 }

958 }

959

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

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

962#else

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

964#endif

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

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

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

968 if (insertingInValidIndexes || firstItemWithViewOnTop)

969 {

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

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

972 bool growUp = false;

973 if (!firstItemWithViewOnTop) {

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

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

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

977 growUp = true;

978 }

979 break;

980 }

981 }

982 }

983

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

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

986 const int modelIndex = insert.index + i;

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

988 if (growUp) {

989 ListItem *firstItem = m_visibleItems.first();

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

991 }

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

993 // if we need adding a new section item

994 if (m_sectionDelegate) {

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

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

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

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

999 ListItem *firstItem = m_visibleItems.first();

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

1001 }

1002 }

1003 }

1004 }

1005 if (firstItemWithViewOnTop) {

1006 ListItem *firstItem = m_visibleItems.first();

1007 firstItem->setY(oldFirstValidIndexPos);

1008 }

1009 adjustMinYExtent();

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

1011 m_firstVisibleIndex += insert.count;

1012 }

1013

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

1015 const int modelIndex = insert.index + i;

1016 if (modelIndex <= m_asyncRequestedIndex) {

1017 m_asyncRequestedIndex++;

1018 }

1019 }

1020 }

1021

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

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

1024#else

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

1026#endif

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

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

1029 ListItem *item = itemAtIndex(i);

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

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

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

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

1034 }

1035 }

1036 }

1037

1038 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1039 adjustMinYExtent();

1040 }

1041

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

1043 ListItem *item = m_visibleItems[i];

1044 if (item->m_sectionItem) {

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

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

1047 }

1048 }

1049

1050 layout();

1051 polish();

1052 m_contentHeightDirty = true;

1053}

1054

1055void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1056{

1057 m_contentHeightDirty = true;

1058 polish();

1059}

1060

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

1062{

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

1064 if (heightDiff != 0) {

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

1066 ListItem *firstItem = m_visibleItems.first();

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

1068 adjustMinYExtent();

1069 layout();

1070 }

1071 refill();

1072 adjustMinYExtent();

1073 polish();

1074 m_contentHeightDirty = true;

1075 }

1076}

1077

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

1079{

1080 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1081 if (m_headerItemShownHeight > 0) {

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

1083 // Change its size

1084 m_headerItemShownHeight += heightDiff;

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

1086 updateClipItem();

1087 adjustMinYExtent();

1088 } else {

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

1090 // If the header is shown because its position

1091 // Change its size

1092 ListItem *firstItem = m_visibleItems.first();

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

1094 layout();

1095 } else {

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

1097 // so the viewport is not changed

1098 adjustMinYExtent();

1099 }

1100 }

1101}

1102

1103

1104void ListViewWithPageHeader::adjustMinYExtent()

1105{

1106 if (m_visibleItems.isEmpty()) {

1107 m_minYExtent = 0;

1108 } else {

1109 qreal nonCreatedHeight = 0;

1110 if (m_firstVisibleIndex != 0) {

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

1112 const int visibleItems = m_visibleItems.count();

1113 qreal visibleItemsHeight = 0;

1114 Q_FOREACH(ListItem *item, m_visibleItems) {

1115 visibleItemsHeight += item->height();

1116 }

1117 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1119 }

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

1121 }

1122}

1123

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

1125{

1126 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1128 return m_visibleItems[visibleIndexedModelIndex];

1129

1130 return nullptr;

1131}

1132

1133void ListViewWithPageHeader::layout()

1134{

1135 if (m_inLayout)

1136 return;

1137

1138 m_inLayout = true;

1139 if (!m_visibleItems.isEmpty()) {

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

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

1142

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

1144

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

1146 int firstReallyVisibleItem = -1;

1147 int modelIndex = m_firstVisibleIndex;

1148 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1150 item->setCulled(cull);

1151 item->setY(pos);

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

1153 firstReallyVisibleItem = modelIndex;

1154 if (m_topSectionItem) {

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

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

1157 // or stick it to the top

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

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

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

1161 bool showStickySectionItem;

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

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

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

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

1166 if (topSectionStickPos > pos) {

1167 showStickySectionItem = true;

1168 } else if (topSectionStickPos == pos) {

1169 showStickySectionItem = !item->m_sectionItem;

1170 } else {

1171 showStickySectionItem = false;

1172 }

1173 if (!showStickySectionItem) {

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

1175 if (item->m_sectionItem) {

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

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

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

1179 // gets shown shortly in the next polish call

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

1181 }

1182 } else {

1183 // Update the top sticky section header

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

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

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

1187

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

1189 m_topSectionItem->setY(topSectionStickPos);

1190 int delegateIndex = modelIndex;

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

1192 while (delegateIndex > 0) {

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

1194 if (prevSection != section)

1195 break;

1196 delegateIndex--;

1197 }

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

1199 if (item->m_sectionItem) {

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

1201 }

1202 }

1203 }

1204 }

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

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

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

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

1209 } else {

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

1211 }

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

1213 pos += item->height();

1214 ++modelIndex;

1215 }

1216

1217 // Second step of section sticky item positioning

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

1219 if (m_topSectionItem) {

1220 if (firstReallyVisibleItem >= 0) {

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

1222 ListItem *item = m_visibleItems[i];

1223 if (item->m_sectionItem) {

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

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

1226 }

1227 break;

1228 }

1229 }

1230 }

1231 }

1232 }

1233 m_inLayout = false;

1234}

1235

1236void ListViewWithPageHeader::updatePolish()

1237{

1238 Q_FOREACH(ListItem *item, m_itemsToRelease)

1239 reallyReleaseItem(item);

1240 m_itemsToRelease.clear();

1241

1242 if (!model())

1243 return;

1244

1245 layout();

1246

1247 refill();

1248

1249 if (m_contentHeightDirty) {

1250 qreal contentHeight;

1251 if (m_visibleItems.isEmpty()) {

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

1253 } else {

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

1255 const int visibleItems = m_visibleItems.count();

1256 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1257 qreal nonCreatedHeight = 0;

1258 if (lastValidIndex != modelCount - 1) {

1259 const int visibleItems = m_visibleItems.count();

1260 qreal visibleItemsHeight = 0;

1261 Q_FOREACH(ListItem *item, m_visibleItems) {

1262 visibleItemsHeight += item->height();

1263 }

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

1265 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1266 }

1267 ListItem *item = m_visibleItems.last();

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

1269 if (m_firstVisibleIndex != 0) {

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

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

1272 }

1273 }

1274

1275 m_contentHeightDirty = false;

1276 adjustMinYExtent();

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

1278 setContentHeight(contentHeight);

1279 m_inContentHeightKeepHeaderShown = false;

1280 }

1281}

1282

1283#include "moc_listviewwithpageheader.cpp"