plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

407 {

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

409 auto realVisibleListItemY = listItemY;

410 if (m_topSectionItem) {

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

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

413 // the top section sticky item

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

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

416 realVisibleListItemY -= m_topSectionItem->height();

417 }

418 }

419 const auto to = qMax(realVisibleListItemY, listItemY + listItem->height() - height());

420 m_contentYAnimation->setTo(to);

421 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

422 m_contentYAnimation->start();

423 }

424 return true;

425 }

426 return false;

427}

428

429qreal ListViewWithPageHeader::minYExtent() const

430{

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

432 return m_minYExtent;

433}

434

435void ListViewWithPageHeader::componentComplete()

436{

437 if (m_delegateModel)

438 m_delegateModel->componentComplete();

439

440 QQuickFlickable::componentComplete();

441

442 polish();

443}

444

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

446{

447 QQuickFlickable::viewportMoved(orient);

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

449 qreal diff = m_previousContentY - contentY();

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

451 if (m_headerItem) {

452 auto oldHeaderItemShownHeight = m_headerItemShownHeight;

453 if (contentY() < -m_minYExtent) {

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

455 m_headerItem->setY(contentY());

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

457 } else {

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

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

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

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

462 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

466

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

468 m_headerItemShownHeight = 0;

469 m_headerItem->setY(contentY());

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

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

472 m_headerItemShownHeight -= diff;

473 else

474 m_headerItemShownHeight += diff;

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

476 m_headerItemShownHeight = 0;

477 } else {

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

479 }

480 if (m_headerItemShownHeight > 0) {

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

482 } else {

483 m_headerItem->setY(-m_minYExtent);

484 }

485 }

486 }

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

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

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

490 if (!showHeaderAnimationRunning) {

491 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

492 } else {

493 diff = -diff;

494 }

495 }

496 if (!m_visibleItems.isEmpty()) {

497 updateClipItem();

498 ListItem *firstItem = m_visibleItems.first();

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

500 if (showHeaderAnimationRunning) {

501 adjustMinYExtent();

502 }

503 }

504

505 m_previousContentY = contentY();

506 layout();

507 polish();

508}

509

510void ListViewWithPageHeader::createDelegateModel()

511{

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

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

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

515#else

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

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

518#endif

519 if (isComponentComplete())

520 m_delegateModel->componentComplete();

521 updateWatchedRoles();

522}

523

524void ListViewWithPageHeader::refill()

525{

526 if (m_inLayout) {

527 return;

528 }

529 if (!isComponentComplete()) {

530 return;

531 }

532

533 const qreal buffer = height() * bufferRatio;

534 const qreal from = contentY();

535 const qreal to = from + height();

536 const qreal bufferFrom = from - buffer;

537 const qreal bufferTo = to + buffer;

538

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

540 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

542

543 if (added || removed) {

544 m_contentHeightDirty = true;

545 }

546}

547

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

549{

550 if (!delegate())

551 return false;

552

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

554 return false;

555

556 ListItem *item;

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

558

559 int modelIndex = 0;

560 qreal pos = 0;

561 if (!m_visibleItems.isEmpty()) {

562 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

563 item = m_visibleItems.last();

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

565 }

566 bool changed = false;

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

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

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

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

571 break;

572 pos += item->height();

573 ++modelIndex;

574 changed = true;

575 }

576

577 modelIndex = 0;

578 pos = 0;

579 if (!m_visibleItems.isEmpty()) {

580 modelIndex = m_firstVisibleIndex - 1;

581 item = m_visibleItems.first();

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

583 }

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

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

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

587 break;

588 pos -= item->height();

589 --modelIndex;

590 changed = true;

591 }

592

593 return changed;

594}

595

596void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

597{

598 QQuickItem *item = listItem->m_item;

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

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

601 if (flags & QQuickVisualModel::Destroyed) {

602#else

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

604 if (flags & QQmlDelegateModel::Destroyed) {

605#endif

606 item->setParentItem(nullptr);

607 }

608 delete listItem->m_sectionItem;

609 delete listItem;

610}

611

612void ListViewWithPageHeader::releaseItem(ListItem *listItem)

613{

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

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

616 m_itemsToRelease << listItem;

617}

618

619void ListViewWithPageHeader::updateWatchedRoles()

620{

621 if (m_delegateModel) {

622 QList<QByteArray> roles;

623 if (!m_sectionProperty.isEmpty())

624 roles << m_sectionProperty.toUtf8();

625 m_delegateModel->setWatchedRoles(roles);

626 }

627}

628

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

630{

631 if (!m_sectionDelegate)

632 return nullptr;

633

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

635 if (modelIndex > 0) {

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

637 if (section == prevSection)

638 return nullptr;

639 }

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

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

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

643 if (section == nextSection) {

644 // Steal the section header

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

646 if (nextItem) {

647 QQuickItem *sectionItem = nextItem->m_sectionItem;

648 nextItem->m_sectionItem = nullptr;

649 return sectionItem;

650 }

651 }

652 }

653

654 return getSectionItem(modelIndex, section);

655}

656

657QQuickItem *ListViewWithPageHeader::getSectionItem(int modelIndex, const QString &sectionText)

658{

659 QQuickItem *sectionItem = nullptr;

660

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

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

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

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

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

666 if (nobj) {

667 QQml_setParent_noEvent(context, nobj);

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

669 if (!sectionItem) {

670 delete nobj;

671 } else {

672 sectionItem->setZ(2);

673 QQml_setParent_noEvent(sectionItem, m_clipItem);

674 sectionItem->setParentItem(m_clipItem);

675 }

676 } else {

677 delete context;

678 }

679 m_sectionDelegate->completeCreate();

680

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

682

683 return sectionItem;

684}

685

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

687{

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

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

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

691 if (contentY() < -m_minYExtent) {

692 return false;

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

694 return false;

695 }

696 bool changed = false;

697

698 bool foundVisible = false;

699 int i = 0;

700 int removedItems = 0;

701 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

703 ListItem *item = m_visibleItems[i];

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

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

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

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

708 releaseItem(item);

709 m_visibleItems.removeAt(i);

710 changed = true;

711 ++removedItems;

712 } else {

713 if (!foundVisible) {

714 foundVisible = true;

715 const int itemIndex = m_firstVisibleIndex + removedItems + i;

716 m_firstVisibleIndex = itemIndex;

717 }

718 ++i;

719 }

720 }

721 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

722 adjustMinYExtent();

723 }

724

725 return changed;

726}

727

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

729{

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

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

732 return nullptr;

733

734 m_asyncRequestedIndex = -1;

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

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

737#else

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

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

740#endif

741 if (!item) {

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

743 m_asyncRequestedIndex = modelIndex;

744#else

745 if (object) {

746 m_delegateModel->release(object);

747 if (!m_delegateValidated) {

748 m_delegateValidated = true;

749 QObject* delegateObj = delegate();

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

751 }

752 } else {

753 m_asyncRequestedIndex = modelIndex;

754 }

755#endif

756 return 0;

757 } else {

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

759 ListItem *listItem = new ListItem;

760 listItem->m_item = item;

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

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

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

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

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

766 // nor is the first item

767 if (prevItem) {

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

769 } else {

770 ListItem *currItem = itemAtIndex(modelIndex);

771 if (currItem) {

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

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

774 } else {

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

776 if (nextItem) {

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

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

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

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

781 lostItem = true;

782 }

783 }

784 }

785 if (lostItem) {

786 releaseItem(listItem);

787 listItem = nullptr;

788 } else {

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

790 if (m_visibleItems.isEmpty()) {

791 m_visibleItems << listItem;

792 } else {

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

794 }

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

796 m_firstVisibleIndex = modelIndex;

797 polish();

798 }

799 if (listItem->m_sectionItem) {

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

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

802 }

803 adjustMinYExtent();

804 m_contentHeightDirty = true;

805 }

806 return listItem;

807 }

808}

809

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

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

812{

813#else

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

815{

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

817 if (!item) {

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

819 return;

820 }

821#endif

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

823

824 item->setParentItem(m_clipItem);

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

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

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

828 if (modelIndex == m_asyncRequestedIndex) {

829 createItem(modelIndex, false);

830 refill();

831 }

832}

833

834void ListViewWithPageHeader::updateClipItem()

835{

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

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

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

839}

840

841void ListViewWithPageHeader::onContentHeightChanged()

842{

843 updateClipItem();

844}

845

846void ListViewWithPageHeader::onContentWidthChanged()

847{

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

849}

850

851void ListViewWithPageHeader::onHeightChanged()

852{

853 polish();

854}

855

856

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

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

859#else

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

861#endif

862{

863 // TODO Do something with reset

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

865 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

866

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

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

869#else

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

871#endif

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

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

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

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

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

877 bool growDown = true;

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

879 const int modelIndex = remove.index + i;

880 ListItem *item = itemAtIndex(modelIndex);

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

882 growDown = false;

883 }

884 }

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

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

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

888 ListItem *item = m_visibleItems[visibleIndex];

889 // Pass the section item down if needed

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

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

892 if (!nextItem->m_sectionItem) {

893 nextItem->m_sectionItem = item->m_sectionItem;

894 item->m_sectionItem = nullptr;

895 }

896 }

897 releaseItem(item);

898 m_visibleItems.removeAt(visibleIndex);

899 }

900 }

901 if (growDown) {

902 adjustMinYExtent();

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

904 if (!m_visibleItems.isEmpty()) {

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

906 // position the new first item correctly

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

908 } else {

909 m_firstVisibleIndex = -1;

910 }

911 }

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

913 m_firstVisibleIndex -= remove.count;

914 }

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

916 const int modelIndex = remove.index + i;

917 if (modelIndex == m_asyncRequestedIndex) {

918 m_asyncRequestedIndex = -1;

919 } else if (modelIndex < m_asyncRequestedIndex) {

920 m_asyncRequestedIndex--;

921 }

922 }

923 }

924

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

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

927#else

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

929#endif

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

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

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

933 if (insertingInValidIndexes || firstItemWithViewOnTop)

934 {

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

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

937 bool growUp = false;

938 if (!firstItemWithViewOnTop) {

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

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

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

942 growUp = true;

943 }

944 break;

945 }

946 }

947 }

948

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

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

951 const int modelIndex = insert.index + i;

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

953 if (growUp) {

954 ListItem *firstItem = m_visibleItems.first();

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

956 adjustMinYExtent();

957 }

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

959 // if we need adding a new section item

960 if (m_sectionDelegate) {

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

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

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

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

965 ListItem *firstItem = m_visibleItems.first();

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

967 adjustMinYExtent();

968 }

969 }

970 }

971 }

972 if (firstItemWithViewOnTop) {

973 ListItem *firstItem = m_visibleItems.first();

974 firstItem->setY(oldFirstValidIndexPos);

975 }

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

977 m_firstVisibleIndex += insert.count;

978 }

979

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

981 const int modelIndex = insert.index + i;

982 if (modelIndex <= m_asyncRequestedIndex) {

983 m_asyncRequestedIndex++;

984 }

985 }

986 }

987

988 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

989 adjustMinYExtent();

990 }

991

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

993 ListItem *item = m_visibleItems[i];

994 if (item->m_sectionItem) {

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

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

997 }

998 }

999

1000 layout();

1001 polish();

1002 m_contentHeightDirty = true;

1003}

1004

1005void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1006{

1007 m_contentHeightDirty = true;

1008 polish();

1009}

1010

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

1012{

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

1014 if (heightDiff != 0) {

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

1016 ListItem *firstItem = m_visibleItems.first();

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

1018 adjustMinYExtent();

1019 layout();

1020 }

1021 refill();

1022 adjustMinYExtent();

1023 polish();

1024 m_contentHeightDirty = true;

1025 }

1026}

1027

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

1029{

1030 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1031 if (m_headerItemShownHeight > 0) {

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

1033 // Change its size

1034 m_headerItemShownHeight += heightDiff;

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

1036 updateClipItem();

1037 adjustMinYExtent();

1038 } else {

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

1040 // If the header is shown because its position

1041 // Change its size

1042 ListItem *firstItem = m_visibleItems.first();

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

1044 layout();

1045 } else {

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

1047 // so the viewport is not changed

1048 adjustMinYExtent();

1049 }

1050 }

1051}

1052

1053

1054void ListViewWithPageHeader::adjustMinYExtent()

1055{

1056 if (m_visibleItems.isEmpty()) {

1057 m_minYExtent = 0;

1058 } else {

1059 qreal nonCreatedHeight = 0;

1060 if (m_firstVisibleIndex != 0) {

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

1062 const int visibleItems = m_visibleItems.count();

1063 qreal visibleItemsHeight = 0;

1064 Q_FOREACH(ListItem *item, m_visibleItems) {

1065 visibleItemsHeight += item->height();

1066 }

1067 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1069 }

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

1071 }

1072}

1073

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

1075{

1076 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1078 return m_visibleItems[visibleIndexedModelIndex];

1079

1080 return nullptr;

1081}

1082

1083void ListViewWithPageHeader::layout()

1084{

1085 if (m_inLayout)

1086 return;

1087

1088 m_inLayout = true;

1089 if (!m_visibleItems.isEmpty()) {

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

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

1092

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

1094

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

1096 int firstReallyVisibleItem = -1;

1097 int modelIndex = m_firstVisibleIndex;

1098 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1100 item->setCulled(cull);

1101 item->setY(pos);

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

1103 firstReallyVisibleItem = modelIndex;

1104 if (m_topSectionItem) {

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

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

1107 // or stick it to the top

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

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

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

1111 bool showStickySectionItem;

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

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

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

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

1116 if (topSectionStickPos > pos) {

1117 showStickySectionItem = true;

1118 } else if (topSectionStickPos == pos) {

1119 showStickySectionItem = !item->m_sectionItem;

1120 } else {

1121 showStickySectionItem = false;

1122 }

1123 if (!showStickySectionItem) {

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

1125 if (item->m_sectionItem) {

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

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

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

1129 // gets shown shortly in the next polish call

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

1131 }

1132 } else {

1133 // Update the top sticky section header

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

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

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

1137

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

1139 m_topSectionItem->setY(topSectionStickPos);

1140 int delegateIndex = modelIndex;

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

1142 while (delegateIndex > 0) {

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

1144 if (prevSection != section)

1145 break;

1146 delegateIndex--;

1147 }

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

1149 if (item->m_sectionItem) {

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

1151 }

1152 }

1153 }

1154 }

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

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

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

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

1159 } else {

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

1161 }

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

1163 pos += item->height();

1164 ++modelIndex;

1165 }

1166

1167 // Second step of section sticky item positioning

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

1169 if (m_topSectionItem) {

1170 if (firstReallyVisibleItem >= 0) {

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

1172 ListItem *item = m_visibleItems[i];

1173 if (item->m_sectionItem) {

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

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

1176 }

1177 break;

1178 }

1179 }

1180 }

1181 }

1182 }

1183 m_inLayout = false;

1184}

1185

1186void ListViewWithPageHeader::updatePolish()

1187{

1188 Q_FOREACH(ListItem *item, m_itemsToRelease)

1189 reallyReleaseItem(item);

1190 m_itemsToRelease.clear();

1191

1192 if (!model())

1193 return;

1194

1195 layout();

1196

1197 refill();

1198

1199 if (m_contentHeightDirty) {

1200 qreal contentHeight;

1201 if (m_visibleItems.isEmpty()) {

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

1203 } else {

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

1205 const int visibleItems = m_visibleItems.count();

1206 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1207 qreal nonCreatedHeight = 0;

1208 if (lastValidIndex != modelCount - 1) {

1209 const int visibleItems = m_visibleItems.count();

1210 qreal visibleItemsHeight = 0;

1211 Q_FOREACH(ListItem *item, m_visibleItems) {

1212 visibleItemsHeight += item->height();

1213 }

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

1215 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1216 }

1217 ListItem *item = m_visibleItems.last();

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

1219 if (m_firstVisibleIndex != 0) {

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

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

1222 }

1223 }

1224

1225 m_contentHeightDirty = false;

1226 setContentHeight(contentHeight);

1227 }

1228}

1229

1230#include "moc_listviewwithpageheader.cpp"