plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

634 releaseItem(item);

635 m_visibleItems.removeAt(i);

636 changed = true;

637 ++removedItems;

638 } else {

639 if (!foundVisible) {

640 foundVisible = true;

641 const int itemIndex = m_firstVisibleIndex + removedItems + i;

642 m_firstVisibleIndex = itemIndex;

643 }

644 ++i;

645 }

646 }

647 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

648 adjustMinYExtent();

649 }

650

651 return changed;

652}

653

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

655{

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

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

658 return nullptr;

659

660 m_asyncRequestedIndex = -1;

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

662 if (!item) {

663 m_asyncRequestedIndex = modelIndex;

664 return 0;

665 } else {

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

667 ListItem *listItem = new ListItem;

668 listItem->m_item = item;

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

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

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

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

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

674 // nor is the first item

675 if (prevItem) {

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

677 } else {

678 ListItem *currItem = itemAtIndex(modelIndex);

679 if (currItem) {

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

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

682 } else {

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

684 if (nextItem) {

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

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

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

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

689 lostItem = true;

690 }

691 }

692 }

693 if (lostItem) {

694 releaseItem(listItem);

695 listItem = nullptr;

696 } else {

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

698 if (m_visibleItems.isEmpty()) {

699 m_visibleItems << listItem;

700 } else {

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

702 }

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

704 m_firstVisibleIndex = modelIndex;

705 polish();

706 }

707 adjustMinYExtent();

708 m_contentHeightDirty = true;

709 }

710 return listItem;

711 }

712}

713

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

715{

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

717

718 item->setParentItem(m_clipItem);

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

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

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

722 if (modelIndex == m_asyncRequestedIndex) {

723 createItem(modelIndex, false);

724 refill();

725 }

726}

727

728void ListViewWithPageHeader::updateClipItem()

729{

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

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

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

733}

734

735void ListViewWithPageHeader::onContentHeightChanged()

736{

737 updateClipItem();

738}

739

740void ListViewWithPageHeader::onContentWidthChanged()

741{

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

743}

744

745void ListViewWithPageHeader::onHeightChanged()

746{

747 polish();

748}

749

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

751{

752 // TODO Do something with reset

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

754 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

755

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

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

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

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

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

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

762 bool growDown = true;

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

764 const int modelIndex = remove.index + i;

765 ListItem *item = itemAtIndex(modelIndex);

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

767 growDown = false;

768 }

769 }

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

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

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

773 ListItem *item = m_visibleItems[visibleIndex];

774 // Pass the section item down if needed

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

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

777 if (!nextItem->m_sectionItem) {

778 nextItem->m_sectionItem = item->m_sectionItem;

779 item->m_sectionItem = nullptr;

780 }

781 }

782 releaseItem(item);

783 m_visibleItems.removeAt(visibleIndex);

784 }

785 }

786 if (growDown) {

787 adjustMinYExtent();

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

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

790 // position the new first item correctly

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

792 }

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

794 m_firstVisibleIndex -= remove.count;

795 }

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

797 const int modelIndex = remove.index + i;

798 if (modelIndex == m_asyncRequestedIndex) {

799 m_asyncRequestedIndex = -1;

800 } else if (modelIndex < m_asyncRequestedIndex) {

801 m_asyncRequestedIndex--;

802 }

803 }

804 }

805

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

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

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

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

810 if (insertingInValidIndexes || firstItemWithViewOnTop)

811 {

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

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

814 bool growUp = false;

815 if (!firstItemWithViewOnTop) {

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

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

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

819 growUp = true;

820 }

821 break;

822 }

823 }

824 }

825

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

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

828 const int modelIndex = insert.index + i;

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

830 if (growUp) {

831 ListItem *firstItem = m_visibleItems.first();

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

833 adjustMinYExtent();

834 }

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

836 // if we need adding a new section item

837 if (m_sectionDelegate) {

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

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

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

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

842 ListItem *firstItem = m_visibleItems.first();

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

844 adjustMinYExtent();

845 }

846 }

847 }

848 }

849 if (firstItemWithViewOnTop) {

850 ListItem *firstItem = m_visibleItems.first();

851 firstItem->setY(oldFirstValidIndexPos);

852 }

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

854 m_firstVisibleIndex += insert.count;

855 }

856

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

858 const int modelIndex = insert.index + i;

859 if (modelIndex <= m_asyncRequestedIndex) {

860 m_asyncRequestedIndex++;

861 }

862 }

863 }

864

865 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

866 adjustMinYExtent();

867 }

868

869 layout();

870 polish();

871 m_contentHeightDirty = true;

872}

873

874void ListViewWithPageHeader::onShowHeaderAnimationFinished()

875{

876 m_contentHeightDirty = true;

877 polish();

878}

879

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

881{

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

883 if (heightDiff != 0) {

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

885 ListItem *firstItem = m_visibleItems.first();

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

887 adjustMinYExtent();

888 layout();

889 }

890 refill();

891 adjustMinYExtent();

892 polish();

893 m_contentHeightDirty = true;

894 }

895}

896

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

898{

899 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

900 if (m_headerItemShownHeight > 0) {

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

902 // Change its size

903 m_headerItemShownHeight += heightDiff;

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

905 updateClipItem();

906 adjustMinYExtent();

907 } else {

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

909 // If the header is shown because its position

910 // Change its size

911 ListItem *firstItem = m_visibleItems.first();

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

913 layout();

914 } else {

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

916 // so the viewport is not changed

917 adjustMinYExtent();

918 }

919 }

920}

921

922

923void ListViewWithPageHeader::adjustMinYExtent()

924{

925 if (m_visibleItems.isEmpty()) {

926 m_minYExtent = 0;

927 } else {

928 qreal nonCreatedHeight = 0;

929 if (m_firstVisibleIndex != 0) {

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

931 const int visibleItems = m_visibleItems.count();

932 qreal visibleItemsHeight = 0;

933 Q_FOREACH(ListItem *item, m_visibleItems) {

934 visibleItemsHeight += item->height();

935 }

936 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

938 }

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

940 }

941}

942

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

944{

945 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

947 return m_visibleItems[visibleIndexedModelIndex];

948

949 return nullptr;

950}

951

952void ListViewWithPageHeader::layout()

953{

954 if (m_inLayout)

955 return;

956

957 m_inLayout = true;

958 if (!m_visibleItems.isEmpty()) {

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

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

961

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

963

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

965 int firstReallyVisibleItem = -1;

966 int modelIndex = m_firstVisibleIndex;

967 Q_FOREACH(ListItem *item, m_visibleItems) {

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

969 item->setCulled(cull);

970 item->setY(pos);

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

972 firstReallyVisibleItem = modelIndex;

973 if (m_topSectionItem) {

974 // Update the top sticky section header

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

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

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

978

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

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

981 // or stick it to the top

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

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

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

985 if (topSectionStickPos <= pos) {

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

987 if (item->m_sectionItem) {

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

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

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

991 // gets shown shortly in the next polish call

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

993 }

994 } else {

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

996 m_topSectionItem->setY(topSectionStickPos);

997 if (item->m_sectionItem) {

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

999 }

1000 }

1001 }

1002 }

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

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

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

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

1007 } else {

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

1009 }

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

1011 pos += item->height();

1012 ++modelIndex;

1013 }

1014

1015 // Second step of section sticky item positioning

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

1017 if (m_topSectionItem) {

1018 if (firstReallyVisibleItem >= 0) {

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

1020 ListItem *item = m_visibleItems[i];

1021 if (item->m_sectionItem) {

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

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

1024 }

1025 break;

1026 }

1027 }

1028 }

1029 }

1030 }

1031 m_inLayout = false;

1032}

1033

1034void ListViewWithPageHeader::updatePolish()

1035{

1036 Q_FOREACH(ListItem *item, m_itemsToRelease)

1037 reallyReleaseItem(item);

1038 m_itemsToRelease.clear();

1039

1040 if (!model())

1041 return;

1042

1043 layout();

1044

1045 refill();

1046

1047 if (m_contentHeightDirty) {

1048 qreal contentHeight;

1049 if (m_visibleItems.isEmpty()) {

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

1051 } else {

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

1053 const int visibleItems = m_visibleItems.count();

1054 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1055 qreal nonCreatedHeight = 0;

1056 if (lastValidIndex != modelCount - 1) {

1057 const int visibleItems = m_visibleItems.count();

1058 qreal visibleItemsHeight = 0;

1059 Q_FOREACH(ListItem *item, m_visibleItems) {

1060 visibleItemsHeight += item->height();

1061 }

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

1063 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1064 }

1065 ListItem *item = m_visibleItems.last();

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

1067 if (m_firstVisibleIndex != 0) {

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

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

1070 }

1071 }

1072

1073 m_contentHeightDirty = false;

1074 setContentHeight(contentHeight);

1075 }

1076}

1077

1078#include "moc_listviewwithpageheader.cpp"