plugins/DashViews/listviewwithpageheader.cpp · unity8

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

455 {

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

457 auto realVisibleListItemY = listItemY;

458 if (m_topSectionItem) {

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

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

461 // the top section sticky item

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

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

464 realVisibleListItemY -= m_topSectionItem->height();

465 }

466 }

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

468 m_contentYAnimation->setTo(to);

469 contentYAnimationType = ContentYAnimationMaximizeVisibleArea;

470 m_contentYAnimation->start();

471 }

472 return true;

473 }

474 return false;

475}

476

477qreal ListViewWithPageHeader::minYExtent() const

478{

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

480 return m_minYExtent;

481}

482

483void ListViewWithPageHeader::componentComplete()

484{

485 if (m_delegateModel)

486 m_delegateModel->componentComplete();

487

488 QQuickFlickable::componentComplete();

489

490 polish();

491}

492

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

494{

495 // Check we are not being taken down and don't paint anything

496 // TODO Check if we still need this in 5.2

497 // For reproduction just inifnite loop testDash or testDashContent

498 if (!QQmlEngine::contextForObject(this)->parentContext())

499 return;

500

501 QQuickFlickable::viewportMoved(orient);

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

503 qreal diff = m_previousContentY - contentY();

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

505 if (m_headerItem) {

506 const auto oldHeaderItemShownHeight = m_headerItemShownHeight;

507 if (uFuzzyCompare(contentY(), -m_minYExtent) || contentY() > -m_minYExtent) {

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

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

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

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

512 const bool scrolledUp = m_previousContentY > contentY();

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

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

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

516

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

518 m_headerItemShownHeight = 0;

519 m_headerItem->setY(-m_minYExtent);

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

521 if (maximizeVisibleAreaRunning && diff > 0) {

522 // If we are maximizing and the header was shown, make sure we hide it

523 m_headerItemShownHeight -= diff;

524 } else {

525 m_headerItemShownHeight += diff;

526 }

527 if (uFuzzyCompare(contentY(), -m_minYExtent)) {

528 m_headerItemShownHeight = 0;

529 } else {

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

531 }

532 if (m_headerItemShownHeight > 0) {

533 if (uFuzzyCompare(m_headerItem->height(), m_headerItemShownHeight)) {

534 m_headerItem->setY(contentY());

535 m_headerItemShownHeight = m_headerItem->height();

536 } else {

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

538 }

539 } else {

540 m_headerItem->setY(-m_minYExtent);

541 }

542 }

543 } else {

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

545 m_headerItem->setY(contentY());

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

547 }

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

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

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

551 if (!showHeaderAnimationRunning) {

552 diff += oldHeaderItemShownHeight - m_headerItemShownHeight;

553 } else {

554 diff = -diff;

555 }

556 }

557 if (!m_visibleItems.isEmpty()) {

558 updateClipItem();

559 ListItem *firstItem = m_visibleItems.first();

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

561 if (showHeaderAnimationRunning) {

562 adjustMinYExtent();

563 }

564 }

565

566 m_previousContentY = contentY();

567 layout();

568 polish();

569}

570

571void ListViewWithPageHeader::createDelegateModel()

572{

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

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

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

576#else

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

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

579#endif

580 if (isComponentComplete())

581 m_delegateModel->componentComplete();

582 updateWatchedRoles();

583}

584

585void ListViewWithPageHeader::refill()

586{

587 if (m_inLayout) {

588 return;

589 }

590 if (!isComponentComplete()) {

591 return;

592 }

593

594 const qreal buffer = height() * bufferRatio;

595 const qreal from = contentY();

596 const qreal to = from + height();

597 const qreal bufferFrom = from - buffer;

598 const qreal bufferTo = to + buffer;

599

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

601 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

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

603

604 if (added || removed) {

605 m_contentHeightDirty = true;

606 }

607}

608

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

610{

611 if (!delegate())

612 return false;

613

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

615 return false;

616

617 ListItem *item;

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

619

620 int modelIndex = 0;

621 qreal pos = 0;

622 if (!m_visibleItems.isEmpty()) {

623 modelIndex = m_firstVisibleIndex + m_visibleItems.count();

624 item = m_visibleItems.last();

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

626 }

627 bool changed = false;

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

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

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

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

632 break;

633 pos += item->height();

634 ++modelIndex;

635 changed = true;

636 }

637

638 modelIndex = 0;

639 pos = 0;

640 if (!m_visibleItems.isEmpty()) {

641 modelIndex = m_firstVisibleIndex - 1;

642 item = m_visibleItems.first();

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

644 }

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

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

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

648 break;

649 pos -= item->height();

650 --modelIndex;

651 changed = true;

652 }

653

654 return changed;

655}

656

657void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)

658{

659 QQuickItem *item = listItem->m_item;

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

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

662 if (flags & QQuickVisualModel::Destroyed) {

663#else

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

665 if (flags & QQmlDelegateModel::Destroyed) {

666#endif

667 item->setParentItem(nullptr);

668 }

669 delete listItem->m_sectionItem;

670 delete listItem;

671}

672

673void ListViewWithPageHeader::releaseItem(ListItem *listItem)

674{

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

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

677 m_itemsToRelease << listItem;

678}

679

680void ListViewWithPageHeader::updateWatchedRoles()

681{

682 if (m_delegateModel) {

683 QList<QByteArray> roles;

684 if (!m_sectionProperty.isEmpty())

685 roles << m_sectionProperty.toUtf8();

686 m_delegateModel->setWatchedRoles(roles);

687 }

688}

689

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

691{

692 if (!m_sectionDelegate)

693 return nullptr;

694

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

696 if (modelIndex > 0) {

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

698 if (section == prevSection)

699 return nullptr;

700 }

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

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

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

704 if (section == nextSection) {

705 // Steal the section header

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

707 if (nextItem) {

708 QQuickItem *sectionItem = nextItem->m_sectionItem;

709 nextItem->m_sectionItem = nullptr;

710 return sectionItem;

711 }

712 }

713 }

714

715 return getSectionItem(section);

716}

717

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

719{

720 QQuickItem *sectionItem = nullptr;

721

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

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

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

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

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

727 if (nobj) {

728 QQml_setParent_noEvent(context, nobj);

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

730 if (!sectionItem) {

731 delete nobj;

732 } else {

733 sectionItem->setZ(2);

734 QQml_setParent_noEvent(sectionItem, m_clipItem);

735 sectionItem->setParentItem(m_clipItem);

736 }

737 } else {

738 delete context;

739 }

740 m_sectionDelegate->completeCreate();

741

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

743

744 return sectionItem;

745}

746

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

748{

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

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

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

752 if (contentY() < -m_minYExtent) {

753 return false;

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

755 return false;

756 }

757 bool changed = false;

758

759 bool foundVisible = false;

760 int i = 0;

761 int removedItems = 0;

762 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

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

764 ListItem *item = m_visibleItems[i];

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

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

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

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

769 releaseItem(item);

770 m_visibleItems.removeAt(i);

771 changed = true;

772 ++removedItems;

773 } else {

774 if (!foundVisible) {

775 foundVisible = true;

776 const int itemIndex = m_firstVisibleIndex + removedItems + i;

777 m_firstVisibleIndex = itemIndex;

778 }

779 ++i;

780 }

781 }

782 if (!foundVisible) {

783 m_firstVisibleIndex = -1;

784 }

785 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

786 adjustMinYExtent();

787 }

788

789 return changed;

790}

791

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

793{

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

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

796 return nullptr;

797

798 m_asyncRequestedIndex = -1;

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

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

801#else

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

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

804#endif

805 if (!item) {

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

807 m_asyncRequestedIndex = modelIndex;

808#else

809 if (object) {

810 m_delegateModel->release(object);

811 if (!m_delegateValidated) {

812 m_delegateValidated = true;

813 QObject* delegateObj = delegate();

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

815 }

816 } else {

817 m_asyncRequestedIndex = modelIndex;

818 }

819#endif

820 return 0;

821 } else {

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

823 ListItem *listItem = new ListItem;

824 listItem->m_item = item;

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

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

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

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

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

830 // nor is the first item

831 if (prevItem) {

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

833 } else {

834 ListItem *currItem = itemAtIndex(modelIndex);

835 if (currItem) {

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

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

838 } else {

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

840 if (nextItem) {

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

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

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

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

845 lostItem = true;

846 }

847 }

848 }

849 if (lostItem) {

850 listItem->setCulled(true);

851 releaseItem(listItem);

852 listItem = nullptr;

853 } else {

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

855 if (m_visibleItems.isEmpty()) {

856 m_visibleItems << listItem;

857 } else {

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

859 }

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

861 m_firstVisibleIndex = modelIndex;

862 polish();

863 }

864 if (listItem->m_sectionItem) {

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

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

867 }

868 adjustMinYExtent();

869 m_contentHeightDirty = true;

870 }

871 return listItem;

872 }

873}

874

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

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

877{

878#else

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

880{

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

882 if (!item) {

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

884 return;

885 }

886#endif

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

888 // Check we are not being taken down and don't paint anything

889 // TODO Check if we still need this in 5.2

890 // For reproduction just inifnite loop testDash or testDashContent

891 if (!QQmlEngine::contextForObject(this)->parentContext())

892 return;

893

894 item->setParentItem(m_clipItem);

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

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

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

898 if (modelIndex == m_asyncRequestedIndex) {

899 createItem(modelIndex, false);

900 refill();

901 }

902}

903

904void ListViewWithPageHeader::updateClipItem()

905{

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

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

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

909}

910

911void ListViewWithPageHeader::onContentHeightChanged()

912{

913 updateClipItem();

914}

915

916void ListViewWithPageHeader::onContentWidthChanged()

917{

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

919}

920

921void ListViewWithPageHeader::onHeightChanged()

922{

923 polish();

924}

925

926

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

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

929#else

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

931#endif

932{

933 // TODO Do something with reset

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

935 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

936

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

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

939#else

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

941#endif

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

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

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

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

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

947 bool growDown = true;

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

949 const int modelIndex = remove.index + i;

950 ListItem *item = itemAtIndex(modelIndex);

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

952 growDown = false;

953 }

954 }

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

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

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

958 ListItem *item = m_visibleItems[visibleIndex];

959 // Pass the section item down if needed

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

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

962 if (!nextItem->m_sectionItem) {

963 nextItem->m_sectionItem = item->m_sectionItem;

964 item->m_sectionItem = nullptr;

965 }

966 }

967 releaseItem(item);

968 m_visibleItems.removeAt(visibleIndex);

969 }

970 }

971 if (growDown) {

972 adjustMinYExtent();

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

974 if (!m_visibleItems.isEmpty()) {

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

976 // position the new first item correctly

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

978 } else {

979 m_firstVisibleIndex = -1;

980 }

981 }

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

983 m_firstVisibleIndex -= remove.count;

984 }

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

986 const int modelIndex = remove.index + i;

987 if (modelIndex == m_asyncRequestedIndex) {

988 m_asyncRequestedIndex = -1;

989 } else if (modelIndex < m_asyncRequestedIndex) {

990 m_asyncRequestedIndex--;

991 }

992 }

993 }

994

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

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

997#else

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

999#endif

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

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

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

1003 if (insertingInValidIndexes || firstItemWithViewOnTop)

1004 {

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

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

1007 bool growUp = false;

1008 if (!firstItemWithViewOnTop) {

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

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

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

1012 growUp = true;

1013 }

1014 break;

1015 }

1016 }

1017 }

1018

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

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

1021 const int modelIndex = insert.index + i;

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

1023 if (growUp) {

1024 ListItem *firstItem = m_visibleItems.first();

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

1026 }

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

1028 // if we need adding a new section item

1029 if (m_sectionDelegate) {

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

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

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

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

1034 ListItem *firstItem = m_visibleItems.first();

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

1036 }

1037 }

1038 }

1039 }

1040 if (firstItemWithViewOnTop) {

1041 ListItem *firstItem = m_visibleItems.first();

1042 firstItem->setY(oldFirstValidIndexPos);

1043 }

1044 adjustMinYExtent();

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

1046 m_firstVisibleIndex += insert.count;

1047 }

1048

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

1050 const int modelIndex = insert.index + i;

1051 if (modelIndex <= m_asyncRequestedIndex) {

1052 m_asyncRequestedIndex++;

1053 }

1054 }

1055 }

1056

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

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

1059#else

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

1061#endif

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

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

1064 ListItem *item = itemAtIndex(i);

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

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

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

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

1069 }

1070 }

1071 }

1072

1073 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

1074 adjustMinYExtent();

1075 }

1076

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

1078 ListItem *item = m_visibleItems[i];

1079 if (item->m_sectionItem) {

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

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

1082 }

1083 }

1084

1085 layout();

1086 polish();

1087 m_contentHeightDirty = true;

1088}

1089

1090void ListViewWithPageHeader::onShowHeaderAnimationFinished()

1091{

1092 m_contentHeightDirty = true;

1093 polish();

1094}

1095

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

1097{

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

1099 if (heightDiff != 0) {

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

1101 ListItem *firstItem = m_visibleItems.first();

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

1103 adjustMinYExtent();

1104 layout();

1105 }

1106 refill();

1107 adjustMinYExtent();

1108 polish();

1109 m_contentHeightDirty = true;

1110 }

1111}

1112

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

1114{

1115 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

1116 if (m_headerItemShownHeight > 0) {

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

1118 // Change its size

1119 m_headerItemShownHeight += heightDiff;

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

1121 updateClipItem();

1122 adjustMinYExtent();

1123 } else {

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

1125 // If the header is shown because its position

1126 // Change its size

1127 ListItem *firstItem = m_visibleItems.first();

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

1129 layout();

1130 } else {

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

1132 // so the viewport is not changed

1133 adjustMinYExtent();

1134 }

1135 }

1136}

1137

1138

1139void ListViewWithPageHeader::adjustMinYExtent()

1140{

1141 if (m_visibleItems.isEmpty()) {

1142 m_minYExtent = 0;

1143 } else {

1144 qreal nonCreatedHeight = 0;

1145 if (m_firstVisibleIndex != 0) {

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

1147 const int visibleItems = m_visibleItems.count();

1148 qreal visibleItemsHeight = 0;

1149 Q_FOREACH(ListItem *item, m_visibleItems) {

1150 visibleItemsHeight += item->height();

1151 }

1152 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

1154 }

1155 const qreal headerHeight = (m_headerItem ? m_headerItem->implicitHeight() : 0);

1156 m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + headerHeight;

1157 if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {

1158 m_minYExtent = 0;

1159 m_visibleItems.first()->setY(nonCreatedHeight - m_clipItem->y() + headerHeight);

1160 }

1161 }

1162}

1163

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

1165{

1166 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

1168 return m_visibleItems[visibleIndexedModelIndex];

1169

1170 return nullptr;

1171}

1172

1173void ListViewWithPageHeader::layout()

1174{

1175 if (m_inLayout)

1176 return;

1177

1178 m_inLayout = true;

1179 if (!m_visibleItems.isEmpty()) {

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

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

1182

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

1184

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

1186 int firstReallyVisibleItem = -1;

1187 int modelIndex = m_firstVisibleIndex;

1188 Q_FOREACH(ListItem *item, m_visibleItems) {

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

1190 item->setCulled(cull);

1191 item->setY(pos);

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

1193 firstReallyVisibleItem = modelIndex;

1194 if (m_topSectionItem) {

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

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

1197 // or stick it to the top

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

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

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

1201 bool showStickySectionItem;

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

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

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

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

1206 if (topSectionStickPos > pos) {

1207 showStickySectionItem = true;

1208 } else if (topSectionStickPos == pos) {

1209 showStickySectionItem = !item->m_sectionItem;

1210 } else {

1211 showStickySectionItem = false;

1212 }

1213 if (!showStickySectionItem) {

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

1215 if (item->m_sectionItem) {

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

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

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

1219 // gets shown shortly in the next polish call

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

1221 }

1222 } else {

1223 // Update the top sticky section header

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

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

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

1227

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

1229 m_topSectionItem->setY(topSectionStickPos);

1230 int delegateIndex = modelIndex;

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

1232 while (delegateIndex > 0) {

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

1234 if (prevSection != section)

1235 break;

1236 delegateIndex--;

1237 }

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

1239 if (item->m_sectionItem) {

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

1241 }

1242 }

1243 }

1244 }

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

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

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

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

1249 } else {

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

1251 }

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

1253 pos += item->height();

1254 ++modelIndex;

1255 }

1256

1257 // Second step of section sticky item positioning

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

1259 if (m_topSectionItem) {

1260 if (firstReallyVisibleItem >= 0) {

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

1262 ListItem *item = m_visibleItems[i];

1263 if (item->m_sectionItem) {

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

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

1266 }

1267 break;

1268 }

1269 }

1270 }

1271 }

1272 }

1273 m_inLayout = false;

1274}

1275

1276void ListViewWithPageHeader::updatePolish()

1277{

1278 // Check we are not being taken down and don't paint anything

1279 // TODO Check if we still need this in 5.2

1280 // For reproduction just inifnite loop testDash or testDashContent

1281 if (!QQmlEngine::contextForObject(this)->parentContext())

1282 return;

1283

1284 Q_FOREACH(ListItem *item, m_itemsToRelease)

1285 reallyReleaseItem(item);

1286 m_itemsToRelease.clear();

1287

1288 if (!model())

1289 return;

1290

1291 layout();

1292

1293 refill();

1294

1295 if (m_contentHeightDirty) {

1296 qreal contentHeight;

1297 if (m_visibleItems.isEmpty()) {

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

1299 } else {

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

1301 const int visibleItems = m_visibleItems.count();

1302 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1303 qreal nonCreatedHeight = 0;

1304 if (lastValidIndex != modelCount - 1) {

1305 const int visibleItems = m_visibleItems.count();

1306 qreal visibleItemsHeight = 0;

1307 Q_FOREACH(ListItem *item, m_visibleItems) {

1308 visibleItemsHeight += item->height();

1309 }

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

1311 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1312 }

1313 ListItem *item = m_visibleItems.last();

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

1315 if (m_firstVisibleIndex != 0) {

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

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

1318 }

1319 }

1320

1321 m_contentHeightDirty = false;

1322 adjustMinYExtent();

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

1324 setContentHeight(contentHeight);

1325 m_inContentHeightKeepHeaderShown = false;

1326 }

1327}

1328

1329#include "moc_listviewwithpageheader.cpp"