KItemListView::KItemListView(QGraphicsWidget* parent) :
QGraphicsWidget(parent),
+ m_enabledSelectionToggles(false),
m_grouped(false),
m_activeTransactions(0),
m_itemSize(),
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);
+ }
+ }
+
+ doLayout(Animation);
onScrollOrientationChanged(orientation, previousOrientation);
emit scrollOrientationChanged(orientation, previousOrientation);
}
m_sizeHintResolver->clearCache();
- updateLayout();
+ doLayout(Animation);
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(Animation);
onVisibleRolesChanged(roles, previousRoles);
}
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;
}
m_sizeHintResolver->clearCache();
- updateLayout();
+ doLayout(Animation);
onStyleOptionChanged(option, previousOption);
}
bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
{
- Q_UNUSED(index);
- Q_UNUSED(pos);
+ 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>();
}
+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();
- updateLayout();
+ 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) {
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) {
if (!hasMultipleRanges) {
doLayout(Animation, index, count);
- update();
}
}
m_layouter->markAsDirty();
if (!hasMultipleRanges) {
doLayout(Animation, index, -count);
- update();
}
}
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) {
// Apply the height of the header to the layouter
const qreal groupHeaderHeight = m_styleOption.fontMetrics.height() +
m_styleOption.margin * 2;
m_layouter->setGroupHeaderHeight(groupHeaderHeight);
- // Assure that headers from already visible items get created
- QHashIterator<int, KItemListWidget*> it(m_visibleItems);
- while (it.hasNext()) {
- it.next();
- KItemListWidget* widget = it.value();
- updateGroupHeaderForWidget(widget);
- }
+ updateVisibleGroupHeaders();
} else {
// Clear all visible headers
QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
Q_ASSERT(m_visibleGroups.isEmpty());
}
- m_layouter->markAsDirty();
- updateLayout();
+ doLayout(Animation);
+}
+
+void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
+{
+ Q_UNUSED(current);
+ Q_UNUSED(previous);
+ if (m_grouped) {
+ updateVisibleGroupHeaders();
+ doLayout(Animation);
+ }
+}
+
+void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
+{
+ Q_UNUSED(current);
+ Q_UNUSED(previous);
+ if (m_grouped) {
+ updateVisibleGroupHeaders();
+ doLayout(Animation);
+ }
}
void KItemListView::slotCurrentChanged(int current, int previous)
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);
}
- updateLayout();
+ 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()
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_layouter->setModel(model);
m_grouped = model->groupedSorting();
if (m_model) {
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_model || m_model->count() < 0 || m_activeTransactions > 0) {
return;
}
if (invisible && !m_animation->isStarted(widget)) {
widget->setVisible(false);
reusableItems.append(index);
+
+ if (m_grouped) {
+ recycleGroupHeaderForWidget(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.
+ // 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()) {
- 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());
+ }
}
}
updateWidgetProperties(widget, index);
m_visibleItems.insert(index, widget);
- if (m_grouped) {
- updateGroupHeaderForWidget(widget);
- }
-
initializeItemListWidget(widget);
}
for (int i = minFirst; i <= maxLast; ++i) {
if (!m_visibleItems.contains(i)) {
KItemListWidget* widget = createWidget(i);
- const QPointF pos = m_layouter->itemRect(i).topLeft();
- widget->setPos(pos);
+ const QRectF itemRect = m_layouter->itemRect(i);
+ widget->setPos(itemRect.topLeft());
+ widget->resize(itemRect.size());
}
}
setLayouterSize(size, sizeType);
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
return;
}
+ const QList<QPair<int, QVariant> > groups = model()->groups();
+ if (groups.isEmpty()) {
+ return;
+ }
+
KItemListGroupHeader* header = m_visibleGroups.value(widget);
if (!header) {
header = m_groupHeaderCreator->create(this);
// Determine the shown data for the header by doing a binary
// search in the groups-list
- const QList<QPair<int, QVariant> > groups = model()->groups();
int min = 0;
int max = groups.count() - 1;
int mid = 0;
header->setData(groups.at(mid).second);
header->setRole(model()->sortRole());
+ header->setStyleOption(m_styleOption);
+ header->setScrollOrientation(scrollOrientation());
header->show();
}
}
}
+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;
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