plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

631 releaseItem(item);

632 m_visibleItems.removeAt(i);

633 changed = true;

634 ++removedItems;

635 } else {

636 if (!foundVisible) {

637 foundVisible = true;

638 const int itemIndex = m_firstVisibleIndex + removedItems + i;

639 m_firstVisibleIndex = itemIndex;

640 }

641 ++i;

642 }

643 }

644 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

645 adjustMinYExtent();

646 }

647

648 return changed;

649}

650

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

652{

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

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

655 return nullptr;

656

657 m_asyncRequestedIndex = -1;

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

659 if (!item) {

660 m_asyncRequestedIndex = modelIndex;

661 return 0;

662 } else {

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

664 ListItem *listItem = new ListItem;

665 listItem->m_item = item;

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

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

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

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

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

671 // nor is the first item

672 if (prevItem) {

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

674 } else {

675 ListItem *currItem = itemAtIndex(modelIndex);

676 if (currItem) {

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

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

679 } else {

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

681 if (nextItem) {

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

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

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

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

686 lostItem = true;

687 }

688 }

689 }

690 if (lostItem) {

691 releaseItem(listItem);

692 listItem = nullptr;

693 } else {

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

695 if (m_visibleItems.isEmpty()) {

696 m_visibleItems << listItem;

697 } else {

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

699 }

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

701 m_firstVisibleIndex = modelIndex;

702 polish();

703 }

704 adjustMinYExtent();

705 m_contentHeightDirty = true;

706 }

707 return listItem;

708 }

709}

710

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

712{

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

714

715 item->setParentItem(m_clipItem);

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

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

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

719 if (modelIndex == m_asyncRequestedIndex) {

720 createItem(modelIndex, false);

721 refill();

722 }

723}

724

725void ListViewWithPageHeader::updateClipItem()

726{

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

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

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

730}

731

732void ListViewWithPageHeader::onContentHeightChanged()

733{

734 updateClipItem();

735}

736

737void ListViewWithPageHeader::onContentWidthChanged()

738{

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

740}

741

742void ListViewWithPageHeader::onHeightChanged()

743{

744 polish();

745}

746

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

748{

749 // TODO Do something with reset

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

751 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

752

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

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

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

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

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

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

759 bool growDown = true;

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

761 const int modelIndex = remove.index + i;

762 ListItem *item = itemAtIndex(modelIndex);

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

764 growDown = false;

765 }

766 }

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

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

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

770 ListItem *item = m_visibleItems[visibleIndex];

771 // Pass the section item down if needed

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

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

774 if (!nextItem->m_sectionItem) {

775 nextItem->m_sectionItem = item->m_sectionItem;

776 item->m_sectionItem = nullptr;

777 }

778 }

779 releaseItem(item);

780 m_visibleItems.removeAt(visibleIndex);

781 }

782 }

783 if (growDown) {

784 adjustMinYExtent();

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

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

787 // position the new first item correctly

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

789 }

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

791 m_firstVisibleIndex -= remove.count;

792 }

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

794 const int modelIndex = remove.index + i;

795 if (modelIndex == m_asyncRequestedIndex) {

796 m_asyncRequestedIndex = -1;

797 } else if (modelIndex < m_asyncRequestedIndex) {

798 m_asyncRequestedIndex--;

799 }

800 }

801 }

802

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

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

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

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

807 if (insertingInValidIndexes || firstItemWithViewOnTop)

808 {

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

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

811 bool growUp = false;

812 if (!firstItemWithViewOnTop) {

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

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

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

816 growUp = true;

817 }

818 break;

819 }

820 }

821 }

822

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

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

825 const int modelIndex = insert.index + i;

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

827 if (growUp) {

828 ListItem *firstItem = m_visibleItems.first();

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

830 adjustMinYExtent();

831 }

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

833 // if we need adding a new section item

834 if (m_sectionDelegate) {

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

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

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

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

839 ListItem *firstItem = m_visibleItems.first();

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

841 adjustMinYExtent();

842 }

843 }

844 }

845 }

846 if (firstItemWithViewOnTop) {

847 ListItem *firstItem = m_visibleItems.first();

848 firstItem->setY(oldFirstValidIndexPos);

849 }

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

851 m_firstVisibleIndex += insert.count;

852 }

853

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

855 const int modelIndex = insert.index + i;

856 if (modelIndex <= m_asyncRequestedIndex) {

857 m_asyncRequestedIndex++;

858 }

859 }

860 }

861

862 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

863 adjustMinYExtent();

864 }

865

866 layout();

867 polish();

868 m_contentHeightDirty = true;

869}

870

871void ListViewWithPageHeader::onShowHeaderAnimationFinished()

872{

873 m_contentHeightDirty = true;

874 polish();

875}

876

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

878{

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

880 if (heightDiff != 0) {

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

882 ListItem *firstItem = m_visibleItems.first();

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

884 adjustMinYExtent();

885 layout();

886 }

887 refill();

888 adjustMinYExtent();

889 polish();

890 m_contentHeightDirty = true;

891 }

892}

893

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

895{

896 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

897 if (m_headerItemShownHeight > 0) {

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

899 // Change its size

900 m_headerItemShownHeight += heightDiff;

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

902 updateClipItem();

903 adjustMinYExtent();

904 } else {

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

906 // If the header is shown because its position

907 // Change its size

908 ListItem *firstItem = m_visibleItems.first();

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

910 layout();

911 } else {

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

913 // so the viewport is not changed

914 adjustMinYExtent();

915 }

916 }

917}

918

919

920void ListViewWithPageHeader::adjustMinYExtent()

921{

922 if (m_visibleItems.isEmpty()) {

923 m_minYExtent = 0;

924 } else {

925 qreal nonCreatedHeight = 0;

926 if (m_firstVisibleIndex != 0) {

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

928 const int visibleItems = m_visibleItems.count();

929 qreal visibleItemsHeight = 0;

930 Q_FOREACH(ListItem *item, m_visibleItems) {

931 visibleItemsHeight += item->height();

932 }

933 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

935 }

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

937 }

938}

939

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

941{

942 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

944 return m_visibleItems[visibleIndexedModelIndex];

945

946 return nullptr;

947}

948

949void ListViewWithPageHeader::layout()

950{

951 if (m_inLayout)

952 return;

953

954 m_inLayout = true;

955 if (!m_visibleItems.isEmpty()) {

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

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

958

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

960

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

962 int firstReallyVisibleItem = -1;

963 int modelIndex = m_firstVisibleIndex;

964 Q_FOREACH(ListItem *item, m_visibleItems) {

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

966 item->setCulled(cull);

967 item->setY(pos);

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

969 firstReallyVisibleItem = modelIndex;

970 if (m_topSectionItem) {

971 // Update the top sticky section header

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

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

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

975

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

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

978 // or stick it to the top

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

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

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

982 if (topSectionStickPos <= pos) {

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

984 if (item->m_sectionItem) {

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

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

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

988 // gets shown shortly in the next polish call

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

990 }

991 } else {

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

993 m_topSectionItem->setY(topSectionStickPos);

994 if (item->m_sectionItem) {

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

996 }

997 }

998 }

999 }

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

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

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

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

1004 } else {

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

1006 }

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

1008 pos += item->height();

1009 ++modelIndex;

1010 }

1011

1012 // Second step of section sticky item positioning

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

1014 if (m_topSectionItem) {

1015 if (firstReallyVisibleItem >= 0) {

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

1017 ListItem *item = m_visibleItems[i];

1018 if (item->m_sectionItem) {

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

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

1021 }

1022 break;

1023 }

1024 }

1025 }

1026 }

1027 }

1028 m_inLayout = false;

1029}

1030

1031void ListViewWithPageHeader::updatePolish()

1032{

1033 Q_FOREACH(ListItem *item, m_itemsToRelease)

1034 reallyReleaseItem(item);

1035 m_itemsToRelease.clear();

1036

1037 if (!model())

1038 return;

1039

1040 layout();

1041

1042 refill();

1043

1044 if (m_contentHeightDirty) {

1045 qreal contentHeight;

1046 if (m_visibleItems.isEmpty()) {

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

1048 } else {

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

1050 const int visibleItems = m_visibleItems.count();

1051 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1052 qreal nonCreatedHeight = 0;

1053 if (lastValidIndex != modelCount - 1) {

1054 const int visibleItems = m_visibleItems.count();

1055 qreal visibleItemsHeight = 0;

1056 Q_FOREACH(ListItem *item, m_visibleItems) {

1057 visibleItemsHeight += item->height();

1058 }

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

1060 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1061 }

1062 ListItem *item = m_visibleItems.last();

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

1064 if (m_firstVisibleIndex != 0) {

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

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

1067 }

1068 }

1069

1070 m_contentHeightDirty = false;

1071 setContentHeight(contentHeight);

1072 }

1073}

1074

1075#include "moc_listviewwithpageheader.cpp"