plugins/ListViewWithPageHeader/listviewwithpageheader.cpp · unity8

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

478 releaseItem(item);

479 m_visibleItems.removeAt(i);

480 changed = true;

481 ++removedItems;

482 } else {

483 if (!foundVisible) {

484 foundVisible = true;

485 const int itemIndex = m_firstVisibleIndex + removedItems + i;

486 m_firstVisibleIndex = itemIndex;

487 }

488 ++i;

489 }

490 }

491

492 return changed;

493}

494

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

496{

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

498 if (asynchronous && m_asyncRequestedIndexes.contains(modelIndex))

499 return nullptr;

500

501 m_asyncRequestedIndexes.remove(modelIndex);

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

503 if (!item) {

504 m_asyncRequestedIndexes << modelIndex;

505 return 0;

506 } else {

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

508 ListItem *listItem = new ListItem;

509 listItem->m_item = item;

510 listItem->m_sectionItem = getSectionItem(modelIndex);

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

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

513 if (prevItem) {

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

515 } else {

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

517 if (nextItem) {

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

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

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

521 }

522 }

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

524 if (m_visibleItems.isEmpty()) {

525 m_visibleItems << listItem;

526 } else {

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

528 }

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

530 m_firstVisibleIndex = modelIndex;

531 adjustMinYExtent();

532 }

533 return listItem;

534 }

535}

536

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

538{

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

540

541 item->setParentItem(m_clipItem);

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

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

544 if (m_asyncRequestedIndexes.remove(modelIndex)) {

545 createItem(modelIndex, false);

546 }

547}

548

549void ListViewWithPageHeader::updateClipItem()

550{

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

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

553 m_clipItem->setClip(m_headerItemShownHeight > 0);

554}

555

556void ListViewWithPageHeader::onContentHeightChanged()

557{

558 updateClipItem();

559}

560

561void ListViewWithPageHeader::onContentWidthChanged()

562{

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

564}

565

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

567{

568 // TODO Do something with reset

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

570 foreach(const QQuickChangeSet::Remove &remove, changeSet.removes()) {

571// qDebug() << "ListViewWithPageHeader::onModelUpdated Remove" << remove;

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

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

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

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

576 bool growDown = true;

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

578 const int modelIndex = remove.index + i;

579 ListItem *item = itemAtIndex(modelIndex);

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

581 growDown = false;

582 }

583 }

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

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

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

587 ListItem *item = m_visibleItems[visibleIndex];

588 releaseItem(item);

589 m_visibleItems.removeAt(visibleIndex);

590 }

591 }

592 if (growDown) {

593 adjustMinYExtent();

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

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

596 // position the new first item correctly

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

598 }

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

600 m_firstVisibleIndex -= remove.count;

601 }

602 }

603

604 foreach(const QQuickChangeSet::Insert &insert, changeSet.inserts()) {

605// qDebug() << "ListViewWithPageHeader::onModelUpdated Insert" << insert;

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

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

608 if (insertingInValidIndexes || firstItemWithViewOnTop)

609 {

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

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

612 bool growUp = false;

613 if (!firstItemWithViewOnTop) {

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

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

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

617 growUp = true;

618 }

619 break;

620 }

621 }

622 }

623

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

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

626 const int modelIndex = insert.index + i;

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

628 if (growUp) {

629 ListItem *firstItem = m_visibleItems.first();

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

631 adjustMinYExtent();

632 }

633 }

634 if (firstItemWithViewOnTop) {

635 ListItem *firstItem = m_visibleItems.first();

636 firstItem->setY(oldFirstValidIndexPos);

637 }

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

639 m_firstVisibleIndex += insert.count;

640 }

641 }

642

643 polish();

644 m_contentHeightDirty = true;

645}

646

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

648{

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

650 if (heightDiff != 0) {

651 if (item == m_headerItem) {

652 headerHeightChanged(newGeometry.height(), oldGeometry.height(), oldGeometry.y());

653 } else {

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

655 ListItem *firstItem = m_visibleItems.first();

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

657 adjustMinYExtent();

658 }

659 }

660 polish();

661 m_contentHeightDirty = true;

662 }

663}

664

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

666{

667 const qreal heightDiff = newHeaderHeight - oldHeaderHeight;

668 if (m_headerItemShownHeight > 0) {

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

670 // Change its size

671 m_headerItemShownHeight += heightDiff;

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

673 updateClipItem();

674 adjustMinYExtent();

675 } else {

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

677 // If the header is shown because its position

678 // Change its size

679 ListItem *firstItem = m_visibleItems.first();

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

681 } else {

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

683 // so the viewport is not changed

684 adjustMinYExtent();

685 }

686 }

687}

688

689

690void ListViewWithPageHeader::adjustMinYExtent()

691{

692 if (m_visibleItems.isEmpty()) {

693 m_minYExtent = 0;

694 } else {

695 m_minYExtent = -m_visibleItems.first()->y() - m_clipItem->y() + (m_headerItem ? m_headerItem->height() : 0);

696 }

697}

698

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

700{

701 const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;

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

703 return m_visibleItems[visibleIndexedModelIndex];

704

705 return nullptr;

706}

707

708void ListViewWithPageHeader::updatePolish()

709{

710 if (!model())

711 return;

712

713 if (!m_visibleItems.isEmpty()) {

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

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

716

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

718

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

720 int firstReallyVisibleItem = -1;

721 int modelIndex = m_firstVisibleIndex;

722 foreach(ListItem *item, m_visibleItems) {

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

724 item->setCulled(cull);

725 item->setY(pos);

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

727 firstReallyVisibleItem = modelIndex;

728 if (m_topSectionItem) {

729 // Update the top sticky section header

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

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

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

733

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

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

736 // or stick it to the top

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

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

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

740 if (topSectionStickPos <= pos) {

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

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

743 } else {

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

745 m_topSectionItem->setY(topSectionStickPos);

746 if (item->m_sectionItem) {

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

748 }

749 }

750 }

751 }

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

753 if (!cull && pos < visibleFrom) {

754 context->setContextProperty(QLatin1String("heightToClip"), visibleFrom - pos);

755 } else {

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

757 }

758// qDebug() << "ListViewWithPageHeader::updatePolish" << /*index << */pos + m_clipItem->y() << /*QQuickItemPrivate::get(item)->culled <<*/ (pos + item->height() < visibleFrom) << (pos > visibleTo);

759 pos += item->height();

760 ++modelIndex;

761 }

762

763 // Second step of section sticky item positioning

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

765 if (m_topSectionItem) {

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

767 ListItem *item = m_visibleItems[i];

768 if (item->m_sectionItem) {

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

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

771 }

772 break;

773 }

774 }

775 }

776 }

777

778 refill();

779

780 if (m_contentHeightDirty) {

781 qreal contentHeight;

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

783 const int visibleItems = m_visibleItems.count();

784 const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;

785 if (lastValidIndex == modelCount - 1) {

786 ListItem *item = m_visibleItems.last();

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

788 if (m_firstVisibleIndex != 0) {

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

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

791 }

792 } else {

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

794 if (!m_visibleItems.isEmpty()) {

795 foreach(ListItem *item, m_visibleItems) {

796 contentHeight += item->height();

797 }

798 const int unknownSizes = modelCount - visibleItems;

799 contentHeight += unknownSizes * contentHeight / visibleItems;

800 }

801 }

802

803 m_contentHeightDirty = false;

804 setContentHeight(contentHeight);

805 }

806

807}

808

809#include "moc_listviewwithpageheader.cpp"