#include "kitemlistview.h"
#include "kitemlistcontroller.h"
-#include "kitemlistheader_p.h"
+#include "kitemlistheader.h"
+#include "kitemlistheaderwidget_p.h"
#include "kitemlistrubberband_p.h"
#include "kitemlistselectionmanager.h"
#include "kitemlistsizehintresolver_p.h"
QGraphicsWidget(parent),
m_enabledSelectionToggles(false),
m_grouped(false),
+ m_supportsItemExpanding(false),
m_activeTransactions(0),
+ m_endTransactionAnimationHint(Animation),
m_itemSize(),
m_controller(0),
m_model(0),
m_visibleRoles(),
- m_visibleRolesSizes(),
- m_stretchedVisibleRolesSizes(),
m_widgetCreator(0),
m_groupHeaderCreator(0),
m_styleOption(),
m_visibleItems(),
m_visibleGroups(),
+ m_columnWidthsCache(),
+ m_visibleCells(),
m_sizeHintResolver(0),
m_layouter(0),
m_animation(0),
m_autoScrollIncrement(0),
m_autoScrollTimer(0),
m_header(0),
- m_useHeaderWidths(false)
+ m_headerWidget(0)
{
setAcceptHoverEvents(true);
m_rubberBand = new KItemListRubberBand(this);
connect(m_rubberBand, SIGNAL(activationChanged(bool)), this, SLOT(slotRubberBandActivationChanged(bool)));
+
+ m_headerWidget = new KItemListHeaderWidget(this);
+ m_headerWidget->setVisible(false);
+
+ m_header = new KItemListHeader(this);
}
KItemListView::~KItemListView()
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());
+
+ const bool alternateBackgroundsChanged = (m_visibleRoles.count() > 1) &&
+ (( m_itemSize.isEmpty() && !itemSize.isEmpty()) ||
+ (!m_itemSize.isEmpty() && itemSize.isEmpty()));
+
m_itemSize = itemSize;
+ if (alternateBackgroundsChanged) {
+ // For an empty item size alternate backgrounds are drawn if more than
+ // one role is shown. Assure that the backgrounds for visible items are
+ // updated when changing the size in this context.
+ updateAlternateBackgrounds();
+ }
+
if (itemSize.isEmpty()) {
- updateVisibleRolesSizes();
+ if (m_headerWidget->automaticColumnResizing()) {
+ updateColumnWidthsCache();
+ } else {
+ // Only apply the changed height and respect the header widths
+ // set by the user
+ const qreal currentWidth = m_layouter->itemSize().width();
+ const QSizeF newSize(currentWidth, itemSize.height());
+ m_layouter->setItemSize(newSize);
+ }
} else {
m_layouter->setItemSize(itemSize);
}
m_sizeHintResolver->clearCache();
- doLayout(Animation);
+ doLayout(animate ? Animation : NoAnimation);
onItemSizeChanged(itemSize, previousSize);
}
}
m_layouter->setItemOffset(offset);
- if (m_header) {
- m_header->setPos(-offset, 0);
+ if (m_headerWidget->isVisible()) {
+ m_headerWidget->setPos(-offset, 0);
}
// Don't check whether the m_layoutTimer is active: Changing the
const QList<QByteArray> previousRoles = m_visibleRoles;
m_visibleRoles = roles;
+ const bool alternateBackgroundsChanged = m_itemSize.isEmpty() &&
+ ((roles.count() > 1 && previousRoles.count() <= 1) ||
+ (roles.count() <= 1 && previousRoles.count() > 1));
+
QHashIterator<int, KItemListWidget*> it(m_visibleItems);
while (it.hasNext()) {
it.next();
KItemListWidget* widget = it.value();
widget->setVisibleRoles(roles);
- widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
+ updateWidgetColumnWidths(widget);
+ if (alternateBackgroundsChanged) {
+ updateAlternateBackgroundForWidget(widget);
+ }
}
m_sizeHintResolver->clearCache();
m_layouter->markAsDirty();
- if (m_header) {
- m_header->setVisibleRoles(roles);
- m_header->setVisibleRolesWidths(headerRolesWidths());
- m_useHeaderWidths = false;
+ if (m_headerWidget->isVisible()) {
+ m_headerWidget->setColumns(roles);
+ m_headerWidget->setAutomaticColumnResizing(true);
}
- updateVisibleRolesSizes();
- doLayout(Animation);
+ updateColumnWidthsCache();
+ 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) {
delete m_autoScrollTimer;
m_autoScrollTimer = 0;
}
-
}
bool KItemListView::autoScroll() const
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();
}
m_sizeHintResolver->clearCache();
- doLayout(Animation);
+ doLayout(animate ? Animation : NoAnimation);
+
onStyleOptionChanged(option, previousOption);
}
// 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) {
+ updateColumnWidthsForHeader();
+
+ if (!m_headerWidget->automaticColumnResizing()) {
QSizeF dynamicItemSize = m_layouter->itemSize();
-
+
if (m_itemSize.width() < 0) {
- const qreal requiredWidth = visibleRolesSizesWidthSum();
+ const qreal requiredWidth = columnWidthsSum();
if (newSize.width() > requiredWidth) {
dynamicItemSize.setWidth(newSize.width());
}
const qreal headerWidth = qMax(newSize.width(), requiredWidth);
- m_header->resize(headerWidth, m_header->size().height());
+ m_headerWidget->resize(headerWidth, m_headerWidget->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 {
- // 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.
+ const bool animate = !changesItemGridLayout(newSize,
+ m_layouter->itemSize(),
+ m_layouter->itemMargin());
m_layouter->setSize(newSize);
- if (!m_layoutTimer->isActive()) {
- m_layoutTimer->start();
+
+ 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);
}
}
}
return itemSize();
}
-QHash<QByteArray, QSizeF> KItemListView::visibleRolesSizes(const KItemRangeList& itemRanges) const
+QHash<QByteArray, qreal> KItemListView::columnWidths(const KItemRangeList& itemRanges) const
{
Q_UNUSED(itemRanges);
- return QHash<QByteArray, QSizeF>();
+ return QHash<QByteArray, qreal>();
+}
+
+void KItemListView::setSupportsItemExpanding(bool supportsExpanding)
+{
+ if (m_supportsItemExpanding != supportsExpanding) {
+ m_supportsItemExpanding = supportsExpanding;
+ updateSiblingsInformation();
+ onSupportsItemExpandingChanged(supportsExpanding);
+ }
}
bool KItemListView::supportsItemExpanding() const
{
- return false;
+ return m_supportsItemExpanding;
}
QRectF KItemListView::itemRect(int index) const
void KItemListView::scrollToItem(int index)
{
QRectF viewGeometry = geometry();
- if (m_header) {
- const qreal headerHeight = m_header->size().height();
+ if (m_headerWidget->isVisible()) {
+ const qreal headerHeight = m_headerWidget->size().height();
viewGeometry.adjust(0, headerHeight, 0, 0);
}
const QRectF currentRect = itemRect(index);
if (m_activeTransactions == 0) {
onTransactionEnd();
- doLayout(Animation);
+ doLayout(m_endTransactionAnimationHint);
+ m_endTransactionAnimationHint = Animation;
}
}
return m_activeTransactions > 0;
}
-
-void KItemListView::setHeaderShown(bool show)
+void KItemListView::setHeaderVisible(bool visible)
{
- 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);
+ if (visible && !m_headerWidget->isVisible()) {
+ m_headerWidget->setPos(0, 0);
+ m_headerWidget->setModel(m_model);
+ m_headerWidget->setColumns(m_visibleRoles);
+ m_headerWidget->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)),
+ connect(m_headerWidget, SIGNAL(columnWidthChanged(QByteArray,qreal,qreal)),
+ this, SLOT(slotHeaderColumnWidthChanged(QByteArray,qreal,qreal)));
+ connect(m_headerWidget, SIGNAL(columnMoved(QByteArray,int,int)),
+ this, SLOT(slotHeaderColumnMoved(QByteArray,int,int)));
+ connect(m_headerWidget, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
this, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
- connect(m_header, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
+ connect(m_headerWidget, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
this, SIGNAL(sortRoleChanged(QByteArray,QByteArray)));
- m_useHeaderWidths = false;
+ m_headerWidget->setAutomaticColumnResizing(true);
+
+ m_layouter->setHeaderHeight(m_headerWidget->size().height());
+ m_headerWidget->setVisible(true);
+ } else if (!visible && m_headerWidget->isVisible()) {
+ disconnect(m_headerWidget, SIGNAL(columnWidthChanged(QByteArray,qreal,qreal)),
+ this, SLOT(slotHeaderColumnWidthChanged(QByteArray,qreal,qreal)));
+ disconnect(m_headerWidget, SIGNAL(columnMoved(QByteArray,int,int)),
+ this, SLOT(slotHeaderColumnMoved(QByteArray,int,int)));
+ disconnect(m_headerWidget, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)),
+ this, SIGNAL(sortOrderChanged(Qt::SortOrder,Qt::SortOrder)));
+ disconnect(m_headerWidget, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
+ this, SIGNAL(sortRoleChanged(QByteArray,QByteArray)));
- 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);
+ m_headerWidget->setAutomaticColumnResizing(true);
+ m_headerWidget->setVisible(false);
}
}
-bool KItemListView::isHeaderShown() const
+bool KItemListView::isHeaderVisible() const
+{
+ return m_headerWidget->isVisible();
+}
+
+KItemListHeader* KItemListView::header() const
{
- return m_header != 0;
+ return m_header;
}
QPixmap KItemListView::createDragPixmap(const QSet<int>& indexes) const
Q_UNUSED(previous);
}
+void KItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
+{
+ Q_UNUSED(supportsExpanding);
+}
+
void KItemListView::onTransactionBegin()
{
}
void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
{
- updateVisibleRolesSizes(itemRanges);
+ updateColumnWidthsCache(itemRanges);
const bool hasMultipleRanges = (itemRanges.count() > 1);
if (hasMultipleRanges) {
beginTransaction();
}
+ m_layouter->markAsDirty();
+
int previouslyInsertedCount = 0;
foreach (const KItemRange& range, itemRanges) {
// range.index is related to the model before anything has been inserted.
for (int i = itemsToMove.count() - 1; i >= 0; --i) {
KItemListWidget* widget = m_visibleItems.value(itemsToMove[i]);
Q_ASSERT(widget);
- setWidgetIndex(widget, widget->index() + count);
+ const int newIndex = widget->index() + count;
+ if (hasMultipleRanges) {
+ setWidgetIndex(widget, newIndex);
+ } else {
+ // Try to animate the moving of the item
+ moveWidgetToIndex(widget, newIndex);
+ }
}
- m_layouter->markAsDirty();
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
}
if (!hasMultipleRanges) {
- doLayout(Animation, index, count);
+ doLayout(animateChangedItemCount(count) ? Animation : NoAnimation, index, count);
+ updateSiblingsInformation();
}
}
}
if (hasMultipleRanges) {
+#ifndef QT_NO_DEBUG
+ // Important: Don't read any m_layouter-property inside the for-loop in case if
+ // multiple ranges are given! m_layouter accesses m_sizeHintResolver which is
+ // updated in each loop-cycle and has only a consistent state after the loop.
+ Q_ASSERT(m_layouter->isDirty());
+#endif
+ m_endTransactionAnimationHint = NoAnimation;
endTransaction();
+ updateSiblingsInformation();
+ }
+
+ if (useAlternateBackgrounds()) {
+ updateAlternateBackgrounds();
}
}
void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
{
- updateVisibleRolesSizes();
+ updateColumnWidthsCache();
const bool hasMultipleRanges = (itemRanges.count() > 1);
if (hasMultipleRanges) {
beginTransaction();
}
+ m_layouter->markAsDirty();
+
for (int i = itemRanges.count() - 1; i >= 0; --i) {
const KItemRange& range = itemRanges.at(i);
const int index = range.index;
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
KItemListWidget* widget = m_visibleItems.value(i);
if (widget) {
const int newIndex = i - count;
- setWidgetIndex(widget, newIndex);
+ if (hasMultipleRanges) {
+ setWidgetIndex(widget, newIndex);
+ } else {
+ // Try to animate the moving of the item
+ moveWidgetToIndex(widget, newIndex);
+ }
}
}
- 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,
// 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;
+ updateSiblingsInformation();
}
}
}
if (hasMultipleRanges) {
+#ifndef QT_NO_DEBUG
+ // Important: Don't read any m_layouter-property inside the for-loop in case if
+ // multiple ranges are given! m_layouter accesses m_sizeHintResolver which is
+ // updated in each loop-cycle and has only a consistent state after the loop.
+ Q_ASSERT(m_layouter->isDirty());
+#endif
+ m_endTransactionAnimationHint = NoAnimation;
endTransaction();
+ updateSiblingsInformation();
+ }
+
+ if (useAlternateBackgrounds()) {
+ updateAlternateBackgrounds();
}
}
KItemListWidget* widget = m_visibleItems.value(index);
if (widget) {
updateWidgetProperties(widget, index);
- if (m_grouped) {
- updateGroupHeaderForWidget(widget);
- }
initializeItemListWidget(widget);
}
}
doLayout(NoAnimation);
+ updateSiblingsInformation();
}
void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
{
const bool updateSizeHints = itemSizeHintUpdateRequired(roles);
if (updateSizeHints) {
- updateVisibleRolesSizes(itemRanges);
+ updateColumnWidthsCache(itemRanges);
}
foreach (const KItemRange& itemRange, itemRanges) {
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);
+ if (useAlternateBackgrounds()) {
+ // Changing the group mode requires to update the alternate backgrounds
+ // as with the enabled group mode the altering is done on base of the first
+ // group item.
+ updateAlternateBackgrounds();
+ }
+ updateSiblingsInformation();
+ 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);
}
}
KItemListWidget* previousWidget = m_visibleItems.value(previous, 0);
if (previousWidget) {
- Q_ASSERT(previousWidget->isCurrent());
previousWidget->setCurrent(false);
}
KItemListWidget* currentWidget = m_visibleItems.value(current, 0);
if (currentWidget) {
- Q_ASSERT(!currentWidget->isCurrent());
currentWidget->setCurrent(true);
}
}
update();
}
-void KItemListView::slotVisibleRoleWidthChanged(const QByteArray& role,
- qreal currentWidth,
- qreal previousWidth)
+void KItemListView::slotHeaderColumnWidthChanged(const QByteArray& role,
+ qreal currentWidth,
+ qreal previousWidth)
{
Q_UNUSED(previousWidth);
- m_useHeaderWidths = true;
+ m_headerWidget->setAutomaticColumnResizing(false);
- if (m_visibleRolesSizes.contains(role)) {
- QSizeF roleSize = m_visibleRolesSizes.value(role);
- roleSize.setWidth(currentWidth);
- m_visibleRolesSizes.insert(role, roleSize);
- m_stretchedVisibleRolesSizes.insert(role, roleSize);
+ if (m_columnWidthsCache.contains(role)) {
+ m_columnWidthsCache.insert(role, currentWidth);
// Apply the new size to the layouter
- QSizeF dynamicItemSize = m_itemSize;
- if (dynamicItemSize.width() < 0) {
- const qreal requiredWidth = visibleRolesSizesWidthSum();
- dynamicItemSize.setWidth(qMax(size().width(), requiredWidth));
- }
- if (dynamicItemSize.height() < 0) {
- const qreal requiredHeight = visibleRolesSizesHeightSum();
- dynamicItemSize.setHeight(qMax(size().height(), requiredHeight));
- }
-
+ const qreal requiredWidth = columnWidthsSum();
+ const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth),
+ m_itemSize.height());
m_layouter->setItemSize(dynamicItemSize);
// Update the role sizes for all visible widgets
- foreach (KItemListWidget* widget, visibleItemListWidgets()) {
- widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
+ QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+ while (it.hasNext()) {
+ it.next();
+ updateWidgetColumnWidths(it.value());
}
-
- doLayout(Animation);
+ doLayout(NoAnimation);
}
}
+void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
+ int currentIndex,
+ int previousIndex)
+{
+ Q_ASSERT(m_visibleRoles[previousIndex] == role);
+
+ const QList<QByteArray> previous = m_visibleRoles;
+
+ QList<QByteArray> current = m_visibleRoles;
+ current.removeAt(previousIndex);
+ current.insert(currentIndex, role);
+
+ setVisibleRoles(current);
+
+ emit visibleRolesChanged(current, previous);
+}
+
void KItemListView::triggerAutoScrolling()
{
if (!m_autoScrollTimer) {
m_autoScrollTimer->start(RepeatingAutoScrollDelay);
}
+void KItemListView::slotGeometryOfGroupHeaderParentChanged()
+{
+ KItemListWidget* widget = qobject_cast<KItemListWidget*>(sender());
+ Q_ASSERT(widget);
+ KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
+ Q_ASSERT(groupHeader);
+ updateGroupHeaderLayout(widget);
+}
+
void KItemListView::setController(KItemListController* controller)
{
if (m_controller != controller) {
}
m_model = model;
- m_layouter->setModel(model);
+ m_layouter->setModel(model);
m_grouped = model->groupedSorting();
if (m_model) {
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;
+ }
+
+ if (!m_model || m_model->count() < 0) {
return;
}
const int lastVisibleIndex = m_layouter->lastVisibleIndex();
- QList<int> reusableItems = recycleInvisibleItems(firstVisibleIndex, lastVisibleIndex);
+ int firstSibblingIndex = -1;
+ int lastSibblingIndex = -1;
+ const bool supportsExpanding = supportsItemExpanding();
+
+ 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
const int oldIndex = reusableItems.takeLast();
widget = m_visibleItems.value(oldIndex);
setWidgetIndex(widget, i);
-
- if (m_grouped) {
- updateGroupHeaderForWidget(widget);
- }
+ updateWidgetProperties(widget, i);
+ initializeItemListWidget(widget);
} else {
// No reusable KItemListWidget instance is available, create a new one
widget = createWidget(i);
}
applyNewPos = false;
}
- } else if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
- applyNewPos = false;
+
+ if (supportsExpanding && changedCount == 0) {
+ if (firstSibblingIndex < 0) {
+ firstSibblingIndex = i;
+ }
+ lastSibblingIndex = i;
+ }
}
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.
- applyNewPos = !moveWidget(widget, itemBounds);
+ applyNewPos = !moveWidget(widget, newPos);
} 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.
- applyNewPos = !moveWidget(widget, itemBounds);
+ applyNewPos = !moveWidget(widget, newPos);
}
} else if (!itemsRemoved && !itemsInserted && !wasHidden) {
// The size of the view might have been changed. Animate the moving of the position.
- applyNewPos = !moveWidget(widget, itemBounds);
+ applyNewPos = !moveWidget(widget, newPos);
}
+ } else {
+ m_animation->stop(widget);
}
if (applyNewPos) {
widget->resize(itemBounds.size());
}
}
+
+ // Updating the cell-information must be done as last step: The decision whether the
+ // moving-animation should be started at all is based on the previous cell-information.
+ const Cell cell(m_layouter->itemColumn(i), m_layouter->itemRow(i));
+ m_visibleCells.insert(i, cell);
}
// Delete invisible KItemListWidget instances that have not been reused
recycleWidget(m_visibleItems.value(index));
}
+ if (supportsExpanding && firstSibblingIndex >= 0) {
+ Q_ASSERT(lastSibblingIndex >= 0);
+ updateSiblingsInformation(firstSibblingIndex, lastSibblingIndex);
+ }
+
if (m_grouped) {
// Update the layout of all visible group headers
QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
emitOffsetChanges();
}
-QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex, int lastVisibleIndex)
+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.
- // 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.
+ // 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 && !m_animation->isStarted(widget)) {
- widget->setVisible(false);
- items.append(index);
- if (m_grouped) {
- recycleGroupHeaderForWidget(widget);
+ 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)
+bool KItemListView::moveWidget(KItemListWidget* widget,const QPointF& newPos)
{
- const QPointF oldPos = widget->pos();
- const QPointF newPos = itemBounds.topLeft();
- if (oldPos == newPos) {
+ if (widget->pos() == newPos) {
return false;
}
-
- bool startMovingAnim = m_itemSize.isEmpty();
- 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.
- int zoomDiff = 0;
- if (widget->size() != itemBounds.size()) {
- // The item-size has been increased or decreased
- const bool zoomOut = (widget->size().width() >= itemBounds.size().width()) &&
- (widget->size().height() >= itemBounds.size().height());
- zoomDiff = zoomOut ? -1 : +1;
- }
+ bool startMovingAnim = false;
- const qreal xMax = m_itemSize.width();
- const qreal yMax = m_itemSize.height();
- qreal xDiff = oldPos.x() - newPos.x();
- qreal yDiff = oldPos.y() - newPos.y();
+ // 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 int index = widget->index();
+ const Cell cell = m_visibleCells.value(index);
+ if (cell.column >= 0 && cell.row >= 0) {
if (scrollOrientation() == Qt::Vertical) {
- if (zoomDiff != 0) {
- // Skip moving animations that changed the row
- startMovingAnim = (zoomDiff > 0 && xDiff < xMax) ||
- (zoomDiff < 0 && -xDiff < xMax);
- } else {
- xDiff = qAbs(xDiff);
- yDiff = qAbs(yDiff);
- startMovingAnim = (xDiff > yDiff && yDiff < yMax);
- }
+ startMovingAnim = (cell.row == m_layouter->itemRow(index));
} else {
- if (zoomDiff != 0) {
- // Skip moving animations that changed the column
- startMovingAnim = (zoomDiff > 0 && yDiff < yMax) ||
- (zoomDiff < 0 && -yDiff < yMax);
- } else {
- xDiff = qAbs(xDiff);
- yDiff = qAbs(yDiff);
- startMovingAnim = (yDiff > xDiff && xDiff < xMax);
- }
+ startMovingAnim = (cell.column == m_layouter->itemColumn(index));
}
}
KItemListWidget* widget = m_widgetCreator->create(this);
widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
- updateWidgetProperties(widget, index);
m_visibleItems.insert(index, widget);
-
- if (m_grouped) {
- updateGroupHeaderForWidget(widget);
- }
-
+ m_visibleCells.insert(index, Cell());
+ updateWidgetProperties(widget, index);
initializeItemListWidget(widget);
return widget;
}
recycleGroupHeaderForWidget(widget);
}
- m_visibleItems.remove(widget->index());
+ const int index = widget->index();
+ m_visibleItems.remove(index);
+ m_visibleCells.remove(index);
+
m_widgetCreator->recycle(widget);
}
{
const int oldIndex = widget->index();
m_visibleItems.remove(oldIndex);
- updateWidgetProperties(widget, index);
+ m_visibleCells.remove(oldIndex);
+
m_visibleItems.insert(index, widget);
+ m_visibleCells.insert(index, Cell());
- initializeItemListWidget(widget);
+ widget->setIndex(index);
+}
+
+void KItemListView::moveWidgetToIndex(KItemListWidget* widget, int index)
+{
+ const int oldIndex = widget->index();
+ const Cell oldCell = m_visibleCells.value(oldIndex);
+
+ setWidgetIndex(widget, index);
+
+ const Cell newCell(m_layouter->itemColumn(index), m_layouter->itemRow(index));
+ const bool vertical = (scrollOrientation() == Qt::Vertical);
+ const bool updateCell = (vertical && oldCell.row == newCell.row) ||
+ (!vertical && oldCell.column == newCell.column);
+ if (updateCell) {
+ m_visibleCells.insert(index, newCell);
+ }
}
void KItemListView::setLayouterSize(const QSizeF& size, SizeType sizeType)
void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
{
widget->setVisibleRoles(m_visibleRoles);
- widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
+ updateWidgetColumnWidths(widget);
widget->setStyleOption(m_styleOption);
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));
+ widget->setSiblingsInformation(QBitArray());
+ updateAlternateBackgroundForWidget(widget);
+
+ if (m_grouped) {
+ updateGroupHeaderForWidget(widget);
+ }
}
void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
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);
+ connect(widget, SIGNAL(geometryChanged()), this, SLOT(slotGeometryOfGroupHeaderParentChanged()));
}
- Q_ASSERT(header->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);
+ Q_ASSERT(groupHeader->parentItem() == widget);
- header->setData(groups.at(mid).second);
- header->setRole(model()->sortRole());
- header->setStyleOption(m_styleOption);
- header->setScrollOrientation(scrollOrientation());
+ const int groupIndex = groupIndexForItem(index);
+ Q_ASSERT(groupIndex >= 0);
+ groupHeader->setData(groups.at(groupIndex).second);
+ groupHeader->setRole(model()->sortRole());
+ groupHeader->setStyleOption(m_styleOption);
+ groupHeader->setScrollOrientation(scrollOrientation());
+ groupHeader->setItemIndex(index);
- 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);
// 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());
- header->setPos(groupHeaderPos);
- header->resize(groupHeaderRect.size());
+ if (scrollOrientation() == Qt::Vertical) {
+ // In the vertical scroll orientation the group header should always span
+ // the whole width no matter which temporary position the parent widget
+ // has. In this case the x-position and width will be adjusted manually.
+ groupHeader->setPos(-widget->x(), -groupHeaderRect.height());
+ groupHeader->resize(size().width(), groupHeaderRect.size().height());
+ } else {
+ groupHeader->setPos(groupHeaderRect.x() - itemRect.x(), -widget->y());
+ groupHeader->resize(groupHeaderRect.size());
+ }
}
void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
header->setParentItem(0);
m_groupHeaderCreator->recycle(header);
m_visibleGroups.remove(widget);
+ disconnect(widget, SIGNAL(geometryChanged()), this, SLOT(slotGeometryOfGroupHeaderParentChanged()));
}
}
}
}
-QHash<QByteArray, qreal> KItemListView::headerRolesWidths() const
+int KItemListView::groupIndexForItem(int index) const
{
- QHash<QByteArray, qreal> rolesWidths;
+ Q_ASSERT(m_grouped);
+
+ const QList<QPair<int, QVariant> > groups = model()->groups();
+ if (groups.isEmpty()) {
+ return -1;
+ }
+
+ int min = 0;
+ int max = groups.count() - 1;
+ int mid = 0;
+ do {
+ mid = (min + max) / 2;
+ if (index > groups[mid].first) {
+ min = mid + 1;
+ } else {
+ max = mid - 1;
+ }
+ } while (groups[mid].first != index && min <= max);
+
+ if (min > max) {
+ while (groups[mid].first > index && mid > 0) {
+ --mid;
+ }
+ }
+
+ return mid;
+}
- QHashIterator<QByteArray, QSizeF> it(m_stretchedVisibleRolesSizes);
+void KItemListView::updateAlternateBackgrounds()
+{
+ QHashIterator<int, KItemListWidget*> it(m_visibleItems);
while (it.hasNext()) {
it.next();
- rolesWidths.insert(it.key(), it.value().width());
+ updateAlternateBackgroundForWidget(it.value());
}
+}
- return rolesWidths;
+void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
+{
+ bool enabled = useAlternateBackgrounds();
+ if (enabled) {
+ const int index = widget->index();
+ enabled = (index & 0x1) > 0;
+ if (m_grouped) {
+ const int groupIndex = groupIndexForItem(index);
+ if (groupIndex >= 0) {
+ const QList<QPair<int, QVariant> > groups = model()->groups();
+ const int indexOfFirstGroupItem = groups[groupIndex].first;
+ const int relativeIndex = index - indexOfFirstGroupItem;
+ enabled = (relativeIndex & 0x1) > 0;
+ }
+ }
+ }
+ widget->setAlternateBackground(enabled);
}
-void KItemListView::updateVisibleRolesSizes(const KItemRangeList& itemRanges)
+bool KItemListView::useAlternateBackgrounds() const
{
- if (!m_itemSize.isEmpty() || m_useHeaderWidths) {
+ return m_itemSize.isEmpty() && m_visibleRoles.count() > 1;
+}
+
+void KItemListView::applyColumnWidthsFromHeader()
+{
+ qreal roleWidthSum = 0;
+ foreach (const QByteArray& role, m_visibleRoles) {
+ const qreal width = m_headerWidget->columnWidth(role);
+ m_columnWidthsCache.insert(role, width);
+ roleWidthSum += width;
+ }
+
+ // Apply the new size to the layouter
+ const QSizeF dynamicItemSize(qMax(size().width(), roleWidthSum),
+ m_itemSize.height());
+ m_layouter->setItemSize(dynamicItemSize);
+
+ // Update the role sizes for all visible widgets
+ QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+ while (it.hasNext()) {
+ it.next();
+ updateWidgetColumnWidths(it.value());
+ }
+ doLayout(NoAnimation);
+}
+
+void KItemListView::updateWidgetColumnWidths(KItemListWidget* widget)
+{
+ foreach (const QByteArray& role, m_visibleRoles) {
+ widget->setColumnWidth(role, m_headerWidget->columnWidth(role));
+ }
+}
+
+void KItemListView::updateColumnWidthsCache(const KItemRangeList& itemRanges)
+{
+ if (!m_itemSize.isEmpty() || !m_headerWidget->automaticColumnResizing()) {
return;
}
}
if (itemCount == rangesItemCount) {
- m_visibleRolesSizes = visibleRolesSizes(itemRanges);
- if (m_header) {
+ m_columnWidthsCache = columnWidths(itemRanges);
+ if (m_headerWidget->isVisible()) {
// 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);
+ const qreal minHeaderRoleWidth = m_headerWidget->minimumColumnWidth();
+ QMutableHashIterator<QByteArray, qreal> it (m_columnWidthsCache);
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);
+ const qreal width = it.value();
+ if (width < minHeaderRoleWidth) {
+ m_columnWidthsCache.insert(it.key(), minHeaderRoleWidth);
}
}
}
} else {
// Only a sub range of the roles need to be determined.
- // The chances are good that the sizes of the sub ranges
- // already fit into the available sizes and hence no
+ // The chances are good that the widths of the sub ranges
+ // already fit into the available widths and hence no
// expensive update might be required.
bool updateRequired = false;
- const QHash<QByteArray, QSizeF> updatedSizes = visibleRolesSizes(itemRanges);
- QHashIterator<QByteArray, QSizeF> it(updatedSizes);
+ const QHash<QByteArray, qreal> updatedWidths = columnWidths(itemRanges);
+ QHashIterator<QByteArray, qreal> it(updatedWidths);
while (it.hasNext()) {
it.next();
const QByteArray& role = it.key();
- const QSizeF& updatedSize = it.value();
- const QSizeF currentSize = m_visibleRolesSizes.value(role);
- if (updatedSize.width() > currentSize.width() || updatedSize.height() > currentSize.height()) {
- m_visibleRolesSizes.insert(role, updatedSize);
+ const qreal updatedWidth = it.value();
+ const qreal currentWidth = m_columnWidthsCache.value(role);
+ if (updatedWidth > currentWidth) {
+ m_columnWidthsCache.insert(role, updatedWidth);
updateRequired = true;
}
}
}
}
- updateStretchedVisibleRolesSizes();
+ updateColumnWidthsForHeader();
}
-void KItemListView::updateVisibleRolesSizes()
+void KItemListView::updateColumnWidthsCache()
{
if (!m_model) {
return;
const int itemCount = m_model->count();
if (itemCount > 0) {
- updateVisibleRolesSizes(KItemRangeList() << KItemRange(0, itemCount));
+ updateColumnWidthsCache(KItemRangeList() << KItemRange(0, itemCount));
}
}
-void KItemListView::updateStretchedVisibleRolesSizes()
+void KItemListView::updateColumnWidthsForHeader()
{
- if (!m_itemSize.isEmpty() || m_useHeaderWidths || m_visibleRoles.isEmpty()) {
+ if (!m_itemSize.isEmpty() || !m_headerWidget->automaticColumnResizing() || m_visibleRoles.isEmpty()) {
return;
}
// Calculate the maximum size of an item by considering the
// visible role sizes and apply them to the layouter. If the
- // size does not use the available view-size it the size of the
+ // size does not use the available view-size the size of the
// first role will get stretched.
- m_stretchedVisibleRolesSizes = m_visibleRolesSizes;
+
+ foreach (const QByteArray& role, m_visibleRoles) {
+ m_headerWidget->setColumnWidth(role, m_columnWidthsCache.value(role));
+ }
+
const QByteArray role = m_visibleRoles.first();
- QSizeF firstRoleSize = m_stretchedVisibleRolesSizes.value(role);
+ qreal firstColumnWidth = m_columnWidthsCache.value(role);
QSizeF dynamicItemSize = m_itemSize;
if (dynamicItemSize.width() <= 0) {
- const qreal requiredWidth = visibleRolesSizesWidthSum();
+ const qreal requiredWidth = columnWidthsSum();
const qreal availableWidth = size().width();
- if (requiredWidth < availableWidth) {
- // Stretch the first role to use the whole width for the item
- firstRoleSize.rwidth() += availableWidth - requiredWidth;
- m_stretchedVisibleRolesSizes.insert(role, firstRoleSize);
- }
- dynamicItemSize.setWidth(qMax(requiredWidth, availableWidth));
- }
+ if (requiredWidth != availableWidth) {
+ // Stretch the first role to use the whole remaining width
+ firstColumnWidth += availableWidth - requiredWidth;
+
+ // TODO: A proper calculation of the minimum width depends on the implementation
+ // of KItemListWidget. Probably a kind of minimum size-hint should be introduced
+ // later.
+ const qreal minWidth = m_styleOption.iconSize * 2 + 200;
+ if (firstColumnWidth < minWidth) {
+ firstColumnWidth = minWidth;
+ }
- if (dynamicItemSize.height() <= 0) {
- const qreal requiredHeight = visibleRolesSizesHeightSum();
- const qreal availableHeight = size().height();
- if (requiredHeight < availableHeight) {
- // Stretch the first role to use the whole height for the item
- firstRoleSize.rheight() += availableHeight - requiredHeight;
- m_stretchedVisibleRolesSizes.insert(role, firstRoleSize);
+ m_headerWidget->setColumnWidth(role, firstColumnWidth);
}
- dynamicItemSize.setHeight(qMax(requiredHeight, availableHeight));
+ dynamicItemSize.rwidth() = qMax(requiredWidth, availableWidth);
}
m_layouter->setItemSize(dynamicItemSize);
- if (m_header) {
- m_header->setVisibleRolesWidths(headerRolesWidths());
- m_header->resize(dynamicItemSize.width(), m_header->size().height());
+ if (m_headerWidget->isVisible()) {
+ m_headerWidget->resize(dynamicItemSize.width(), m_headerWidget->size().height());
}
// Update the role sizes for all visible widgets
- foreach (KItemListWidget* widget, visibleItemListWidgets()) {
- widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
+ QHashIterator<int, KItemListWidget*> it(m_visibleItems);
+ while (it.hasNext()) {
+ it.next();
+ updateWidgetColumnWidths(it.value());
}
}
-qreal KItemListView::visibleRolesSizesWidthSum() const
+qreal KItemListView::columnWidthsSum() const
{
qreal widthSum = 0;
- QHashIterator<QByteArray, QSizeF> it(m_visibleRolesSizes);
+ QHashIterator<QByteArray, qreal> it(m_columnWidthsCache);
while (it.hasNext()) {
it.next();
- widthSum += it.value().width();
+ widthSum += it.value();
}
return widthSum;
}
-qreal KItemListView::visibleRolesSizesHeightSum() const
+QRectF KItemListView::headerBoundaries() const
{
- qreal heightSum = 0;
- QHashIterator<QByteArray, QSizeF> it(m_visibleRolesSizes);
- while (it.hasNext()) {
- it.next();
- heightSum += it.value().height();
+ return m_headerWidget->isVisible() ? m_headerWidget->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 heightSum;
+
+ return false;
}
-QRectF KItemListView::headerBoundaries() const
+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()
{
- return m_header ? m_header->geometry() : QRectF();
+ qreal groupHeaderHeight = m_styleOption.fontMetrics.height();
+ qreal groupHeaderMargin = 0;
+
+ if (scrollOrientation() == Qt::Horizontal) {
+ // The vertical margin above and below the header should be
+ // equal to the horizontal margin, not the vertical margin
+ // from m_styleOption.
+ groupHeaderHeight += 2 * m_styleOption.horizontalMargin;
+ groupHeaderMargin = m_styleOption.horizontalMargin;
+ } else if (m_itemSize.isEmpty()){
+ groupHeaderHeight += 4 * m_styleOption.padding;
+ groupHeaderMargin = m_styleOption.iconSize / 2;
+ } else {
+ groupHeaderHeight += 2 * m_styleOption.padding + m_styleOption.verticalMargin;
+ groupHeaderMargin = m_styleOption.iconSize / 4;
+ }
+ m_layouter->setGroupHeaderHeight(groupHeaderHeight);
+ m_layouter->setGroupHeaderMargin(groupHeaderMargin);
+
+ updateVisibleGroupHeaders();
+}
+
+void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
+{
+ if (!supportsItemExpanding() || !m_model) {
+ return;
+ }
+
+ if (firstIndex < 0 || lastIndex < 0) {
+ firstIndex = m_layouter->firstVisibleIndex();
+ lastIndex = m_layouter->lastVisibleIndex();
+ } else {
+ const bool isRangeVisible = (firstIndex <= m_layouter->lastVisibleIndex() &&
+ lastIndex >= m_layouter->firstVisibleIndex());
+ if (!isRangeVisible) {
+ return;
+ }
+ }
+
+ int previousParents = 0;
+ QBitArray previousSiblings;
+
+ // The rootIndex describes the first index where the siblings get
+ // calculated from. For the calculation the upper most parent item
+ // is required. For performance reasons it is checked first whether
+ // the visible items before or after the current range already
+ // contain a siblings information which can be used as base.
+ int rootIndex = firstIndex;
+
+ KItemListWidget* widget = m_visibleItems.value(firstIndex - 1);
+ if (!widget) {
+ // There is no visible widget before the range, check whether there
+ // is one after the range:
+ widget = m_visibleItems.value(lastIndex + 1);
+ if (widget) {
+ // The sibling information of the widget may only be used if
+ // all items of the range have the same number of parents.
+ const int parents = m_model->expandedParentsCount(lastIndex + 1);
+ for (int i = lastIndex; i >= firstIndex; --i) {
+ if (m_model->expandedParentsCount(i) != parents) {
+ widget = 0;
+ break;
+ }
+ }
+ }
+ }
+
+ if (widget) {
+ // Performance optimization: Use the sibling information of the visible
+ // widget beside the given range.
+ previousSiblings = widget->siblingsInformation();
+ if (previousSiblings.isEmpty()) {
+ return;
+ }
+ previousParents = previousSiblings.count() - 1;
+ previousSiblings.truncate(previousParents);
+ } else {
+ // Potentially slow path: Go back to the upper most parent of firstIndex
+ // to be able to calculate the initial value for the siblings.
+ while (rootIndex > 0 && m_model->expandedParentsCount(rootIndex) > 0) {
+ --rootIndex;
+ }
+ }
+
+ Q_ASSERT(previousParents >= 0);
+ for (int i = rootIndex; i <= lastIndex; ++i) {
+ // Update the parent-siblings in case if the current item represents
+ // a child or an upper parent.
+ const int currentParents = m_model->expandedParentsCount(i);
+ Q_ASSERT(currentParents >= 0);
+ if (previousParents < currentParents) {
+ previousParents = currentParents;
+ previousSiblings.resize(currentParents);
+ previousSiblings.setBit(currentParents - 1, hasSiblingSuccessor(i - 1));
+ } else if (previousParents > currentParents) {
+ previousParents = currentParents;
+ previousSiblings.truncate(currentParents);
+ }
+
+ if (i >= firstIndex) {
+ // The index represents a visible item. Apply the parent-siblings
+ // and update the sibling of the current item.
+ KItemListWidget* widget = m_visibleItems.value(i);
+ if (!widget) {
+ continue;
+ }
+
+ QBitArray siblings = previousSiblings;
+ siblings.resize(siblings.count() + 1);
+ siblings.setBit(siblings.count() - 1, hasSiblingSuccessor(i));
+
+ widget->setSiblingsInformation(siblings);
+ }
+ }
+}
+
+bool KItemListView::hasSiblingSuccessor(int index) const
+{
+ bool hasSuccessor = false;
+ const int parentsCount = m_model->expandedParentsCount(index);
+ int successorIndex = index + 1;
+
+ // Search the next sibling
+ const int itemCount = m_model->count();
+ while (successorIndex < itemCount) {
+ const int currentParentsCount = m_model->expandedParentsCount(successorIndex);
+ if (currentParentsCount == parentsCount) {
+ hasSuccessor = true;
+ break;
+ } else if (currentParentsCount < parentsCount) {
+ break;
+ }
+ ++successorIndex;
+ }
+
+ if (m_grouped && hasSuccessor) {
+ // If the sibling is part of another group, don't mark it as
+ // successor as the group header is between the sibling connections.
+ for (int i = index + 1; i <= successorIndex; ++i) {
+ if (m_layouter->isFirstGroupItem(i)) {
+ hasSuccessor = false;
+ break;
+ }
+ }
+ }
+
+ return hasSuccessor;
}
int KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
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