m_enabledSelectionToggles(false),
m_grouped(false),
m_activeTransactions(0),
+ m_endTransactionAnimationHint(Animation),
m_itemSize(),
m_controller(0),
m_model(0),
it.next();
it.value()->setScrollOrientation(orientation);
}
+ updateGroupHeaderHeight();
+
}
- doLayout(Animation);
+ doLayout(NoAnimation);
onScrollOrientationChanged(orientation, previousOrientation);
emit scrollOrientationChanged(orientation, previousOrientation);
return;
}
+ // Skip animations when the number of rows or columns
+ // are changed in the grid layout. Although the animation
+ // engine can handle this usecase, it looks obtrusive.
+ const bool animate = !changesItemGridLayout(m_layouter->size(),
+ itemSize,
+ m_layouter->itemMargin());
+
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();
- doLayout(Animation);
+ doLayout(animate ? Animation : NoAnimation);
onItemSizeChanged(itemSize, previousSize);
}
}
updateVisibleRolesSizes();
- doLayout(Animation);
+ doLayout(NoAnimation);
onVisibleRolesChanged(roles, previousRoles);
}
{
if (enabled && !m_autoScrollTimer) {
m_autoScrollTimer = new QTimer(this);
- m_autoScrollTimer->setSingleShot(false);
+ m_autoScrollTimer->setSingleShot(true);
connect(m_autoScrollTimer, SIGNAL(timeout()), this, SLOT(triggerAutoScrolling()));
m_autoScrollTimer->start(InitialAutoScrollDelay);
} else if (!enabled && m_autoScrollTimer) {
const KItemListStyleOption previousOption = m_styleOption;
m_styleOption = option;
+ bool animate = true;
+ const QSizeF margin(option.horizontalMargin, option.verticalMargin);
+ if (margin != m_layouter->itemMargin()) {
+ // Skip animations when the number of rows or columns
+ // are changed in the grid layout. Although the animation
+ // engine can handle this usecase, it looks obtrusive.
+ animate = !changesItemGridLayout(m_layouter->size(),
+ m_layouter->itemSize(),
+ margin);
+ m_layouter->setItemMargin(margin);
+ }
+
+ if (m_grouped) {
+ updateGroupHeaderHeight();
+ }
+
QHashIterator<int, KItemListWidget*> it(m_visibleItems);
while (it.hasNext()) {
it.next();
it.value()->setStyleOption(option);
}
- m_sizeHintResolver->clearCache();
- doLayout(Animation);
+ m_sizeHintResolver->clearCache();
+ doLayout(animate ? Animation : NoAnimation);
+
onStyleOptionChanged(option, previousOption);
}
m_layouter->setSize(newSize);
doLayout(Animation);
} else {
- // 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.
- if (m_model->count() > 0) {
- prepareLayoutForIncreasedItemCount(newSize, LayouterSize);
+ const bool animate = !changesItemGridLayout(newSize,
+ m_layouter->itemSize(),
+ m_layouter->itemMargin());
+ m_layouter->setSize(newSize);
+
+ if (animate) {
+ // Trigger an asynchronous relayout with m_layoutTimer to prevent
+ // performance bottlenecks. If the timer is exceeded, an animated layout
+ // will be triggered.
+ if (!m_layoutTimer->isActive()) {
+ m_layoutTimer->start();
+ }
} else {
- m_layouter->setSize(newSize);
- }
-
- if (!m_layoutTimer->isActive()) {
- m_layoutTimer->start();
+ m_layoutTimer->stop();
+ doLayout(NoAnimation);
}
}
}
if (!viewGeometry.contains(currentRect)) {
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();
+ 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.right() > viewGeometry.right())) {
- if (scrollOrientation() == Qt::Horizontal) {
+ } else {
+ if (currentRect.left() < viewGeometry.left()) {
+ newOffset += currentRect.left() - viewGeometry.left();
+ } else if (currentRect.right() > viewGeometry.right()) {
newOffset += currentRect.right() - viewGeometry.right();
}
}
if (m_activeTransactions == 0) {
onTransactionEnd();
- doLayout(Animation);
+ doLayout(m_endTransactionAnimationHint);
+ m_endTransactionAnimationHint = Animation;
}
}
return m_activeTransactions > 0;
}
-
void KItemListView::setHeaderShown(bool show)
{
}
if (!hasMultipleRanges) {
- doLayout(Animation, index, count);
+ doLayout(animateChangedItemCount(count) ? Animation : NoAnimation, index, count);
}
}
continue;
}
- if (m_model->count() == 0) {
- // For performance reasons no animation is done when all items have
- // been removed.
+ if (m_model->count() == 0 || hasMultipleRanges || !animateChangedItemCount(count)) {
+ // Remove the widget without animation
recycleWidget(widget);
} else {
// Animate the removing of the items. Special case: When removing an item there
// geometry update if necessary.
const int activeTransactions = m_activeTransactions;
m_activeTransactions = 0;
- doLayout(Animation, index, -count);
+ doLayout(animateChangedItemCount(count) ? Animation : NoAnimation, index, -count);
m_activeTransactions = activeTransactions;
}
}
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);
-
- updateVisibleGroupHeaders();
+ updateGroupHeaderHeight();
} else {
// Clear all visible headers
QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
Q_ASSERT(m_visibleGroups.isEmpty());
}
- doLayout(Animation);
+ doLayout(NoAnimation);
}
void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
Q_UNUSED(previous);
if (m_grouped) {
updateVisibleGroupHeaders();
- doLayout(Animation);
+ doLayout(NoAnimation);
}
}
Q_UNUSED(previous);
if (m_grouped) {
updateVisibleGroupHeaders();
- doLayout(Animation);
+ doLayout(NoAnimation);
}
}
widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
}
- doLayout(Animation);
+ doLayout(NoAnimation);
}
}
m_layoutTimer->stop();
}
- if (!m_model || m_model->count() < 0 || m_activeTransactions > 0) {
+ if (m_activeTransactions > 0) {
+ if (hint == NoAnimation) {
+ // As soon as at least one property change should be done without animation,
+ // the whole transaction will be marked as not animated.
+ m_endTransactionAnimationHint = NoAnimation;
+ }
return;
}
- const int firstVisibleIndex = m_layouter->firstVisibleIndex();
- const int lastVisibleIndex = m_layouter->lastVisibleIndex();
+ if (!m_model || m_model->count() < 0) {
+ return;
+ }
+
+ int firstVisibleIndex = m_layouter->firstVisibleIndex();
if (firstVisibleIndex < 0) {
emitOffsetChanges();
return;
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<int> reusableItems;
- QHashIterator<int, KItemListWidget*> 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<int> reusableItems = recycleInvisibleItems(firstVisibleIndex, lastVisibleIndex, hint);
// Assure that for each visible item a KItemListWidget is available. KItemListWidget
// instances from invisible items are reused. If no reusable items are
}
applyNewPos = false;
}
- } else if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
- applyNewPos = false;
}
if (animate) {
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, itemBounds);
} else if (itemsInserted && i >= changedIndex) {
// The item is located after the first inserted item
if (i <= changedIndex + changedCount - 1) {
// 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, itemBounds);
}
} 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, itemBounds);
}
+ } else {
+ m_animation->stop(widget);
}
if (applyNewPos) {
emitOffsetChanges();
}
+QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
+ int lastVisibleIndex,
+ LayoutAnimationHint hint)
+{
+ // Determine all items that are completely invisible and might be
+ // reused for items that just got (at least partly) visible. If the
+ // animation hint is set to 'Animation' 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<int> items;
+
+ QHashIterator<int, KItemListWidget*> 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) {
+ if (m_animation->isStarted(widget)) {
+ if (hint == NoAnimation) {
+ // Stopping the animation will call KItemListView::slotAnimationFinished()
+ // and the widget will be recycled if necessary there.
+ m_animation->stop(widget);
+ }
+ } else {
+ widget->setVisible(false);
+ items.append(index);
+
+ if (m_grouped) {
+ recycleGroupHeaderForWidget(widget);
+ }
+ }
+ }
+ }
+
+ return items;
+}
+
+bool KItemListView::moveWidget(KItemListWidget* widget,const QRectF& itemBounds)
+{
+ const QPointF oldPos = widget->pos();
+ const QPointF newPos = itemBounds.topLeft();
+ if (oldPos == newPos) {
+ return false;
+ }
+
+ bool startMovingAnim = m_itemSize.isEmpty() || widget->size() != itemBounds.size();
+ if (!startMovingAnim) {
+ // When having a grid the moving-animation should only be started, if it is done within
+ // one row in the vertical scroll-orientation or one column in the horizontal scroll-orientation.
+ // Otherwise instead of a moving-animation a create-animation on the new position will be used
+ // instead. This is done to prevent overlapping (and confusing) moving-animations.
+ const QSizeF itemMargin = m_layouter->itemMargin();
+ const qreal xMax = m_itemSize.width() + itemMargin.width();
+ const qreal yMax = m_itemSize.height() + itemMargin.height();
+ qreal xDiff = qAbs(oldPos.x() - newPos.x());
+ qreal yDiff = qAbs(oldPos.y() - newPos.y());
+ if (scrollOrientation() == Qt::Vertical) {
+ startMovingAnim = (xDiff > yDiff && yDiff < yMax);
+ } else {
+ startMovingAnim = (yDiff > xDiff && xDiff < xMax);
+ }
+ }
+
+ if (startMovingAnim) {
+ 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();
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) {
return;
}
- KItemListGroupHeader* header = m_visibleGroups.value(widget);
- if (!header) {
- header = m_groupHeaderCreator->create(this);
- header->setParentItem(widget);
- m_visibleGroups.insert(widget, header);
+ KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+ if (!groupHeader) {
+ groupHeader = m_groupHeaderCreator->create(this);
+ groupHeader->setParentItem(widget);
+ m_visibleGroups.insert(widget, groupHeader);
}
- Q_ASSERT(header->parentItem() == widget);
+ Q_ASSERT(groupHeader->parentItem() == widget);
// Determine the shown data for the header by doing a binary
// search in the groups-list
}
} while (groups.at(mid).first != index && min <= max);
- header->setData(groups.at(mid).second);
- header->setRole(model()->sortRole());
- header->setStyleOption(m_styleOption);
- header->setScrollOrientation(scrollOrientation());
+ groupHeader->setData(groups.at(mid).second);
+ groupHeader->setRole(model()->sortRole());
+ groupHeader->setStyleOption(m_styleOption);
+ groupHeader->setScrollOrientation(scrollOrientation());
- header->show();
+ groupHeader->show();
}
void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
{
- KItemListGroupHeader* header = m_visibleGroups.value(widget);
- Q_ASSERT(header);
+ KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+ Q_ASSERT(groupHeader);
const int index = widget->index();
const QRectF groupHeaderRect = m_layouter->groupHeaderRect(index);
// group header position to the relative position.
const QPointF groupHeaderPos(groupHeaderRect.x() - itemRect.x(),
- groupHeaderRect.height());
- header->setPos(groupHeaderPos);
- header->resize(groupHeaderRect.size());
+ groupHeader->setPos(groupHeaderPos);
+ groupHeader->resize(groupHeaderRect.size());
}
void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
return m_header ? m_header->geometry() : QRectF();
}
+bool KItemListView::changesItemGridLayout(const QSizeF& newGridSize,
+ const QSizeF& newItemSize,
+ const QSizeF& newItemMargin) const
+{
+ if (newItemSize.isEmpty() || newGridSize.isEmpty()) {
+ return false;
+ }
+
+ if (m_layouter->scrollOrientation() == Qt::Vertical) {
+ const qreal itemWidth = m_layouter->itemSize().width();
+ if (itemWidth > 0) {
+ const int newColumnCount = itemsPerSize(newGridSize.width(),
+ newItemSize.width(),
+ newItemMargin.width());
+ if (m_model->count() > newColumnCount) {
+ const int oldColumnCount = itemsPerSize(m_layouter->size().width(),
+ itemWidth,
+ m_layouter->itemMargin().width());
+ return oldColumnCount != newColumnCount;
+ }
+ }
+ } else {
+ const qreal itemHeight = m_layouter->itemSize().height();
+ if (itemHeight > 0) {
+ const int newRowCount = itemsPerSize(newGridSize.height(),
+ newItemSize.height(),
+ newItemMargin.height());
+ if (m_model->count() > newRowCount) {
+ const int oldRowCount = itemsPerSize(m_layouter->size().height(),
+ itemHeight,
+ m_layouter->itemMargin().height());
+ return oldRowCount != newRowCount;
+ }
+ }
+ }
+
+ return false;
+}
+
+bool KItemListView::animateChangedItemCount(int changedItemCount) const
+{
+ if (m_layouter->size().isEmpty() || m_layouter->itemSize().isEmpty()) {
+ return false;
+ }
+
+ const int maximum = (scrollOrientation() == Qt::Vertical)
+ ? m_layouter->size().width() / m_layouter->itemSize().width()
+ : m_layouter->size().height() / m_layouter->itemSize().height();
+ // Only animate if up to 2/3 of a row or column are inserted or removed
+ return changedItemCount <= maximum * 2 / 3;
+}
+
+
+bool KItemListView::scrollBarRequired(const QSizeF& size) const
+{
+ const QSizeF oldSize = m_layouter->size();
+
+ m_layouter->setSize(size);
+ const qreal maxOffset = m_layouter->maximumScrollOffset();
+ m_layouter->setSize(oldSize);
+
+ return m_layouter->scrollOrientation() == Qt::Vertical ? maxOffset > size.height()
+ : maxOffset > size.width();
+}
+
+void KItemListView::updateGroupHeaderHeight()
+{
+ qreal groupHeaderHeight = m_styleOption.fontMetrics.height();
+ groupHeaderHeight += (scrollOrientation() == Qt::Vertical)
+ ? m_styleOption.padding * 4 : m_styleOption.padding * 2;
+ m_layouter->setGroupHeaderHeight(groupHeaderHeight);
+
+ updateVisibleGroupHeaders();
+}
+
int KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
{
int inc = 0;
return inc;
}
+int KItemListView::itemsPerSize(qreal size, qreal itemSize, qreal itemMargin)
+{
+ const qreal availableSize = size - itemMargin;
+ const int count = availableSize / (itemSize + itemMargin);
+ return count;
+}
+
KItemListCreatorBase::~KItemListCreatorBase()
projects / dolphin.git / blobdiff