File indexing completed on 2024-11-10 09:41:49
0001 /* 0002 This file is part of the KDE project 0003 SPDX-FileCopyrightText: 2007, 2009 Rafael Fernández López <ereslibre@kde.org> 0004 0005 SPDX-License-Identifier: LGPL-2.0-or-later 0006 */ 0007 0008 /** 0009 * IMPLEMENTATION NOTES: 0010 * 0011 * QListView::setRowHidden() and QListView::isRowHidden() are not taken into 0012 * account. This methods should actually not exist. This effect should be handled 0013 * by an hypothetical QSortFilterProxyModel which filters out the desired rows. 0014 * 0015 * In case this needs to be implemented, contact me, but I consider this a faulty 0016 * design. 0017 */ 0018 0019 #include "kcategorizedview.h" 0020 #include "kcategorizedview_p.h" 0021 0022 #include <QPaintEvent> 0023 #include <QPainter> 0024 #include <QScrollBar> 0025 0026 #include "kcategorizedsortfilterproxymodel.h" 0027 #include "kcategorydrawer.h" 0028 0029 // BEGIN: Private part 0030 0031 struct KCategorizedViewPrivate::Item { 0032 Item() 0033 : topLeft(QPoint()) 0034 , size(QSize()) 0035 { 0036 } 0037 0038 QPoint topLeft; 0039 QSize size; 0040 }; 0041 0042 struct KCategorizedViewPrivate::Block { 0043 Block() 0044 : topLeft(QPoint()) 0045 , firstIndex(QModelIndex()) 0046 , quarantineStart(QModelIndex()) 0047 , items(QList<Item>()) 0048 { 0049 } 0050 0051 bool operator!=(const Block &rhs) const 0052 { 0053 return firstIndex != rhs.firstIndex; 0054 } 0055 0056 static bool lessThan(const Block &left, const Block &right) 0057 { 0058 Q_ASSERT(left.firstIndex.isValid()); 0059 Q_ASSERT(right.firstIndex.isValid()); 0060 return left.firstIndex.row() < right.firstIndex.row(); 0061 } 0062 0063 QPoint topLeft; 0064 int height = -1; 0065 QPersistentModelIndex firstIndex; 0066 // if we have n elements on this block, and we inserted an element at position i. The quarantine 0067 // will start at index (i, column, parent). This means that for all elements j where i <= j <= n, the 0068 // visual rect position of item j will have to be recomputed (cannot use the cached point). The quarantine 0069 // will only affect the current block, since the rest of blocks can be affected only in the way 0070 // that the whole block will have different offset, but items will keep the same relative position 0071 // in terms of their parent blocks. 0072 QPersistentModelIndex quarantineStart; 0073 QList<Item> items; 0074 0075 // this affects the whole block, not items separately. items contain the topLeft point relative 0076 // to the block. Because of insertions or removals a whole block can be moved, so the whole block 0077 // will enter in quarantine, what is faster than moving all items in absolute terms. 0078 bool outOfQuarantine = false; 0079 0080 // should we alternate its color ? is just a hint, could not be used 0081 bool alternate = false; 0082 bool collapsed = false; 0083 }; 0084 0085 KCategorizedViewPrivate::KCategorizedViewPrivate(KCategorizedView *qq) 0086 : q(qq) 0087 , hoveredBlock(new Block()) 0088 , hoveredIndex(QModelIndex()) 0089 , pressedPosition(QPoint()) 0090 , rubberBandRect(QRect()) 0091 { 0092 } 0093 0094 KCategorizedViewPrivate::~KCategorizedViewPrivate() 0095 { 0096 delete hoveredBlock; 0097 } 0098 0099 bool KCategorizedViewPrivate::isCategorized() const 0100 { 0101 return proxyModel && categoryDrawer && proxyModel->isCategorizedModel(); 0102 } 0103 0104 QStyleOptionViewItem KCategorizedViewPrivate::viewOpts() 0105 { 0106 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) 0107 QStyleOptionViewItem option; 0108 q->initViewItemOption(&option); 0109 #else 0110 QStyleOptionViewItem option(q->viewOptions()); 0111 #endif 0112 return option; 0113 } 0114 0115 QStyleOptionViewItem KCategorizedViewPrivate::blockRect(const QModelIndex &representative) 0116 { 0117 QStyleOptionViewItem option = viewOpts(); 0118 0119 const int height = categoryDrawer->categoryHeight(representative, option); 0120 const QString categoryDisplay = representative.data(KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); 0121 QPoint pos = blockPosition(categoryDisplay); 0122 pos.ry() -= height; 0123 option.rect.setTopLeft(pos); 0124 option.rect.setWidth(viewportWidth() + categoryDrawer->leftMargin() + categoryDrawer->rightMargin()); 0125 option.rect.setHeight(height + blockHeight(categoryDisplay)); 0126 option.rect = mapToViewport(option.rect); 0127 0128 return option; 0129 } 0130 0131 std::pair<QModelIndex, QModelIndex> KCategorizedViewPrivate::intersectingIndexesWithRect(const QRect &_rect) const 0132 { 0133 const int rowCount = proxyModel->rowCount(); 0134 0135 const QRect rect = _rect.normalized(); 0136 0137 // binary search to find out the top border 0138 int bottom = 0; 0139 int top = rowCount - 1; 0140 while (bottom <= top) { 0141 const int middle = (bottom + top) / 2; 0142 const QModelIndex index = proxyModel->index(middle, q->modelColumn(), q->rootIndex()); 0143 const QRect itemRect = q->visualRect(index); 0144 if (itemRect.bottomRight().y() <= rect.topLeft().y()) { 0145 bottom = middle + 1; 0146 } else { 0147 top = middle - 1; 0148 } 0149 } 0150 0151 const QModelIndex bottomIndex = proxyModel->index(bottom, q->modelColumn(), q->rootIndex()); 0152 0153 // binary search to find out the bottom border 0154 bottom = 0; 0155 top = rowCount - 1; 0156 while (bottom <= top) { 0157 const int middle = (bottom + top) / 2; 0158 const QModelIndex index = proxyModel->index(middle, q->modelColumn(), q->rootIndex()); 0159 const QRect itemRect = q->visualRect(index); 0160 if (itemRect.topLeft().y() <= rect.bottomRight().y()) { 0161 bottom = middle + 1; 0162 } else { 0163 top = middle - 1; 0164 } 0165 } 0166 0167 const QModelIndex topIndex = proxyModel->index(top, q->modelColumn(), q->rootIndex()); 0168 0169 return {bottomIndex, topIndex}; 0170 } 0171 0172 QPoint KCategorizedViewPrivate::blockPosition(const QString &category) 0173 { 0174 Block &block = blocks[category]; 0175 0176 if (block.outOfQuarantine && !block.topLeft.isNull()) { 0177 return block.topLeft; 0178 } 0179 0180 QPoint res(categorySpacing, 0); 0181 0182 const QModelIndex index = block.firstIndex; 0183 0184 for (auto it = blocks.begin(); it != blocks.end(); ++it) { 0185 Block &block = *it; 0186 const QModelIndex categoryIndex = block.firstIndex; 0187 if (index.row() < categoryIndex.row()) { 0188 continue; 0189 } 0190 0191 res.ry() += categoryDrawer->categoryHeight(categoryIndex, viewOpts()) + categorySpacing; 0192 if (index.row() == categoryIndex.row()) { 0193 continue; 0194 } 0195 res.ry() += blockHeight(it.key()); 0196 } 0197 0198 block.outOfQuarantine = true; 0199 block.topLeft = res; 0200 0201 return res; 0202 } 0203 0204 int KCategorizedViewPrivate::blockHeight(const QString &category) 0205 { 0206 Block &block = blocks[category]; 0207 0208 if (block.collapsed) { 0209 return 0; 0210 } 0211 0212 if (block.height > -1) { 0213 return block.height; 0214 } 0215 0216 const QModelIndex firstIndex = block.firstIndex; 0217 const QModelIndex lastIndex = proxyModel->index(firstIndex.row() + block.items.count() - 1, q->modelColumn(), q->rootIndex()); 0218 const QRect topLeft = q->visualRect(firstIndex); 0219 QRect bottomRight = q->visualRect(lastIndex); 0220 0221 if (hasGrid()) { 0222 bottomRight.setHeight(qMax(bottomRight.height(), q->gridSize().height())); 0223 } else { 0224 if (!q->uniformItemSizes()) { 0225 bottomRight.setHeight(highestElementInLastRow(block) + q->spacing() * 2); 0226 } 0227 } 0228 0229 const int height = bottomRight.bottomRight().y() - topLeft.topLeft().y() + 1; 0230 block.height = height; 0231 0232 return height; 0233 } 0234 0235 int KCategorizedViewPrivate::viewportWidth() const 0236 { 0237 return q->viewport()->width() - categorySpacing * 2 - categoryDrawer->leftMargin() - categoryDrawer->rightMargin(); 0238 } 0239 0240 void KCategorizedViewPrivate::regenerateAllElements() 0241 { 0242 for (QHash<QString, Block>::Iterator it = blocks.begin(); it != blocks.end(); ++it) { 0243 Block &block = *it; 0244 block.outOfQuarantine = false; 0245 block.quarantineStart = block.firstIndex; 0246 block.height = -1; 0247 } 0248 } 0249 0250 void KCategorizedViewPrivate::rowsInserted(const QModelIndex &parent, int start, int end) 0251 { 0252 if (!isCategorized()) { 0253 return; 0254 } 0255 0256 for (int i = start; i <= end; ++i) { 0257 const QModelIndex index = proxyModel->index(i, q->modelColumn(), parent); 0258 0259 Q_ASSERT(index.isValid()); 0260 0261 const QString category = categoryForIndex(index); 0262 0263 Block &block = blocks[category]; 0264 0265 // BEGIN: update firstIndex 0266 // save as firstIndex in block if 0267 // - it forced the category creation (first element on this category) 0268 // - it is before the first row on that category 0269 const QModelIndex firstIndex = block.firstIndex; 0270 if (!firstIndex.isValid() || index.row() < firstIndex.row()) { 0271 block.firstIndex = index; 0272 } 0273 // END: update firstIndex 0274 0275 Q_ASSERT(block.firstIndex.isValid()); 0276 0277 const int firstIndexRow = block.firstIndex.row(); 0278 0279 block.items.insert(index.row() - firstIndexRow, KCategorizedViewPrivate::Item()); 0280 block.height = -1; 0281 0282 q->visualRect(index); 0283 q->viewport()->update(); 0284 } 0285 0286 // BEGIN: update the items that are in quarantine in affected categories 0287 { 0288 const QModelIndex lastIndex = proxyModel->index(end, q->modelColumn(), parent); 0289 const QString category = categoryForIndex(lastIndex); 0290 KCategorizedViewPrivate::Block &block = blocks[category]; 0291 block.quarantineStart = block.firstIndex; 0292 } 0293 // END: update the items that are in quarantine in affected categories 0294 0295 // BEGIN: mark as in quarantine those categories that are under the affected ones 0296 { 0297 const QModelIndex firstIndex = proxyModel->index(start, q->modelColumn(), parent); 0298 const QString category = categoryForIndex(firstIndex); 0299 const QModelIndex firstAffectedCategory = blocks[category].firstIndex; 0300 // BEGIN: order for marking as alternate those blocks that are alternate 0301 QList<Block> blockList = blocks.values(); 0302 std::sort(blockList.begin(), blockList.end(), Block::lessThan); 0303 QList<int> firstIndexesRows; 0304 for (const Block &block : std::as_const(blockList)) { 0305 firstIndexesRows << block.firstIndex.row(); 0306 } 0307 // END: order for marking as alternate those blocks that are alternate 0308 for (auto it = blocks.begin(); it != blocks.end(); ++it) { 0309 KCategorizedViewPrivate::Block &block = *it; 0310 if (block.firstIndex.row() > firstAffectedCategory.row()) { 0311 block.outOfQuarantine = false; 0312 block.alternate = firstIndexesRows.indexOf(block.firstIndex.row()) % 2; 0313 } else if (block.firstIndex.row() == firstAffectedCategory.row()) { 0314 block.alternate = firstIndexesRows.indexOf(block.firstIndex.row()) % 2; 0315 } 0316 } 0317 } 0318 // END: mark as in quarantine those categories that are under the affected ones 0319 } 0320 0321 QRect KCategorizedViewPrivate::mapToViewport(const QRect &rect) const 0322 { 0323 const int dx = -q->horizontalOffset(); 0324 const int dy = -q->verticalOffset(); 0325 return rect.adjusted(dx, dy, dx, dy); 0326 } 0327 0328 QRect KCategorizedViewPrivate::mapFromViewport(const QRect &rect) const 0329 { 0330 const int dx = q->horizontalOffset(); 0331 const int dy = q->verticalOffset(); 0332 return rect.adjusted(dx, dy, dx, dy); 0333 } 0334 0335 int KCategorizedViewPrivate::highestElementInLastRow(const Block &block) const 0336 { 0337 // Find the highest element in the last row 0338 const QModelIndex lastIndex = proxyModel->index(block.firstIndex.row() + block.items.count() - 1, q->modelColumn(), q->rootIndex()); 0339 const QRect prevRect = q->visualRect(lastIndex); 0340 int res = prevRect.height(); 0341 QModelIndex prevIndex = proxyModel->index(lastIndex.row() - 1, q->modelColumn(), q->rootIndex()); 0342 if (!prevIndex.isValid()) { 0343 return res; 0344 } 0345 Q_FOREVER { 0346 const QRect tempRect = q->visualRect(prevIndex); 0347 if (tempRect.topLeft().y() < prevRect.topLeft().y()) { 0348 break; 0349 } 0350 res = qMax(res, tempRect.height()); 0351 if (prevIndex == block.firstIndex) { 0352 break; 0353 } 0354 prevIndex = proxyModel->index(prevIndex.row() - 1, q->modelColumn(), q->rootIndex()); 0355 } 0356 0357 return res; 0358 } 0359 0360 bool KCategorizedViewPrivate::hasGrid() const 0361 { 0362 const QSize gridSize = q->gridSize(); 0363 return gridSize.isValid() && !gridSize.isNull(); 0364 } 0365 0366 QString KCategorizedViewPrivate::categoryForIndex(const QModelIndex &index) const 0367 { 0368 const QModelIndex categoryIndex = index.model()->index(index.row(), proxyModel->sortColumn(), index.parent()); 0369 return categoryIndex.data(KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); 0370 } 0371 0372 void KCategorizedViewPrivate::leftToRightVisualRect(const QModelIndex &index, Item &item, const Block &block, const QPoint &blockPos) const 0373 { 0374 const int firstIndexRow = block.firstIndex.row(); 0375 0376 if (hasGrid()) { 0377 const int relativeRow = index.row() - firstIndexRow; 0378 const int maxItemsPerRow = qMax(viewportWidth() / q->gridSize().width(), 1); 0379 if (q->layoutDirection() == Qt::LeftToRight) { 0380 item.topLeft.rx() = (relativeRow % maxItemsPerRow) * q->gridSize().width() + blockPos.x() + categoryDrawer->leftMargin(); 0381 } else { 0382 item.topLeft.rx() = viewportWidth() - ((relativeRow % maxItemsPerRow) + 1) * q->gridSize().width() + categoryDrawer->leftMargin() + categorySpacing; 0383 } 0384 item.topLeft.ry() = (relativeRow / maxItemsPerRow) * q->gridSize().height(); 0385 } else { 0386 if (q->uniformItemSizes()) { 0387 const int relativeRow = index.row() - firstIndexRow; 0388 const QSize itemSize = q->sizeHintForIndex(index); 0389 const int maxItemsPerRow = qMax((viewportWidth() - q->spacing()) / (itemSize.width() + q->spacing()), 1); 0390 if (q->layoutDirection() == Qt::LeftToRight) { 0391 item.topLeft.rx() = (relativeRow % maxItemsPerRow) * itemSize.width() + blockPos.x() + categoryDrawer->leftMargin(); 0392 } else { 0393 item.topLeft.rx() = viewportWidth() - (relativeRow % maxItemsPerRow) * itemSize.width() + categoryDrawer->leftMargin() + categorySpacing; 0394 } 0395 item.topLeft.ry() = (relativeRow / maxItemsPerRow) * itemSize.height(); 0396 } else { 0397 const QSize currSize = q->sizeHintForIndex(index); 0398 if (index != block.firstIndex) { 0399 const int viewportW = viewportWidth() - q->spacing(); 0400 QModelIndex prevIndex = proxyModel->index(index.row() - 1, q->modelColumn(), q->rootIndex()); 0401 QRect prevRect = q->visualRect(prevIndex); 0402 prevRect = mapFromViewport(prevRect); 0403 if ((prevRect.bottomRight().x() + 1) + currSize.width() - blockPos.x() + q->spacing() > viewportW) { 0404 // we have to check the whole previous row, and see which one was the 0405 // highest. 0406 Q_FOREVER { 0407 prevIndex = proxyModel->index(prevIndex.row() - 1, q->modelColumn(), q->rootIndex()); 0408 const QRect tempRect = q->visualRect(prevIndex); 0409 if (tempRect.topLeft().y() < prevRect.topLeft().y()) { 0410 break; 0411 } 0412 if (tempRect.bottomRight().y() > prevRect.bottomRight().y()) { 0413 prevRect = tempRect; 0414 } 0415 if (prevIndex == block.firstIndex) { 0416 break; 0417 } 0418 } 0419 if (q->layoutDirection() == Qt::LeftToRight) { 0420 item.topLeft.rx() = categoryDrawer->leftMargin() + blockPos.x() + q->spacing(); 0421 } else { 0422 item.topLeft.rx() = viewportWidth() - currSize.width() + categoryDrawer->leftMargin() + categorySpacing; 0423 } 0424 item.topLeft.ry() = (prevRect.bottomRight().y() + 1) + q->spacing() - blockPos.y(); 0425 } else { 0426 if (q->layoutDirection() == Qt::LeftToRight) { 0427 item.topLeft.rx() = (prevRect.bottomRight().x() + 1) + q->spacing(); 0428 } else { 0429 item.topLeft.rx() = (prevRect.bottomLeft().x() - 1) - q->spacing() - item.size.width() + categoryDrawer->leftMargin() + categorySpacing; 0430 } 0431 item.topLeft.ry() = prevRect.topLeft().y() - blockPos.y(); 0432 } 0433 } else { 0434 if (q->layoutDirection() == Qt::LeftToRight) { 0435 item.topLeft.rx() = blockPos.x() + categoryDrawer->leftMargin() + q->spacing(); 0436 } else { 0437 item.topLeft.rx() = viewportWidth() - currSize.width() + categoryDrawer->leftMargin() + categorySpacing; 0438 } 0439 item.topLeft.ry() = q->spacing(); 0440 } 0441 } 0442 } 0443 item.size = q->sizeHintForIndex(index); 0444 } 0445 0446 void KCategorizedViewPrivate::topToBottomVisualRect(const QModelIndex &index, Item &item, const Block &block, const QPoint &blockPos) const 0447 { 0448 const int firstIndexRow = block.firstIndex.row(); 0449 0450 if (hasGrid()) { 0451 const int relativeRow = index.row() - firstIndexRow; 0452 item.topLeft.rx() = blockPos.x() + categoryDrawer->leftMargin(); 0453 item.topLeft.ry() = relativeRow * q->gridSize().height(); 0454 } else { 0455 if (q->uniformItemSizes()) { 0456 const int relativeRow = index.row() - firstIndexRow; 0457 const QSize itemSize = q->sizeHintForIndex(index); 0458 item.topLeft.rx() = blockPos.x() + categoryDrawer->leftMargin(); 0459 item.topLeft.ry() = relativeRow * itemSize.height(); 0460 } else { 0461 if (index != block.firstIndex) { 0462 QModelIndex prevIndex = proxyModel->index(index.row() - 1, q->modelColumn(), q->rootIndex()); 0463 QRect prevRect = q->visualRect(prevIndex); 0464 prevRect = mapFromViewport(prevRect); 0465 item.topLeft.rx() = blockPos.x() + categoryDrawer->leftMargin() + q->spacing(); 0466 item.topLeft.ry() = (prevRect.bottomRight().y() + 1) + q->spacing() - blockPos.y(); 0467 } else { 0468 item.topLeft.rx() = blockPos.x() + categoryDrawer->leftMargin() + q->spacing(); 0469 item.topLeft.ry() = q->spacing(); 0470 } 0471 } 0472 } 0473 item.size = q->sizeHintForIndex(index); 0474 item.size.setWidth(viewportWidth()); 0475 } 0476 0477 void KCategorizedViewPrivate::_k_slotCollapseOrExpandClicked(QModelIndex) 0478 { 0479 } 0480 0481 // END: Private part 0482 0483 // BEGIN: Public part 0484 0485 KCategorizedView::KCategorizedView(QWidget *parent) 0486 : QListView(parent) 0487 , d(new KCategorizedViewPrivate(this)) 0488 { 0489 } 0490 0491 KCategorizedView::~KCategorizedView() = default; 0492 0493 void KCategorizedView::setModel(QAbstractItemModel *model) 0494 { 0495 if (d->proxyModel == model) { 0496 return; 0497 } 0498 0499 d->blocks.clear(); 0500 0501 if (d->proxyModel) { 0502 disconnect(d->proxyModel, SIGNAL(layoutChanged()), this, SLOT(slotLayoutChanged())); 0503 } 0504 0505 d->proxyModel = dynamic_cast<KCategorizedSortFilterProxyModel *>(model); 0506 0507 if (d->proxyModel) { 0508 connect(d->proxyModel, SIGNAL(layoutChanged()), this, SLOT(slotLayoutChanged())); 0509 } 0510 0511 QListView::setModel(model); 0512 0513 // if the model already had information inserted, update our data structures to it 0514 if (model->rowCount()) { 0515 slotLayoutChanged(); 0516 } 0517 } 0518 0519 void KCategorizedView::setGridSize(const QSize &size) 0520 { 0521 setGridSizeOwn(size); 0522 } 0523 0524 void KCategorizedView::setGridSizeOwn(const QSize &size) 0525 { 0526 d->regenerateAllElements(); 0527 QListView::setGridSize(size); 0528 } 0529 0530 QRect KCategorizedView::visualRect(const QModelIndex &index) const 0531 { 0532 if (!d->isCategorized()) { 0533 return QListView::visualRect(index); 0534 } 0535 0536 if (!index.isValid()) { 0537 return QRect(); 0538 } 0539 0540 const QString category = d->categoryForIndex(index); 0541 0542 if (!d->blocks.contains(category)) { 0543 return QRect(); 0544 } 0545 0546 KCategorizedViewPrivate::Block &block = d->blocks[category]; 0547 const int firstIndexRow = block.firstIndex.row(); 0548 0549 Q_ASSERT(block.firstIndex.isValid()); 0550 0551 if (index.row() - firstIndexRow < 0 || index.row() - firstIndexRow >= block.items.count()) { 0552 return QRect(); 0553 } 0554 0555 const QPoint blockPos = d->blockPosition(category); 0556 0557 KCategorizedViewPrivate::Item &ritem = block.items[index.row() - firstIndexRow]; 0558 0559 if (ritem.topLeft.isNull() // 0560 || (block.quarantineStart.isValid() && index.row() >= block.quarantineStart.row())) { 0561 if (flow() == LeftToRight) { 0562 d->leftToRightVisualRect(index, ritem, block, blockPos); 0563 } else { 0564 d->topToBottomVisualRect(index, ritem, block, blockPos); 0565 } 0566 0567 // BEGIN: update the quarantine start 0568 const bool wasLastIndex = (index.row() == (block.firstIndex.row() + block.items.count() - 1)); 0569 if (index.row() == block.quarantineStart.row()) { 0570 if (wasLastIndex) { 0571 block.quarantineStart = QModelIndex(); 0572 } else { 0573 const QModelIndex nextIndex = d->proxyModel->index(index.row() + 1, modelColumn(), rootIndex()); 0574 block.quarantineStart = nextIndex; 0575 } 0576 } 0577 // END: update the quarantine start 0578 } 0579 0580 // we get now the absolute position through the relative position of the parent block. do not 0581 // save this on ritem, since this would override the item relative position in block terms. 0582 KCategorizedViewPrivate::Item item(ritem); 0583 item.topLeft.ry() += blockPos.y(); 0584 0585 const QSize sizeHint = item.size; 0586 0587 if (d->hasGrid()) { 0588 const QSize sizeGrid = gridSize(); 0589 const QSize resultingSize = sizeHint.boundedTo(sizeGrid); 0590 QRect res(item.topLeft.x() + ((sizeGrid.width() - resultingSize.width()) / 2), item.topLeft.y(), resultingSize.width(), resultingSize.height()); 0591 if (block.collapsed) { 0592 // we can still do binary search, while we "hide" items. We move those items in collapsed 0593 // blocks to the left and set a 0 height. 0594 res.setLeft(-resultingSize.width()); 0595 res.setHeight(0); 0596 } 0597 return d->mapToViewport(res); 0598 } 0599 0600 QRect res(item.topLeft.x(), item.topLeft.y(), sizeHint.width(), sizeHint.height()); 0601 if (block.collapsed) { 0602 // we can still do binary search, while we "hide" items. We move those items in collapsed 0603 // blocks to the left and set a 0 height. 0604 res.setLeft(-sizeHint.width()); 0605 res.setHeight(0); 0606 } 0607 return d->mapToViewport(res); 0608 } 0609 0610 KCategoryDrawer *KCategorizedView::categoryDrawer() const 0611 { 0612 return d->categoryDrawer; 0613 } 0614 0615 void KCategorizedView::setCategoryDrawer(KCategoryDrawer *categoryDrawer) 0616 { 0617 if (d->categoryDrawer) { 0618 disconnect(d->categoryDrawer, SIGNAL(collapseOrExpandClicked(QModelIndex)), this, SLOT(_k_slotCollapseOrExpandClicked(QModelIndex))); 0619 } 0620 0621 d->categoryDrawer = categoryDrawer; 0622 0623 connect(d->categoryDrawer, SIGNAL(collapseOrExpandClicked(QModelIndex)), this, SLOT(_k_slotCollapseOrExpandClicked(QModelIndex))); 0624 } 0625 0626 int KCategorizedView::categorySpacing() const 0627 { 0628 return d->categorySpacing; 0629 } 0630 0631 void KCategorizedView::setCategorySpacing(int categorySpacing) 0632 { 0633 if (d->categorySpacing == categorySpacing) { 0634 return; 0635 } 0636 0637 d->categorySpacing = categorySpacing; 0638 0639 for (auto it = d->blocks.begin(); it != d->blocks.end(); ++it) { 0640 KCategorizedViewPrivate::Block &block = *it; 0641 block.outOfQuarantine = false; 0642 } 0643 } 0644 0645 bool KCategorizedView::alternatingBlockColors() const 0646 { 0647 return d->alternatingBlockColors; 0648 } 0649 0650 void KCategorizedView::setAlternatingBlockColors(bool enable) 0651 { 0652 d->alternatingBlockColors = enable; 0653 } 0654 0655 bool KCategorizedView::collapsibleBlocks() const 0656 { 0657 return d->collapsibleBlocks; 0658 } 0659 0660 void KCategorizedView::setCollapsibleBlocks(bool enable) 0661 { 0662 d->collapsibleBlocks = enable; 0663 } 0664 0665 QModelIndexList KCategorizedView::block(const QString &category) 0666 { 0667 QModelIndexList res; 0668 const KCategorizedViewPrivate::Block &block = d->blocks[category]; 0669 if (block.height == -1) { 0670 return res; 0671 } 0672 QModelIndex current = block.firstIndex; 0673 const int first = current.row(); 0674 for (int i = 1; i <= block.items.count(); ++i) { 0675 if (current.isValid()) { 0676 res << current; 0677 } 0678 current = d->proxyModel->index(first + i, modelColumn(), rootIndex()); 0679 } 0680 return res; 0681 } 0682 0683 QModelIndexList KCategorizedView::block(const QModelIndex &representative) 0684 { 0685 return block(representative.data(KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString()); 0686 } 0687 0688 QModelIndex KCategorizedView::indexAt(const QPoint &point) const 0689 { 0690 if (!d->isCategorized()) { 0691 return QListView::indexAt(point); 0692 } 0693 0694 const int rowCount = d->proxyModel->rowCount(); 0695 if (!rowCount) { 0696 return QModelIndex(); 0697 } 0698 0699 // Binary search that will try to spot if there is an index under point 0700 int bottom = 0; 0701 int top = rowCount - 1; 0702 while (bottom <= top) { 0703 const int middle = (bottom + top) / 2; 0704 const QModelIndex index = d->proxyModel->index(middle, modelColumn(), rootIndex()); 0705 const QRect rect = visualRect(index); 0706 if (rect.contains(point)) { 0707 if (index.model()->flags(index) & Qt::ItemIsEnabled) { 0708 return index; 0709 } 0710 return QModelIndex(); 0711 } 0712 bool directionCondition; 0713 if (layoutDirection() == Qt::LeftToRight) { 0714 directionCondition = point.x() >= rect.bottomLeft().x(); 0715 } else { 0716 directionCondition = point.x() <= rect.bottomRight().x(); 0717 } 0718 if (point.y() < rect.topLeft().y()) { 0719 top = middle - 1; 0720 } else if (directionCondition) { 0721 bottom = middle + 1; 0722 } else if (point.y() <= rect.bottomRight().y()) { 0723 top = middle - 1; 0724 } else { 0725 bool after = true; 0726 for (int i = middle - 1; i >= bottom; i--) { 0727 const QModelIndex newIndex = d->proxyModel->index(i, modelColumn(), rootIndex()); 0728 const QRect newRect = visualRect(newIndex); 0729 if (newRect.topLeft().y() < rect.topLeft().y()) { 0730 break; 0731 } else if (newRect.contains(point)) { 0732 if (newIndex.model()->flags(newIndex) & Qt::ItemIsEnabled) { 0733 return newIndex; 0734 } 0735 return QModelIndex(); 0736 // clang-format off 0737 } else if ((layoutDirection() == Qt::LeftToRight) ? 0738 (newRect.topLeft().x() <= point.x()) : 0739 (newRect.topRight().x() >= point.x())) { 0740 // clang-format on 0741 break; 0742 } else if (newRect.bottomRight().y() >= point.y()) { 0743 after = false; 0744 } 0745 } 0746 if (!after) { 0747 return QModelIndex(); 0748 } 0749 bottom = middle + 1; 0750 } 0751 } 0752 return QModelIndex(); 0753 } 0754 0755 void KCategorizedView::reset() 0756 { 0757 d->blocks.clear(); 0758 QListView::reset(); 0759 } 0760 0761 void KCategorizedView::paintEvent(QPaintEvent *event) 0762 { 0763 if (!d->isCategorized()) { 0764 QListView::paintEvent(event); 0765 return; 0766 } 0767 0768 const std::pair<QModelIndex, QModelIndex> intersecting = d->intersectingIndexesWithRect(viewport()->rect().intersected(event->rect())); 0769 0770 QPainter p(viewport()); 0771 p.save(); 0772 0773 Q_ASSERT(selectionModel()->model() == d->proxyModel); 0774 0775 // BEGIN: draw categories 0776 auto it = d->blocks.constBegin(); 0777 while (it != d->blocks.constEnd()) { 0778 const KCategorizedViewPrivate::Block &block = *it; 0779 const QModelIndex categoryIndex = d->proxyModel->index(block.firstIndex.row(), d->proxyModel->sortColumn(), rootIndex()); 0780 0781 QStyleOptionViewItem option = d->viewOpts(); 0782 option.features |= d->alternatingBlockColors && block.alternate // 0783 ? QStyleOptionViewItem::Alternate 0784 : QStyleOptionViewItem::None; 0785 option.state |= !d->collapsibleBlocks || !block.collapsed // 0786 ? QStyle::State_Open 0787 : QStyle::State_None; 0788 const int height = d->categoryDrawer->categoryHeight(categoryIndex, option); 0789 QPoint pos = d->blockPosition(it.key()); 0790 pos.ry() -= height; 0791 option.rect.setTopLeft(pos); 0792 option.rect.setWidth(d->viewportWidth() + d->categoryDrawer->leftMargin() + d->categoryDrawer->rightMargin()); 0793 option.rect.setHeight(height + d->blockHeight(it.key())); 0794 option.rect = d->mapToViewport(option.rect); 0795 if (!option.rect.intersects(viewport()->rect())) { 0796 ++it; 0797 continue; 0798 } 0799 d->categoryDrawer->drawCategory(categoryIndex, d->proxyModel->sortRole(), option, &p); 0800 ++it; 0801 } 0802 // END: draw categories 0803 0804 if (intersecting.first.isValid() && intersecting.second.isValid()) { 0805 // BEGIN: draw items 0806 int i = intersecting.first.row(); 0807 int indexToCheckIfBlockCollapsed = i; 0808 QModelIndex categoryIndex; 0809 QString category; 0810 KCategorizedViewPrivate::Block *block = nullptr; 0811 while (i <= intersecting.second.row()) { 0812 // BEGIN: first check if the block is collapsed. if so, we have to skip the item painting 0813 if (i == indexToCheckIfBlockCollapsed) { 0814 categoryIndex = d->proxyModel->index(i, d->proxyModel->sortColumn(), rootIndex()); 0815 category = categoryIndex.data(KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); 0816 block = &d->blocks[category]; 0817 indexToCheckIfBlockCollapsed = block->firstIndex.row() + block->items.count(); 0818 if (block->collapsed) { 0819 i = indexToCheckIfBlockCollapsed; 0820 continue; 0821 } 0822 } 0823 // END: first check if the block is collapsed. if so, we have to skip the item painting 0824 0825 Q_ASSERT(block); 0826 0827 const bool alternateItem = (i - block->firstIndex.row()) % 2; 0828 0829 const QModelIndex index = d->proxyModel->index(i, modelColumn(), rootIndex()); 0830 const Qt::ItemFlags flags = d->proxyModel->flags(index); 0831 QStyleOptionViewItem option(d->viewOpts()); 0832 option.rect = visualRect(index); 0833 option.widget = this; 0834 option.features |= wordWrap() ? QStyleOptionViewItem::WrapText : QStyleOptionViewItem::None; 0835 option.features |= alternatingRowColors() && alternateItem ? QStyleOptionViewItem::Alternate : QStyleOptionViewItem::None; 0836 if (flags & Qt::ItemIsSelectable) { 0837 option.state |= selectionModel()->isSelected(index) ? QStyle::State_Selected : QStyle::State_None; 0838 } else { 0839 option.state &= ~QStyle::State_Selected; 0840 } 0841 option.state |= (index == currentIndex()) ? QStyle::State_HasFocus : QStyle::State_None; 0842 if (!(flags & Qt::ItemIsEnabled)) { 0843 option.state &= ~QStyle::State_Enabled; 0844 } else { 0845 option.state |= (index == d->hoveredIndex) ? QStyle::State_MouseOver : QStyle::State_None; 0846 } 0847 0848 itemDelegate(index)->paint(&p, option, index); 0849 ++i; 0850 } 0851 // END: draw items 0852 } 0853 0854 // BEGIN: draw selection rect 0855 if (isSelectionRectVisible() && d->rubberBandRect.isValid()) { 0856 QStyleOptionRubberBand opt; 0857 opt.initFrom(this); 0858 opt.shape = QRubberBand::Rectangle; 0859 opt.opaque = false; 0860 opt.rect = d->mapToViewport(d->rubberBandRect).intersected(viewport()->rect().adjusted(-16, -16, 16, 16)); 0861 p.save(); 0862 style()->drawControl(QStyle::CE_RubberBand, &opt, &p); 0863 p.restore(); 0864 } 0865 // END: draw selection rect 0866 0867 p.restore(); 0868 } 0869 0870 void KCategorizedView::resizeEvent(QResizeEvent *event) 0871 { 0872 d->regenerateAllElements(); 0873 QListView::resizeEvent(event); 0874 } 0875 0876 void KCategorizedView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags flags) 0877 { 0878 if (!d->isCategorized()) { 0879 QListView::setSelection(rect, flags); 0880 return; 0881 } 0882 0883 if (rect.topLeft() == rect.bottomRight()) { 0884 const QModelIndex index = indexAt(rect.topLeft()); 0885 selectionModel()->select(index, flags); 0886 return; 0887 } 0888 0889 const std::pair<QModelIndex, QModelIndex> intersecting = d->intersectingIndexesWithRect(rect); 0890 0891 QItemSelection selection; 0892 0893 // TODO: think of a faster implementation 0894 QModelIndex firstIndex; 0895 QModelIndex lastIndex; 0896 for (int i = intersecting.first.row(); i <= intersecting.second.row(); ++i) { 0897 const QModelIndex index = d->proxyModel->index(i, modelColumn(), rootIndex()); 0898 const bool visualRectIntersects = visualRect(index).intersects(rect); 0899 if (firstIndex.isValid()) { 0900 if (visualRectIntersects) { 0901 lastIndex = index; 0902 } else { 0903 selection << QItemSelectionRange(firstIndex, lastIndex); 0904 firstIndex = QModelIndex(); 0905 } 0906 } else if (visualRectIntersects) { 0907 firstIndex = index; 0908 lastIndex = index; 0909 } 0910 } 0911 0912 if (firstIndex.isValid()) { 0913 selection << QItemSelectionRange(firstIndex, lastIndex); 0914 } 0915 0916 selectionModel()->select(selection, flags); 0917 } 0918 0919 void KCategorizedView::mouseMoveEvent(QMouseEvent *event) 0920 { 0921 QListView::mouseMoveEvent(event); 0922 d->hoveredIndex = indexAt(event->pos()); 0923 const SelectionMode itemViewSelectionMode = selectionMode(); 0924 if (state() == DragSelectingState // 0925 && isSelectionRectVisible() // 0926 && itemViewSelectionMode != SingleSelection // 0927 && itemViewSelectionMode != NoSelection) { 0928 QRect rect(d->pressedPosition, event->pos() + QPoint(horizontalOffset(), verticalOffset())); 0929 rect = rect.normalized(); 0930 update(rect.united(d->rubberBandRect)); 0931 d->rubberBandRect = rect; 0932 } 0933 if (!d->categoryDrawer) { 0934 return; 0935 } 0936 auto it = d->blocks.constBegin(); 0937 while (it != d->blocks.constEnd()) { 0938 const KCategorizedViewPrivate::Block &block = *it; 0939 const QModelIndex categoryIndex = d->proxyModel->index(block.firstIndex.row(), d->proxyModel->sortColumn(), rootIndex()); 0940 QStyleOptionViewItem option(d->viewOpts()); 0941 const int height = d->categoryDrawer->categoryHeight(categoryIndex, option); 0942 QPoint pos = d->blockPosition(it.key()); 0943 pos.ry() -= height; 0944 option.rect.setTopLeft(pos); 0945 option.rect.setWidth(d->viewportWidth() + d->categoryDrawer->leftMargin() + d->categoryDrawer->rightMargin()); 0946 option.rect.setHeight(height + d->blockHeight(it.key())); 0947 option.rect = d->mapToViewport(option.rect); 0948 const QPoint mousePos = viewport()->mapFromGlobal(QCursor::pos()); 0949 if (option.rect.contains(mousePos)) { 0950 if (d->hoveredBlock->height != -1 && *d->hoveredBlock != block) { 0951 const QModelIndex categoryIndex = d->proxyModel->index(d->hoveredBlock->firstIndex.row(), d->proxyModel->sortColumn(), rootIndex()); 0952 const QStyleOptionViewItem option = d->blockRect(categoryIndex); 0953 d->categoryDrawer->mouseLeft(categoryIndex, option.rect); 0954 *d->hoveredBlock = block; 0955 d->hoveredCategory = it.key(); 0956 viewport()->update(option.rect); 0957 } else if (d->hoveredBlock->height == -1) { 0958 *d->hoveredBlock = block; 0959 d->hoveredCategory = it.key(); 0960 } else { 0961 d->categoryDrawer->mouseMoved(categoryIndex, option.rect, event); 0962 } 0963 viewport()->update(option.rect); 0964 return; 0965 } 0966 ++it; 0967 } 0968 if (d->hoveredBlock->height != -1) { 0969 const QModelIndex categoryIndex = d->proxyModel->index(d->hoveredBlock->firstIndex.row(), d->proxyModel->sortColumn(), rootIndex()); 0970 const QStyleOptionViewItem option = d->blockRect(categoryIndex); 0971 d->categoryDrawer->mouseLeft(categoryIndex, option.rect); 0972 *d->hoveredBlock = KCategorizedViewPrivate::Block(); 0973 d->hoveredCategory = QString(); 0974 viewport()->update(option.rect); 0975 } 0976 } 0977 0978 void KCategorizedView::mousePressEvent(QMouseEvent *event) 0979 { 0980 if (event->button() == Qt::LeftButton) { 0981 d->pressedPosition = event->pos(); 0982 d->pressedPosition.rx() += horizontalOffset(); 0983 d->pressedPosition.ry() += verticalOffset(); 0984 } 0985 if (!d->categoryDrawer) { 0986 QListView::mousePressEvent(event); 0987 return; 0988 } 0989 auto it = d->blocks.constBegin(); 0990 while (it != d->blocks.constEnd()) { 0991 const KCategorizedViewPrivate::Block &block = *it; 0992 const QModelIndex categoryIndex = d->proxyModel->index(block.firstIndex.row(), d->proxyModel->sortColumn(), rootIndex()); 0993 const QStyleOptionViewItem option = d->blockRect(categoryIndex); 0994 const QPoint mousePos = viewport()->mapFromGlobal(QCursor::pos()); 0995 if (option.rect.contains(mousePos)) { 0996 d->categoryDrawer->mouseButtonPressed(categoryIndex, option.rect, event); 0997 viewport()->update(option.rect); 0998 if (!event->isAccepted()) { 0999 QListView::mousePressEvent(event); 1000 } 1001 return; 1002 } 1003 ++it; 1004 } 1005 QListView::mousePressEvent(event); 1006 } 1007 1008 void KCategorizedView::mouseReleaseEvent(QMouseEvent *event) 1009 { 1010 d->pressedPosition = QPoint(); 1011 d->rubberBandRect = QRect(); 1012 if (!d->categoryDrawer) { 1013 QListView::mouseReleaseEvent(event); 1014 return; 1015 } 1016 auto it = d->blocks.constBegin(); 1017 while (it != d->blocks.constEnd()) { 1018 const KCategorizedViewPrivate::Block &block = *it; 1019 const QModelIndex categoryIndex = d->proxyModel->index(block.firstIndex.row(), d->proxyModel->sortColumn(), rootIndex()); 1020 const QStyleOptionViewItem option = d->blockRect(categoryIndex); 1021 const QPoint mousePos = viewport()->mapFromGlobal(QCursor::pos()); 1022 if (option.rect.contains(mousePos)) { 1023 d->categoryDrawer->mouseButtonReleased(categoryIndex, option.rect, event); 1024 viewport()->update(option.rect); 1025 if (!event->isAccepted()) { 1026 QListView::mouseReleaseEvent(event); 1027 } 1028 return; 1029 } 1030 ++it; 1031 } 1032 QListView::mouseReleaseEvent(event); 1033 } 1034 1035 void KCategorizedView::leaveEvent(QEvent *event) 1036 { 1037 QListView::leaveEvent(event); 1038 if (d->hoveredIndex.isValid()) { 1039 viewport()->update(visualRect(d->hoveredIndex)); 1040 d->hoveredIndex = QModelIndex(); 1041 } 1042 if (d->categoryDrawer && d->hoveredBlock->height != -1) { 1043 const QModelIndex categoryIndex = d->proxyModel->index(d->hoveredBlock->firstIndex.row(), d->proxyModel->sortColumn(), rootIndex()); 1044 const QStyleOptionViewItem option = d->blockRect(categoryIndex); 1045 d->categoryDrawer->mouseLeft(categoryIndex, option.rect); 1046 *d->hoveredBlock = KCategorizedViewPrivate::Block(); 1047 d->hoveredCategory = QString(); 1048 viewport()->update(option.rect); 1049 } 1050 } 1051 1052 void KCategorizedView::startDrag(Qt::DropActions supportedActions) 1053 { 1054 QListView::startDrag(supportedActions); 1055 } 1056 1057 void KCategorizedView::dragMoveEvent(QDragMoveEvent *event) 1058 { 1059 QListView::dragMoveEvent(event); 1060 d->hoveredIndex = indexAt(event->pos()); 1061 } 1062 1063 void KCategorizedView::dragEnterEvent(QDragEnterEvent *event) 1064 { 1065 QListView::dragEnterEvent(event); 1066 } 1067 1068 void KCategorizedView::dragLeaveEvent(QDragLeaveEvent *event) 1069 { 1070 QListView::dragLeaveEvent(event); 1071 } 1072 1073 void KCategorizedView::dropEvent(QDropEvent *event) 1074 { 1075 QListView::dropEvent(event); 1076 } 1077 1078 // TODO: improve se we take into account collapsed blocks 1079 // TODO: take into account when there is no grid and no uniformItemSizes 1080 QModelIndex KCategorizedView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers) 1081 { 1082 if (!d->isCategorized() || viewMode() == QListView::ListMode) { 1083 return QListView::moveCursor(cursorAction, modifiers); 1084 } 1085 1086 const QModelIndex current = currentIndex(); 1087 const QRect currentRect = visualRect(current); 1088 if (!current.isValid()) { 1089 const int rowCount = d->proxyModel->rowCount(rootIndex()); 1090 if (!rowCount) { 1091 return QModelIndex(); 1092 } 1093 return d->proxyModel->index(0, modelColumn(), rootIndex()); 1094 } 1095 1096 switch (cursorAction) { 1097 case MoveLeft: { 1098 if (!current.row()) { 1099 return QModelIndex(); 1100 } 1101 const QModelIndex previous = d->proxyModel->index(current.row() - 1, modelColumn(), rootIndex()); 1102 const QRect previousRect = visualRect(previous); 1103 if (previousRect.top() == currentRect.top()) { 1104 return previous; 1105 } 1106 1107 return QModelIndex(); 1108 } 1109 case MoveRight: { 1110 if (current.row() == d->proxyModel->rowCount() - 1) { 1111 return QModelIndex(); 1112 } 1113 const QModelIndex next = d->proxyModel->index(current.row() + 1, modelColumn(), rootIndex()); 1114 const QRect nextRect = visualRect(next); 1115 if (nextRect.top() == currentRect.top()) { 1116 return next; 1117 } 1118 1119 return QModelIndex(); 1120 } 1121 case MoveDown: { 1122 if (d->hasGrid() || uniformItemSizes()) { 1123 const QModelIndex current = currentIndex(); 1124 const QSize itemSize = d->hasGrid() ? gridSize() : sizeHintForIndex(current); 1125 const KCategorizedViewPrivate::Block &block = d->blocks[d->categoryForIndex(current)]; 1126 const int maxItemsPerRow = qMax(d->viewportWidth() / itemSize.width(), 1); 1127 const bool canMove = current.row() + maxItemsPerRow < block.firstIndex.row() + block.items.count(); 1128 1129 if (canMove) { 1130 return d->proxyModel->index(current.row() + maxItemsPerRow, modelColumn(), rootIndex()); 1131 } 1132 1133 const int currentRelativePos = (current.row() - block.firstIndex.row()) % maxItemsPerRow; 1134 const QModelIndex nextIndex = d->proxyModel->index(block.firstIndex.row() + block.items.count(), modelColumn(), rootIndex()); 1135 1136 if (!nextIndex.isValid()) { 1137 return QModelIndex(); 1138 } 1139 1140 const KCategorizedViewPrivate::Block &nextBlock = d->blocks[d->categoryForIndex(nextIndex)]; 1141 1142 if (nextBlock.items.count() <= currentRelativePos) { 1143 return QModelIndex(); 1144 } 1145 1146 if (currentRelativePos < (block.items.count() % maxItemsPerRow)) { 1147 return d->proxyModel->index(nextBlock.firstIndex.row() + currentRelativePos, modelColumn(), rootIndex()); 1148 } 1149 } 1150 return QModelIndex(); 1151 } 1152 case MoveUp: { 1153 if (d->hasGrid() || uniformItemSizes()) { 1154 const QModelIndex current = currentIndex(); 1155 const QSize itemSize = d->hasGrid() ? gridSize() : sizeHintForIndex(current); 1156 const KCategorizedViewPrivate::Block &block = d->blocks[d->categoryForIndex(current)]; 1157 const int maxItemsPerRow = qMax(d->viewportWidth() / itemSize.width(), 1); 1158 const bool canMove = current.row() - maxItemsPerRow >= block.firstIndex.row(); 1159 1160 if (canMove) { 1161 return d->proxyModel->index(current.row() - maxItemsPerRow, modelColumn(), rootIndex()); 1162 } 1163 1164 const int currentRelativePos = (current.row() - block.firstIndex.row()) % maxItemsPerRow; 1165 const QModelIndex prevIndex = d->proxyModel->index(block.firstIndex.row() - 1, modelColumn(), rootIndex()); 1166 1167 if (!prevIndex.isValid()) { 1168 return QModelIndex(); 1169 } 1170 1171 const KCategorizedViewPrivate::Block &prevBlock = d->blocks[d->categoryForIndex(prevIndex)]; 1172 1173 if (prevBlock.items.count() <= currentRelativePos) { 1174 return QModelIndex(); 1175 } 1176 1177 const int remainder = prevBlock.items.count() % maxItemsPerRow; 1178 if (currentRelativePos < remainder) { 1179 return d->proxyModel->index(prevBlock.firstIndex.row() + prevBlock.items.count() - remainder + currentRelativePos, modelColumn(), rootIndex()); 1180 } 1181 1182 return QModelIndex(); 1183 } 1184 break; 1185 } 1186 default: 1187 break; 1188 } 1189 1190 return QModelIndex(); 1191 } 1192 1193 void KCategorizedView::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end) 1194 { 1195 if (!d->isCategorized()) { 1196 QListView::rowsAboutToBeRemoved(parent, start, end); 1197 return; 1198 } 1199 1200 *d->hoveredBlock = KCategorizedViewPrivate::Block(); 1201 d->hoveredCategory = QString(); 1202 1203 if (end - start + 1 == d->proxyModel->rowCount()) { 1204 d->blocks.clear(); 1205 QListView::rowsAboutToBeRemoved(parent, start, end); 1206 return; 1207 } 1208 1209 // Removal feels a bit more complicated than insertion. Basically we can consider there are 1210 // 3 different cases when going to remove items. (*) represents an item, Items between ([) and 1211 // (]) are the ones which are marked for removal. 1212 // 1213 // - 1st case: 1214 // ... * * * * * * [ * * * ... 1215 // 1216 // The items marked for removal are the last part of this category. No need to mark any item 1217 // of this category as in quarantine, because no special offset will be pushed to items at 1218 // the right because of any changes (since the removed items are those on the right most part 1219 // of the category). 1220 // 1221 // - 2nd case: 1222 // ... * * * * * * ] * * * ... 1223 // 1224 // The items marked for removal are the first part of this category. We have to mark as in 1225 // quarantine all items in this category. Absolutely all. All items will have to be moved to 1226 // the left (or moving up, because rows got a different offset). 1227 // 1228 // - 3rd case: 1229 // ... * * [ * * * * ] * * ... 1230 // 1231 // The items marked for removal are in between of this category. We have to mark as in 1232 // quarantine only those items that are at the right of the end of the removal interval, 1233 // (starting on "]"). 1234 // 1235 // It hasn't been explicitly said, but when we remove, we have to mark all blocks that are 1236 // located under the top most affected category as in quarantine (the block itself, as a whole), 1237 // because such a change can force it to have a different offset (note that items themselves 1238 // contain relative positions to the block, so marking the block as in quarantine is enough). 1239 // 1240 // Also note that removal implicitly means that we have to update correctly firstIndex of each 1241 // block, and in general keep updated the internal information of elements. 1242 1243 QStringList listOfCategoriesMarkedForRemoval; 1244 1245 QString lastCategory; 1246 int alreadyRemoved = 0; 1247 for (int i = start; i <= end; ++i) { 1248 const QModelIndex index = d->proxyModel->index(i, modelColumn(), parent); 1249 1250 Q_ASSERT(index.isValid()); 1251 1252 const QString category = d->categoryForIndex(index); 1253 1254 if (lastCategory != category) { 1255 lastCategory = category; 1256 alreadyRemoved = 0; 1257 } 1258 1259 KCategorizedViewPrivate::Block &block = d->blocks[category]; 1260 block.items.removeAt(i - block.firstIndex.row() - alreadyRemoved); 1261 ++alreadyRemoved; 1262 1263 if (block.items.isEmpty()) { 1264 listOfCategoriesMarkedForRemoval << category; 1265 } 1266 1267 block.height = -1; 1268 1269 viewport()->update(); 1270 } 1271 1272 // BEGIN: update the items that are in quarantine in affected categories 1273 { 1274 const QModelIndex lastIndex = d->proxyModel->index(end, modelColumn(), parent); 1275 const QString category = d->categoryForIndex(lastIndex); 1276 KCategorizedViewPrivate::Block &block = d->blocks[category]; 1277 if (!block.items.isEmpty() && start <= block.firstIndex.row() && end >= block.firstIndex.row()) { 1278 block.firstIndex = d->proxyModel->index(end + 1, modelColumn(), parent); 1279 } 1280 block.quarantineStart = block.firstIndex; 1281 } 1282 // END: update the items that are in quarantine in affected categories 1283 1284 for (const QString &category : std::as_const(listOfCategoriesMarkedForRemoval)) { 1285 d->blocks.remove(category); 1286 } 1287 1288 // BEGIN: mark as in quarantine those categories that are under the affected ones 1289 { 1290 // BEGIN: order for marking as alternate those blocks that are alternate 1291 QList<KCategorizedViewPrivate::Block> blockList = d->blocks.values(); 1292 std::sort(blockList.begin(), blockList.end(), KCategorizedViewPrivate::Block::lessThan); 1293 QList<int> firstIndexesRows; 1294 for (const KCategorizedViewPrivate::Block &block : std::as_const(blockList)) { 1295 firstIndexesRows << block.firstIndex.row(); 1296 } 1297 // END: order for marking as alternate those blocks that are alternate 1298 for (auto it = d->blocks.begin(); it != d->blocks.end(); ++it) { 1299 KCategorizedViewPrivate::Block &block = *it; 1300 if (block.firstIndex.row() > start) { 1301 block.outOfQuarantine = false; 1302 block.alternate = firstIndexesRows.indexOf(block.firstIndex.row()) % 2; 1303 } else if (block.firstIndex.row() == start) { 1304 block.alternate = firstIndexesRows.indexOf(block.firstIndex.row()) % 2; 1305 } 1306 } 1307 } 1308 // END: mark as in quarantine those categories that are under the affected ones 1309 1310 QListView::rowsAboutToBeRemoved(parent, start, end); 1311 } 1312 1313 void KCategorizedView::updateGeometries() 1314 { 1315 const int oldVerticalOffset = verticalOffset(); 1316 const Qt::ScrollBarPolicy verticalP = verticalScrollBarPolicy(); 1317 const Qt::ScrollBarPolicy horizontalP = horizontalScrollBarPolicy(); 1318 1319 // BEGIN bugs 213068, 287847 ------------------------------------------------------------ 1320 /* 1321 * QListView::updateGeometries() has it's own opinion on whether the scrollbars should be visible (valid range) or not 1322 * and triggers a (sometimes additionally timered) resize through ::layoutChildren() 1323 * http://qt.gitorious.org/qt/qt/blobs/4.7/src/gui/itemviews/qlistview.cpp#line1499 1324 * (the comment above the main block isn't all accurate, layoutChldren is called regardless of the policy) 1325 * 1326 * As a result QListView and KCategorizedView occasionally started a race on the scrollbar visibility, effectively blocking the UI 1327 * So we prevent QListView from having an own opinion on the scrollbar visibility by 1328 * fixing it before calling the baseclass QListView::updateGeometries() 1329 * 1330 * Since the implicit show/hide by the following range setting will cause further resizes if the policy is Qt::ScrollBarAsNeeded 1331 * we keep it static until we're done, then restore the original value and ultimately change the scrollbar visibility ourself. 1332 */ 1333 if (d->isCategorized()) { // important! - otherwise we'd pollute the setting if the view is initially not categorized 1334 setVerticalScrollBarPolicy((verticalP == Qt::ScrollBarAlwaysOn || verticalScrollBar()->isVisibleTo(this)) ? Qt::ScrollBarAlwaysOn 1335 : Qt::ScrollBarAlwaysOff); 1336 setHorizontalScrollBarPolicy((horizontalP == Qt::ScrollBarAlwaysOn || horizontalScrollBar()->isVisibleTo(this)) ? Qt::ScrollBarAlwaysOn 1337 : Qt::ScrollBarAlwaysOff); 1338 } 1339 // END bugs 213068, 287847 -------------------------------------------------------------- 1340 1341 QListView::updateGeometries(); 1342 1343 if (!d->isCategorized()) { 1344 return; 1345 } 1346 1347 const int rowCount = d->proxyModel->rowCount(); 1348 if (!rowCount) { 1349 verticalScrollBar()->setRange(0, 0); 1350 // unconditional, see function end todo 1351 // BEGIN bugs 213068, 287847 ------------------------------------------------------------ 1352 // restoring values from above ... 1353 horizontalScrollBar()->setRange(0, 0); 1354 setVerticalScrollBarPolicy(verticalP); 1355 setHorizontalScrollBarPolicy(horizontalP); 1356 // END bugs 213068, 287847 -------------------------------------------------------------- 1357 return; 1358 } 1359 1360 const QModelIndex lastIndex = d->proxyModel->index(rowCount - 1, modelColumn(), rootIndex()); 1361 Q_ASSERT(lastIndex.isValid()); 1362 QRect lastItemRect = visualRect(lastIndex); 1363 1364 if (d->hasGrid()) { 1365 lastItemRect.setSize(lastItemRect.size().expandedTo(gridSize())); 1366 } else { 1367 if (uniformItemSizes()) { 1368 QSize itemSize = sizeHintForIndex(lastIndex); 1369 itemSize.setHeight(itemSize.height() + spacing()); 1370 lastItemRect.setSize(itemSize); 1371 } else { 1372 QSize itemSize = sizeHintForIndex(lastIndex); 1373 const QString category = d->categoryForIndex(lastIndex); 1374 itemSize.setHeight(d->highestElementInLastRow(d->blocks[category]) + spacing()); 1375 lastItemRect.setSize(itemSize); 1376 } 1377 } 1378 1379 const int bottomRange = lastItemRect.bottomRight().y() + verticalOffset() - viewport()->height(); 1380 1381 if (verticalScrollMode() == ScrollPerItem) { 1382 verticalScrollBar()->setSingleStep(lastItemRect.height()); 1383 const int rowsPerPage = qMax(viewport()->height() / lastItemRect.height(), 1); 1384 verticalScrollBar()->setPageStep(rowsPerPage * lastItemRect.height()); 1385 } 1386 1387 verticalScrollBar()->setRange(0, bottomRange); 1388 verticalScrollBar()->setValue(oldVerticalOffset); 1389 1390 // TODO: also consider working with the horizontal scroll bar. since at this level I am not still 1391 // supporting "top to bottom" flow, there is no real problem. If I support that someday 1392 // (think how to draw categories), we would have to take care of the horizontal scroll bar too. 1393 // In theory, as KCategorizedView has been designed, there is no need of horizontal scroll bar. 1394 horizontalScrollBar()->setRange(0, 0); 1395 1396 // BEGIN bugs 213068, 287847 ------------------------------------------------------------ 1397 // restoring values from above ... 1398 setVerticalScrollBarPolicy(verticalP); 1399 setHorizontalScrollBarPolicy(horizontalP); 1400 // ... and correct the visibility 1401 bool validRange = verticalScrollBar()->maximum() != verticalScrollBar()->minimum(); 1402 if (verticalP == Qt::ScrollBarAsNeeded && (verticalScrollBar()->isVisibleTo(this) != validRange)) { 1403 verticalScrollBar()->setVisible(validRange); 1404 } 1405 validRange = horizontalScrollBar()->maximum() > horizontalScrollBar()->minimum(); 1406 if (horizontalP == Qt::ScrollBarAsNeeded && (horizontalScrollBar()->isVisibleTo(this) != validRange)) { 1407 horizontalScrollBar()->setVisible(validRange); 1408 } 1409 // END bugs 213068, 287847 -------------------------------------------------------------- 1410 } 1411 1412 void KCategorizedView::currentChanged(const QModelIndex ¤t, const QModelIndex &previous) 1413 { 1414 QListView::currentChanged(current, previous); 1415 } 1416 1417 void KCategorizedView::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles) 1418 { 1419 QListView::dataChanged(topLeft, bottomRight, roles); 1420 if (!d->isCategorized()) { 1421 return; 1422 } 1423 1424 *d->hoveredBlock = KCategorizedViewPrivate::Block(); 1425 d->hoveredCategory = QString(); 1426 1427 // BEGIN: since the model changed data, we need to reconsider item sizes 1428 int i = topLeft.row(); 1429 int indexToCheck = i; 1430 QModelIndex categoryIndex; 1431 QString category; 1432 KCategorizedViewPrivate::Block *block; 1433 while (i <= bottomRight.row()) { 1434 const QModelIndex currIndex = d->proxyModel->index(i, modelColumn(), rootIndex()); 1435 if (i == indexToCheck) { 1436 categoryIndex = d->proxyModel->index(i, d->proxyModel->sortColumn(), rootIndex()); 1437 category = categoryIndex.data(KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); 1438 block = &d->blocks[category]; 1439 block->quarantineStart = currIndex; 1440 indexToCheck = block->firstIndex.row() + block->items.count(); 1441 } 1442 visualRect(currIndex); 1443 ++i; 1444 } 1445 // END: since the model changed data, we need to reconsider item sizes 1446 } 1447 1448 void KCategorizedView::rowsInserted(const QModelIndex &parent, int start, int end) 1449 { 1450 QListView::rowsInserted(parent, start, end); 1451 if (!d->isCategorized()) { 1452 return; 1453 } 1454 1455 *d->hoveredBlock = KCategorizedViewPrivate::Block(); 1456 d->hoveredCategory = QString(); 1457 d->rowsInserted(parent, start, end); 1458 } 1459 1460 #if KITEMVIEWS_BUILD_DEPRECATED_SINCE(4, 4) 1461 void KCategorizedView::rowsInsertedArtifficial(const QModelIndex &parent, int start, int end) 1462 { 1463 Q_UNUSED(parent); 1464 Q_UNUSED(start); 1465 Q_UNUSED(end); 1466 } 1467 #endif 1468 1469 #if KITEMVIEWS_BUILD_DEPRECATED_SINCE(4, 4) 1470 void KCategorizedView::rowsRemoved(const QModelIndex &parent, int start, int end) 1471 { 1472 Q_UNUSED(parent); 1473 Q_UNUSED(start); 1474 Q_UNUSED(end); 1475 } 1476 #endif 1477 1478 void KCategorizedView::slotLayoutChanged() 1479 { 1480 if (!d->isCategorized()) { 1481 return; 1482 } 1483 1484 d->blocks.clear(); 1485 *d->hoveredBlock = KCategorizedViewPrivate::Block(); 1486 d->hoveredCategory = QString(); 1487 if (d->proxyModel->rowCount()) { 1488 d->rowsInserted(rootIndex(), 0, d->proxyModel->rowCount() - 1); 1489 } 1490 } 1491 1492 // END: Public part 1493 1494 #include "moc_kcategorizedview.cpp"