X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/f63daef339dde16c7ef598f6fdaa5d2191da4685..0222d552811efb7049de2d024247b0b8eaeffe2b:/src/kitemviews/kitemlistview.cpp diff --git a/src/kitemviews/kitemlistview.cpp b/src/kitemviews/kitemlistview.cpp index 478bf6260..263c04461 100644 --- a/src/kitemviews/kitemlistview.cpp +++ b/src/kitemviews/kitemlistview.cpp @@ -52,6 +52,7 @@ namespace { KItemListView::KItemListView(QGraphicsWidget* parent) : QGraphicsWidget(parent), + m_enabledSelectionToggles(false), m_grouped(false), m_activeTransactions(0), m_itemSize(), @@ -126,7 +127,7 @@ void KItemListView::setScrollOrientation(Qt::Orientation orientation) } } - updateLayout(); + doLayout(Animation); onScrollOrientationChanged(orientation, previousOrientation); emit scrollOrientationChanged(orientation, previousOrientation); @@ -146,19 +147,14 @@ void KItemListView::setItemSize(const QSizeF& itemSize) m_itemSize = itemSize; - const bool emptySize = itemSize.isEmpty(); - if (emptySize) { + if (itemSize.isEmpty()) { updateVisibleRolesSizes(); } else { - if (itemSize.width() < previousSize.width() || itemSize.height() < previousSize.height()) { - prepareLayoutForIncreasedItemCount(itemSize, ItemSize); - } else { - m_layouter->setItemSize(itemSize); - } + m_layouter->setItemSize(itemSize); } m_sizeHintResolver->clearCache(); - updateLayout(); + doLayout(Animation); onItemSizeChanged(itemSize, previousSize); } @@ -180,10 +176,11 @@ void KItemListView::setScrollOffset(qreal offset) m_layouter->setScrollOffset(offset); m_animation->setScrollOffset(offset); - if (!m_layoutTimer->isActive()) { - doLayout(NoAnimation, 0, 0); - update(); - } + + // Don't check whether the m_layoutTimer is active: Changing the + // scroll offset must always trigger a synchronous layout, otherwise + // the smooth-scrolling might get jerky. + doLayout(NoAnimation); onScrollOffsetChanged(offset, previousOffset); } @@ -199,14 +196,19 @@ qreal KItemListView::maximumScrollOffset() const void KItemListView::setItemOffset(qreal offset) { + if (m_layouter->itemOffset() == offset) { + return; + } + m_layouter->setItemOffset(offset); if (m_header) { m_header->setPos(-offset, 0); } - if (!m_layoutTimer->isActive()) { - doLayout(NoAnimation, 0, 0); - update(); - } + + // Don't check whether the m_layoutTimer is active: Changing the + // item offset must always trigger a synchronous layout, otherwise + // the smooth-scrolling might get jerky. + doLayout(NoAnimation); } qreal KItemListView::itemOffset() const @@ -242,7 +244,7 @@ void KItemListView::setVisibleRoles(const QList& roles) } updateVisibleRolesSizes(); - updateLayout(); + doLayout(Animation); onVisibleRolesChanged(roles, previousRoles); } @@ -271,6 +273,24 @@ bool KItemListView::autoScroll() const return m_autoScrollTimer != 0; } +void KItemListView::setEnabledSelectionToggles(bool enabled) +{ + if (m_enabledSelectionToggles != enabled) { + m_enabledSelectionToggles = enabled; + + QHashIterator it(m_visibleItems); + while (it.hasNext()) { + it.next(); + it.value()->setEnabledSelectionToggle(enabled); + } + } +} + +bool KItemListView::enabledSelectionToggles() const +{ + return m_enabledSelectionToggles; +} + KItemListController* KItemListView::controller() const { return m_controller; @@ -313,7 +333,7 @@ void KItemListView::setStyleOption(const KItemListStyleOption& option) } m_sizeHintResolver->clearCache(); - updateLayout(); + doLayout(Animation); onStyleOptionChanged(option, previousOption); } @@ -330,20 +350,50 @@ void KItemListView::setGeometry(const QRectF& rect) return; } - if (m_model->count() > 0) { - prepareLayoutForIncreasedItemCount(rect.size(), LayouterSize); + const QSizeF newSize = rect.size(); + if (m_itemSize.isEmpty()) { + // The item size is dynamic: + // Changing the geometry does not require to do an expensive + // update of the visible-roles sizes, only the stretched sizes + // need to be adjusted to the new size. + updateStretchedVisibleRolesSizes(); + + if (m_useHeaderWidths) { + QSizeF dynamicItemSize = m_layouter->itemSize(); + + if (m_itemSize.width() < 0) { + const qreal requiredWidth = visibleRolesSizesWidthSum(); + if (newSize.width() > requiredWidth) { + dynamicItemSize.setWidth(newSize.width()); + } + const qreal headerWidth = qMax(newSize.width(), requiredWidth); + m_header->resize(headerWidth, m_header->size().height()); + } + + if (m_itemSize.height() < 0) { + const qreal requiredHeight = visibleRolesSizesHeightSum(); + if (newSize.height() > requiredHeight) { + dynamicItemSize.setHeight(newSize.height()); + } + // TODO: KItemListHeader is not prepared for vertical alignment + } + + m_layouter->setItemSize(dynamicItemSize); + } + + // Triggering a synchronous layout is fine from a performance point of view, + // as with dynamic item sizes no moving animation must be done. + m_layouter->setSize(newSize); + doLayout(Animation); } else { - m_layouter->setSize(rect.size()); - } - - if (!m_layoutTimer->isActive()) { - m_layoutTimer->start(); + // The item size is not dynamic and most probably the geometry change results + // in animated position changes of the items. Trigger an asynchronous relayout + // with m_layoutTimer to prevent performance bottlenecks. + m_layouter->setSize(newSize); + if (!m_layoutTimer->isActive()) { + m_layoutTimer->start(); + } } - - // Changing the geometry does not require to do an expensive - // update of the visible-roles sizes, only the stretched sizes - // need to be adjusted to the new size. - updateStretchedVisibleRolesSizes(); } int KItemListView::itemAt(const QPointF& pos) const @@ -364,8 +414,18 @@ int KItemListView::itemAt(const QPointF& pos) const bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const { - Q_UNUSED(index); - Q_UNUSED(pos); + if (!m_enabledSelectionToggles) { + return false; + } + + const KItemListWidget* widget = m_visibleItems.value(index); + if (widget) { + const QRectF selectionToggleRect = widget->selectionToggleRect(); + if (!selectionToggleRect.isEmpty()) { + const QPointF mappedPos = widget->mapFromItem(this, pos); + return selectionToggleRect.contains(mappedPos); + } + } return false; } @@ -404,14 +464,58 @@ QHash KItemListView::visibleRolesSizes(const KItemRangeList& return QHash(); } +bool KItemListView::supportsItemExpanding() const +{ + return false; +} + QRectF KItemListView::itemRect(int index) const { return m_layouter->itemRect(index); } -int KItemListView::itemsPerOffset() const +QRectF KItemListView::itemContextRect(int index) const { - return m_layouter->itemsPerOffset(); + QRectF contextRect; + + const KItemListWidget* widget = m_visibleItems.value(index); + if (widget) { + contextRect = widget->iconRect() | widget->textRect(); + contextRect.translate(itemRect(index).topLeft()); + } + + return contextRect; +} + +void KItemListView::scrollToItem(int index) +{ + QRectF viewGeometry = geometry(); + if (m_header) { + const qreal headerHeight = m_header->size().height(); + viewGeometry.adjust(0, headerHeight, 0, 0); + } + const QRectF currentRect = itemRect(index); + + if (!viewGeometry.contains(currentRect)) { + qreal newOffset = scrollOffset(); + if (scrollOrientation() == Qt::Vertical) { + if (currentRect.top() < viewGeometry.top()) { + newOffset += currentRect.top() - viewGeometry.top(); + } else if (currentRect.bottom() > viewGeometry.bottom()) { + newOffset += currentRect.bottom() - viewGeometry.bottom(); + } + } else { + if (currentRect.left() < viewGeometry.left()) { + newOffset += currentRect.left() - viewGeometry.left(); + } else if (currentRect.right() > viewGeometry.right()) { + newOffset += currentRect.right() - viewGeometry.right(); + } + } + + if (newOffset != scrollOffset()) { + emit scrollTo(newOffset); + } + } } void KItemListView::beginTransaction() @@ -432,7 +536,7 @@ void KItemListView::endTransaction() if (m_activeTransactions == 0) { onTransactionEnd(); - updateLayout(); + doLayout(Animation); } } @@ -453,10 +557,14 @@ void KItemListView::setHeaderShown(bool show) m_header->setVisibleRolesWidths(headerRolesWidths()); m_header->setZValue(1); - m_useHeaderWidths = false; - connect(m_header, SIGNAL(visibleRoleWidthChanged(QByteArray,qreal,qreal)), this, SLOT(slotVisibleRoleWidthChanged(QByteArray,qreal,qreal))); + connect(m_header, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)), + this, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder))); + connect(m_header, SIGNAL(sortRoleChanged(QByteArray,QByteArray)), + this, SIGNAL(sortRoleChanged(QByteArray,QByteArray))); + + m_useHeaderWidths = false; m_layouter->setHeaderHeight(m_header->size().height()); } else if (!show && m_header) { @@ -622,34 +730,6 @@ QList KItemListView::visibleItemListWidgets() const return m_visibleItems.values(); } -void KItemListView::resizeEvent(QGraphicsSceneResizeEvent* event) -{ - QGraphicsWidget::resizeEvent(event); - if (m_itemSize.isEmpty() && m_useHeaderWidths) { - QSizeF dynamicItemSize = m_layouter->itemSize(); - const QSizeF newSize = event->newSize(); - - if (m_itemSize.width() < 0) { - const qreal requiredWidth = visibleRolesSizesWidthSum(); - if (newSize.width() > requiredWidth) { - dynamicItemSize.setWidth(newSize.width()); - } - const qreal headerWidth = qMax(newSize.width(), requiredWidth); - m_header->resize(headerWidth, m_header->size().height()); - } - - if (m_itemSize.height() < 0) { - const qreal requiredHeight = visibleRolesSizesHeightSum(); - if (newSize.height() > requiredHeight) { - dynamicItemSize.setHeight(newSize.height()); - } - // TODO: KItemListHeader is not prepared for vertical alignment - } - - m_layouter->setItemSize(dynamicItemSize); - } -} - void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges) { updateVisibleRolesSizes(itemRanges); @@ -696,21 +776,27 @@ void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges) } m_layouter->markAsDirty(); - if (m_model->count() == count && maximumScrollOffset() > size().height()) { - kDebug() << "Scrollbar required, skipping layout"; - const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent); - QSizeF layouterSize = m_layouter->size(); - if (scrollOrientation() == Qt::Vertical) { - layouterSize.rwidth() -= scrollBarExtent; - } else { - layouterSize.rheight() -= scrollBarExtent; + if (m_model->count() == count && m_activeTransactions == 0) { + // Check whether a scrollbar is required to show the inserted items. In this case + // the size of the layouter will be decreased before calling doLayout(): This prevents + // an unnecessary temporary animation due to the geometry change of the inserted scrollbar. + const bool verticalScrollOrientation = (scrollOrientation() == Qt::Vertical); + const bool decreaseLayouterSize = ( verticalScrollOrientation && maximumScrollOffset() > size().height()) || + (!verticalScrollOrientation && maximumScrollOffset() > size().width()); + if (decreaseLayouterSize) { + const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent); + QSizeF layouterSize = m_layouter->size(); + if (verticalScrollOrientation) { + layouterSize.rwidth() -= scrollBarExtent; + } else { + layouterSize.rheight() -= scrollBarExtent; + } + m_layouter->setSize(layouterSize); } - m_layouter->setSize(layouterSize); } if (!hasMultipleRanges) { doLayout(Animation, index, count); - update(); } } @@ -790,8 +876,14 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges) m_layouter->markAsDirty(); if (!hasMultipleRanges) { + // The decrease-layout-size optimization in KItemListView::slotItemsInserted() + // assumes an updated geometry. If items are removed during an active transaction, + // the transaction will be temporary deactivated so that doLayout() triggers a + // geometry update if necessary. + const int activeTransactions = m_activeTransactions; + m_activeTransactions = 0; doLayout(Animation, index, -count); - update(); + m_activeTransactions = activeTransactions; } } @@ -806,6 +898,13 @@ void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges) void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList& movedToIndexes) { + m_sizeHintResolver->itemsMoved(itemRange.index, itemRange.count); + m_layouter->markAsDirty(); + + if (m_controller) { + m_controller->selectionManager()->itemsMoved(itemRange, movedToIndexes); + } + const int firstVisibleMovedIndex = qMax(firstVisibleIndex(), itemRange.index); const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1); @@ -813,12 +912,14 @@ void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList KItemListWidget* widget = m_visibleItems.value(index); if (widget) { updateWidgetProperties(widget, index); + if (m_grouped) { + updateGroupHeaderForWidget(widget); + } + initializeItemListWidget(widget); } } - if (m_controller) { - m_controller->selectionManager()->itemsMoved(itemRange, movedToIndexes); - } + doLayout(NoAnimation); } void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges, @@ -836,6 +937,7 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges, if (updateSizeHints) { m_sizeHintResolver->itemsChanged(index, count, roles); m_layouter->markAsDirty(); + if (!m_layoutTimer->isActive()) { m_layoutTimer->start(); } @@ -850,24 +952,27 @@ void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges, } } + if (m_grouped && roles.contains(m_model->sortRole())) { + // The sort-role has been changed which might result + // in modified group headers + updateVisibleGroupHeaders(); + doLayout(NoAnimation); + } } } void KItemListView::slotGroupedSortingChanged(bool current) { m_grouped = current; + m_layouter->markAsDirty(); + if (m_grouped) { // Apply the height of the header to the layouter const qreal groupHeaderHeight = m_styleOption.fontMetrics.height() + m_styleOption.margin * 2; m_layouter->setGroupHeaderHeight(groupHeaderHeight); - // Assure that headers from already visible items get created - QHashIterator it(m_visibleItems); - while (it.hasNext()) { - it.next(); - updateGroupHeaderForWidget(it.value()); - } + updateVisibleGroupHeaders(); } else { // Clear all visible headers QMutableHashIterator it (m_visibleGroups); @@ -878,8 +983,27 @@ void KItemListView::slotGroupedSortingChanged(bool current) Q_ASSERT(m_visibleGroups.isEmpty()); } - m_layouter->markAsDirty(); - updateLayout(); + doLayout(Animation); +} + +void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous) +{ + Q_UNUSED(current); + Q_UNUSED(previous); + if (m_grouped) { + updateVisibleGroupHeaders(); + doLayout(Animation); + } +} + +void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous) +{ + Q_UNUSED(current); + Q_UNUSED(previous); + if (m_grouped) { + updateVisibleGroupHeaders(); + doLayout(Animation); + } } void KItemListView::slotCurrentChanged(int current, int previous) @@ -897,33 +1021,6 @@ void KItemListView::slotCurrentChanged(int current, int previous) Q_ASSERT(!currentWidget->isCurrent()); currentWidget->setCurrent(true); } - - const QRectF viewGeometry = geometry(); - const QRectF currentRect = itemRect(current); - - if (!viewGeometry.contains(currentRect)) { - // Make sure that the new current item is fully visible in the view. - qreal newOffset = scrollOffset(); - if (currentRect.top() < viewGeometry.top()) { - Q_ASSERT(scrollOrientation() == Qt::Vertical); - newOffset += currentRect.top() - viewGeometry.top(); - } else if ((currentRect.bottom() > viewGeometry.bottom())) { - Q_ASSERT(scrollOrientation() == Qt::Vertical); - newOffset += currentRect.bottom() - viewGeometry.bottom(); - } else if (currentRect.left() < viewGeometry.left()) { - if (scrollOrientation() == Qt::Horizontal) { - newOffset += currentRect.left() - viewGeometry.left(); - } - } else if ((currentRect.right() > viewGeometry.right())) { - if (scrollOrientation() == Qt::Horizontal) { - newOffset += currentRect.right() - viewGeometry.right(); - } - } - - if (newOffset != scrollOffset()) { - emit scrollTo(newOffset); - } - } } void KItemListView::slotSelectionChanged(const QSet& current, const QSet& previous) @@ -979,7 +1076,7 @@ void KItemListView::slotAnimationFinished(QGraphicsWidget* widget, void KItemListView::slotLayoutTimerFinished() { m_layouter->setSize(geometry().size()); - doLayout(Animation, 0, 0); + doLayout(Animation); } void KItemListView::slotRubberBandPosChanged() @@ -1034,7 +1131,7 @@ void KItemListView::slotVisibleRoleWidthChanged(const QByteArray& role, widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes); } - updateLayout(); + doLayout(Animation); } } @@ -1088,7 +1185,9 @@ void KItemListView::triggerAutoScrolling() // the autoscrolling may not get skipped anymore until a new rubberband is created m_skipAutoScrollForRubberBand = false; - setScrollOffset(scrollOffset() + m_autoScrollIncrement); + const qreal maxVisibleOffset = qMax(qreal(0), maximumScrollOffset() - visibleSize); + const qreal newScrollOffset = qMin(scrollOffset() + m_autoScrollIncrement, maxVisibleOffset); + setScrollOffset(newScrollOffset); // Trigger the autoscroll timer which will periodically call // triggerAutoScrolling() @@ -1136,10 +1235,14 @@ void KItemListView::setModel(KItemModelBase* model) this, SLOT(slotItemsMoved(KItemRange,QList))); disconnect(m_model, SIGNAL(groupedSortingChanged(bool)), this, SLOT(slotGroupedSortingChanged(bool))); + disconnect(m_model, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)), + this, SLOT(slotSortOrderChanged(Qt::SortOrder,Qt::SortOrder))); + disconnect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)), + this, SLOT(slotSortRoleChanged(QByteArray,QByteArray))); } m_model = model; - m_layouter->setModel(model); + m_layouter->setModel(model); m_grouped = model->groupedSorting(); if (m_model) { @@ -1153,6 +1256,10 @@ void KItemListView::setModel(KItemModelBase* model) this, SLOT(slotItemsMoved(KItemRange,QList))); connect(m_model, SIGNAL(groupedSortingChanged(bool)), this, SLOT(slotGroupedSortingChanged(bool))); + connect(m_model, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)), + this, SLOT(slotSortOrderChanged(Qt::SortOrder,Qt::SortOrder))); + connect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)), + this, SLOT(slotSortRoleChanged(QByteArray,QByteArray))); } onModelChanged(model, previous); @@ -1163,25 +1270,17 @@ KItemListRubberBand* KItemListView::rubberBand() const return m_rubberBand; } -void KItemListView::updateLayout() -{ - doLayout(Animation, 0, 0); - update(); -} - void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount) { if (m_layoutTimer->isActive()) { - kDebug() << "Stopping layout timer, synchronous layout requested"; m_layoutTimer->stop(); } - if (m_model->count() < 0 || m_activeTransactions > 0) { + if (!m_model || m_model->count() < 0 || m_activeTransactions > 0) { return; } - const int firstVisibleIndex = m_layouter->firstVisibleIndex(); - const int lastVisibleIndex = m_layouter->lastVisibleIndex(); + int firstVisibleIndex = m_layouter->firstVisibleIndex(); if (firstVisibleIndex < 0) { emitOffsetChanges(); return; @@ -1194,29 +1293,12 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha const qreal maxOffsetToShowFullRange = maximumScrollOffset() - visibleOffsetRange; if (scrollOffset() > maxOffsetToShowFullRange) { m_layouter->setScrollOffset(qMax(qreal(0), maxOffsetToShowFullRange)); + firstVisibleIndex = m_layouter->firstVisibleIndex(); } - // Determine all items that are completely invisible and might be - // reused for items that just got (at least partly) visible. - // Items that do e.g. an animated moving of their position are not - // marked as invisible: This assures that a scrolling inside the view - // can be done without breaking an animation. - QList reusableItems; - QHashIterator it(m_visibleItems); - while (it.hasNext()) { - it.next(); - KItemListWidget* widget = it.value(); - const int index = widget->index(); - const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex); - if (invisible && !m_animation->isStarted(widget)) { - widget->setVisible(false); - reusableItems.append(index); + const int lastVisibleIndex = m_layouter->lastVisibleIndex(); - if (m_grouped) { - recycleGroupHeaderForWidget(widget); - } - } - } + QList reusableItems = recycleInvisibleItems(firstVisibleIndex, lastVisibleIndex); // Assure that for each visible item a KItemListWidget is available. KItemListWidget // instances from invisible items are reused. If no reusable items are @@ -1248,7 +1330,8 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha if (animate && changedCount < 0) { // Items have been deleted, move the created item to the - // imaginary old position. + // imaginary old position. They will get animated to the new position + // later. const QRectF itemRect = m_layouter->itemRect(i - changedCount); if (itemRect.isEmpty()) { const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical) @@ -1266,11 +1349,9 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha if (animate) { const bool itemsRemoved = (changedCount < 0); const bool itemsInserted = (changedCount > 0); - if (itemsRemoved && (i >= changedIndex + changedCount + 1)) { // The item is located after the removed items. Animate the moving of the position. - m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos); - applyNewPos = false; + applyNewPos = !moveWidget(widget, newPos); } else if (itemsInserted && i >= changedIndex) { // The item is located after the first inserted item if (i <= changedIndex + changedCount - 1) { @@ -1284,13 +1365,11 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha // The item was already there before, so animate the moving of the position. // No moving animation is done if the item is animated by a create animation: This // prevents a "move animation mess" when inserting several ranges in parallel. - m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos); - applyNewPos = false; + applyNewPos = !moveWidget(widget, newPos); } } else if (!itemsRemoved && !itemsInserted && !wasHidden) { // The size of the view might have been changed. Animate the moving of the position. - m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos); - applyNewPos = false; + applyNewPos = !moveWidget(widget, newPos); } } @@ -1302,7 +1381,21 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha widget->setVisible(true); if (widget->size() != itemBounds.size()) { - m_animation->start(widget, KItemListViewAnimation::ResizeAnimation, itemBounds.size()); + // Resize the widget for the item to the changed size. + if (animate) { + // If a dynamic item size is used then no animation is done in the direction + // of the dynamic size. + if (m_itemSize.width() <= 0) { + // The width is dynamic, apply the new width without animation. + widget->resize(itemBounds.width(), widget->size().height()); + } else if (m_itemSize.height() <= 0) { + // The height is dynamic, apply the new height without animation. + widget->resize(widget->size().width(), itemBounds.height()); + } + m_animation->start(widget, KItemListViewAnimation::ResizeAnimation, itemBounds.size()); + } else { + widget->resize(itemBounds.size()); + } } } @@ -1323,6 +1416,60 @@ void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int cha emitOffsetChanges(); } +QList KItemListView::recycleInvisibleItems(int firstVisibleIndex, int lastVisibleIndex) +{ + // Determine all items that are completely invisible and might be + // reused for items that just got (at least partly) visible. + // Items that do e.g. an animated moving of their position are not + // marked as invisible: This assures that a scrolling inside the view + // can be done without breaking an animation. + + QList items; + + QHashIterator it(m_visibleItems); + while (it.hasNext()) { + it.next(); + KItemListWidget* widget = it.value(); + const int index = widget->index(); + const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex); + if (invisible && !m_animation->isStarted(widget)) { + widget->setVisible(false); + items.append(index); + + if (m_grouped) { + recycleGroupHeaderForWidget(widget); + } + } + } + + return items; +} + +bool KItemListView::moveWidget(KItemListWidget* widget, const QPointF& newPos) +{ + // The moving-animation should only be started, if it is done within one + // row or one column. Otherwise instead of a moving-animation a + // create-animation on the new position will be used instead. This is done + // to prevent "irritating" moving-animations. + const QPointF oldPos = widget->pos(); + const qreal xMax = m_itemSize.width(); + const qreal yMax = m_itemSize.height(); + + const bool startMovingAnim = xMax <= 0 + || yMax <= 0 + || qAbs(oldPos.x() - newPos.x()) < xMax + || qAbs(oldPos.y() - newPos.y()) < yMax; + if (startMovingAnim) { + // The moving animation is done inside a column or a row. + m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos); + return true; + } + + m_animation->stop(widget); + m_animation->start(widget, KItemListViewAnimation::CreateAnimation); + return false; +} + void KItemListView::emitOffsetChanges() { const qreal newScrollOffset = m_layouter->scrollOffset(); @@ -1386,52 +1533,6 @@ void KItemListView::setWidgetIndex(KItemListWidget* widget, int index) initializeItemListWidget(widget); } -void KItemListView::prepareLayoutForIncreasedItemCount(const QSizeF& size, SizeType sizeType) -{ - // Calculate the first visible index and last visible index for the current size - const int currentFirst = m_layouter->firstVisibleIndex(); - const int currentLast = m_layouter->lastVisibleIndex(); - - const QSizeF currentSize = (sizeType == LayouterSize) ? m_layouter->size() : m_layouter->itemSize(); - - // Calculate the first visible index and last visible index for the new size - setLayouterSize(size, sizeType); - const int newFirst = m_layouter->firstVisibleIndex(); - const int newLast = m_layouter->lastVisibleIndex(); - - if ((currentFirst != newFirst) || (currentLast != newLast)) { - // At least one index has been changed. Assure that widgets for all possible - // visible items get created so that a move-animation can be started later. - const int maxVisibleItems = m_layouter->maximumVisibleItems(); - int minFirst = qMin(newFirst, currentFirst); - const int maxLast = qMax(newLast, currentLast); - - if (maxLast - minFirst + 1 < maxVisibleItems) { - // Increasing the size might result in a smaller KItemListView::offset(). - // Decrease the first visible index in a way that at least the maximum - // visible items are shown. - minFirst = qMax(0, maxLast - maxVisibleItems + 1); - } - - if (maxLast - minFirst > maxVisibleItems + maxVisibleItems / 2) { - // The creating of widgets is quite expensive. Assure that never more - // than 50 % of the maximum visible items get created for the animations. - return; - } - - setLayouterSize(currentSize, sizeType); - for (int i = minFirst; i <= maxLast; ++i) { - if (!m_visibleItems.contains(i)) { - KItemListWidget* widget = createWidget(i); - const QRectF itemRect = m_layouter->itemRect(i); - widget->setPos(itemRect.topLeft()); - widget->resize(itemRect.size()); - } - } - setLayouterSize(size, sizeType); - } -} - void KItemListView::setLayouterSize(const QSizeF& size, SizeType sizeType) { switch (sizeType) { @@ -1452,12 +1553,15 @@ void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index) widget->setSelected(selectionManager->isSelected(index)); widget->setHovered(false); widget->setAlternatingBackgroundColors(false); + widget->setEnabledSelectionToggle(enabledSelectionToggles()); widget->setIndex(index); widget->setData(m_model->data(index)); } void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget) { + Q_ASSERT(m_grouped); + const int index = widget->index(); if (!m_layouter->isFirstGroupItem(index)) { // The widget does not represent the first item of a group @@ -1466,6 +1570,11 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget) return; } + const QList > groups = model()->groups(); + if (groups.isEmpty()) { + return; + } + KItemListGroupHeader* header = m_visibleGroups.value(widget); if (!header) { header = m_groupHeaderCreator->create(this); @@ -1476,7 +1585,6 @@ void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget) // Determine the shown data for the header by doing a binary // search in the groups-list - const QList > groups = model()->groups(); int min = 0; int max = groups.count() - 1; int mid = 0; @@ -1524,6 +1632,18 @@ void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget) } } +void KItemListView::updateVisibleGroupHeaders() +{ + Q_ASSERT(m_grouped); + m_layouter->markAsDirty(); + + QHashIterator it(m_visibleItems); + while (it.hasNext()) { + it.next(); + updateGroupHeaderForWidget(it.value()); + } +} + QHash KItemListView::headerRolesWidths() const { QHash rolesWidths; @@ -1597,6 +1717,10 @@ void KItemListView::updateVisibleRolesSizes(const KItemRangeList& itemRanges) void KItemListView::updateVisibleRolesSizes() { + if (!m_model) { + return; + } + const int itemCount = m_model->count(); if (itemCount > 0) { updateVisibleRolesSizes(KItemRangeList() << KItemRange(0, itemCount)); @@ -1605,7 +1729,7 @@ void KItemListView::updateVisibleRolesSizes() void KItemListView::updateStretchedVisibleRolesSizes() { - if (!m_itemSize.isEmpty() || m_useHeaderWidths) { + if (!m_itemSize.isEmpty() || m_useHeaderWidths || m_visibleRoles.isEmpty()) { return; } @@ -1614,7 +1738,7 @@ void KItemListView::updateStretchedVisibleRolesSizes() // size does not use the available view-size it the size of the // first role will get stretched. m_stretchedVisibleRolesSizes = m_visibleRolesSizes; - const QByteArray role = visibleRoles().first(); + const QByteArray role = m_visibleRoles.first(); QSizeF firstRoleSize = m_stretchedVisibleRolesSizes.value(role); QSizeF dynamicItemSize = m_itemSize;