plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

615 releaseItem(item);

616 m_visibleItems.removeAt(i);

617 changed = true;

618 ++removedItems;

619 } else {

620 if (!foundVisible) {

621 foundVisible = true;

622 const int itemIndex = m_firstVisibleIndex + removedItems + i;

623 m_firstVisibleIndex = itemIndex;

624 }

625 ++i;

626 }

627 }

628 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

629 adjustMinYExtent();

630 }

631

632 return changed;

633}

634

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

636{

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

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

639 return nullptr;

640

641 m_asyncRequestedIndex = -1;

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

643 if (!item) {

644 m_asyncRequestedIndex = modelIndex;

645 return 0;

646 } else {

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

648 ListItem *listItem = new ListItem;

649 listItem->m_item = item;

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

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

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

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

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

655 // nor is the first item

656 if (prevItem) {

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

658 } else {

659 ListItem *currItem = itemAtIndex(modelIndex);

660 if (currItem) {

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

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

663 } else {

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

665 if (nextItem) {

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

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

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

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

670 lostItem = true;

671 }

672 }

673 }

674 if (lostItem) {

675 releaseItem(listItem);

676 listItem = nullptr;

677 } else {

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

679 if (m_visibleItems.isEmpty()) {

680 m_visibleItems << listItem;

681 } else {

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

683 }

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

685 m_firstVisibleIndex = modelIndex;

686 polish();

687 }

688 adjustMinYExtent();

689 m_contentHeightDirty = true;

690 }

691 return listItem;

692 }

693}

694

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

696{

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

698

699 item->setParentItem(m_clipItem);

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

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

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

703 if (modelIndex == m_asyncRequestedIndex) {

704 createItem(modelIndex, false);

705 refill();

706 }

707}

708

709void ListViewWithPageHeader::updateClipItem()

710{

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

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

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

714}

715

716void ListViewWithPageHeader::onContentHeightChanged()

717{

718 updateClipItem();

719}

720

721void ListViewWithPageHeader::onContentWidthChanged()

722{

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

724}

725

726void ListViewWithPageHeader::onHeightChanged()

727{

728 polish();

729}

730

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

732{

733 // TODO Do something with reset

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

735 const auto oldFirstVisibleIndex = m_firstVisibleIndex;

736

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

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

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

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

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

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

743 bool growDown = true;

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

745 const int modelIndex = remove.index + i;

746 ListItem *item = itemAtIndex(modelIndex);

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

748 growDown = false;

749 }

750 }

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

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

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

754 ListItem *item = m_visibleItems[visibleIndex];

755 // Pass the section item down if needed

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

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

758 if (!nextItem->m_sectionItem) {

759 nextItem->m_sectionItem = item->m_sectionItem;

760 item->m_sectionItem = nullptr;

761 }

762 }

763 releaseItem(item);

764 m_visibleItems.removeAt(visibleIndex);

765 }

766 }

767 if (growDown) {

768 adjustMinYExtent();

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

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

771 // position the new first item correctly

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

773 }

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

775 m_firstVisibleIndex -= remove.count;

776 }

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

778 const int modelIndex = remove.index + i;

779 if (modelIndex == m_asyncRequestedIndex) {

780 m_asyncRequestedIndex = -1;

781 } else if (modelIndex < m_asyncRequestedIndex) {

782 m_asyncRequestedIndex--;

783 }

784 }

785 }

786

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

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

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

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

791 if (insertingInValidIndexes || firstItemWithViewOnTop)

792 {

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

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

795 bool growUp = false;

796 if (!firstItemWithViewOnTop) {

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

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

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

800 growUp = true;

801 }

802 break;

803 }

804 }

805 }

806

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

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

809 const int modelIndex = insert.index + i;

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

811 if (growUp) {

812 ListItem *firstItem = m_visibleItems.first();

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

814 adjustMinYExtent();

815 }

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

817 // if we need adding a new section item

818 if (m_sectionDelegate) {

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

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

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

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

823 ListItem *firstItem = m_visibleItems.first();

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

825 adjustMinYExtent();

826 }

827 }

828 }

829 }

830 if (firstItemWithViewOnTop) {

831 ListItem *firstItem = m_visibleItems.first();

832 firstItem->setY(oldFirstValidIndexPos);

833 }

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

835 m_firstVisibleIndex += insert.count;

836 }

837

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

839 const int modelIndex = insert.index + i;

840 if (modelIndex <= m_asyncRequestedIndex) {

841 m_asyncRequestedIndex++;

842 }

843 }

844 }

845

846 if (m_firstVisibleIndex != oldFirstVisibleIndex) {

847 adjustMinYExtent();

848 }

849

850 layout();

851 polish();

852 m_contentHeightDirty = true;

853}

854

855void ListViewWithPageHeader::onShowHeaderAnimationFinished()

856{

857 m_contentHeightDirty = true;

858 polish();

859}

860

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

862{

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

864 if (heightDiff != 0) {

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

866 ListItem *firstItem = m_visibleItems.first();

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

868 adjustMinYExtent();

869 layout();

870 }

871 refill();

872 adjustMinYExtent();

873 polish();

874 m_contentHeightDirty = true;

875 }

876}

877

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

879{

880 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

881 if (m_headerItemShownHeight > 0) {

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

883 // Change its size

884 m_headerItemShownHeight += heightDiff;

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

886 updateClipItem();

887 adjustMinYExtent();

888 } else {

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

890 // If the header is shown because its position

891 // Change its size

892 ListItem *firstItem = m_visibleItems.first();

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

894 layout();

895 } else {

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

897 // so the viewport is not changed

898 adjustMinYExtent();

899 }

900 }

901}

902

903

904void ListViewWithPageHeader::adjustMinYExtent()

905{

906 if (m_visibleItems.isEmpty()) {

907 m_minYExtent = 0;

908 } else {

909 qreal nonCreatedHeight = 0;

910 if (m_firstVisibleIndex != 0) {

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

912 const int visibleItems = m_visibleItems.count();

913 qreal visibleItemsHeight = 0;

914 Q_FOREACH(ListItem *item, m_visibleItems) {

915 visibleItemsHeight += item->height();

916 }

917 nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;

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

919 }

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

921 }

922}

923

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

925{

926 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

928 return m_visibleItems[visibleIndexedModelIndex];

929

930 return nullptr;

931}

932

933void ListViewWithPageHeader::layout()

934{

935 if (m_inLayout)

936 return;

937

938 m_inLayout = true;

939 if (!m_visibleItems.isEmpty()) {

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

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

942

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

944

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

946 int firstReallyVisibleItem = -1;

947 int modelIndex = m_firstVisibleIndex;

948 Q_FOREACH(ListItem *item, m_visibleItems) {

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

950 item->setCulled(cull);

951 item->setY(pos);

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

953 firstReallyVisibleItem = modelIndex;

954 if (m_topSectionItem) {

955 // Update the top sticky section header

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

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

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

959

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

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

962 // or stick it to the top

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

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

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

966 if (topSectionStickPos <= pos) {

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

968 if (item->m_sectionItem) {

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

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

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

972 // gets shown shortly in the next polish call

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

974 }

975 } else {

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

977 m_topSectionItem->setY(topSectionStickPos);

978 if (item->m_sectionItem) {

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

980 }

981 }

982 }

983 }

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

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

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

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

988 } else {

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

990 }

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

992 pos += item->height();

993 ++modelIndex;

994 }

995

996 // Second step of section sticky item positioning

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

998 if (m_topSectionItem) {

999 if (firstReallyVisibleItem >= 0) {

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

1001 ListItem *item = m_visibleItems[i];

1002 if (item->m_sectionItem) {

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

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

1005 }

1006 break;

1007 }

1008 }

1009 }

1010 }

1011 }

1012 m_inLayout = false;

1013}

1014

1015void ListViewWithPageHeader::updatePolish()

1016{

1017 Q_FOREACH(ListItem *item, m_itemsToRelease)

1018 reallyReleaseItem(item);

1019 m_itemsToRelease.clear();

1020

1021 if (!model())

1022 return;

1023

1024 layout();

1025

1026 refill();

1027

1028 if (m_contentHeightDirty) {

1029 qreal contentHeight;

1030 if (m_visibleItems.isEmpty()) {

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

1032 } else {

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

1034 const int visibleItems = m_visibleItems.count();

1035 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

1036 qreal nonCreatedHeight = 0;

1037 if (lastValidIndex != modelCount - 1) {

1038 const int visibleItems = m_visibleItems.count();

1039 qreal visibleItemsHeight = 0;

1040 Q_FOREACH(ListItem *item, m_visibleItems) {

1041 visibleItemsHeight += item->height();

1042 }

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

1044 nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;

1045 }

1046 ListItem *item = m_visibleItems.last();

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

1048 if (m_firstVisibleIndex != 0) {

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

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

1051 }

1052 }

1053

1054 m_contentHeightDirty = false;

1055 setContentHeight(contentHeight);

1056 }

1057}

1058

1059#include "moc_listviewwithpageheader.cpp"