plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

618 releaseItem(item);

619 m_visibleItems.removeAt(i);

620 changed = true;

621 ++removedItems;

622 } else {

623 if (!foundVisible) {

624 foundVisible = true;

625 const int itemIndex = m_firstVisibleIndex + removedItems + i;

626 m_firstVisibleIndex = itemIndex;

627 }

628 ++i;

629 }

630 }

631 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

632 adjustMinYExtent();

633 }

634

635 return changed;

636}

637

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

639{

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

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

642 return nullptr;

643

644 m_asyncRequestedIndex = -1;

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

646 if (!item) {

647 m_asyncRequestedIndex = modelIndex;

648 return 0;

649 } else {

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

651 ListItem *listItem = new ListItem;

652 listItem->m_item = item;

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

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

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

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

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

658 // nor is the first item

659 if (prevItem) {

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

661 } else {

662 ListItem *currItem = itemAtIndex(modelIndex);

663 if (currItem) {

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

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

666 } else {

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

668 if (nextItem) {

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

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

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

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

673 lostItem = true;

674 }

675 }

676 }

677 if (lostItem) {

678 releaseItem(listItem);

679 listItem = nullptr;

680 } else {

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

682 if (m_visibleItems.isEmpty()) {

683 m_visibleItems << listItem;

684 } else {

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

686 }

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

688 m_firstVisibleIndex = modelIndex;

689 polish();

690 }

691 adjustMinYExtent();

692 m_contentHeightDirty = true;

693 }

694 return listItem;

695 }

696}

697

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

699{

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

701

702 item->setParentItem(m_clipItem);

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

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

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

706 if (modelIndex == m_asyncRequestedIndex) {

707 createItem(modelIndex, false);

708 refill();

709 }

710}

711

712void ListViewWithPageHeader::updateClipItem()

713{

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

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

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

717}

718

719void ListViewWithPageHeader::onContentHeightChanged()

720{

721 updateClipItem();

722}

723

724void ListViewWithPageHeader::onContentWidthChanged()

725{

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

727}

728

729void ListViewWithPageHeader::onHeightChanged()

730{

731 polish();

732}

733

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

735{

736 // TODO Do something with reset

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

738 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

739

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

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

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

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

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

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

746 bool growDown = true;

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

748 const int modelIndex = remove.index + i;

749 ListItem *item = itemAtIndex(modelIndex);

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

751 growDown = false;

752 }

753 }

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

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

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

757 ListItem *item = m_visibleItems[visibleIndex];

758 // Pass the section item down if needed

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

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

761 if (!nextItem->m_sectionItem) {

762 nextItem->m_sectionItem = item->m_sectionItem;

763 item->m_sectionItem = nullptr;

764 }

765 }

766 releaseItem(item);

767 m_visibleItems.removeAt(visibleIndex);

768 }

769 }

770 if (growDown) {

771 adjustMinYExtent();

772 } else if (remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {

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

774 // position the new first item correctly

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

776 }

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

778 m_firstVisibleIndex -= remove.count;

779 }

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

781 const int modelIndex = remove.index + i;

782 if (modelIndex == m_asyncRequestedIndex) {

783 m_asyncRequestedIndex = -1;

784 } else if (modelIndex < m_asyncRequestedIndex) {

785 m_asyncRequestedIndex--;

786 }

787 }

788 }

789

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

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

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

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

794 if (insertingInValidIndexes || firstItemWithViewOnTop)

795 {

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

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

798 bool growUp = false;

799 if (!firstItemWithViewOnTop) {

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

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

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

803 growUp = true;

804 }

805 break;

806 }

807 }

808 }

809

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

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

812 const int modelIndex = insert.index + i;

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

814 if (growUp) {

815 ListItem *firstItem = m_visibleItems.first();

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

817 adjustMinYExtent();

818 }

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

820 // if we need adding a new section item

821 if (m_sectionDelegate) {

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

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

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

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

826 ListItem *firstItem = m_visibleItems.first();

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

828 adjustMinYExtent();

829 }

830 }

831 }

832 }

833 if (firstItemWithViewOnTop) {

834 ListItem *firstItem = m_visibleItems.first();

835 firstItem->setY(oldFirstValidIndexPos);

836 }

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

838 m_firstVisibleIndex += insert.count;

839 }

840

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

842 const int modelIndex = insert.index + i;

843 if (modelIndex <= m_asyncRequestedIndex) {

844 m_asyncRequestedIndex++;

845 }

846 }

847 }

848

849 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

850 adjustMinYExtent();

851 }

852

853 layout();

854 polish();

855 m_contentHeightDirty = true;

856}

857

858void ListViewWithPageHeader::onShowHeaderAnimationFinished()

859{

860 m_contentHeightDirty = true;

861 polish();

862}

863

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

865{

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

867 if (heightDiff != 0) {

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

869 ListItem *firstItem = m_visibleItems.first();

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

871 adjustMinYExtent();

872 layout();

873 }

874 refill();

875 adjustMinYExtent();

876 polish();

877 m_contentHeightDirty = true;

878 }

879}

880

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

882{

883 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

884 if (m_headerItemShownHeight > 0) {

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

886 // Change its size

887 m_headerItemShownHeight += heightDiff;

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

889 updateClipItem();

890 adjustMinYExtent();

891 } else {

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

893 // If the header is shown because its position

894 // Change its size

895 ListItem *firstItem = m_visibleItems.first();

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

897 layout();

898 } else {

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

900 // so the viewport is not changed

901 adjustMinYExtent();

902 }

903 }

904}

905

906

907void ListViewWithPageHeader::adjustMinYExtent()

908{

909 if (m_visibleItems.isEmpty()) {

910 m_minYExtent = 0;

911 } else {

912 qreal nonCreatedHeight = 0;

913 if (m_firstVisibleIndex != 0) {

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

915 const int visibleItems = m_visibleItems.count();

916 qreal visibleItemsHeight = 0;

917 Q_FOREACH(ListItem *item, m_visibleItems) {

918 visibleItemsHeight += item->height();

919 }

920 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

922 }

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

924 }

925}

926

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

928{

929 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

931 return m_visibleItems[visibleIndexedModelIndex];

932

933 return nullptr;

934}

935

936void ListViewWithPageHeader::layout()

937{

938 if (m_inLayout)

939 return;

940

941 m_inLayout = true;

942 if (!m_visibleItems.isEmpty()) {

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

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

945

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

947

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

949 int firstReallyVisibleItem = -1;

950 int modelIndex = m_firstVisibleIndex;

951 Q_FOREACH(ListItem *item, m_visibleItems) {

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

953 item->setCulled(cull);

954 item->setY(pos);

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

956 firstReallyVisibleItem = modelIndex;

957 if (m_topSectionItem) {

958 // Update the top sticky section header

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

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

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

962

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

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

965 // or stick it to the top

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

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

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

969 if (topSectionStickPos <= pos) {

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

971 if (item->m_sectionItem) {

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

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

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

975 // gets shown shortly in the next polish call

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

977 }

978 } else {

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

980 m_topSectionItem->setY(topSectionStickPos);

981 if (item->m_sectionItem) {

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

983 }

984 }

985 }

986 }

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

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

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

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

991 } else {

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

993 }

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

995 pos += item->height();

996 ++modelIndex;

997 }

998

999 // Second step of section sticky item positioning

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

1001 if (m_topSectionItem) {

1002 if (firstReallyVisibleItem >= 0) {

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

1004 ListItem *item = m_visibleItems[i];

1005 if (item->m_sectionItem) {

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

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

1008 }

1009 break;

1010 }

1011 }

1012 }

1013 }

1014 }

1015 m_inLayout = false;

1016}

1017

1018void ListViewWithPageHeader::updatePolish()

1019{

1020 Q_FOREACH(ListItem *item, m_itemsToRelease)

1021 reallyReleaseItem(item);

1022 m_itemsToRelease.clear();

1023

1024 if (!model())

1025 return;

1026

1027 layout();

1028

1029 refill();

1030

1031 if (m_contentHeightDirty) {

1032 qreal contentHeight;

1033 if (m_visibleItems.isEmpty()) {

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

1035 } else {

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

1037 const int visibleItems = m_visibleItems.count();

1038 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1039 qreal nonCreatedHeight = 0;

1040 if (lastValidIndex != modelCount - 1) {

1041 const int visibleItems = m_visibleItems.count();

1042 qreal visibleItemsHeight = 0;

1043 Q_FOREACH(ListItem *item, m_visibleItems) {

1044 visibleItemsHeight += item->height();

1045 }

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

1047 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1048 }

1049 ListItem *item = m_visibleItems.last();

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

1051 if (m_firstVisibleIndex != 0) {

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

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

1054 }

1055 }

1056

1057 m_contentHeightDirty = false;

1058 setContentHeight(contentHeight);

1059 }

1060}

1061

1062#include "moc_listviewwithpageheader.cpp"