}
}
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
onScrollOrientationChanged(orientation, previousOrientation);
emit scrollOrientationChanged(orientation, previousOrientation);
}
m_sizeHintResolver->clearCache();
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
onItemSizeChanged(itemSize, previousSize);
}
m_layouter->setScrollOffset(offset);
m_animation->setScrollOffset(offset);
- if (!m_layoutTimer->isActive()) {
- doLayout(NoAnimation, 0, 0);
- }
+
+ // 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);
}
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);
- }
+
+ // 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
}
updateVisibleRolesSizes();
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
onVisibleRolesChanged(roles, previousRoles);
}
}
m_sizeHintResolver->clearCache();
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
onStyleOptionChanged(option, previousOption);
}
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());
- }
+ // 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);
+ } else {
+ m_layouter->setSize(newSize);
+ }
- if (!m_layoutTimer->isActive()) {
- m_layoutTimer->start();
+ 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
bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
{
+ if (!m_enabledSelectionToggles) {
+ return false;
+ }
+
const KItemListWidget* widget = m_visibleItems.value(index);
if (widget) {
const QRectF selectionToggleRect = widget->selectionToggleRect();
return QHash<QByteArray, QSizeF>();
}
+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 (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::beginTransaction()
if (m_activeTransactions == 0) {
onTransactionEnd();
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
}
}
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) {
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);
}
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) {
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);
+ m_activeTransactions = activeTransactions;
}
}
}
}
- doLayout(NoAnimation, 0, 0);
+ doLayout(NoAnimation);
}
void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
// The sort-role has been changed which might result
// in modified group headers
updateVisibleGroupHeaders();
- doLayout(NoAnimation, 0, 0);
+ doLayout(NoAnimation);
}
}
}
Q_ASSERT(m_visibleGroups.isEmpty());
}
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
}
void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
Q_UNUSED(previous);
if (m_grouped) {
updateVisibleGroupHeaders();
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
}
}
Q_UNUSED(previous);
if (m_grouped) {
updateVisibleGroupHeaders();
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
}
}
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<int>& current, const QSet<int>& previous)
void KItemListView::slotLayoutTimerFinished()
{
m_layouter->setSize(geometry().size());
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
}
void KItemListView::slotRubberBandPosChanged()
widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
}
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
}
}
// 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()
}
m_model = model;
- m_layouter->setModel(model);
+ m_layouter->setModel(model);
m_grouped = model->groupedSorting();
if (m_model) {
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;
}
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)
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);
widget->setVisible(true);
if (widget->size() != 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());
void KItemListView::updateVisibleRolesSizes()
{
+ if (!m_model) {
+ return;
+ }
+
const int itemCount = m_model->count();
if (itemCount > 0) {
updateVisibleRolesSizes(KItemRangeList() << KItemRange(0, itemCount));
void KItemListView::updateStretchedVisibleRolesSizes()
{
- if (!m_itemSize.isEmpty() || m_useHeaderWidths) {
+ if (!m_itemSize.isEmpty() || m_useHeaderWidths || m_visibleRoles.isEmpty()) {
return;
}
// 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;
projects / dolphin.git / blobdiff