#include "kitemlistview.h"
#include "kitemlistcontroller.h"
-#include "kitemlistgroupheader.h"
#include "kitemlistheader_p.h"
#include "kitemlistrubberband_p.h"
#include "kitemlistselectionmanager.h"
KItemListView::KItemListView(QGraphicsWidget* parent) :
QGraphicsWidget(parent),
+ m_enabledSelectionToggles(false),
m_grouped(false),
m_activeTransactions(0),
+ m_endTransactionAnimationHint(Animation),
m_itemSize(),
m_controller(0),
m_model(0),
m_layouter->setScrollOrientation(orientation);
m_animation->setScrollOrientation(orientation);
m_sizeHintResolver->clearCache();
- updateLayout();
+
+ if (m_grouped) {
+ QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+ while (it.hasNext()) {
+ it.next();
+ it.value()->setScrollOrientation(orientation);
+ }
+ updateGroupHeaderHeight();
+
+ }
+
+ 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);
}
- setHeaderShown(emptySize);
m_sizeHintResolver->clearCache();
- updateLayout();
+ doLayout(animate ? Animation : NoAnimation);
onItemSizeChanged(itemSize, previousSize);
}
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);
}
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
}
updateVisibleRolesSizes();
- updateLayout();
+ 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) {
return m_autoScrollTimer != 0;
}
+void KItemListView::setEnabledSelectionToggles(bool enabled)
+{
+ if (m_enabledSelectionToggles != enabled) {
+ m_enabledSelectionToggles = enabled;
+
+ QHashIterator<int, KItemListWidget*> 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;
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();
- updateLayout();
+ m_sizeHintResolver->clearCache();
+ doLayout(animate ? Animation : NoAnimation);
+
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());
- }
-
- if (!m_layoutTimer->isActive()) {
- m_layoutTimer->start();
+ 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_layoutTimer->stop();
+ doLayout(NoAnimation);
+ }
}
-
- // 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
{
- 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;
}
return QHash<QByteArray, QSizeF>();
}
-QRectF KItemListView::itemBoundingRect(int index) const
+bool KItemListView::supportsItemExpanding() const
{
- return m_layouter->itemBoundingRect(index);
+ return false;
+}
+
+QRectF KItemListView::itemRect(int index) const
+{
+ return m_layouter->itemRect(index);
+}
+
+QRectF KItemListView::itemContextRect(int index) const
+{
+ QRectF contextRect;
+
+ const KItemListWidget* widget = m_visibleItems.value(index);
+ if (widget) {
+ contextRect = widget->iconRect() | widget->textRect();
+ contextRect.translate(itemRect(index).topLeft());
+ }
+
+ return contextRect;
}
-int KItemListView::itemsPerOffset() const
+void KItemListView::scrollToItem(int index)
{
- return m_layouter->itemsPerOffset();
+ 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()
if (m_activeTransactions == 0) {
onTransactionEnd();
- updateLayout();
+ doLayout(m_endTransactionAnimationHint);
+ m_endTransactionAnimationHint = Animation;
}
}
return m_activeTransactions > 0;
}
+void KItemListView::setHeaderShown(bool show)
+{
+
+ if (show && !m_header) {
+ m_header = new KItemListHeader(this);
+ m_header->setPos(0, 0);
+ m_header->setModel(m_model);
+ m_header->setVisibleRoles(m_visibleRoles);
+ m_header->setVisibleRolesWidths(headerRolesWidths());
+ m_header->setZValue(1);
+
+ 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) {
+ delete m_header;
+ m_header = 0;
+ m_useHeaderWidths = false;
+ m_layouter->setHeaderHeight(0);
+ }
+}
+
+bool KItemListView::isHeaderShown() const
+{
+ return m_header != 0;
+}
+
QPixmap KItemListView::createDragPixmap(const QSet<int>& indexes) const
{
Q_UNUSED(indexes);
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) {
- doLayout(Animation, index, count);
- update();
+ 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
m_layouter->markAsDirty();
if (!hasMultipleRanges) {
- doLayout(Animation, index, -count);
- update();
+ // 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(animateChangedItemCount(count) ? Animation : NoAnimation, index, -count);
+ m_activeTransactions = activeTransactions;
}
}
void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>& 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);
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,
if (updateSizeHints) {
m_sizeHintResolver->itemsChanged(index, count, roles);
m_layouter->markAsDirty();
+
if (!m_layoutTimer->isActive()) {
m_layoutTimer->start();
}
}
}
+ 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) {
+ updateGroupHeaderHeight();
+ } else {
+ // Clear all visible headers
+ QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+ while (it.hasNext()) {
+ it.next();
+ recycleGroupHeaderForWidget(it.key());
+ }
+ Q_ASSERT(m_visibleGroups.isEmpty());
+ }
+
+ doLayout(NoAnimation);
+}
+
+void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
+{
+ Q_UNUSED(current);
+ Q_UNUSED(previous);
+ if (m_grouped) {
+ updateVisibleGroupHeaders();
+ doLayout(NoAnimation);
+ }
+}
+
+void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
+{
+ Q_UNUSED(current);
+ Q_UNUSED(previous);
+ if (m_grouped) {
+ updateVisibleGroupHeaders();
+ doLayout(NoAnimation);
}
}
Q_ASSERT(!currentWidget->isCurrent());
currentWidget->setCurrent(true);
}
-
- const QRectF viewGeometry = geometry();
- const QRectF currentBoundingRect = itemBoundingRect(current);
-
- if (!viewGeometry.contains(currentBoundingRect)) {
- // Make sure that the new current item is fully visible in the view.
- qreal newOffset = scrollOffset();
- if (currentBoundingRect.top() < viewGeometry.top()) {
- Q_ASSERT(scrollOrientation() == Qt::Vertical);
- newOffset += currentBoundingRect.top() - viewGeometry.top();
- } else if ((currentBoundingRect.bottom() > viewGeometry.bottom())) {
- Q_ASSERT(scrollOrientation() == Qt::Vertical);
- newOffset += currentBoundingRect.bottom() - viewGeometry.bottom();
- } else if (currentBoundingRect.left() < viewGeometry.left()) {
- if (scrollOrientation() == Qt::Horizontal) {
- newOffset += currentBoundingRect.left() - viewGeometry.left();
- }
- } else if ((currentBoundingRect.right() > viewGeometry.right())) {
- if (scrollOrientation() == Qt::Horizontal) {
- newOffset += currentBoundingRect.right() - viewGeometry.right();
- }
- }
-
- if (newOffset != scrollOffset()) {
- emit scrollTo(newOffset);
- }
- }
}
void KItemListView::slotSelectionChanged(const QSet<int>& current, const QSet<int>& previous)
// All KItemListWidgets that are animated by the DeleteAnimation are not maintained
// by m_visibleWidgets and must be deleted manually after the animation has
// been finished.
- KItemListGroupHeader* header = m_visibleGroups.value(itemListWidget);
- if (header) {
- m_groupHeaderCreator->recycle(header);
- m_visibleGroups.remove(itemListWidget);
- }
+ recycleGroupHeaderForWidget(itemListWidget);
m_widgetCreator->recycle(itemListWidget);
break;
}
void KItemListView::slotLayoutTimerFinished()
{
m_layouter->setSize(geometry().size());
- doLayout(Animation, 0, 0);
+ doLayout(Animation);
}
void KItemListView::slotRubberBandPosChanged()
widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
}
- updateLayout();
+ doLayout(NoAnimation);
}
}
// 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()
this, SLOT(slotItemsRemoved(KItemRangeList)));
disconnect(m_model, SIGNAL(itemsMoved(KItemRange,QList<int>)),
this, SLOT(slotItemsMoved(KItemRange,QList<int>)));
+ 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_grouped = !model->groupRole().isEmpty();
+ m_layouter->setModel(model);
+ m_grouped = model->groupedSorting();
if (m_model) {
connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
this, SLOT(slotItemsRemoved(KItemRangeList)));
connect(m_model, SIGNAL(itemsMoved(KItemRange,QList<int>)),
this, SLOT(slotItemsMoved(KItemRange,QList<int>)));
+ 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);
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_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;
}
- //markVisibleRolesSizesAsDirty();
+ if (!m_model || m_model->count() < 0) {
+ return;
+ }
- const int firstVisibleIndex = m_layouter->firstVisibleIndex();
- const int lastVisibleIndex = m_layouter->lastVisibleIndex();
+ 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();
+
+ 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
bool applyNewPos = true;
bool wasHidden = false;
- const QRectF itemBounds = m_layouter->itemBoundingRect(i);
+ const QRectF itemBounds = m_layouter->itemRect(i);
const QPointF newPos = itemBounds.topLeft();
KItemListWidget* widget = m_visibleItems.value(i);
if (!widget) {
const int oldIndex = reusableItems.takeLast();
widget = m_visibleItems.value(oldIndex);
setWidgetIndex(widget, i);
+
+ if (m_grouped) {
+ updateGroupHeaderForWidget(widget);
+ }
} else {
// No reusable KItemListWidget instance is available, create a new one
widget = createWidget(i);
if (animate && changedCount < 0) {
// Items have been deleted, move the created item to the
- // imaginary old position.
- const QRectF itemBoundingRect = m_layouter->itemBoundingRect(i - changedCount);
- if (itemBoundingRect.isEmpty()) {
+ // 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)
? QPointF(0, size().height()) : QPointF(size().width(), 0);
widget->setPos(invisibleOldPos);
} else {
- widget->setPos(itemBoundingRect.topLeft());
+ widget->setPos(itemRect.topLeft());
}
applyNewPos = false;
}
- } else if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
- applyNewPos = false;
}
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, 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) {
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());
+ }
}
}
recycleWidget(m_visibleItems.value(index));
}
+ if (m_grouped) {
+ // Update the layout of all visible group headers
+ QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
+ while (it.hasNext()) {
+ it.next();
+ updateGroupHeaderLayout(it.key());
+ }
+ }
+
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();
KItemListWidget* KItemListView::createWidget(int index)
{
KItemListWidget* widget = m_widgetCreator->create(this);
+ widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
+
updateWidgetProperties(widget, index);
m_visibleItems.insert(index, widget);
if (m_grouped) {
- if (m_layouter->isFirstGroupItem(index)) {
- KItemListGroupHeader* header = m_groupHeaderCreator->create(widget);
- header->setPos(0, -50);
- header->resize(50, 50);
- m_visibleGroups.insert(widget, header);
- }
+ updateGroupHeaderForWidget(widget);
}
initializeItemListWidget(widget);
void KItemListView::recycleWidget(KItemListWidget* widget)
{
if (m_grouped) {
- KItemListGroupHeader* header = m_visibleGroups.value(widget);
- if (header) {
- m_groupHeaderCreator->recycle(header);
- m_visibleGroups.remove(widget);
- }
+ recycleGroupHeaderForWidget(widget);
}
m_visibleItems.remove(widget->index());
void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
{
- if (m_grouped) {
- bool createHeader = m_layouter->isFirstGroupItem(index);
- KItemListGroupHeader* header = m_visibleGroups.value(widget);
- if (header) {
- if (createHeader) {
- createHeader = false;
- } else {
- m_groupHeaderCreator->recycle(header);
- m_visibleGroups.remove(widget);
- }
- }
-
- if (createHeader) {
- KItemListGroupHeader* header = m_groupHeaderCreator->create(widget);
- header->setPos(0, -50);
- header->resize(50, 50);
- m_visibleGroups.insert(widget, header);
- }
- }
-
const int oldIndex = widget->index();
m_visibleItems.remove(oldIndex);
updateWidgetProperties(widget, 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 QPointF pos = m_layouter->itemBoundingRect(i).topLeft();
- widget->setPos(pos);
- }
- }
- setLayouterSize(size, sizeType);
- }
-}
-
void KItemListView::setLayouterSize(const QSizeF& size, SizeType sizeType)
{
switch (sizeType) {
const KItemListSelectionManager* selectionManager = m_controller->selectionManager();
widget->setCurrent(index == selectionManager->currentItem());
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
+ // and hence requires no header
+ recycleGroupHeaderForWidget(widget);
+ return;
+ }
+
+ const QList<QPair<int, QVariant> > groups = model()->groups();
+ if (groups.isEmpty()) {
+ return;
+ }
+
+ KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+ if (!groupHeader) {
+ groupHeader = m_groupHeaderCreator->create(this);
+ groupHeader->setParentItem(widget);
+ m_visibleGroups.insert(widget, groupHeader);
+ }
+ Q_ASSERT(groupHeader->parentItem() == widget);
+
+ // Determine the shown data for the header by doing a binary
+ // search in the groups-list
+ int min = 0;
+ int max = groups.count() - 1;
+ int mid = 0;
+ do {
+ mid = (min + max) / 2;
+ if (index > groups.at(mid).first) {
+ min = mid + 1;
+ } else {
+ max = mid - 1;
+ }
+ } while (groups.at(mid).first != index && min <= max);
+
+ groupHeader->setData(groups.at(mid).second);
+ groupHeader->setRole(model()->sortRole());
+ groupHeader->setStyleOption(m_styleOption);
+ groupHeader->setScrollOrientation(scrollOrientation());
+
+ groupHeader->show();
+}
+
+void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
+{
+ KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+ Q_ASSERT(groupHeader);
+
+ const int index = widget->index();
+ const QRectF groupHeaderRect = m_layouter->groupHeaderRect(index);
+ const QRectF itemRect = m_layouter->itemRect(index);
+
+ // The group-header is a child of the itemlist widget. Translate the
+ // group header position to the relative position.
+ const QPointF groupHeaderPos(groupHeaderRect.x() - itemRect.x(),
+ - groupHeaderRect.height());
+ groupHeader->setPos(groupHeaderPos);
+ groupHeader->resize(groupHeaderRect.size());
+}
+
+void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
+{
+ KItemListGroupHeader* header = m_visibleGroups.value(widget);
+ if (header) {
+ header->setParentItem(0);
+ m_groupHeaderCreator->recycle(header);
+ m_visibleGroups.remove(widget);
+ }
+}
+
+void KItemListView::updateVisibleGroupHeaders()
+{
+ Q_ASSERT(m_grouped);
+ m_layouter->markAsDirty();
+
+ QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+ while (it.hasNext()) {
+ it.next();
+ updateGroupHeaderForWidget(it.value());
+ }
+}
+
QHash<QByteArray, qreal> KItemListView::headerRolesWidths() const
{
QHash<QByteArray, qreal> rolesWidths;
}
if (itemCount == rangesItemCount) {
- // The sizes of all roles need to be determined
m_visibleRolesSizes = visibleRolesSizes(itemRanges);
+ if (m_header) {
+ // Assure the the sizes are not smaller than the minimum defined by the header
+ // TODO: Currently only implemented for a top-aligned header
+ const qreal minHeaderRoleWidth = m_header->minimumRoleWidth();
+ QMutableHashIterator<QByteArray, QSizeF> it (m_visibleRolesSizes);
+ while (it.hasNext()) {
+ it.next();
+ const QSizeF& size = it.value();
+ if (size.width() < minHeaderRoleWidth) {
+ const QSizeF newSize(minHeaderRoleWidth, size.height());
+ m_visibleRolesSizes.insert(it.key(), newSize);
+ }
+ }
+ }
} else {
// Only a sub range of the roles need to be determined.
// The chances are good that the sizes of the sub ranges
if (!updateRequired) {
// All the updated sizes are smaller than the current sizes and no change
- // of the roles-widths is required
+ // of the stretched roles-widths is required
return;
}
}
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;
}
}
-void KItemListView::setHeaderShown(bool show)
-{
- if (show && !m_header) {
- m_header = new KItemListHeader(this);
- m_header->setPos(0, 0);
- m_header->setModel(m_model);
- m_header->setVisibleRoles(m_visibleRoles);
- 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)));
-
- m_layouter->setHeaderHeight(m_header->size().height());
- } else if (!show && m_header) {
- delete m_header;
- m_header = 0;
- m_useHeaderWidths = false;
- m_layouter->setHeaderHeight(0);
- }
-}
-
qreal KItemListView::visibleRolesSizesWidthSum() const
{
qreal widthSum = 0;
return heightSum;
}
+QRectF KItemListView::headerBoundaries() const
+{
+ 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()
void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
{
+ widget->setParentItem(0);
widget->setOpacity(1.0);
pushRecycleableWidget(widget);
}
projects / dolphin.git / blobdiff