src/kitemviews/kitemlistview.cpp

   1 /*
   2  * SPDX-FileCopyrightText: 2011 Peter Penz <peter.penz19@gmail.com>
   3  *
   4  * Based on the Itemviews NG project from Trolltech Labs
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-or-later
   7  */
   8
   9 #include "kitemlistview.h"
  10
  11 #include "dolphindebug.h"
  12 #include "kitemlistcontainer.h"
  13 #include "kitemlistcontroller.h"
  14 #include "kitemlistheader.h"
  15 #include "kitemlistselectionmanager.h"
  16 #include "kitemlistviewaccessible.h"
  17 #include "kstandarditemlistwidget.h"
  18
  19 #include "private/kitemlistheaderwidget.h"
  20 #include "private/kitemlistrubberband.h"
  21 #include "private/kitemlistsizehintresolver.h"
  22 #include "private/kitemlistviewlayouter.h"
  23
  24 #include <QElapsedTimer>
  25 #include <QGraphicsSceneMouseEvent>
  26 #include <QGraphicsView>
  27 #include <QStyleOptionRubberBand>
  28 #include <QTimer>
  29
  30
  31 namespace {
  32     // Time in ms until reaching the autoscroll margin triggers
  33     // an initial autoscrolling
  34     const int InitialAutoScrollDelay = 700;
  35
  36     // Delay in ms for triggering the next autoscroll
  37     const int RepeatingAutoScrollDelay = 1000 / 60;
  38 }
  39
  40 #ifndef QT_NO_ACCESSIBILITY
  41 QAccessibleInterface* accessibleInterfaceFactory(const QString& key, QObject* object)
  42 {
  43     Q_UNUSED(key)
  44
  45     if (KItemListContainer* container = qobject_cast<KItemListContainer*>(object)) {
  46         return new KItemListContainerAccessible(container);
  47     } else if (KItemListView* view = qobject_cast<KItemListView*>(object)) {
  48         return new KItemListViewAccessible(view);
  49     }
  50
  51     return nullptr;
  52 }
  53 #endif
  54
  55 KItemListView::KItemListView(QGraphicsWidget* parent) :
  56     QGraphicsWidget(parent),
  57     m_enabledSelectionToggles(false),
  58     m_grouped(false),
  59     m_supportsItemExpanding(false),
  60     m_editingRole(false),
  61     m_activeTransactions(0),
  62     m_endTransactionAnimationHint(Animation),
  63     m_itemSize(),
  64     m_controller(nullptr),
  65     m_model(nullptr),
  66     m_visibleRoles(),
  67     m_widgetCreator(nullptr),
  68     m_groupHeaderCreator(nullptr),
  69     m_styleOption(),
  70     m_visibleItems(),
  71     m_visibleGroups(),
  72     m_visibleCells(),
  73     m_sizeHintResolver(nullptr),
  74     m_layouter(nullptr),
  75     m_animation(nullptr),
  76     m_layoutTimer(nullptr),
  77     m_oldScrollOffset(0),
  78     m_oldMaximumScrollOffset(0),
  79     m_oldItemOffset(0),
  80     m_oldMaximumItemOffset(0),
  81     m_skipAutoScrollForRubberBand(false),
  82     m_rubberBand(nullptr),
  83     m_mousePos(),
  84     m_autoScrollIncrement(0),
  85     m_autoScrollTimer(nullptr),
  86     m_header(nullptr),
  87     m_headerWidget(nullptr),
  88     m_dropIndicator()
  89 {
  90     setAcceptHoverEvents(true);
  91
  92     m_sizeHintResolver = new KItemListSizeHintResolver(this);
  93
  94     m_layouter = new KItemListViewLayouter(m_sizeHintResolver, this);
  95
  96     m_animation = new KItemListViewAnimation(this);
  97     connect(m_animation, &KItemListViewAnimation::finished,
  98             this, &KItemListView::slotAnimationFinished);
  99
 100     m_layoutTimer = new QTimer(this);
 101     m_layoutTimer->setInterval(300);
 102     m_layoutTimer->setSingleShot(true);
 103     connect(m_layoutTimer, &QTimer::timeout, this, &KItemListView::slotLayoutTimerFinished);
 104
 105     m_rubberBand = new KItemListRubberBand(this);
 106     connect(m_rubberBand, &KItemListRubberBand::activationChanged, this, &KItemListView::slotRubberBandActivationChanged);
 107
 108     m_headerWidget = new KItemListHeaderWidget(this);
 109     m_headerWidget->setVisible(false);
 110
 111     m_header = new KItemListHeader(this);
 112
 113 #ifndef QT_NO_ACCESSIBILITY
 114     QAccessible::installFactory(accessibleInterfaceFactory);
 115 #endif
 116
 117 }
 118
 119 KItemListView::~KItemListView()
 120 {
 121     // The group headers are children of the widgets created by
 122     // widgetCreator(). So it is mandatory to delete the group headers
 123     // first.
 124     delete m_groupHeaderCreator;
 125     m_groupHeaderCreator = nullptr;
 126
 127     delete m_widgetCreator;
 128     m_widgetCreator = nullptr;
 129
 130     delete m_sizeHintResolver;
 131     m_sizeHintResolver = nullptr;
 132 }
 133
 134 void KItemListView::setScrollOffset(qreal offset)
 135 {
 136     if (offset < 0) {
 137         offset = 0;
 138     }
 139
 140     const qreal previousOffset = m_layouter->scrollOffset();
 141     if (offset == previousOffset) {
 142         return;
 143     }
 144
 145     m_layouter->setScrollOffset(offset);
 146     m_animation->setScrollOffset(offset);
 147
 148     // Don't check whether the m_layoutTimer is active: Changing the
 149     // scroll offset must always trigger a synchronous layout, otherwise
 150     // the smooth-scrolling might get jerky.
 151     doLayout(NoAnimation);
 152     onScrollOffsetChanged(offset, previousOffset);
 153 }
 154
 155 qreal KItemListView::scrollOffset() const
 156 {
 157     return m_layouter->scrollOffset();
 158 }
 159
 160 qreal KItemListView::maximumScrollOffset() const
 161 {
 162     return m_layouter->maximumScrollOffset();
 163 }
 164
 165 void KItemListView::setItemOffset(qreal offset)
 166 {
 167     if (m_layouter->itemOffset() == offset) {
 168         return;
 169     }
 170
 171     m_layouter->setItemOffset(offset);
 172     if (m_headerWidget->isVisible()) {
 173         m_headerWidget->setOffset(offset);
 174     }
 175
 176     // Don't check whether the m_layoutTimer is active: Changing the
 177     // item offset must always trigger a synchronous layout, otherwise
 178     // the smooth-scrolling might get jerky.
 179     doLayout(NoAnimation);
 180 }
 181
 182 qreal KItemListView::itemOffset() const
 183 {
 184     return m_layouter->itemOffset();
 185 }
 186
 187 qreal KItemListView::maximumItemOffset() const
 188 {
 189     return m_layouter->maximumItemOffset();
 190 }
 191
 192 int KItemListView::maximumVisibleItems() const
 193 {
 194     return m_layouter->maximumVisibleItems();
 195 }
 196
 197 void KItemListView::setVisibleRoles(const QList<QByteArray>& roles)
 198 {
 199     const QList<QByteArray> previousRoles = m_visibleRoles;
 200     m_visibleRoles = roles;
 201     onVisibleRolesChanged(roles, previousRoles);
 202
 203     m_sizeHintResolver->clearCache();
 204     m_layouter->markAsDirty();
 205
 206     if (m_itemSize.isEmpty()) {
 207         m_headerWidget->setColumns(roles);
 208         updatePreferredColumnWidths();
 209         if (!m_headerWidget->automaticColumnResizing()) {
 210             // The column-width of new roles are still 0. Apply the preferred
 211             // column-width as default with.
 212             foreach (const QByteArray& role, m_visibleRoles) {
 213                 if (m_headerWidget->columnWidth(role) == 0) {
 214                     const qreal width = m_headerWidget->preferredColumnWidth(role);
 215                     m_headerWidget->setColumnWidth(role, width);
 216                 }
 217             }
 218
 219             applyColumnWidthsFromHeader();
 220         }
 221     }
 222
 223     const bool alternateBackgroundsChanged = m_itemSize.isEmpty() &&
 224                                              ((roles.count() > 1 && previousRoles.count() <= 1) ||
 225                                               (roles.count() <= 1 && previousRoles.count() > 1));
 226
 227     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
 228     while (it.hasNext()) {
 229         it.next();
 230         KItemListWidget* widget = it.value();
 231         widget->setVisibleRoles(roles);
 232         if (alternateBackgroundsChanged) {
 233             updateAlternateBackgroundForWidget(widget);
 234         }
 235     }
 236
 237     doLayout(NoAnimation);
 238 }
 239
 240 QList<QByteArray> KItemListView::visibleRoles() const
 241 {
 242     return m_visibleRoles;
 243 }
 244
 245 void KItemListView::setAutoScroll(bool enabled)
 246 {
 247     if (enabled && !m_autoScrollTimer) {
 248         m_autoScrollTimer = new QTimer(this);
 249         m_autoScrollTimer->setSingleShot(true);
 250         connect(m_autoScrollTimer, &QTimer::timeout, this, &KItemListView::triggerAutoScrolling);
 251         m_autoScrollTimer->start(InitialAutoScrollDelay);
 252     } else if (!enabled && m_autoScrollTimer) {
 253         delete m_autoScrollTimer;
 254         m_autoScrollTimer = nullptr;
 255     }
 256 }
 257
 258 bool KItemListView::autoScroll() const
 259 {
 260     return m_autoScrollTimer != nullptr;
 261 }
 262
 263 void KItemListView::setEnabledSelectionToggles(bool enabled)
 264 {
 265     if (m_enabledSelectionToggles != enabled) {
 266         m_enabledSelectionToggles = enabled;
 267
 268         QHashIterator<int, KItemListWidget*> it(m_visibleItems);
 269         while (it.hasNext()) {
 270             it.next();
 271             it.value()->setEnabledSelectionToggle(enabled);
 272         }
 273     }
 274 }
 275
 276 bool KItemListView::enabledSelectionToggles() const
 277 {
 278     return m_enabledSelectionToggles;
 279 }
 280
 281 KItemListController* KItemListView::controller() const
 282 {
 283     return m_controller;
 284 }
 285
 286 KItemModelBase* KItemListView::model() const
 287 {
 288     return m_model;
 289 }
 290
 291 void KItemListView::setWidgetCreator(KItemListWidgetCreatorBase* widgetCreator)
 292 {
 293     delete m_widgetCreator;
 294     m_widgetCreator = widgetCreator;
 295 }
 296
 297 KItemListWidgetCreatorBase* KItemListView::widgetCreator() const
 298 {
 299     if (!m_widgetCreator) {
 300         m_widgetCreator = defaultWidgetCreator();
 301     }
 302     return m_widgetCreator;
 303 }
 304
 305 void KItemListView::setGroupHeaderCreator(KItemListGroupHeaderCreatorBase* groupHeaderCreator)
 306 {
 307     delete m_groupHeaderCreator;
 308     m_groupHeaderCreator = groupHeaderCreator;
 309 }
 310
 311 KItemListGroupHeaderCreatorBase* KItemListView::groupHeaderCreator() const
 312 {
 313     if (!m_groupHeaderCreator) {
 314         m_groupHeaderCreator = defaultGroupHeaderCreator();
 315     }
 316     return m_groupHeaderCreator;
 317 }
 318
 319 QSizeF KItemListView::itemSize() const
 320 {
 321     return m_itemSize;
 322 }
 323
 324 const KItemListStyleOption& KItemListView::styleOption() const
 325 {
 326     return m_styleOption;
 327 }
 328
 329 void KItemListView::setGeometry(const QRectF& rect)
 330 {
 331     QGraphicsWidget::setGeometry(rect);
 332
 333     if (!m_model) {
 334         return;
 335     }
 336
 337     const QSizeF newSize = rect.size();
 338     if (m_itemSize.isEmpty()) {
 339         m_headerWidget->resize(rect.width(), m_headerWidget->size().height());
 340         if (m_headerWidget->automaticColumnResizing()) {
 341             applyAutomaticColumnWidths();
 342         } else {
 343             const qreal requiredWidth = columnWidthsSum();
 344             const QSizeF dynamicItemSize(qMax(newSize.width(), requiredWidth),
 345                                          m_itemSize.height());
 346             m_layouter->setItemSize(dynamicItemSize);
 347         }
 348
 349         // Triggering a synchronous layout is fine from a performance point of view,
 350         // as with dynamic item sizes no moving animation must be done.
 351         m_layouter->setSize(newSize);
 352         doLayout(NoAnimation);
 353     } else {
 354         const bool animate = !changesItemGridLayout(newSize,
 355                                                     m_layouter->itemSize(),
 356                                                     m_layouter->itemMargin());
 357         m_layouter->setSize(newSize);
 358
 359         if (animate) {
 360             // Trigger an asynchronous relayout with m_layoutTimer to prevent
 361             // performance bottlenecks. If the timer is exceeded, an animated layout
 362             // will be triggered.
 363             if (!m_layoutTimer->isActive()) {
 364                 m_layoutTimer->start();
 365             }
 366         } else {
 367             m_layoutTimer->stop();
 368             doLayout(NoAnimation);
 369         }
 370     }
 371 }
 372
 373 qreal KItemListView::verticalPageStep() const
 374 {
 375     qreal headerHeight = 0;
 376     if (m_headerWidget->isVisible()) {
 377         headerHeight = m_headerWidget->size().height();
 378     }
 379     return size().height() - headerHeight;
 380 }
 381
 382 int KItemListView::itemAt(const QPointF& pos) const
 383 {
 384     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
 385     while (it.hasNext()) {
 386         it.next();
 387
 388         const KItemListWidget* widget = it.value();
 389         const QPointF mappedPos = widget->mapFromItem(this, pos);
 390         if (widget->contains(mappedPos)) {
 391             return it.key();
 392         }
 393     }
 394
 395     return -1;
 396 }
 397
 398 bool KItemListView::isAboveSelectionToggle(int index, const QPointF& pos) const
 399 {
 400     if (!m_enabledSelectionToggles) {
 401         return false;
 402     }
 403
 404     const KItemListWidget* widget = m_visibleItems.value(index);
 405     if (widget) {
 406         const QRectF selectionToggleRect = widget->selectionToggleRect();
 407         if (!selectionToggleRect.isEmpty()) {
 408             const QPointF mappedPos = widget->mapFromItem(this, pos);
 409             return selectionToggleRect.contains(mappedPos);
 410         }
 411     }
 412     return false;
 413 }
 414
 415 bool KItemListView::isAboveExpansionToggle(int index, const QPointF& pos) const
 416 {
 417     const KItemListWidget* widget = m_visibleItems.value(index);
 418     if (widget) {
 419         const QRectF expansionToggleRect = widget->expansionToggleRect();
 420         if (!expansionToggleRect.isEmpty()) {
 421             const QPointF mappedPos = widget->mapFromItem(this, pos);
 422             return expansionToggleRect.contains(mappedPos);
 423         }
 424     }
 425     return false;
 426 }
 427
 428 bool KItemListView::isAboveText(int index, const QPointF &pos) const
 429 {
 430     const KItemListWidget* widget = m_visibleItems.value(index);
 431     if (widget) {
 432         const QRectF &textRect = widget->textRect();
 433         if (!textRect.isEmpty()) {
 434             const QPointF mappedPos = widget->mapFromItem(this, pos);
 435             return textRect.contains(mappedPos);
 436         }
 437     }
 438     return false;
 439 }
 440
 441 int KItemListView::firstVisibleIndex() const
 442 {
 443     return m_layouter->firstVisibleIndex();
 444 }
 445
 446 int KItemListView::lastVisibleIndex() const
 447 {
 448     return m_layouter->lastVisibleIndex();
 449 }
 450
 451 void KItemListView::calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint) const
 452 {
 453     widgetCreator()->calculateItemSizeHints(logicalHeightHints, logicalWidthHint, this);
 454 }
 455
 456 void KItemListView::setSupportsItemExpanding(bool supportsExpanding)
 457 {
 458     if (m_supportsItemExpanding != supportsExpanding) {
 459         m_supportsItemExpanding = supportsExpanding;
 460         updateSiblingsInformation();
 461         onSupportsItemExpandingChanged(supportsExpanding);
 462     }
 463 }
 464
 465 bool KItemListView::supportsItemExpanding() const
 466 {
 467     return m_supportsItemExpanding;
 468 }
 469
 470 QRectF KItemListView::itemRect(int index) const
 471 {
 472     return m_layouter->itemRect(index);
 473 }
 474
 475 QRectF KItemListView::itemContextRect(int index) const
 476 {
 477     QRectF contextRect;
 478
 479     const KItemListWidget* widget = m_visibleItems.value(index);
 480     if (widget) {
 481         contextRect = widget->iconRect() | widget->textRect();
 482         contextRect.translate(itemRect(index).topLeft());
 483     }
 484
 485     return contextRect;
 486 }
 487
 488 void KItemListView::scrollToItem(int index)
 489 {
 490     QRectF viewGeometry = geometry();
 491     if (m_headerWidget->isVisible()) {
 492         const qreal headerHeight = m_headerWidget->size().height();
 493         viewGeometry.adjust(0, headerHeight, 0, 0);
 494     }
 495     QRectF currentRect = itemRect(index);
 496
 497     // Fix for Bug 311099 - View the underscore when using Ctrl + PagDown
 498     currentRect.adjust(-m_styleOption.horizontalMargin, -m_styleOption.verticalMargin,
 499                         m_styleOption.horizontalMargin,  m_styleOption.verticalMargin);
 500
 501     if (!viewGeometry.contains(currentRect)) {
 502         qreal newOffset = scrollOffset();
 503         if (scrollOrientation() == Qt::Vertical) {
 504             if (currentRect.top() < viewGeometry.top()) {
 505                 newOffset += currentRect.top() - viewGeometry.top();
 506             } else if (currentRect.bottom() > viewGeometry.bottom()) {
 507                 newOffset += currentRect.bottom() - viewGeometry.bottom();
 508             }
 509         } else {
 510             if (currentRect.left() < viewGeometry.left()) {
 511                 newOffset += currentRect.left() - viewGeometry.left();
 512             } else if (currentRect.right() > viewGeometry.right()) {
 513                 newOffset += currentRect.right() - viewGeometry.right();
 514             }
 515         }
 516
 517         if (newOffset != scrollOffset()) {
 518             emit scrollTo(newOffset);
 519         }
 520     }
 521 }
 522
 523 void KItemListView::beginTransaction()
 524 {
 525     ++m_activeTransactions;
 526     if (m_activeTransactions == 1) {
 527         onTransactionBegin();
 528     }
 529 }
 530
 531 void KItemListView::endTransaction()
 532 {
 533     --m_activeTransactions;
 534     if (m_activeTransactions < 0) {
 535         m_activeTransactions = 0;
 536         qCWarning(DolphinDebug) << "Mismatch between beginTransaction()/endTransaction()";
 537     }
 538
 539     if (m_activeTransactions == 0) {
 540         onTransactionEnd();
 541         doLayout(m_endTransactionAnimationHint);
 542         m_endTransactionAnimationHint = Animation;
 543     }
 544 }
 545
 546 bool KItemListView::isTransactionActive() const
 547 {
 548     return m_activeTransactions > 0;
 549 }
 550
 551 void KItemListView::setHeaderVisible(bool visible)
 552 {
 553     if (visible && !m_headerWidget->isVisible()) {
 554         QStyleOptionHeader option;
 555         const QSize headerSize = style()->sizeFromContents(QStyle::CT_HeaderSection,
 556                                                            &option, QSize());
 557
 558         m_headerWidget->setPos(0, 0);
 559         m_headerWidget->resize(size().width(), headerSize.height());
 560         m_headerWidget->setModel(m_model);
 561         m_headerWidget->setColumns(m_visibleRoles);
 562         m_headerWidget->setZValue(1);
 563
 564         connect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
 565                 this, &KItemListView::slotHeaderColumnWidthChanged);
 566         connect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
 567                 this, &KItemListView::slotHeaderColumnMoved);
 568         connect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
 569                 this, &KItemListView::sortOrderChanged);
 570         connect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
 571                 this, &KItemListView::sortRoleChanged);
 572
 573         m_layouter->setHeaderHeight(headerSize.height());
 574         m_headerWidget->setVisible(true);
 575     } else if (!visible && m_headerWidget->isVisible()) {
 576         disconnect(m_headerWidget, &KItemListHeaderWidget::columnWidthChanged,
 577                    this, &KItemListView::slotHeaderColumnWidthChanged);
 578         disconnect(m_headerWidget, &KItemListHeaderWidget::columnMoved,
 579                    this, &KItemListView::slotHeaderColumnMoved);
 580         disconnect(m_headerWidget, &KItemListHeaderWidget::sortOrderChanged,
 581                    this, &KItemListView::sortOrderChanged);
 582         disconnect(m_headerWidget, &KItemListHeaderWidget::sortRoleChanged,
 583                    this, &KItemListView::sortRoleChanged);
 584
 585         m_layouter->setHeaderHeight(0);
 586         m_headerWidget->setVisible(false);
 587     }
 588 }
 589
 590 bool KItemListView::isHeaderVisible() const
 591 {
 592     return m_headerWidget->isVisible();
 593 }
 594
 595 KItemListHeader* KItemListView::header() const
 596 {
 597     return m_header;
 598 }
 599
 600 QPixmap KItemListView::createDragPixmap(const KItemSet& indexes) const
 601 {
 602     QPixmap pixmap;
 603
 604     if (indexes.count() == 1) {
 605         KItemListWidget* item = m_visibleItems.value(indexes.first());
 606         QGraphicsView* graphicsView = scene()->views()[0];
 607         if (item && graphicsView) {
 608             pixmap = item->createDragPixmap(nullptr, graphicsView);
 609         }
 610     } else {
 611         // TODO: Not implemented yet. Probably extend the interface
 612         // from KItemListWidget::createDragPixmap() to return a pixmap
 613         // that can be used for multiple indexes.
 614     }
 615
 616     return pixmap;
 617 }
 618
 619 void KItemListView::editRole(int index, const QByteArray& role)
 620 {
 621     KStandardItemListWidget* widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));
 622     if (!widget || m_editingRole) {
 623         return;
 624     }
 625
 626     m_editingRole = true;
 627     widget->setEditedRole(role);
 628
 629     connect(widget, &KItemListWidget::roleEditingCanceled,
 630             this, &KItemListView::slotRoleEditingCanceled);
 631     connect(widget, &KItemListWidget::roleEditingFinished,
 632             this, &KItemListView::slotRoleEditingFinished);
 633
 634     connect(this, &KItemListView::scrollOffsetChanged,
 635             widget, &KStandardItemListWidget::finishRoleEditing);
 636 }
 637
 638 void KItemListView::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
 639 {
 640     QGraphicsWidget::paint(painter, option, widget);
 641
 642     if (m_rubberBand->isActive()) {
 643         QRectF rubberBandRect = QRectF(m_rubberBand->startPosition(),
 644                                        m_rubberBand->endPosition()).normalized();
 645
 646         const QPointF topLeft = rubberBandRect.topLeft();
 647         if (scrollOrientation() == Qt::Vertical) {
 648             rubberBandRect.moveTo(topLeft.x(), topLeft.y() - scrollOffset());
 649         } else {
 650             rubberBandRect.moveTo(topLeft.x() - scrollOffset(), topLeft.y());
 651         }
 652
 653         QStyleOptionRubberBand opt;
 654         initStyleOption(&opt);
 655         opt.shape = QRubberBand::Rectangle;
 656         opt.opaque = false;
 657         opt.rect = rubberBandRect.toRect();
 658         style()->drawControl(QStyle::CE_RubberBand, &opt, painter);
 659     }
 660
 661     if (!m_dropIndicator.isEmpty()) {
 662         const QRectF r = m_dropIndicator.toRect();
 663
 664         QColor color = palette().brush(QPalette::Normal, QPalette::Text).color();
 665         painter->setPen(color);
 666
 667         // TODO: The following implementation works only for a vertical scroll-orientation
 668         // and assumes a height of the m_draggingInsertIndicator of 1.
 669         Q_ASSERT(r.height() == 1);
 670         painter->drawLine(r.left() + 1, r.top(), r.right() - 1, r.top());
 671
 672         color.setAlpha(128);
 673         painter->setPen(color);
 674         painter->drawRect(r.left(), r.top() - 1, r.width() - 1, 2);
 675     }
 676 }
 677
 678 QVariant KItemListView::itemChange(GraphicsItemChange change, const QVariant &value)
 679 {
 680     if (change == QGraphicsItem::ItemSceneHasChanged && scene()) {
 681         if (!scene()->views().isEmpty()) {
 682             m_styleOption.palette = scene()->views().at(0)->palette();
 683         }
 684     }
 685     return QGraphicsItem::itemChange(change, value);
 686 }
 687
 688 void KItemListView::setItemSize(const QSizeF& size)
 689 {
 690     const QSizeF previousSize = m_itemSize;
 691     if (size == previousSize) {
 692         return;
 693     }
 694
 695     // Skip animations when the number of rows or columns
 696     // are changed in the grid layout. Although the animation
 697     // engine can handle this usecase, it looks obtrusive.
 698     const bool animate = !changesItemGridLayout(m_layouter->size(),
 699                                                 size,
 700                                                 m_layouter->itemMargin());
 701
 702     const bool alternateBackgroundsChanged = (m_visibleRoles.count() > 1) &&
 703                                              (( m_itemSize.isEmpty() && !size.isEmpty()) ||
 704                                               (!m_itemSize.isEmpty() && size.isEmpty()));
 705
 706     m_itemSize = size;
 707
 708     if (alternateBackgroundsChanged) {
 709         // For an empty item size alternate backgrounds are drawn if more than
 710         // one role is shown. Assure that the backgrounds for visible items are
 711         // updated when changing the size in this context.
 712         updateAlternateBackgrounds();
 713     }
 714
 715     if (size.isEmpty()) {
 716         if (m_headerWidget->automaticColumnResizing()) {
 717             updatePreferredColumnWidths();
 718         } else {
 719             // Only apply the changed height and respect the header widths
 720             // set by the user
 721             const qreal currentWidth = m_layouter->itemSize().width();
 722             const QSizeF newSize(currentWidth, size.height());
 723             m_layouter->setItemSize(newSize);
 724         }
 725     } else {
 726         m_layouter->setItemSize(size);
 727     }
 728
 729     m_sizeHintResolver->clearCache();
 730     doLayout(animate ? Animation : NoAnimation);
 731     onItemSizeChanged(size, previousSize);
 732 }
 733
 734 void KItemListView::setStyleOption(const KItemListStyleOption& option)
 735 {
 736     if (m_styleOption == option) {
 737         return;
 738     }
 739
 740     const KItemListStyleOption previousOption = m_styleOption;
 741     m_styleOption = option;
 742
 743     bool animate = true;
 744     const QSizeF margin(option.horizontalMargin, option.verticalMargin);
 745     if (margin != m_layouter->itemMargin()) {
 746         // Skip animations when the number of rows or columns
 747         // are changed in the grid layout. Although the animation
 748         // engine can handle this usecase, it looks obtrusive.
 749         animate = !changesItemGridLayout(m_layouter->size(),
 750                                          m_layouter->itemSize(),
 751                                          margin);
 752         m_layouter->setItemMargin(margin);
 753     }
 754
 755     if (m_grouped) {
 756         updateGroupHeaderHeight();
 757     }
 758
 759     if (animate &&
 760         (previousOption.maxTextLines != option.maxTextLines || previousOption.maxTextWidth != option.maxTextWidth)) {
 761         // Animating a change of the maximum text size just results in expensive
 762         // temporary eliding and clipping operations and does not look good visually.
 763         animate = false;
 764     }
 765
 766     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
 767     while (it.hasNext()) {
 768         it.next();
 769         it.value()->setStyleOption(option);
 770     }
 771
 772     m_sizeHintResolver->clearCache();
 773     m_layouter->markAsDirty();
 774     doLayout(animate ? Animation : NoAnimation);
 775
 776     if (m_itemSize.isEmpty()) {
 777         updatePreferredColumnWidths();
 778     }
 779
 780     onStyleOptionChanged(option, previousOption);
 781 }
 782
 783 void KItemListView::setScrollOrientation(Qt::Orientation orientation)
 784 {
 785     const Qt::Orientation previousOrientation = m_layouter->scrollOrientation();
 786     if (orientation == previousOrientation) {
 787         return;
 788     }
 789
 790     m_layouter->setScrollOrientation(orientation);
 791     m_animation->setScrollOrientation(orientation);
 792     m_sizeHintResolver->clearCache();
 793
 794     if (m_grouped) {
 795         QMutableHashIterator<KItemListWidget*, KItemListGroupHeader*> it (m_visibleGroups);
 796         while (it.hasNext()) {
 797             it.next();
 798             it.value()->setScrollOrientation(orientation);
 799         }
 800         updateGroupHeaderHeight();
 801
 802     }
 803
 804     doLayout(NoAnimation);
 805
 806     onScrollOrientationChanged(orientation, previousOrientation);
 807     emit scrollOrientationChanged(orientation, previousOrientation);
 808 }
 809
 810 Qt::Orientation KItemListView::scrollOrientation() const
 811 {
 812     return m_layouter->scrollOrientation();
 813 }
 814
 815 KItemListWidgetCreatorBase* KItemListView::defaultWidgetCreator() const
 816 {
 817     return nullptr;
 818 }
 819
 820 KItemListGroupHeaderCreatorBase* KItemListView::defaultGroupHeaderCreator() const
 821 {
 822     return nullptr;
 823 }
 824
 825 void KItemListView::initializeItemListWidget(KItemListWidget* item)
 826 {
 827     Q_UNUSED(item)
 828 }
 829
 830 bool KItemListView::itemSizeHintUpdateRequired(const QSet<QByteArray>& changedRoles) const
 831 {
 832     Q_UNUSED(changedRoles)
 833     return true;
 834 }
 835
 836 void KItemListView::onControllerChanged(KItemListController* current, KItemListController* previous)
 837 {
 838     Q_UNUSED(current)
 839     Q_UNUSED(previous)
 840 }
 841
 842 void KItemListView::onModelChanged(KItemModelBase* current, KItemModelBase* previous)
 843 {
 844     Q_UNUSED(current)
 845     Q_UNUSED(previous)
 846 }
 847
 848 void KItemListView::onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 849 {
 850     Q_UNUSED(current)
 851     Q_UNUSED(previous)
 852 }
 853
 854 void KItemListView::onItemSizeChanged(const QSizeF& current, const QSizeF& previous)
 855 {
 856     Q_UNUSED(current)
 857     Q_UNUSED(previous)
 858 }
 859
 860 void KItemListView::onScrollOffsetChanged(qreal current, qreal previous)
 861 {
 862     Q_UNUSED(current)
 863     Q_UNUSED(previous)
 864 }
 865
 866 void KItemListView::onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous)
 867 {
 868     Q_UNUSED(current)
 869     Q_UNUSED(previous)
 870 }
 871
 872 void KItemListView::onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous)
 873 {
 874     Q_UNUSED(current)
 875     Q_UNUSED(previous)
 876 }
 877
 878 void KItemListView::onSupportsItemExpandingChanged(bool supportsExpanding)
 879 {
 880     Q_UNUSED(supportsExpanding)
 881 }
 882
 883 void KItemListView::onTransactionBegin()
 884 {
 885 }
 886
 887 void KItemListView::onTransactionEnd()
 888 {
 889 }
 890
 891 bool KItemListView::event(QEvent* event)
 892 {
 893     switch (event->type()) {
 894     case QEvent::PaletteChange:
 895         updatePalette();
 896         break;
 897
 898     case QEvent::FontChange:
 899         updateFont();
 900         break;
 901
 902     default:
 903         // Forward all other events to the controller and handle them there
 904         if (!m_editingRole && m_controller && m_controller->processEvent(event, transform())) {
 905             event->accept();
 906             return true;
 907         }
 908     }
 909
 910     return QGraphicsWidget::event(event);
 911 }
 912
 913 void KItemListView::mousePressEvent(QGraphicsSceneMouseEvent* event)
 914 {
 915     m_mousePos = transform().map(event->pos());
 916     event->accept();
 917 }
 918
 919 void KItemListView::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
 920 {
 921     QGraphicsWidget::mouseMoveEvent(event);
 922
 923     m_mousePos = transform().map(event->pos());
 924     if (m_autoScrollTimer && !m_autoScrollTimer->isActive()) {
 925         m_autoScrollTimer->start(InitialAutoScrollDelay);
 926     }
 927 }
 928
 929 void KItemListView::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
 930 {
 931     event->setAccepted(true);
 932     setAutoScroll(true);
 933 }
 934
 935 void KItemListView::dragMoveEvent(QGraphicsSceneDragDropEvent* event)
 936 {
 937     QGraphicsWidget::dragMoveEvent(event);
 938
 939     m_mousePos = transform().map(event->pos());
 940     if (m_autoScrollTimer && !m_autoScrollTimer->isActive()) {
 941         m_autoScrollTimer->start(InitialAutoScrollDelay);
 942     }
 943 }
 944
 945 void KItemListView::dragLeaveEvent(QGraphicsSceneDragDropEvent* event)
 946 {
 947     QGraphicsWidget::dragLeaveEvent(event);
 948     setAutoScroll(false);
 949 }
 950
 951 void KItemListView::dropEvent(QGraphicsSceneDragDropEvent* event)
 952 {
 953     QGraphicsWidget::dropEvent(event);
 954     setAutoScroll(false);
 955 }
 956
 957 QList<KItemListWidget*> KItemListView::visibleItemListWidgets() const
 958 {
 959     return m_visibleItems.values();
 960 }
 961
 962 void KItemListView::updateFont()
 963 {
 964     if (scene() && !scene()->views().isEmpty()) {
 965         KItemListStyleOption option = styleOption();
 966         option.font = scene()->views().first()->font();
 967         option.fontMetrics = QFontMetrics(option.font);
 968
 969         setStyleOption(option);
 970     }
 971 }
 972
 973 void KItemListView::updatePalette()
 974 {
 975     if (scene() && !scene()->views().isEmpty()) {
 976         KItemListStyleOption option = styleOption();
 977         option.palette = scene()->views().first()->palette();
 978
 979         setStyleOption(option);
 980     }
 981 }
 982
 983 void KItemListView::slotItemsInserted(const KItemRangeList& itemRanges)
 984 {
 985     if (m_itemSize.isEmpty()) {
 986         updatePreferredColumnWidths(itemRanges);
 987     }
 988
 989     const bool hasMultipleRanges = (itemRanges.count() > 1);
 990     if (hasMultipleRanges) {
 991         beginTransaction();
 992     }
 993
 994     m_layouter->markAsDirty();
 995
 996     m_sizeHintResolver->itemsInserted(itemRanges);
 997
 998     int previouslyInsertedCount = 0;
 999     foreach (const KItemRange& range, itemRanges) {
1000         // range.index is related to the model before anything has been inserted.
1001         // As in each loop the current item-range gets inserted the index must
1002         // be increased by the already previously inserted items.
1003         const int index = range.index + previouslyInsertedCount;
1004         const int count = range.count;
1005         if (index < 0 || count <= 0) {
1006             qCWarning(DolphinDebug) << "Invalid item range (index:" << index << ", count:" << count << ")";
1007             continue;
1008         }
1009         previouslyInsertedCount += count;
1010
1011         // Determine which visible items must be moved
1012         QList<int> itemsToMove;
1013         QHashIterator<int, KItemListWidget*> it(m_visibleItems);
1014         while (it.hasNext()) {
1015             it.next();
1016             const int visibleItemIndex = it.key();
1017             if (visibleItemIndex >= index) {
1018                 itemsToMove.append(visibleItemIndex);
1019             }
1020         }
1021
1022         // Update the indexes of all KItemListWidget instances that are located
1023         // after the inserted items. It is important to adjust the indexes in the order
1024         // from the highest index to the lowest index to prevent overlaps when setting the new index.
1025         std::sort(itemsToMove.begin(), itemsToMove.end());
1026         for (int i = itemsToMove.count() - 1; i >= 0; --i) {
1027             KItemListWidget* widget = m_visibleItems.value(itemsToMove[i]);
1028             Q_ASSERT(widget);
1029             const int newIndex = widget->index() + count;
1030             if (hasMultipleRanges) {
1031                 setWidgetIndex(widget, newIndex);
1032             } else {
1033                 // Try to animate the moving of the item
1034                 moveWidgetToIndex(widget, newIndex);
1035             }
1036         }
1037
1038         if (m_model->count() == count && m_activeTransactions == 0) {
1039             // Check whether a scrollbar is required to show the inserted items. In this case
1040             // the size of the layouter will be decreased before calling doLayout(): This prevents
1041             // an unnecessary temporary animation due to the geometry change of the inserted scrollbar.
1042             const bool verticalScrollOrientation = (scrollOrientation() == Qt::Vertical);
1043             const bool decreaseLayouterSize = ( verticalScrollOrientation && maximumScrollOffset() > size().height()) ||
1044                                               (!verticalScrollOrientation && maximumScrollOffset() > size().width());
1045             if (decreaseLayouterSize) {
1046                 const int scrollBarExtent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
1047
1048                 int scrollbarSpacing = 0;
1049                 if (style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents)) {
1050                     scrollbarSpacing = style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing);
1051                 }
1052
1053                 QSizeF layouterSize = m_layouter->size();
1054                 if (verticalScrollOrientation) {
1055                     layouterSize.rwidth() -= scrollBarExtent + scrollbarSpacing;
1056                 } else {
1057                     layouterSize.rheight() -= scrollBarExtent + scrollbarSpacing;
1058                 }
1059                 m_layouter->setSize(layouterSize);
1060             }
1061         }
1062
1063         if (!hasMultipleRanges) {
1064             doLayout(animateChangedItemCount(count) ? Animation : NoAnimation, index, count);
1065             updateSiblingsInformation();
1066         }
1067     }
1068
1069     if (m_controller) {
1070         m_controller->selectionManager()->itemsInserted(itemRanges);
1071     }
1072
1073     if (hasMultipleRanges) {
1074         m_endTransactionAnimationHint = NoAnimation;
1075         endTransaction();
1076
1077         updateSiblingsInformation();
1078     }
1079
1080     if (m_grouped && (hasMultipleRanges || itemRanges.first().count < m_model->count())) {
1081         // In case if items of the same group have been inserted before an item that
1082         // currently represents the first item of the group, the group header of
1083         // this item must be removed.
1084         updateVisibleGroupHeaders();
1085     }
1086
1087     if (useAlternateBackgrounds()) {
1088         updateAlternateBackgrounds();
1089     }
1090 }
1091
1092 void KItemListView::slotItemsRemoved(const KItemRangeList& itemRanges)
1093 {
1094     if (m_itemSize.isEmpty()) {
1095         // Don't pass the item-range: The preferred column-widths of
1096         // all items must be adjusted when removing items.
1097         updatePreferredColumnWidths();
1098     }
1099
1100     const bool hasMultipleRanges = (itemRanges.count() > 1);
1101     if (hasMultipleRanges) {
1102         beginTransaction();
1103     }
1104
1105     m_layouter->markAsDirty();
1106
1107     m_sizeHintResolver->itemsRemoved(itemRanges);
1108
1109     for (int i = itemRanges.count() - 1; i >= 0; --i) {
1110         const KItemRange& range = itemRanges[i];
1111         const int index = range.index;
1112         const int count = range.count;
1113         if (index < 0 || count <= 0) {
1114             qCWarning(DolphinDebug) << "Invalid item range (index:" << index << ", count:" << count << ")";
1115             continue;
1116         }
1117
1118         const int firstRemovedIndex = index;
1119         const int lastRemovedIndex = index + count - 1;
1120
1121         // Remember which items have to be moved because they are behind the removed range.
1122         QVector<int> itemsToMove;
1123
1124         // Remove all KItemListWidget instances that got deleted
1125         foreach (KItemListWidget* widget, m_visibleItems) {
1126             const int i = widget->index();
1127             if (i < firstRemovedIndex) {
1128                 continue;
1129             } else if (i > lastRemovedIndex) {
1130                 itemsToMove.append(i);
1131                 continue;
1132             }
1133
1134             m_animation->stop(widget);
1135             // Stopping the animation might lead to recycling the widget if
1136             // it is invisible (see slotAnimationFinished()).
1137             // Check again whether it is still visible:
1138             if (!m_visibleItems.contains(i)) {
1139                 continue;
1140             }
1141
1142             if (m_model->count() == 0 || hasMultipleRanges || !animateChangedItemCount(count)) {
1143                 // Remove the widget without animation
1144                 recycleWidget(widget);
1145             } else {
1146                 // Animate the removing of the items. Special case: When removing an item there
1147                 // is no valid model index available anymore. For the
1148                 // remove-animation the item gets removed from m_visibleItems but the widget
1149                 // will stay alive until the animation has been finished and will
1150                 // be recycled (deleted) in KItemListView::slotAnimationFinished().
1151                 m_visibleItems.remove(i);
1152                 widget->setIndex(-1);
1153                 m_animation->start(widget, KItemListViewAnimation::DeleteAnimation);
1154             }
1155         }
1156
1157         // Update the indexes of all KItemListWidget instances that are located
1158         // after the deleted items. It is important to update them in ascending
1159         // order to prevent overlaps when setting the new index.
1160         std::sort(itemsToMove.begin(), itemsToMove.end());
1161         foreach (int i, itemsToMove) {
1162             KItemListWidget* widget = m_visibleItems.value(i);
1163             Q_ASSERT(widget);
1164             const int newIndex = i - count;
1165             if (hasMultipleRanges) {
1166                 setWidgetIndex(widget, newIndex);
1167             } else {
1168                 // Try to animate the moving of the item
1169                 moveWidgetToIndex(widget, newIndex);
1170             }
1171         }
1172
1173         if (!hasMultipleRanges) {
1174             // The decrease-layout-size optimization in KItemListView::slotItemsInserted()
1175             // assumes an updated geometry. If items are removed during an active transaction,
1176             // the transaction will be temporary deactivated so that doLayout() triggers a
1177             // geometry update if necessary.
1178             const int activeTransactions = m_activeTransactions;
1179             m_activeTransactions = 0;
1180             doLayout(animateChangedItemCount(count) ? Animation : NoAnimation, index, -count);
1181             m_activeTransactions = activeTransactions;
1182             updateSiblingsInformation();
1183         }
1184     }
1185
1186     if (m_controller) {
1187         m_controller->selectionManager()->itemsRemoved(itemRanges);
1188     }
1189
1190     if (hasMultipleRanges) {
1191         m_endTransactionAnimationHint = NoAnimation;
1192         endTransaction();
1193         updateSiblingsInformation();
1194     }
1195
1196     if (m_grouped && (hasMultipleRanges || m_model->count() > 0)) {
1197         // In case if the first item of a group has been removed, the group header
1198         // must be applied to the next visible item.
1199         updateVisibleGroupHeaders();
1200     }
1201
1202     if (useAlternateBackgrounds()) {
1203         updateAlternateBackgrounds();
1204     }
1205 }
1206
1207 void KItemListView::slotItemsMoved(const KItemRange& itemRange, const QList<int>& movedToIndexes)
1208 {
1209     m_sizeHintResolver->itemsMoved(itemRange, movedToIndexes);
1210     m_layouter->markAsDirty();
1211
1212     if (m_controller) {
1213         m_controller->selectionManager()->itemsMoved(itemRange, movedToIndexes);
1214     }
1215
1216     const int firstVisibleMovedIndex = qMax(firstVisibleIndex(), itemRange.index);
1217     const int lastVisibleMovedIndex = qMin(lastVisibleIndex(), itemRange.index + itemRange.count - 1);
1218
1219     for (int index = firstVisibleMovedIndex; index <= lastVisibleMovedIndex; ++index) {
1220         KItemListWidget* widget = m_visibleItems.value(index);
1221         if (widget) {
1222             updateWidgetProperties(widget, index);
1223             initializeItemListWidget(widget);
1224         }
1225     }
1226
1227     doLayout(NoAnimation);
1228     updateSiblingsInformation();
1229 }
1230
1231 void KItemListView::slotItemsChanged(const KItemRangeList& itemRanges,
1232                                      const QSet<QByteArray>& roles)
1233 {
1234     const bool updateSizeHints = itemSizeHintUpdateRequired(roles);
1235     if (updateSizeHints && m_itemSize.isEmpty()) {
1236         updatePreferredColumnWidths(itemRanges);
1237     }
1238
1239     foreach (const KItemRange& itemRange, itemRanges) {
1240         const int index = itemRange.index;
1241         const int count = itemRange.count;
1242
1243         if (updateSizeHints) {
1244             m_sizeHintResolver->itemsChanged(index, count, roles);
1245             m_layouter->markAsDirty();
1246
1247             if (!m_layoutTimer->isActive()) {
1248                 m_layoutTimer->start();
1249             }
1250         }
1251
1252         // Apply the changed roles to the visible item-widgets
1253         const int lastIndex = index + count - 1;
1254         for (int i = index; i <= lastIndex; ++i) {
1255             KItemListWidget* widget = m_visibleItems.value(i);
1256             if (widget) {
1257                 widget->setData(m_model->data(i), roles);
1258             }
1259         }
1260
1261         if (m_grouped && roles.contains(m_model->sortRole())) {
1262             // The sort-role has been changed which might result
1263             // in modified group headers
1264             updateVisibleGroupHeaders();
1265             doLayout(NoAnimation);
1266         }
1267
1268         QAccessibleTableModelChangeEvent ev(this, QAccessibleTableModelChangeEvent::DataChanged);
1269         ev.setFirstRow(itemRange.index);
1270         ev.setLastRow(itemRange.index + itemRange.count);
1271         QAccessible::updateAccessibility(&ev);
1272     }
1273 }
1274
1275 void KItemListView::slotGroupsChanged()
1276 {
1277     updateVisibleGroupHeaders();
1278     doLayout(NoAnimation);
1279     updateSiblingsInformation();
1280 }
1281
1282 void KItemListView::slotGroupedSortingChanged(bool current)
1283 {
1284     m_grouped = current;
1285     m_layouter->markAsDirty();
1286
1287     if (m_grouped) {
1288         updateGroupHeaderHeight();
1289     } else {
1290         // Clear all visible headers. Note that the QHashIterator takes a copy of
1291         // m_visibleGroups. Therefore, it remains valid even if items are removed
1292         // from m_visibleGroups in recycleGroupHeaderForWidget().
1293         QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
1294         while (it.hasNext()) {
1295             it.next();
1296             recycleGroupHeaderForWidget(it.key());
1297         }
1298         Q_ASSERT(m_visibleGroups.isEmpty());
1299     }
1300
1301     if (useAlternateBackgrounds()) {
1302         // Changing the group mode requires to update the alternate backgrounds
1303         // as with the enabled group mode the altering is done on base of the first
1304         // group item.
1305         updateAlternateBackgrounds();
1306     }
1307     updateSiblingsInformation();
1308     doLayout(NoAnimation);
1309 }
1310
1311 void KItemListView::slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
1312 {
1313     Q_UNUSED(current)
1314     Q_UNUSED(previous)
1315     if (m_grouped) {
1316         updateVisibleGroupHeaders();
1317         doLayout(NoAnimation);
1318     }
1319 }
1320
1321 void KItemListView::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
1322 {
1323     Q_UNUSED(current)
1324     Q_UNUSED(previous)
1325     if (m_grouped) {
1326         updateVisibleGroupHeaders();
1327         doLayout(NoAnimation);
1328     }
1329 }
1330
1331 void KItemListView::slotCurrentChanged(int current, int previous)
1332 {
1333     Q_UNUSED(previous)
1334
1335     // In SingleSelection mode (e.g., in the Places Panel), the current item is
1336     // always the selected item. It is not necessary to highlight the current item then.
1337     if (m_controller->selectionBehavior() != KItemListController::SingleSelection) {
1338         KItemListWidget* previousWidget = m_visibleItems.value(previous, nullptr);
1339         if (previousWidget) {
1340             previousWidget->setCurrent(false);
1341         }
1342
1343         KItemListWidget* currentWidget = m_visibleItems.value(current, nullptr);
1344         if (currentWidget) {
1345             currentWidget->setCurrent(true);
1346         }
1347     }
1348
1349     QAccessibleEvent ev(this, QAccessible::Focus);
1350     ev.setChild(current);
1351     QAccessible::updateAccessibility(&ev);
1352 }
1353
1354 void KItemListView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
1355 {
1356     Q_UNUSED(previous)
1357
1358     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
1359     while (it.hasNext()) {
1360         it.next();
1361         const int index = it.key();
1362         KItemListWidget* widget = it.value();
1363         widget->setSelected(current.contains(index));
1364     }
1365 }
1366
1367 void KItemListView::slotAnimationFinished(QGraphicsWidget* widget,
1368                                           KItemListViewAnimation::AnimationType type)
1369 {
1370     KItemListWidget* itemListWidget = qobject_cast<KItemListWidget*>(widget);
1371     Q_ASSERT(itemListWidget);
1372
1373     switch (type) {
1374     case KItemListViewAnimation::DeleteAnimation: {
1375         // As we recycle the widget in this case it is important to assure that no
1376         // other animation has been started. This is a convention in KItemListView and
1377         // not a requirement defined by KItemListViewAnimation.
1378         Q_ASSERT(!m_animation->isStarted(itemListWidget));
1379
1380         // All KItemListWidgets that are animated by the DeleteAnimation are not maintained
1381         // by m_visibleWidgets and must be deleted manually after the animation has
1382         // been finished.
1383         recycleGroupHeaderForWidget(itemListWidget);
1384         widgetCreator()->recycle(itemListWidget);
1385         break;
1386     }
1387
1388     case KItemListViewAnimation::CreateAnimation:
1389     case KItemListViewAnimation::MovingAnimation:
1390     case KItemListViewAnimation::ResizeAnimation: {
1391         const int index = itemListWidget->index();
1392         const bool invisible = (index < m_layouter->firstVisibleIndex()) ||
1393                                (index > m_layouter->lastVisibleIndex());
1394         if (invisible && !m_animation->isStarted(itemListWidget)) {
1395             recycleWidget(itemListWidget);
1396         }
1397         break;
1398     }
1399
1400     default: break;
1401     }
1402 }
1403
1404 void KItemListView::slotLayoutTimerFinished()
1405 {
1406     m_layouter->setSize(geometry().size());
1407     doLayout(Animation);
1408 }
1409
1410 void KItemListView::slotRubberBandPosChanged()
1411 {
1412     update();
1413 }
1414
1415 void KItemListView::slotRubberBandActivationChanged(bool active)
1416 {
1417     if (active) {
1418         connect(m_rubberBand, &KItemListRubberBand::startPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
1419         connect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
1420         m_skipAutoScrollForRubberBand = true;
1421     } else {
1422         disconnect(m_rubberBand, &KItemListRubberBand::startPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
1423         disconnect(m_rubberBand, &KItemListRubberBand::endPositionChanged, this, &KItemListView::slotRubberBandPosChanged);
1424         m_skipAutoScrollForRubberBand = false;
1425     }
1426
1427     update();
1428 }
1429
1430 void KItemListView::slotHeaderColumnWidthChanged(const QByteArray& role,
1431                                                  qreal currentWidth,
1432                                                  qreal previousWidth)
1433 {
1434     Q_UNUSED(role)
1435     Q_UNUSED(currentWidth)
1436     Q_UNUSED(previousWidth)
1437
1438     m_headerWidget->setAutomaticColumnResizing(false);
1439     applyColumnWidthsFromHeader();
1440     doLayout(NoAnimation);
1441 }
1442
1443 void KItemListView::slotHeaderColumnMoved(const QByteArray& role,
1444                                           int currentIndex,
1445                                           int previousIndex)
1446 {
1447     Q_ASSERT(m_visibleRoles[previousIndex] == role);
1448
1449     const QList<QByteArray> previous = m_visibleRoles;
1450
1451     QList<QByteArray> current = m_visibleRoles;
1452     current.removeAt(previousIndex);
1453     current.insert(currentIndex, role);
1454
1455     setVisibleRoles(current);
1456
1457     emit visibleRolesChanged(current, previous);
1458 }
1459
1460 void KItemListView::triggerAutoScrolling()
1461 {
1462     if (!m_autoScrollTimer) {
1463         return;
1464     }
1465
1466     int pos = 0;
1467     int visibleSize = 0;
1468     if (scrollOrientation() == Qt::Vertical) {
1469         pos = m_mousePos.y();
1470         visibleSize = size().height();
1471     } else {
1472         pos = m_mousePos.x();
1473         visibleSize = size().width();
1474     }
1475
1476     if (m_autoScrollTimer->interval() == InitialAutoScrollDelay) {
1477         m_autoScrollIncrement = 0;
1478     }
1479
1480     m_autoScrollIncrement = calculateAutoScrollingIncrement(pos, visibleSize, m_autoScrollIncrement);
1481     if (m_autoScrollIncrement == 0) {
1482         // The mouse position is not above an autoscroll margin (the autoscroll timer
1483         // will be restarted in mouseMoveEvent())
1484         m_autoScrollTimer->stop();
1485         return;
1486     }
1487
1488     if (m_rubberBand->isActive() && m_skipAutoScrollForRubberBand) {
1489         // If a rubberband selection is ongoing the autoscrolling may only get triggered
1490         // if the direction of the rubberband is similar to the autoscroll direction. This
1491         // prevents that starting to create a rubberband within the autoscroll margins starts
1492         // an autoscrolling.
1493
1494         const qreal minDiff = 4; // Ignore any autoscrolling if the rubberband is very small
1495         const qreal diff = (scrollOrientation() == Qt::Vertical)
1496                            ? m_rubberBand->endPosition().y() - m_rubberBand->startPosition().y()
1497                            : m_rubberBand->endPosition().x() - m_rubberBand->startPosition().x();
1498         if (qAbs(diff) < minDiff || (m_autoScrollIncrement < 0 && diff > 0) || (m_autoScrollIncrement > 0 && diff < 0)) {
1499             // The rubberband direction is different from the scroll direction (e.g. the rubberband has
1500             // been moved up although the autoscroll direction might be down)
1501             m_autoScrollTimer->stop();
1502             return;
1503         }
1504     }
1505
1506     // As soon as the autoscrolling has been triggered at least once despite having an active rubberband,
1507     // the autoscrolling may not get skipped anymore until a new rubberband is created
1508     m_skipAutoScrollForRubberBand = false;
1509
1510     const qreal maxVisibleOffset = qMax(qreal(0), maximumScrollOffset() - visibleSize);
1511     const qreal newScrollOffset = qMin(scrollOffset() + m_autoScrollIncrement, maxVisibleOffset);
1512     setScrollOffset(newScrollOffset);
1513
1514     // Trigger the autoscroll timer which will periodically call
1515     // triggerAutoScrolling()
1516     m_autoScrollTimer->start(RepeatingAutoScrollDelay);
1517 }
1518
1519 void KItemListView::slotGeometryOfGroupHeaderParentChanged()
1520 {
1521     KItemListWidget* widget = qobject_cast<KItemListWidget*>(sender());
1522     Q_ASSERT(widget);
1523     KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
1524     Q_ASSERT(groupHeader);
1525     updateGroupHeaderLayout(widget);
1526 }
1527
1528 void KItemListView::slotRoleEditingCanceled(int index, const QByteArray& role, const QVariant& value)
1529 {
1530     disconnectRoleEditingSignals(index);
1531
1532     emit roleEditingCanceled(index, role, value);
1533     m_editingRole = false;
1534 }
1535
1536 void KItemListView::slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value)
1537 {
1538     disconnectRoleEditingSignals(index);
1539
1540     emit roleEditingFinished(index, role, value);
1541     m_editingRole = false;
1542 }
1543
1544 void KItemListView::setController(KItemListController* controller)
1545 {
1546     if (m_controller != controller) {
1547         KItemListController* previous = m_controller;
1548         if (previous) {
1549             KItemListSelectionManager* selectionManager = previous->selectionManager();
1550             disconnect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
1551             disconnect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
1552         }
1553
1554         m_controller = controller;
1555
1556         if (controller) {
1557             KItemListSelectionManager* selectionManager = controller->selectionManager();
1558             connect(selectionManager, &KItemListSelectionManager::currentChanged, this, &KItemListView::slotCurrentChanged);
1559             connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &KItemListView::slotSelectionChanged);
1560         }
1561
1562         onControllerChanged(controller, previous);
1563     }
1564 }
1565
1566 void KItemListView::setModel(KItemModelBase* model)
1567 {
1568     if (m_model == model) {
1569         return;
1570     }
1571
1572     KItemModelBase* previous = m_model;
1573
1574     if (m_model) {
1575         disconnect(m_model, &KItemModelBase::itemsChanged,
1576                    this,    &KItemListView::slotItemsChanged);
1577         disconnect(m_model, &KItemModelBase::itemsInserted,
1578                    this,    &KItemListView::slotItemsInserted);
1579         disconnect(m_model, &KItemModelBase::itemsRemoved,
1580                    this,    &KItemListView::slotItemsRemoved);
1581         disconnect(m_model, &KItemModelBase::itemsMoved,
1582                    this,    &KItemListView::slotItemsMoved);
1583         disconnect(m_model, &KItemModelBase::groupsChanged,
1584                    this,    &KItemListView::slotGroupsChanged);
1585         disconnect(m_model, &KItemModelBase::groupedSortingChanged,
1586                    this,    &KItemListView::slotGroupedSortingChanged);
1587         disconnect(m_model, &KItemModelBase::sortOrderChanged,
1588                    this,    &KItemListView::slotSortOrderChanged);
1589         disconnect(m_model, &KItemModelBase::sortRoleChanged,
1590                    this,    &KItemListView::slotSortRoleChanged);
1591
1592         m_sizeHintResolver->itemsRemoved(KItemRangeList() << KItemRange(0, m_model->count()));
1593     }
1594
1595     m_model = model;
1596     m_layouter->setModel(model);
1597     m_grouped = model->groupedSorting();
1598
1599     if (m_model) {
1600         connect(m_model, &KItemModelBase::itemsChanged,
1601                 this,    &KItemListView::slotItemsChanged);
1602         connect(m_model, &KItemModelBase::itemsInserted,
1603                 this,    &KItemListView::slotItemsInserted);
1604         connect(m_model, &KItemModelBase::itemsRemoved,
1605                 this,    &KItemListView::slotItemsRemoved);
1606         connect(m_model, &KItemModelBase::itemsMoved,
1607                 this,    &KItemListView::slotItemsMoved);
1608         connect(m_model, &KItemModelBase::groupsChanged,
1609                 this,    &KItemListView::slotGroupsChanged);
1610         connect(m_model, &KItemModelBase::groupedSortingChanged,
1611                 this,    &KItemListView::slotGroupedSortingChanged);
1612         connect(m_model, &KItemModelBase::sortOrderChanged,
1613                 this,    &KItemListView::slotSortOrderChanged);
1614         connect(m_model, &KItemModelBase::sortRoleChanged,
1615                 this,    &KItemListView::slotSortRoleChanged);
1616
1617         const int itemCount = m_model->count();
1618         if (itemCount > 0) {
1619             slotItemsInserted(KItemRangeList() << KItemRange(0, itemCount));
1620         }
1621     }
1622
1623     onModelChanged(model, previous);
1624 }
1625
1626 KItemListRubberBand* KItemListView::rubberBand() const
1627 {
1628     return m_rubberBand;
1629 }
1630
1631 void KItemListView::doLayout(LayoutAnimationHint hint, int changedIndex, int changedCount)
1632 {
1633     if (m_layoutTimer->isActive()) {
1634         m_layoutTimer->stop();
1635     }
1636
1637     if (m_activeTransactions > 0) {
1638         if (hint == NoAnimation) {
1639             // As soon as at least one property change should be done without animation,
1640             // the whole transaction will be marked as not animated.
1641             m_endTransactionAnimationHint = NoAnimation;
1642         }
1643         return;
1644     }
1645
1646     if (!m_model || m_model->count() < 0) {
1647         return;
1648     }
1649
1650     int firstVisibleIndex = m_layouter->firstVisibleIndex();
1651     if (firstVisibleIndex < 0) {
1652         emitOffsetChanges();
1653         return;
1654     }
1655
1656     // Do a sanity check of the scroll-offset property: When properties of the itemlist-view have been changed
1657     // it might be possible that the maximum offset got changed too. Assure that the full visible range
1658     // is still shown if the maximum offset got decreased.
1659     const qreal visibleOffsetRange = (scrollOrientation() == Qt::Horizontal) ? size().width() : size().height();
1660     const qreal maxOffsetToShowFullRange = maximumScrollOffset() - visibleOffsetRange;
1661     if (scrollOffset() > maxOffsetToShowFullRange) {
1662         m_layouter->setScrollOffset(qMax(qreal(0), maxOffsetToShowFullRange));
1663         firstVisibleIndex = m_layouter->firstVisibleIndex();
1664     }
1665
1666     const int lastVisibleIndex = m_layouter->lastVisibleIndex();
1667
1668     int firstSibblingIndex = -1;
1669     int lastSibblingIndex = -1;
1670     const bool supportsExpanding = supportsItemExpanding();
1671
1672     QList<int> reusableItems = recycleInvisibleItems(firstVisibleIndex, lastVisibleIndex, hint);
1673
1674     // Assure that for each visible item a KItemListWidget is available. KItemListWidget
1675     // instances from invisible items are reused. If no reusable items are
1676     // found then new KItemListWidget instances get created.
1677     const bool animate = (hint == Animation);
1678     for (int i = firstVisibleIndex; i <= lastVisibleIndex; ++i) {
1679         bool applyNewPos = true;
1680         bool wasHidden = false;
1681
1682         const QRectF itemBounds = m_layouter->itemRect(i);
1683         const QPointF newPos = itemBounds.topLeft();
1684         KItemListWidget* widget = m_visibleItems.value(i);
1685         if (!widget) {
1686             wasHidden = true;
1687             if (!reusableItems.isEmpty()) {
1688                 // Reuse a KItemListWidget instance from an invisible item
1689                 const int oldIndex = reusableItems.takeLast();
1690                 widget = m_visibleItems.value(oldIndex);
1691                 setWidgetIndex(widget, i);
1692                 updateWidgetProperties(widget, i);
1693                 initializeItemListWidget(widget);
1694             } else {
1695                 // No reusable KItemListWidget instance is available, create a new one
1696                 widget = createWidget(i);
1697             }
1698             widget->resize(itemBounds.size());
1699
1700             if (animate && changedCount < 0) {
1701                 // Items have been deleted.
1702                 if (i >= changedIndex) {
1703                     // The item is located behind the removed range. Move the
1704                     // created item to the imaginary old position outside the
1705                     // view. It will get animated to the new position later.
1706                     const int previousIndex = i - changedCount;
1707                     const QRectF itemRect = m_layouter->itemRect(previousIndex);
1708                     if (itemRect.isEmpty()) {
1709                         const QPointF invisibleOldPos = (scrollOrientation() == Qt::Vertical)
1710                                                         ? QPointF(0, size().height()) : QPointF(size().width(), 0);
1711                         widget->setPos(invisibleOldPos);
1712                     } else {
1713                         widget->setPos(itemRect.topLeft());
1714                     }
1715                     applyNewPos = false;
1716                 }
1717             }
1718
1719             if (supportsExpanding && changedCount == 0) {
1720                 if (firstSibblingIndex < 0) {
1721                     firstSibblingIndex = i;
1722                 }
1723                 lastSibblingIndex = i;
1724             }
1725         }
1726
1727         if (animate) {
1728             if (m_animation->isStarted(widget, KItemListViewAnimation::MovingAnimation)) {
1729                 m_animation->start(widget,  KItemListViewAnimation::MovingAnimation, newPos);
1730                 applyNewPos = false;
1731             }
1732
1733             const bool itemsRemoved = (changedCount < 0);
1734             const bool itemsInserted = (changedCount > 0);
1735             if (itemsRemoved && (i >= changedIndex)) {
1736                 // The item is located after the removed items. Animate the moving of the position.
1737                 applyNewPos = !moveWidget(widget, newPos);
1738             } else if (itemsInserted && i >= changedIndex) {
1739                 // The item is located after the first inserted item
1740                 if (i <= changedIndex + changedCount - 1) {
1741                     // The item is an inserted item. Animate the appearing of the item.
1742                     // For performance reasons no animation is done when changedCount is equal
1743                     // to all available items.
1744                     if (changedCount < m_model->count()) {
1745                         m_animation->start(widget, KItemListViewAnimation::CreateAnimation);
1746                     }
1747                 } else if (!m_animation->isStarted(widget, KItemListViewAnimation::CreateAnimation)) {
1748                     // The item was already there before, so animate the moving of the position.
1749                     // No moving animation is done if the item is animated by a create animation: This
1750                     // prevents a "move animation mess" when inserting several ranges in parallel.
1751                     applyNewPos = !moveWidget(widget, newPos);
1752                 }
1753             } else if (!itemsRemoved && !itemsInserted && !wasHidden) {
1754                 // The size of the view might have been changed. Animate the moving of the position.
1755                 applyNewPos = !moveWidget(widget, newPos);
1756             }
1757         } else {
1758             m_animation->stop(widget);
1759         }
1760
1761         if (applyNewPos) {
1762             widget->setPos(newPos);
1763         }
1764
1765         Q_ASSERT(widget->index() == i);
1766         widget->setVisible(true);
1767
1768         if (widget->size() != itemBounds.size()) {
1769             // Resize the widget for the item to the changed size.
1770             if (animate) {
1771                 // If a dynamic item size is used then no animation is done in the direction
1772                 // of the dynamic size.
1773                 if (m_itemSize.width() <= 0) {
1774                     // The width is dynamic, apply the new width without animation.
1775                     widget->resize(itemBounds.width(), widget->size().height());
1776                 } else if (m_itemSize.height() <= 0) {
1777                     // The height is dynamic, apply the new height without animation.
1778                     widget->resize(widget->size().width(), itemBounds.height());
1779                 }
1780                 m_animation->start(widget, KItemListViewAnimation::ResizeAnimation, itemBounds.size());
1781             } else {
1782                 widget->resize(itemBounds.size());
1783             }
1784         }
1785
1786         // Updating the cell-information must be done as last step: The decision whether the
1787         // moving-animation should be started at all is based on the previous cell-information.
1788         const Cell cell(m_layouter->itemColumn(i), m_layouter->itemRow(i));
1789         m_visibleCells.insert(i, cell);
1790     }
1791
1792     // Delete invisible KItemListWidget instances that have not been reused
1793     foreach (int index, reusableItems) {
1794         recycleWidget(m_visibleItems.value(index));
1795     }
1796
1797     if (supportsExpanding && firstSibblingIndex >= 0) {
1798         Q_ASSERT(lastSibblingIndex >= 0);
1799         updateSiblingsInformation(firstSibblingIndex, lastSibblingIndex);
1800     }
1801
1802     if (m_grouped) {
1803         // Update the layout of all visible group headers
1804         QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_visibleGroups);
1805         while (it.hasNext()) {
1806             it.next();
1807             updateGroupHeaderLayout(it.key());
1808         }
1809     }
1810
1811     emitOffsetChanges();
1812 }
1813
1814 QList<int> KItemListView::recycleInvisibleItems(int firstVisibleIndex,
1815                                                 int lastVisibleIndex,
1816                                                 LayoutAnimationHint hint)
1817 {
1818     // Determine all items that are completely invisible and might be
1819     // reused for items that just got (at least partly) visible. If the
1820     // animation hint is set to 'Animation' items that do e.g. an animated
1821     // moving of their position are not marked as invisible: This assures
1822     // that a scrolling inside the view can be done without breaking an animation.
1823
1824     QList<int> items;
1825
1826     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
1827     while (it.hasNext()) {
1828         it.next();
1829
1830         KItemListWidget* widget = it.value();
1831         const int index = widget->index();
1832         const bool invisible = (index < firstVisibleIndex) || (index > lastVisibleIndex);
1833
1834         if (invisible) {
1835             if (m_animation->isStarted(widget)) {
1836                 if (hint == NoAnimation) {
1837                     // Stopping the animation will call KItemListView::slotAnimationFinished()
1838                     // and the widget will be recycled if necessary there.
1839                     m_animation->stop(widget);
1840                 }
1841             } else {
1842                 widget->setVisible(false);
1843                 items.append(index);
1844
1845                 if (m_grouped) {
1846                     recycleGroupHeaderForWidget(widget);
1847                 }
1848             }
1849         }
1850     }
1851
1852     return items;
1853 }
1854
1855 bool KItemListView::moveWidget(KItemListWidget* widget,const QPointF& newPos)
1856 {
1857     if (widget->pos() == newPos) {
1858         return false;
1859     }
1860
1861     bool startMovingAnim = false;
1862
1863     if (m_itemSize.isEmpty()) {
1864         // The items are not aligned in a grid but either as columns or rows.
1865         startMovingAnim = true;
1866     } else {
1867         // When having a grid the moving-animation should only be started, if it is done within
1868         // one row in the vertical scroll-orientation or one column in the horizontal scroll-orientation.
1869         // Otherwise instead of a moving-animation a create-animation on the new position will be used
1870         // instead. This is done to prevent overlapping (and confusing) moving-animations.
1871         const int index = widget->index();
1872         const Cell cell = m_visibleCells.value(index);
1873         if (cell.column >= 0 && cell.row >= 0) {
1874             if (scrollOrientation() == Qt::Vertical) {
1875                 startMovingAnim = (cell.row == m_layouter->itemRow(index));
1876             } else {
1877                 startMovingAnim = (cell.column == m_layouter->itemColumn(index));
1878             }
1879         }
1880     }
1881
1882     if (startMovingAnim) {
1883         m_animation->start(widget, KItemListViewAnimation::MovingAnimation, newPos);
1884         return true;
1885     }
1886
1887     m_animation->stop(widget);
1888     m_animation->start(widget, KItemListViewAnimation::CreateAnimation);
1889     return false;
1890 }
1891
1892 void KItemListView::emitOffsetChanges()
1893 {
1894     const qreal newScrollOffset = m_layouter->scrollOffset();
1895     if (m_oldScrollOffset != newScrollOffset) {
1896         emit scrollOffsetChanged(newScrollOffset, m_oldScrollOffset);
1897         m_oldScrollOffset = newScrollOffset;
1898     }
1899
1900     const qreal newMaximumScrollOffset = m_layouter->maximumScrollOffset();
1901     if (m_oldMaximumScrollOffset != newMaximumScrollOffset) {
1902         emit maximumScrollOffsetChanged(newMaximumScrollOffset, m_oldMaximumScrollOffset);
1903         m_oldMaximumScrollOffset = newMaximumScrollOffset;
1904     }
1905
1906     const qreal newItemOffset = m_layouter->itemOffset();
1907     if (m_oldItemOffset != newItemOffset) {
1908         emit itemOffsetChanged(newItemOffset, m_oldItemOffset);
1909         m_oldItemOffset = newItemOffset;
1910     }
1911
1912     const qreal newMaximumItemOffset = m_layouter->maximumItemOffset();
1913     if (m_oldMaximumItemOffset != newMaximumItemOffset) {
1914         emit maximumItemOffsetChanged(newMaximumItemOffset, m_oldMaximumItemOffset);
1915         m_oldMaximumItemOffset = newMaximumItemOffset;
1916     }
1917 }
1918
1919 KItemListWidget* KItemListView::createWidget(int index)
1920 {
1921     KItemListWidget* widget = widgetCreator()->create(this);
1922     widget->setFlag(QGraphicsItem::ItemStacksBehindParent);
1923
1924     m_visibleItems.insert(index, widget);
1925     m_visibleCells.insert(index, Cell());
1926     updateWidgetProperties(widget, index);
1927     initializeItemListWidget(widget);
1928     return widget;
1929 }
1930
1931 void KItemListView::recycleWidget(KItemListWidget* widget)
1932 {
1933     if (m_grouped) {
1934         recycleGroupHeaderForWidget(widget);
1935     }
1936
1937     const int index = widget->index();
1938     m_visibleItems.remove(index);
1939     m_visibleCells.remove(index);
1940
1941     widgetCreator()->recycle(widget);
1942 }
1943
1944 void KItemListView::setWidgetIndex(KItemListWidget* widget, int index)
1945 {
1946     const int oldIndex = widget->index();
1947     m_visibleItems.remove(oldIndex);
1948     m_visibleCells.remove(oldIndex);
1949
1950     m_visibleItems.insert(index, widget);
1951     m_visibleCells.insert(index, Cell());
1952
1953     widget->setIndex(index);
1954 }
1955
1956 void KItemListView::moveWidgetToIndex(KItemListWidget* widget, int index)
1957 {
1958     const int oldIndex = widget->index();
1959     const Cell oldCell = m_visibleCells.value(oldIndex);
1960
1961     setWidgetIndex(widget, index);
1962
1963     const Cell newCell(m_layouter->itemColumn(index), m_layouter->itemRow(index));
1964     const bool vertical = (scrollOrientation() == Qt::Vertical);
1965     const bool updateCell = (vertical  && oldCell.row    == newCell.row) ||
1966                             (!vertical && oldCell.column == newCell.column);
1967     if (updateCell) {
1968         m_visibleCells.insert(index, newCell);
1969     }
1970 }
1971
1972 void KItemListView::setLayouterSize(const QSizeF& size, SizeType sizeType)
1973 {
1974     switch (sizeType) {
1975     case LayouterSize: m_layouter->setSize(size); break;
1976     case ItemSize: m_layouter->setItemSize(size); break;
1977     default: break;
1978     }
1979 }
1980
1981 void KItemListView::updateWidgetProperties(KItemListWidget* widget, int index)
1982 {
1983     widget->setVisibleRoles(m_visibleRoles);
1984     updateWidgetColumnWidths(widget);
1985     widget->setStyleOption(m_styleOption);
1986
1987     const KItemListSelectionManager* selectionManager = m_controller->selectionManager();
1988
1989     // In SingleSelection mode (e.g., in the Places Panel), the current item is
1990     // always the selected item. It is not necessary to highlight the current item then.
1991     if (m_controller->selectionBehavior() != KItemListController::SingleSelection) {
1992         widget->setCurrent(index == selectionManager->currentItem());
1993     }
1994     widget->setSelected(selectionManager->isSelected(index));
1995     widget->setHovered(false);
1996     widget->setEnabledSelectionToggle(enabledSelectionToggles());
1997     widget->setIndex(index);
1998     widget->setData(m_model->data(index));
1999     widget->setSiblingsInformation(QBitArray());
2000     updateAlternateBackgroundForWidget(widget);
2001
2002     if (m_grouped) {
2003         updateGroupHeaderForWidget(widget);
2004     }
2005 }
2006
2007 void KItemListView::updateGroupHeaderForWidget(KItemListWidget* widget)
2008 {
2009     Q_ASSERT(m_grouped);
2010
2011     const int index = widget->index();
2012     if (!m_layouter->isFirstGroupItem(index)) {
2013         // The widget does not represent the first item of a group
2014         // and hence requires no header
2015         recycleGroupHeaderForWidget(widget);
2016         return;
2017     }
2018
2019     const QList<QPair<int, QVariant> > groups = model()->groups();
2020     if (groups.isEmpty() || !groupHeaderCreator()) {
2021         return;
2022     }
2023
2024     KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
2025     if (!groupHeader) {
2026         groupHeader = groupHeaderCreator()->create(this);
2027         groupHeader->setParentItem(widget);
2028         m_visibleGroups.insert(widget, groupHeader);
2029         connect(widget, &KItemListWidget::geometryChanged, this, &KItemListView::slotGeometryOfGroupHeaderParentChanged);
2030     }
2031     Q_ASSERT(groupHeader->parentItem() == widget);
2032
2033     const int groupIndex = groupIndexForItem(index);
2034     Q_ASSERT(groupIndex >= 0);
2035     groupHeader->setData(groups.at(groupIndex).second);
2036     groupHeader->setRole(model()->sortRole());
2037     groupHeader->setStyleOption(m_styleOption);
2038     groupHeader->setScrollOrientation(scrollOrientation());
2039     groupHeader->setItemIndex(index);
2040
2041     groupHeader->show();
2042 }
2043
2044 void KItemListView::updateGroupHeaderLayout(KItemListWidget* widget)
2045 {
2046     KItemListGroupHeader* groupHeader = m_visibleGroups.value(widget);
2047     Q_ASSERT(groupHeader);
2048
2049     const int index = widget->index();
2050     const QRectF groupHeaderRect = m_layouter->groupHeaderRect(index);
2051     const QRectF itemRect = m_layouter->itemRect(index);
2052
2053     // The group-header is a child of the itemlist widget. Translate the
2054     // group header position to the relative position.
2055     if (scrollOrientation() == Qt::Vertical) {
2056         // In the vertical scroll orientation the group header should always span
2057         // the whole width no matter which temporary position the parent widget
2058         // has. In this case the x-position and width will be adjusted manually.
2059         const qreal x = -widget->x() - itemOffset();
2060         const qreal width = maximumItemOffset();
2061         groupHeader->setPos(x, -groupHeaderRect.height());
2062         groupHeader->resize(width, groupHeaderRect.size().height());
2063     } else {
2064         groupHeader->setPos(groupHeaderRect.x() - itemRect.x(), -widget->y());
2065         groupHeader->resize(groupHeaderRect.size());
2066     }
2067 }
2068
2069 void KItemListView::recycleGroupHeaderForWidget(KItemListWidget* widget)
2070 {
2071     KItemListGroupHeader* header = m_visibleGroups.value(widget);
2072     if (header) {
2073         header->setParentItem(nullptr);
2074         groupHeaderCreator()->recycle(header);
2075         m_visibleGroups.remove(widget);
2076         disconnect(widget, &KItemListWidget::geometryChanged, this, &KItemListView::slotGeometryOfGroupHeaderParentChanged);
2077     }
2078 }
2079
2080 void KItemListView::updateVisibleGroupHeaders()
2081 {
2082     Q_ASSERT(m_grouped);
2083     m_layouter->markAsDirty();
2084
2085     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
2086     while (it.hasNext()) {
2087         it.next();
2088         updateGroupHeaderForWidget(it.value());
2089     }
2090 }
2091
2092 int KItemListView::groupIndexForItem(int index) const
2093 {
2094     Q_ASSERT(m_grouped);
2095
2096     const QList<QPair<int, QVariant> > groups = model()->groups();
2097     if (groups.isEmpty()) {
2098         return -1;
2099     }
2100
2101     int min = 0;
2102     int max = groups.count() - 1;
2103     int mid = 0;
2104     do {
2105         mid = (min + max) / 2;
2106         if (index > groups[mid].first) {
2107             min = mid + 1;
2108         } else {
2109             max = mid - 1;
2110         }
2111     } while (groups[mid].first != index && min <= max);
2112
2113     if (min > max) {
2114         while (groups[mid].first > index && mid > 0) {
2115             --mid;
2116         }
2117     }
2118
2119     return mid;
2120 }
2121
2122 void KItemListView::updateAlternateBackgrounds()
2123 {
2124     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
2125     while (it.hasNext()) {
2126         it.next();
2127         updateAlternateBackgroundForWidget(it.value());
2128     }
2129 }
2130
2131 void KItemListView::updateAlternateBackgroundForWidget(KItemListWidget* widget)
2132 {
2133     bool enabled = useAlternateBackgrounds();
2134     if (enabled) {
2135         const int index = widget->index();
2136         enabled = (index & 0x1) > 0;
2137         if (m_grouped) {
2138             const int groupIndex = groupIndexForItem(index);
2139             if (groupIndex >= 0) {
2140                 const QList<QPair<int, QVariant> > groups = model()->groups();
2141                 const int indexOfFirstGroupItem = groups[groupIndex].first;
2142                 const int relativeIndex = index - indexOfFirstGroupItem;
2143                 enabled = (relativeIndex & 0x1) > 0;
2144             }
2145         }
2146     }
2147     widget->setAlternateBackground(enabled);
2148 }
2149
2150 bool KItemListView::useAlternateBackgrounds() const
2151 {
2152     return m_itemSize.isEmpty() && m_visibleRoles.count() > 1;
2153 }
2154
2155 QHash<QByteArray, qreal> KItemListView::preferredColumnWidths(const KItemRangeList& itemRanges) const
2156 {
2157     QElapsedTimer timer;
2158     timer.start();
2159
2160     QHash<QByteArray, qreal> widths;
2161
2162     // Calculate the minimum width for each column that is required
2163     // to show the headline unclipped.
2164     const QFontMetricsF fontMetrics(m_headerWidget->font());
2165     const int gripMargin   = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderGripMargin);
2166     const int headerMargin = m_headerWidget->style()->pixelMetric(QStyle::PM_HeaderMargin);
2167     foreach (const QByteArray& visibleRole, visibleRoles()) {
2168         const QString headerText = m_model->roleDescription(visibleRole);
2169         const qreal headerWidth = fontMetrics.width(headerText) + gripMargin + headerMargin * 2;
2170         widths.insert(visibleRole, headerWidth);
2171     }
2172
2173     // Calculate the preferred column withs for each item and ignore values
2174     // smaller than the width for showing the headline unclipped.
2175     const KItemListWidgetCreatorBase* creator = widgetCreator();
2176     int calculatedItemCount = 0;
2177     bool maxTimeExceeded = false;
2178     foreach (const KItemRange& itemRange, itemRanges) {
2179         const int startIndex = itemRange.index;
2180         const int endIndex = startIndex + itemRange.count - 1;
2181
2182         for (int i = startIndex; i <= endIndex; ++i) {
2183             foreach (const QByteArray& visibleRole, visibleRoles()) {
2184                 qreal maxWidth = widths.value(visibleRole, 0);
2185                 const qreal width = creator->preferredRoleColumnWidth(visibleRole, i, this);
2186                 maxWidth = qMax(width, maxWidth);
2187                 widths.insert(visibleRole, maxWidth);
2188             }
2189
2190             if (calculatedItemCount > 100 && timer.elapsed() > 200) {
2191                 // When having several thousands of items calculating the sizes can get
2192                 // very expensive. We accept a possibly too small role-size in favour
2193                 // of having no blocking user interface.
2194                 maxTimeExceeded = true;
2195                 break;
2196             }
2197             ++calculatedItemCount;
2198         }
2199         if (maxTimeExceeded) {
2200             break;
2201         }
2202     }
2203
2204     return widths;
2205 }
2206
2207 void KItemListView::applyColumnWidthsFromHeader()
2208 {
2209     // Apply the new size to the layouter
2210     const qreal requiredWidth = columnWidthsSum();
2211     const QSizeF dynamicItemSize(qMax(size().width(), requiredWidth),
2212                                  m_itemSize.height());
2213     m_layouter->setItemSize(dynamicItemSize);
2214
2215     // Update the role sizes for all visible widgets
2216     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
2217     while (it.hasNext()) {
2218         it.next();
2219         updateWidgetColumnWidths(it.value());
2220     }
2221 }
2222
2223 void KItemListView::updateWidgetColumnWidths(KItemListWidget* widget)
2224 {
2225     foreach (const QByteArray& role, m_visibleRoles) {
2226         widget->setColumnWidth(role, m_headerWidget->columnWidth(role));
2227     }
2228 }
2229
2230 void KItemListView::updatePreferredColumnWidths(const KItemRangeList& itemRanges)
2231 {
2232     Q_ASSERT(m_itemSize.isEmpty());
2233     const int itemCount = m_model->count();
2234     int rangesItemCount = 0;
2235     foreach (const KItemRange& range, itemRanges) {
2236         rangesItemCount += range.count;
2237     }
2238
2239     if (itemCount == rangesItemCount) {
2240         const QHash<QByteArray, qreal> preferredWidths = preferredColumnWidths(itemRanges);
2241         foreach (const QByteArray& role, m_visibleRoles) {
2242             m_headerWidget->setPreferredColumnWidth(role, preferredWidths.value(role));
2243         }
2244     } else {
2245         // Only a sub range of the roles need to be determined.
2246         // The chances are good that the widths of the sub ranges
2247         // already fit into the available widths and hence no
2248         // expensive update might be required.
2249         bool changed = false;
2250
2251         const QHash<QByteArray, qreal> updatedWidths = preferredColumnWidths(itemRanges);
2252         QHashIterator<QByteArray, qreal> it(updatedWidths);
2253         while (it.hasNext()) {
2254             it.next();
2255             const QByteArray& role = it.key();
2256             const qreal updatedWidth = it.value();
2257             const qreal currentWidth = m_headerWidget->preferredColumnWidth(role);
2258             if (updatedWidth > currentWidth) {
2259                 m_headerWidget->setPreferredColumnWidth(role, updatedWidth);
2260                 changed = true;
2261             }
2262         }
2263
2264         if (!changed) {
2265             // All the updated sizes are smaller than the current sizes and no change
2266             // of the stretched roles-widths is required
2267             return;
2268         }
2269     }
2270
2271     if (m_headerWidget->automaticColumnResizing()) {
2272         applyAutomaticColumnWidths();
2273     }
2274 }
2275
2276 void KItemListView::updatePreferredColumnWidths()
2277 {
2278     if (m_model) {
2279         updatePreferredColumnWidths(KItemRangeList() << KItemRange(0, m_model->count()));
2280     }
2281 }
2282
2283 void KItemListView::applyAutomaticColumnWidths()
2284 {
2285     Q_ASSERT(m_itemSize.isEmpty());
2286     Q_ASSERT(m_headerWidget->automaticColumnResizing());
2287     if (m_visibleRoles.isEmpty()) {
2288         return;
2289     }
2290
2291     // Calculate the maximum size of an item by considering the
2292     // visible role sizes and apply them to the layouter. If the
2293     // size does not use the available view-size the size of the
2294     // first role will get stretched.
2295
2296     foreach (const QByteArray& role, m_visibleRoles) {
2297         const qreal preferredWidth = m_headerWidget->preferredColumnWidth(role);
2298         m_headerWidget->setColumnWidth(role, preferredWidth);
2299     }
2300
2301     const QByteArray firstRole = m_visibleRoles.first();
2302     qreal firstColumnWidth = m_headerWidget->columnWidth(firstRole);
2303     QSizeF dynamicItemSize = m_itemSize;
2304
2305     qreal requiredWidth = columnWidthsSum();
2306     const qreal availableWidth = size().width();
2307     if (requiredWidth < availableWidth) {
2308         // Stretch the first column to use the whole remaining width
2309         firstColumnWidth += availableWidth - requiredWidth;
2310         m_headerWidget->setColumnWidth(firstRole, firstColumnWidth);
2311     } else if (requiredWidth > availableWidth && m_visibleRoles.count() > 1) {
2312         // Shrink the first column to be able to show as much other
2313         // columns as possible
2314         qreal shrinkedFirstColumnWidth = firstColumnWidth - requiredWidth + availableWidth;
2315
2316         // TODO: A proper calculation of the minimum width depends on the implementation
2317         // of KItemListWidget. Probably a kind of minimum size-hint should be introduced
2318         // later.
2319         const qreal minWidth = qMin(firstColumnWidth, qreal(m_styleOption.iconSize * 2 + 200));
2320         if (shrinkedFirstColumnWidth < minWidth) {
2321             shrinkedFirstColumnWidth = minWidth;
2322         }
2323
2324         m_headerWidget->setColumnWidth(firstRole, shrinkedFirstColumnWidth);
2325         requiredWidth -= firstColumnWidth - shrinkedFirstColumnWidth;
2326     }
2327
2328     dynamicItemSize.rwidth() = qMax(requiredWidth, availableWidth);
2329
2330     m_layouter->setItemSize(dynamicItemSize);
2331
2332     // Update the role sizes for all visible widgets
2333     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
2334     while (it.hasNext()) {
2335         it.next();
2336         updateWidgetColumnWidths(it.value());
2337     }
2338 }
2339
2340 qreal KItemListView::columnWidthsSum() const
2341 {
2342     qreal widthsSum = 0;
2343     foreach (const QByteArray& role, m_visibleRoles) {
2344         widthsSum += m_headerWidget->columnWidth(role);
2345     }
2346     return widthsSum;
2347 }
2348
2349 QRectF KItemListView::headerBoundaries() const
2350 {
2351     return m_headerWidget->isVisible() ? m_headerWidget->geometry() : QRectF();
2352 }
2353
2354 bool KItemListView::changesItemGridLayout(const QSizeF& newGridSize,
2355                                           const QSizeF& newItemSize,
2356                                           const QSizeF& newItemMargin) const
2357 {
2358     if (newItemSize.isEmpty() || newGridSize.isEmpty()) {
2359         return false;
2360     }
2361
2362     if (m_layouter->scrollOrientation() == Qt::Vertical) {
2363         const qreal itemWidth = m_layouter->itemSize().width();
2364         if (itemWidth > 0) {
2365             const int newColumnCount = itemsPerSize(newGridSize.width(),
2366                                                     newItemSize.width(),
2367                                                     newItemMargin.width());
2368             if (m_model->count() > newColumnCount) {
2369                 const int oldColumnCount = itemsPerSize(m_layouter->size().width(),
2370                                                         itemWidth,
2371                                                         m_layouter->itemMargin().width());
2372                 return oldColumnCount != newColumnCount;
2373             }
2374         }
2375     } else {
2376         const qreal itemHeight = m_layouter->itemSize().height();
2377         if (itemHeight > 0) {
2378             const int newRowCount = itemsPerSize(newGridSize.height(),
2379                                                  newItemSize.height(),
2380                                                  newItemMargin.height());
2381             if (m_model->count() > newRowCount) {
2382                 const int oldRowCount = itemsPerSize(m_layouter->size().height(),
2383                                                      itemHeight,
2384                                                      m_layouter->itemMargin().height());
2385                 return oldRowCount != newRowCount;
2386             }
2387         }
2388     }
2389
2390     return false;
2391 }
2392
2393 bool KItemListView::animateChangedItemCount(int changedItemCount) const
2394 {
2395     if (m_itemSize.isEmpty()) {
2396         // We have only columns or only rows, but no grid: An animation is usually
2397         // welcome when inserting or removing items.
2398         return !supportsItemExpanding();
2399     }
2400
2401     if (m_layouter->size().isEmpty() || m_layouter->itemSize().isEmpty()) {
2402         return false;
2403     }
2404
2405     const int maximum = (scrollOrientation() == Qt::Vertical)
2406                         ? m_layouter->size().width()  / m_layouter->itemSize().width()
2407                         : m_layouter->size().height() / m_layouter->itemSize().height();
2408     // Only animate if up to 2/3 of a row or column are inserted or removed
2409     return changedItemCount <= maximum * 2 / 3;
2410 }
2411
2412
2413 bool KItemListView::scrollBarRequired(const QSizeF& size) const
2414 {
2415     const QSizeF oldSize = m_layouter->size();
2416
2417     m_layouter->setSize(size);
2418     const qreal maxOffset = m_layouter->maximumScrollOffset();
2419     m_layouter->setSize(oldSize);
2420
2421     return m_layouter->scrollOrientation() == Qt::Vertical ? maxOffset > size.height()
2422                                                            : maxOffset > size.width();
2423 }
2424
2425 int KItemListView::showDropIndicator(const QPointF& pos)
2426 {
2427     QHashIterator<int, KItemListWidget*> it(m_visibleItems);
2428     while (it.hasNext()) {
2429         it.next();
2430         const KItemListWidget* widget = it.value();
2431
2432         const QPointF mappedPos = widget->mapFromItem(this, pos);
2433         const QRectF rect = itemRect(widget->index());
2434         if (mappedPos.y() >= 0 && mappedPos.y() <= rect.height()) {
2435             if (m_model->supportsDropping(widget->index())) {
2436                 // Keep 30% of the rectangle as the gap instead of always having a fixed gap
2437                 const int gap = qMax(qreal(4.0), qreal(0.3) * rect.height());
2438                 if (mappedPos.y() >= gap && mappedPos.y() <= rect.height() - gap) {
2439                     return -1;
2440                 }
2441             }
2442
2443             const bool isAboveItem = (mappedPos.y () < rect.height() / 2);
2444             const qreal y = isAboveItem ? rect.top() : rect.bottom();
2445
2446             const QRectF draggingInsertIndicator(rect.left(), y, rect.width(), 1);
2447             if (m_dropIndicator != draggingInsertIndicator) {
2448                 m_dropIndicator = draggingInsertIndicator;
2449                 update();
2450             }
2451
2452             int index = widget->index();
2453             if (!isAboveItem) {
2454                 ++index;
2455             }
2456             return index;
2457         }
2458     }
2459
2460     const QRectF firstItemRect = itemRect(firstVisibleIndex());
2461     return (pos.y() <= firstItemRect.top()) ? 0 : -1;
2462 }
2463
2464 void KItemListView::hideDropIndicator()
2465 {
2466     if (!m_dropIndicator.isNull()) {
2467         m_dropIndicator = QRectF();
2468         update();
2469     }
2470 }
2471
2472 void KItemListView::updateGroupHeaderHeight()
2473 {
2474     qreal groupHeaderHeight = m_styleOption.fontMetrics.height();
2475     qreal groupHeaderMargin = 0;
2476
2477     if (scrollOrientation() == Qt::Horizontal) {
2478         // The vertical margin above and below the header should be
2479         // equal to the horizontal margin, not the vertical margin
2480         // from m_styleOption.
2481         groupHeaderHeight += 2 * m_styleOption.horizontalMargin;
2482         groupHeaderMargin = m_styleOption.horizontalMargin;
2483     } else if (m_itemSize.isEmpty()){
2484         groupHeaderHeight += 4 * m_styleOption.padding;
2485         groupHeaderMargin = m_styleOption.iconSize / 2;
2486     } else {
2487         groupHeaderHeight += 2 * m_styleOption.padding + m_styleOption.verticalMargin;
2488         groupHeaderMargin = m_styleOption.iconSize / 4;
2489     }
2490     m_layouter->setGroupHeaderHeight(groupHeaderHeight);
2491     m_layouter->setGroupHeaderMargin(groupHeaderMargin);
2492
2493     updateVisibleGroupHeaders();
2494 }
2495
2496 void KItemListView::updateSiblingsInformation(int firstIndex, int lastIndex)
2497 {
2498     if (!supportsItemExpanding() || !m_model) {
2499         return;
2500     }
2501
2502     if (firstIndex < 0 || lastIndex < 0) {
2503         firstIndex = m_layouter->firstVisibleIndex();
2504         lastIndex  = m_layouter->lastVisibleIndex();
2505     } else {
2506         const bool isRangeVisible = (firstIndex <= m_layouter->lastVisibleIndex() &&
2507                                      lastIndex  >= m_layouter->firstVisibleIndex());
2508         if (!isRangeVisible) {
2509             return;
2510         }
2511     }
2512
2513     int previousParents = 0;
2514     QBitArray previousSiblings;
2515
2516     // The rootIndex describes the first index where the siblings get
2517     // calculated from. For the calculation the upper most parent item
2518     // is required. For performance reasons it is checked first whether
2519     // the visible items before or after the current range already
2520     // contain a siblings information which can be used as base.
2521     int rootIndex = firstIndex;
2522
2523     KItemListWidget* widget = m_visibleItems.value(firstIndex - 1);
2524     if (!widget) {
2525         // There is no visible widget before the range, check whether there
2526         // is one after the range:
2527         widget = m_visibleItems.value(lastIndex + 1);
2528         if (widget) {
2529             // The sibling information of the widget may only be used if
2530             // all items of the range have the same number of parents.
2531             const int parents = m_model->expandedParentsCount(lastIndex + 1);
2532             for (int i = lastIndex; i >= firstIndex; --i) {
2533                 if (m_model->expandedParentsCount(i) != parents) {
2534                     widget = nullptr;
2535                     break;
2536                 }
2537             }
2538         }
2539     }
2540
2541     if (widget) {
2542         // Performance optimization: Use the sibling information of the visible
2543         // widget beside the given range.
2544         previousSiblings = widget->siblingsInformation();
2545         if (previousSiblings.isEmpty()) {
2546             return;
2547         }
2548         previousParents = previousSiblings.count() - 1;
2549         previousSiblings.truncate(previousParents);
2550     } else {
2551         // Potentially slow path: Go back to the upper most parent of firstIndex
2552         // to be able to calculate the initial value for the siblings.
2553         while (rootIndex > 0 && m_model->expandedParentsCount(rootIndex) > 0) {
2554             --rootIndex;
2555         }
2556     }
2557
2558     Q_ASSERT(previousParents >= 0);
2559     for (int i = rootIndex; i <= lastIndex; ++i) {
2560         // Update the parent-siblings in case if the current item represents
2561         // a child or an upper parent.
2562         const int currentParents = m_model->expandedParentsCount(i);
2563         Q_ASSERT(currentParents >= 0);
2564         if (previousParents < currentParents) {
2565             previousParents = currentParents;
2566             previousSiblings.resize(currentParents);
2567             previousSiblings.setBit(currentParents - 1, hasSiblingSuccessor(i - 1));
2568         } else if (previousParents > currentParents) {
2569             previousParents = currentParents;
2570             previousSiblings.truncate(currentParents);
2571         }
2572
2573         if (i >= firstIndex) {
2574             // The index represents a visible item. Apply the parent-siblings
2575             // and update the sibling of the current item.
2576             KItemListWidget* widget = m_visibleItems.value(i);
2577             if (!widget) {
2578                 continue;
2579             }
2580
2581             QBitArray siblings = previousSiblings;
2582             siblings.resize(siblings.count() + 1);
2583             siblings.setBit(siblings.count() - 1, hasSiblingSuccessor(i));
2584
2585             widget->setSiblingsInformation(siblings);
2586         }
2587     }
2588 }
2589
2590 bool KItemListView::hasSiblingSuccessor(int index) const
2591 {
2592     bool hasSuccessor = false;
2593     const int parentsCount = m_model->expandedParentsCount(index);
2594     int successorIndex = index + 1;
2595
2596     // Search the next sibling
2597     const int itemCount = m_model->count();
2598     while (successorIndex < itemCount) {
2599         const int currentParentsCount = m_model->expandedParentsCount(successorIndex);
2600         if (currentParentsCount == parentsCount) {
2601             hasSuccessor = true;
2602             break;
2603         } else if (currentParentsCount < parentsCount) {
2604             break;
2605         }
2606         ++successorIndex;
2607     }
2608
2609     if (m_grouped && hasSuccessor) {
2610         // If the sibling is part of another group, don't mark it as
2611         // successor as the group header is between the sibling connections.
2612         for (int i = index + 1; i <= successorIndex; ++i) {
2613             if (m_layouter->isFirstGroupItem(i)) {
2614                 hasSuccessor = false;
2615                 break;
2616             }
2617         }
2618     }
2619
2620     return hasSuccessor;
2621 }
2622
2623 void KItemListView::disconnectRoleEditingSignals(int index)
2624 {
2625     KStandardItemListWidget* widget = qobject_cast<KStandardItemListWidget *>(m_visibleItems.value(index));
2626     if (!widget) {
2627         return;
2628     }
2629
2630     disconnect(widget, &KItemListWidget::roleEditingCanceled, this, nullptr);
2631     disconnect(widget, &KItemListWidget::roleEditingFinished, this, nullptr);
2632     disconnect(this, &KItemListView::scrollOffsetChanged, widget, nullptr);
2633 }
2634
2635 int KItemListView::calculateAutoScrollingIncrement(int pos, int range, int oldInc)
2636 {
2637     int inc = 0;
2638
2639     const int minSpeed = 4;
2640     const int maxSpeed = 128;
2641     const int speedLimiter = 96;
2642     const int autoScrollBorder = 64;
2643
2644     // Limit the increment that is allowed to be added in comparison to 'oldInc'.
2645     // This assures that the autoscrolling speed grows gradually.
2646     const int incLimiter = 1;
2647
2648     if (pos < autoScrollBorder) {
2649         inc = -minSpeed + qAbs(pos - autoScrollBorder) * (pos - autoScrollBorder) / speedLimiter;
2650         inc = qMax(inc, -maxSpeed);
2651         inc = qMax(inc, oldInc - incLimiter);
2652     } else if (pos > range - autoScrollBorder) {
2653         inc = minSpeed + qAbs(pos - range + autoScrollBorder) * (pos - range + autoScrollBorder) / speedLimiter;
2654         inc = qMin(inc, maxSpeed);
2655         inc = qMin(inc, oldInc + incLimiter);
2656     }
2657
2658     return inc;
2659 }
2660
2661 int KItemListView::itemsPerSize(qreal size, qreal itemSize, qreal itemMargin)
2662 {
2663     const qreal availableSize = size - itemMargin;
2664     const int count = availableSize / (itemSize + itemMargin);
2665     return count;
2666 }
2667
2668
2669
2670 KItemListCreatorBase::~KItemListCreatorBase()
2671 {
2672     qDeleteAll(m_recycleableWidgets);
2673     qDeleteAll(m_createdWidgets);
2674 }
2675
2676 void KItemListCreatorBase::addCreatedWidget(QGraphicsWidget* widget)
2677 {
2678     m_createdWidgets.insert(widget);
2679 }
2680
2681 void KItemListCreatorBase::pushRecycleableWidget(QGraphicsWidget* widget)
2682 {
2683     Q_ASSERT(m_createdWidgets.contains(widget));
2684     m_createdWidgets.remove(widget);
2685
2686     if (m_recycleableWidgets.count() < 100) {
2687         m_recycleableWidgets.append(widget);
2688         widget->setVisible(false);
2689     } else {
2690         delete widget;
2691     }
2692 }
2693
2694 QGraphicsWidget* KItemListCreatorBase::popRecycleableWidget()
2695 {
2696     if (m_recycleableWidgets.isEmpty()) {
2697         return nullptr;
2698     }
2699
2700     QGraphicsWidget* widget = m_recycleableWidgets.takeLast();
2701     m_createdWidgets.insert(widget);
2702     return widget;
2703 }
2704
2705 KItemListWidgetCreatorBase::~KItemListWidgetCreatorBase()
2706 {
2707 }
2708
2709 void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
2710 {
2711     widget->setParentItem(nullptr);
2712     widget->setOpacity(1.0);
2713     pushRecycleableWidget(widget);
2714 }
2715
2716 KItemListGroupHeaderCreatorBase::~KItemListGroupHeaderCreatorBase()
2717 {
2718 }
2719
2720 void KItemListGroupHeaderCreatorBase::recycle(KItemListGroupHeader* header)
2721 {
2722     header->setOpacity(1.0);
2723     pushRecycleableWidget(header);
2724 }
2725