#include "kitemlistview.h"
#include "kitemlistcontroller.h"
-#include "kitemlistgroupheader.h"
#include "kitemlistheader_p.h"
#include "kitemlistrubberband_p.h"
#include "kitemlistselectionmanager.h"
m_animation->setScrollOrientation(orientation);
m_sizeHintResolver->clearCache();
updateLayout();
+
onScrollOrientationChanged(orientation, previousOrientation);
+ emit scrollOrientationChanged(orientation, previousOrientation);
}
Qt::Orientation KItemListView::scrollOrientation() const
m_itemSize = itemSize;
- if (itemSize.isEmpty()) {
+ const bool emptySize = itemSize.isEmpty();
+ if (emptySize) {
updateVisibleRolesSizes();
- }
-
- if (itemSize.width() < previousSize.width() || itemSize.height() < previousSize.height()) {
- prepareLayoutForIncreasedItemCount(itemSize, ItemSize);
} else {
- m_layouter->setItemSize(itemSize);
+ if (itemSize.width() < previousSize.width() || itemSize.height() < previousSize.height()) {
+ prepareLayoutForIncreasedItemCount(itemSize, ItemSize);
+ } else {
+ m_layouter->setItemSize(itemSize);
+ }
}
m_sizeHintResolver->clearCache();
void KItemListView::setItemOffset(qreal offset)
{
m_layouter->setItemOffset(offset);
+ if (m_header) {
+ m_header->setPos(-offset, 0);
+ }
+ if (!m_layoutTimer->isActive()) {
+ doLayout(NoAnimation, 0, 0);
+ update();
+ }
}
qreal KItemListView::itemOffset() const
m_sizeHintResolver->clearCache();
m_layouter->markAsDirty();
- onVisibleRolesChanged(roles, previousRoles);
-
- updateVisibleRolesSizes();
- updateLayout();
if (m_header) {
m_header->setVisibleRoles(roles);
m_header->setVisibleRolesWidths(headerRolesWidths());
m_useHeaderWidths = false;
}
+
+ updateVisibleRolesSizes();
+ updateLayout();
+
+ onVisibleRolesChanged(roles, previousRoles);
}
QList<QByteArray> KItemListView::visibleRoles() const
return m_autoScrollTimer != 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);
-
- m_useHeaderWidths = false;
- updateHeaderWidth();
-
- 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);
- }
-}
-
-bool KItemListView::isHeaderShown() const
-{
- return m_header != 0;
-}
-
KItemListController* KItemListView::controller() const
{
return m_controller;
return QHash<QByteArray, QSizeF>();
}
-QRectF KItemListView::itemBoundingRect(int index) const
+QRectF KItemListView::itemRect(int index) const
{
- return m_layouter->itemBoundingRect(index);
+ return m_layouter->itemRect(index);
}
int KItemListView::itemsPerOffset() const
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);
+
+ 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);
+ }
+}
+
+bool KItemListView::isHeaderShown() const
+{
+ return m_header != 0;
+}
+
QPixmap KItemListView::createDragPixmap(const QSet<int>& indexes) const
{
Q_UNUSED(indexes);
void KItemListView::resizeEvent(QGraphicsSceneResizeEvent* event)
{
QGraphicsWidget::resizeEvent(event);
- updateHeaderWidth();
+ 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)
}
}
+void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>& movedToIndexes)
+{
+ const int firstVisibleMovedIndex = qMax(firstVisibleIndex(), itemRange.index);
+ const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
+
+ for (int index = firstVisibleMovedIndex; index <= lastVisibleMovedIndex; ++index) {
+ KItemListWidget* widget = m_visibleItems.value(index);
+ if (widget) {
+ updateWidgetProperties(widget, index);
+ }
+ }
+
+ if (m_controller) {
+ m_controller->selectionManager()->itemsMoved(itemRange, movedToIndexes);
+ }
+}
+
void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
const QSet<QByteArray>& roles)
{
}
}
+void KItemListView::slotGroupedSortingChanged(bool current)
+{
+ m_grouped = current;
+ 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);
+ }
+ } else {
+ // Clear all visible headers
+ QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
+ while (it.hasNext()) {
+ it.next();
+ recycleGroupHeaderForWidget(it.key());
+ }
+ Q_ASSERT(m_visibleGroups.isEmpty());
+ }
+
+ m_layouter->markAsDirty();
+ updateLayout();
+}
+
void KItemListView::slotCurrentChanged(int current, int previous)
{
Q_UNUSED(previous);
}
const QRectF viewGeometry = geometry();
- const QRectF currentBoundingRect = itemBoundingRect(current);
+ const QRectF currentRect = itemRect(current);
- if (!viewGeometry.contains(currentBoundingRect)) {
+ if (!viewGeometry.contains(currentRect)) {
// Make sure that the new current item is fully visible in the view.
qreal newOffset = scrollOffset();
- if (currentBoundingRect.top() < viewGeometry.top()) {
+ if (currentRect.top() < viewGeometry.top()) {
Q_ASSERT(scrollOrientation() == Qt::Vertical);
- newOffset += currentBoundingRect.top() - viewGeometry.top();
- } else if ((currentBoundingRect.bottom() > viewGeometry.bottom())) {
+ newOffset += currentRect.top() - viewGeometry.top();
+ } else if ((currentRect.bottom() > viewGeometry.bottom())) {
Q_ASSERT(scrollOrientation() == Qt::Vertical);
- newOffset += currentBoundingRect.bottom() - viewGeometry.bottom();
- } else if (currentBoundingRect.left() < viewGeometry.left()) {
+ newOffset += currentRect.bottom() - viewGeometry.bottom();
+ } else if (currentRect.left() < viewGeometry.left()) {
if (scrollOrientation() == Qt::Horizontal) {
- newOffset += currentBoundingRect.left() - viewGeometry.left();
+ newOffset += currentRect.left() - viewGeometry.left();
}
- } else if ((currentBoundingRect.right() > viewGeometry.right())) {
+ } else if ((currentRect.right() > viewGeometry.right())) {
if (scrollOrientation() == Qt::Horizontal) {
- newOffset += currentBoundingRect.right() - viewGeometry.right();
+ newOffset += currentRect.right() - viewGeometry.right();
}
}
// 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;
}
m_visibleRolesSizes.insert(role, roleSize);
m_stretchedVisibleRolesSizes.insert(role, roleSize);
- updateVisibleRolesSizes();
+ // 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));
+ }
+
+ m_layouter->setItemSize(dynamicItemSize);
+
+ // Update the role sizes for all visible widgets
+ foreach (KItemListWidget* widget, visibleItemListWidgets()) {
+ widget->setVisibleRolesSizes(m_stretchedVisibleRolesSizes);
+ }
+
updateLayout();
}
}
this, SLOT(slotItemsInserted(KItemRangeList)));
disconnect(m_model, SIGNAL(itemsRemoved(KItemRangeList)),
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)));
}
m_model = model;
m_layouter->setModel(model);
- m_grouped = !model->groupRole().isEmpty();
+ m_grouped = model->groupedSorting();
if (m_model) {
connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
this, SLOT(slotItemsInserted(KItemRangeList)));
connect(m_model, SIGNAL(itemsRemoved(KItemRangeList)),
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)));
}
onModelChanged(model, previous);
return;
}
- //markVisibleRolesSizesAsDirty();
-
const int firstVisibleIndex = m_layouter->firstVisibleIndex();
const int lastVisibleIndex = m_layouter->lastVisibleIndex();
if (firstVisibleIndex < 0) {
if (invisible && !m_animation->isStarted(widget)) {
widget->setVisible(false);
reusableItems.append(index);
+
+ if (m_grouped) {
+ recycleGroupHeaderForWidget(widget);
+ }
}
}
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()) {
+ 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;
}
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();
}
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);
for (int i = minFirst; i <= maxLast; ++i) {
if (!m_visibleItems.contains(i)) {
KItemListWidget* widget = createWidget(i);
- const QPointF pos = m_layouter->itemBoundingRect(i).topLeft();
+ const QPointF pos = m_layouter->itemRect(i).topLeft();
widget->setPos(pos);
}
}
const KItemListSelectionManager* selectionManager = m_controller->selectionManager();
widget->setCurrent(index == selectionManager->currentItem());
-
- if (selectionManager->hasSelection()) {
- const QSet<int> selectedItems = selectionManager->selectedItems();
- widget->setSelected(selectedItems.contains(index));
- } else {
- widget->setSelected(false);
- }
-
+ widget->setSelected(selectionManager->isSelected(index));
widget->setHovered(false);
-
+ widget->setAlternatingBackgroundColors(false);
widget->setIndex(index);
widget->setData(m_model->data(index));
}
-void KItemListView::updateHeaderWidth()
+void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
{
- if (!m_header) {
+ 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;
}
- // TODO 1: Use the required width of all roles
- m_header->resize(size().width(), m_header->size().height());
+ KItemListGroupHeader* header = m_visibleGroups.value(widget);
+ if (!header) {
+ header = m_groupHeaderCreator->create(this);
+ header->setParentItem(widget);
+ m_visibleGroups.insert(widget, header);
+ }
+ Q_ASSERT(header->parentItem() == widget);
+
+ // 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;
+ 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);
+
+ header->setData(groups.at(mid).second);
+ header->setRole(model()->sortRole());
+ header->setStyleOption(m_styleOption);
+ header->setScrollOrientation(scrollOrientation());
+
+ header->show();
+}
+
+void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
+{
+ KItemListGroupHeader* header = m_visibleGroups.value(widget);
+ Q_ASSERT(header);
+
+ 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());
+ header->setPos(groupHeaderPos);
+ header->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);
+ }
}
QHash<QByteArray, qreal> KItemListView::headerRolesWidths() const
}
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;
}
}
// visible role sizes and apply them to the layouter. If the
// size does not use the available view-size it the size of the
// first role will get stretched.
- qreal requiredWidth = 0;
- qreal requiredHeight = 0;
-
- QHashIterator<QByteArray, QSizeF> it(m_visibleRolesSizes);
- while (it.hasNext()) {
- it.next();
- const QSizeF& visibleRoleSize = it.value();
- requiredWidth += visibleRoleSize.width();
- requiredHeight += visibleRoleSize.height();
- }
-
m_stretchedVisibleRolesSizes = m_visibleRolesSizes;
const QByteArray role = visibleRoles().first();
QSizeF firstRoleSize = m_stretchedVisibleRolesSizes.value(role);
QSizeF dynamicItemSize = m_itemSize;
if (dynamicItemSize.width() <= 0) {
+ const qreal requiredWidth = visibleRolesSizesWidthSum();
const qreal availableWidth = size().width();
if (requiredWidth < availableWidth) {
// Stretch the first role to use the whole width for the item
}
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
if (m_header) {
m_header->setVisibleRolesWidths(headerRolesWidths());
+ m_header->resize(dynamicItemSize.width(), m_header->size().height());
}
// Update the role sizes for all visible widgets
}
}
+qreal KItemListView::visibleRolesSizesWidthSum() const
+{
+ qreal widthSum = 0;
+ QHashIterator<QByteArray, QSizeF> it(m_visibleRolesSizes);
+ while (it.hasNext()) {
+ it.next();
+ widthSum += it.value().width();
+ }
+ return widthSum;
+}
+
+qreal KItemListView::visibleRolesSizesHeightSum() const
+{
+ qreal heightSum = 0;
+ QHashIterator<QByteArray, QSizeF> it(m_visibleRolesSizes);
+ while (it.hasNext()) {
+ it.next();
+ heightSum += it.value().height();
+ }
+ return heightSum;
+}
+
+QRectF KItemListView::headerBoundaries() const
+{
+ return m_header ? m_header->geometry() : QRectF();
+}
+
int KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
{
int inc = 0;
void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
{
+ widget->setParentItem(0);
widget->setOpacity(1.0);
pushRecycleableWidget(widget);
}
projects / dolphin.git / blobdiff