src/gui/torrentcontentmodel.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2022-2024  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2006-2012  Christophe Dumez <chris@qbittorrent.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "torrentcontentmodel.h"
  31
  32 #include <algorithm>
  33
  34 #include <QFileIconProvider>
  35 #include <QFileInfo>
  36 #include <QIcon>
  37 #include <QPointer>
  38 #include <QScopeGuard>
  39
  40 #if defined(Q_OS_MACOS)
  41 #define QBT_PIXMAP_CACHE_FOR_FILE_ICONS
  42 #include <QPixmapCache>
  43 #elif !defined(Q_OS_WIN)
  44 #include <QMimeDatabase>
  45 #include <QMimeType>
  46 #endif
  47
  48 #include "base/bittorrent/downloadpriority.h"
  49 #include "base/bittorrent/torrentcontenthandler.h"
  50 #include "base/exceptions.h"
  51 #include "base/global.h"
  52 #include "base/path.h"
  53 #include "base/utils/fs.h"
  54 #include "torrentcontentmodelfile.h"
  55 #include "torrentcontentmodelfolder.h"
  56 #include "torrentcontentmodelitem.h"
  57 #include "uithememanager.h"
  58
  59 #ifdef Q_OS_MACOS
  60 #include "macutilities.h"
  61 #endif
  62
  63 namespace
  64 {
  65     class UnifiedFileIconProvider : public QFileIconProvider
  66     {
  67     public:
  68         UnifiedFileIconProvider()
  69             : m_textPlainIcon {UIThemeManager::instance()->getIcon(u"help-about"_s, u"text-plain"_s)}
  70         {
  71         }
  72
  73         using QFileIconProvider::icon;
  74
  75         QIcon icon(const QFileInfo &) const override
  76         {
  77             return m_textPlainIcon;
  78         }
  79
  80     private:
  81         QIcon m_textPlainIcon;
  82     };
  83
  84 #ifdef QBT_PIXMAP_CACHE_FOR_FILE_ICONS
  85     class CachingFileIconProvider : public UnifiedFileIconProvider
  86     {
  87     public:
  88         using QFileIconProvider::icon;
  89
  90         QIcon icon(const QFileInfo &info) const final
  91         {
  92             const QString ext = info.suffix();
  93             if (!ext.isEmpty())
  94             {
  95                 QPixmap cached;
  96                 if (QPixmapCache::find(ext, &cached))
  97                     return {cached};
  98
  99                 const QPixmap pixmap = pixmapForExtension(ext);
 100                 if (!pixmap.isNull())
 101                 {
 102                     QPixmapCache::insert(ext, pixmap);
 103                     return {pixmap};
 104                 }
 105             }
 106             return UnifiedFileIconProvider::icon(info);
 107         }
 108
 109     protected:
 110         virtual QPixmap pixmapForExtension(const QString &ext) const = 0;
 111     };
 112 #endif // QBT_PIXMAP_CACHE_FOR_FILE_ICONS
 113
 114 #if defined(Q_OS_MACOS)
 115     // There is a bug on macOS, to be reported to Qt
 116     // https://github.com/qbittorrent/qBittorrent/pull/6156#issuecomment-316302615
 117     class MacFileIconProvider final : public CachingFileIconProvider
 118     {
 119         QPixmap pixmapForExtension(const QString &ext) const override
 120         {
 121             return MacUtils::pixmapForExtension(ext, QSize(32, 32));
 122         }
 123     };
 124 #elif !defined(Q_OS_WIN)
 125     /**
 126      * @brief Tests whether QFileIconProvider actually works
 127      *
 128      * Some QPA plugins do not implement QPlatformTheme::fileIcon(), and
 129      * QFileIconProvider::icon() returns empty icons as the result. Here we ask it for
 130      * two icons for probably absent files and when both icons are null, we assume that
 131      * the current QPA plugin does not implement QPlatformTheme::fileIcon().
 132      */
 133     bool doesQFileIconProviderWork()
 134     {
 135         const Path PSEUDO_UNIQUE_FILE_NAME = Utils::Fs::tempPath() / Path(u"qBittorrent-test-QFileIconProvider-845eb448-7ad5-4cdb-b764-b3f322a266a9"_s);
 136         QFileIconProvider provider;
 137         const QIcon testIcon1 = provider.icon(QFileInfo((PSEUDO_UNIQUE_FILE_NAME + u".pdf").data()));
 138         const QIcon testIcon2 = provider.icon(QFileInfo((PSEUDO_UNIQUE_FILE_NAME + u".png").data()));
 139         return (!testIcon1.isNull() || !testIcon2.isNull());
 140     }
 141
 142     class MimeFileIconProvider final : public UnifiedFileIconProvider
 143     {
 144         using QFileIconProvider::icon;
 145
 146         QIcon icon(const QFileInfo &info) const override
 147         {
 148             const QMimeType mimeType = QMimeDatabase().mimeTypeForFile(info, QMimeDatabase::MatchExtension);
 149
 150             const auto mimeIcon = QIcon::fromTheme(mimeType.iconName());
 151             if (!mimeIcon.isNull())
 152                 return mimeIcon;
 153
 154             const auto genericIcon = QIcon::fromTheme(mimeType.genericIconName());
 155             if (!genericIcon.isNull())
 156                 return genericIcon;
 157
 158             return UnifiedFileIconProvider::icon(info);
 159         }
 160     };
 161 #endif // Q_OS_WIN
 162 }
 163
 164 TorrentContentModel::TorrentContentModel(QObject *parent)
 165     : QAbstractItemModel(parent)
 166     , m_rootItem(new TorrentContentModelFolder(QList<QString>({ tr("Name"), tr("Total Size"), tr("Progress"), tr("Download Priority"), tr("Remaining"), tr("Availability") })))
 167 #if defined(Q_OS_WIN)
 168     , m_fileIconProvider {new QFileIconProvider}
 169 #elif defined(Q_OS_MACOS)
 170     , m_fileIconProvider {new MacFileIconProvider}
 171 #else
 172     , m_fileIconProvider {doesQFileIconProviderWork() ? new QFileIconProvider : new MimeFileIconProvider}
 173 #endif
 174 {
 175     m_fileIconProvider->setOptions(QFileIconProvider::DontUseCustomDirectoryIcons);
 176 }
 177
 178 TorrentContentModel::~TorrentContentModel()
 179 {
 180     delete m_fileIconProvider;
 181     delete m_rootItem;
 182 }
 183
 184 void TorrentContentModel::updateFilesProgress()
 185 {
 186     Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata());
 187
 188     const QList<qreal> &filesProgress = m_contentHandler->filesProgress();
 189     Q_ASSERT(m_filesIndex.size() == filesProgress.size());
 190     // XXX: Why is this necessary?
 191     if (m_filesIndex.size() != filesProgress.size()) [[unlikely]]
 192         return;
 193
 194     for (int i = 0; i < filesProgress.size(); ++i)
 195         m_filesIndex[i]->setProgress(filesProgress[i]);
 196     // Update folders progress in the tree
 197     m_rootItem->recalculateProgress();
 198     m_rootItem->recalculateAvailability();
 199 }
 200
 201 void TorrentContentModel::updateFilesPriorities()
 202 {
 203     Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata());
 204
 205     const QList<BitTorrent::DownloadPriority> fprio = m_contentHandler->filePriorities();
 206     Q_ASSERT(m_filesIndex.size() == fprio.size());
 207     // XXX: Why is this necessary?
 208     if (m_filesIndex.size() != fprio.size())
 209         return;
 210
 211     for (int i = 0; i < fprio.size(); ++i)
 212         m_filesIndex[i]->setPriority(static_cast<BitTorrent::DownloadPriority>(fprio[i]));
 213 }
 214
 215 void TorrentContentModel::updateFilesAvailability()
 216 {
 217     Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata());
 218
 219     using HandlerPtr = QPointer<BitTorrent::TorrentContentHandler>;
 220     m_contentHandler->fetchAvailableFileFractions([this, handler = HandlerPtr(m_contentHandler)](const QList<qreal> &availableFileFractions)
 221     {
 222         if (handler != m_contentHandler)
 223             return;
 224
 225         Q_ASSERT(m_filesIndex.size() == availableFileFractions.size());
 226         // XXX: Why is this necessary?
 227         if (m_filesIndex.size() != availableFileFractions.size()) [[unlikely]]
 228             return;
 229
 230         for (int i = 0; i < m_filesIndex.size(); ++i)
 231             m_filesIndex[i]->setAvailability(availableFileFractions[i]);
 232         // Update folders progress in the tree
 233         m_rootItem->recalculateProgress();
 234     });
 235 }
 236
 237 bool TorrentContentModel::setItemPriority(const QModelIndex &index, BitTorrent::DownloadPriority priority)
 238 {
 239     Q_ASSERT(index.isValid());
 240
 241     auto *item = static_cast<TorrentContentModelItem *>(index.internalPointer());
 242     const BitTorrent::DownloadPriority currentPriority = item->priority();
 243     if (currentPriority == priority)
 244         return false;
 245
 246     item->setPriority(priority);
 247     m_contentHandler->prioritizeFiles(getFilePriorities());
 248
 249     // Update folders progress in the tree
 250     m_rootItem->recalculateProgress();
 251     m_rootItem->recalculateAvailability();
 252
 253     const QList<ColumnInterval> columns =
 254     {
 255         {TorrentContentModelItem::COL_NAME, TorrentContentModelItem::COL_NAME},
 256         {TorrentContentModelItem::COL_PRIO, TorrentContentModelItem::COL_PRIO}
 257     };
 258     notifySubtreeUpdated(index, columns);
 259
 260     return true;
 261 }
 262
 263 QList<BitTorrent::DownloadPriority> TorrentContentModel::getFilePriorities() const
 264 {
 265     QList<BitTorrent::DownloadPriority> prio;
 266     prio.reserve(m_filesIndex.size());
 267     for (const TorrentContentModelFile *file : asConst(m_filesIndex))
 268         prio.push_back(file->priority());
 269     return prio;
 270 }
 271
 272 int TorrentContentModel::columnCount([[maybe_unused]] const QModelIndex &parent) const
 273 {
 274     return TorrentContentModelItem::NB_COL;
 275 }
 276
 277 bool TorrentContentModel::setData(const QModelIndex &index, const QVariant &value, const int role)
 278 {
 279     if (!index.isValid())
 280         return false;
 281
 282     if ((index.column() == TorrentContentModelItem::COL_NAME) && (role == Qt::CheckStateRole))
 283     {
 284         const auto checkState = static_cast<Qt::CheckState>(value.toInt());
 285         const BitTorrent::DownloadPriority newPrio = (checkState == Qt::PartiallyChecked)
 286             ? BitTorrent::DownloadPriority::Mixed
 287             : ((checkState == Qt::Unchecked)
 288                 ? BitTorrent::DownloadPriority::Ignored
 289                 : BitTorrent::DownloadPriority::Normal);
 290
 291         return setItemPriority(index, newPrio);
 292     }
 293
 294     if (role == Qt::EditRole)
 295     {
 296         auto *item = static_cast<TorrentContentModelItem *>(index.internalPointer());
 297
 298         switch (index.column())
 299         {
 300         case TorrentContentModelItem::COL_NAME:
 301             {
 302                 const QString currentName = item->name();
 303                 const QString newName = value.toString();
 304                 if (currentName != newName)
 305                 {
 306                     try
 307                     {
 308                         const Path parentPath = getItemPath(index.parent());
 309                         const Path oldPath = parentPath / Path(currentName);
 310                         const Path newPath = parentPath / Path(newName);
 311
 312                         if (item->itemType() == TorrentContentModelItem::FileType)
 313                             m_contentHandler->renameFile(oldPath, newPath);
 314                         else
 315                             m_contentHandler->renameFolder(oldPath, newPath);
 316                     }
 317                     catch (const RuntimeError &error)
 318                     {
 319                         emit renameFailed(error.message());
 320                         return false;
 321                     }
 322
 323                     item->setName(newName);
 324                     emit dataChanged(index, index);
 325                     return true;
 326                 }
 327             }
 328             break;
 329
 330         case TorrentContentModelItem::COL_PRIO:
 331             {
 332                 const auto newPrio = static_cast<BitTorrent::DownloadPriority>(value.toInt());
 333                 return setItemPriority(index, newPrio);
 334             }
 335             break;
 336
 337         default:
 338             break;
 339         }
 340     }
 341
 342     return false;
 343 }
 344
 345 TorrentContentModelItem::ItemType TorrentContentModel::itemType(const QModelIndex &index) const
 346 {
 347     return static_cast<const TorrentContentModelItem *>(index.internalPointer())->itemType();
 348 }
 349
 350 int TorrentContentModel::getFileIndex(const QModelIndex &index) const
 351 {
 352     auto *item = static_cast<TorrentContentModelItem *>(index.internalPointer());
 353     if (item->itemType() == TorrentContentModelItem::FileType)
 354         return static_cast<TorrentContentModelFile *>(item)->fileIndex();
 355
 356     return -1;
 357 }
 358
 359 Path TorrentContentModel::getItemPath(const QModelIndex &index) const
 360 {
 361     Path path;
 362     for (QModelIndex i = index; i.isValid(); i = i.parent())
 363         path = Path(i.data().toString()) / path;
 364     return path;
 365 }
 366
 367 QVariant TorrentContentModel::data(const QModelIndex &index, const int role) const
 368 {
 369     if (!index.isValid())
 370         return {};
 371
 372     auto *item = static_cast<TorrentContentModelItem *>(index.internalPointer());
 373
 374     switch (role)
 375     {
 376     case Qt::DecorationRole:
 377         if (index.column() != TorrentContentModelItem::COL_NAME)
 378             return {};
 379
 380         if (item->itemType() == TorrentContentModelItem::FolderType)
 381             return m_fileIconProvider->icon(QFileIconProvider::Folder);
 382
 383         return m_fileIconProvider->icon(QFileInfo(item->name()));
 384
 385     case Qt::CheckStateRole:
 386         if (index.column() != TorrentContentModelItem::COL_NAME)
 387             return {};
 388
 389         if (item->priority() == BitTorrent::DownloadPriority::Ignored)
 390             return Qt::Unchecked;
 391
 392         if (item->priority() == BitTorrent::DownloadPriority::Mixed)
 393         {
 394             Q_ASSERT(item->itemType() == TorrentContentModelItem::FolderType);
 395
 396             const auto *folder = static_cast<TorrentContentModelFolder *>(item);
 397             const auto childItems = folder->children();
 398             const bool hasIgnored = std::any_of(childItems.cbegin(), childItems.cend()
 399                          , [](const TorrentContentModelItem *childItem)
 400             {
 401                 return (childItem->priority() == BitTorrent::DownloadPriority::Ignored);
 402             });
 403
 404             return hasIgnored ? Qt::PartiallyChecked : Qt::Checked;
 405         }
 406
 407         return Qt::Checked;
 408
 409     case Qt::TextAlignmentRole:
 410         if ((index.column() == TorrentContentModelItem::COL_SIZE)
 411             || (index.column() == TorrentContentModelItem::COL_REMAINING))
 412         {
 413             return QVariant {Qt::AlignRight | Qt::AlignVCenter};
 414         }
 415
 416         return {};
 417
 418     case Qt::DisplayRole:
 419     case Qt::ToolTipRole:
 420         return item->displayData(index.column());
 421
 422     case Roles::UnderlyingDataRole:
 423         return item->underlyingData(index.column());
 424
 425     default:
 426         break;
 427     }
 428
 429     return {};
 430 }
 431
 432 Qt::ItemFlags TorrentContentModel::flags(const QModelIndex &index) const
 433 {
 434     if (!index.isValid())
 435         return Qt::NoItemFlags;
 436
 437     Qt::ItemFlags flags {Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable};
 438     if (itemType(index) == TorrentContentModelItem::FolderType)
 439         flags |= Qt::ItemIsAutoTristate;
 440     if (index.column() == TorrentContentModelItem::COL_PRIO)
 441         flags |= Qt::ItemIsEditable;
 442
 443     return flags;
 444 }
 445
 446 QVariant TorrentContentModel::headerData(int section, Qt::Orientation orientation, int role) const
 447 {
 448     if (orientation != Qt::Horizontal)
 449         return {};
 450
 451     switch (role)
 452     {
 453     case Qt::DisplayRole:
 454         return m_rootItem->displayData(section);
 455
 456     case Qt::TextAlignmentRole:
 457         if ((section == TorrentContentModelItem::COL_SIZE)
 458             || (section == TorrentContentModelItem::COL_REMAINING))
 459         {
 460             return QVariant {Qt::AlignRight | Qt::AlignVCenter};
 461         }
 462
 463         return {};
 464
 465     default:
 466         return {};
 467     }
 468 }
 469
 470 QModelIndex TorrentContentModel::index(const int row, const int column, const QModelIndex &parent) const
 471 {
 472     if (column >= columnCount())
 473         return {};
 474
 475     const TorrentContentModelFolder *parentItem = parent.isValid()
 476         ? static_cast<TorrentContentModelFolder *>(parent.internalPointer())
 477         : m_rootItem;
 478     Q_ASSERT(parentItem);
 479
 480     if (row >= parentItem->childCount())
 481         return {};
 482
 483     TorrentContentModelItem *childItem = parentItem->child(row);
 484     if (childItem)
 485         return createIndex(row, column, childItem);
 486
 487     return {};
 488 }
 489
 490 QModelIndex TorrentContentModel::parent(const QModelIndex &index) const
 491 {
 492     if (!index.isValid())
 493         return {};
 494
 495     const auto *item = static_cast<TorrentContentModelItem *>(index.internalPointer());
 496     if (!item)
 497         return {};
 498
 499     TorrentContentModelItem *parentItem = item->parent();
 500     if (parentItem == m_rootItem)
 501         return {};
 502
 503     // From https://doc.qt.io/qt-6/qabstractitemmodel.html#parent:
 504     // A common convention used in models that expose tree data structures is that only items
 505     // in the first column have children. For that case, when reimplementing this function in
 506     // a subclass the column of the returned QModelIndex would be 0.
 507     return createIndex(parentItem->row(), 0, parentItem);
 508 }
 509
 510 int TorrentContentModel::rowCount(const QModelIndex &parent) const
 511 {
 512     const TorrentContentModelFolder *parentItem = parent.isValid()
 513         ? dynamic_cast<TorrentContentModelFolder *>(static_cast<TorrentContentModelItem *>(parent.internalPointer()))
 514         : m_rootItem;
 515     return parentItem ? parentItem->childCount() : 0;
 516 }
 517
 518 void TorrentContentModel::populate()
 519 {
 520     Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata());
 521
 522     const int filesCount = m_contentHandler->filesCount();
 523     m_filesIndex.reserve(filesCount);
 524
 525     QHash<TorrentContentModelFolder *, QHash<QString, TorrentContentModelFolder *>> folderMap;
 526     QList<QString> lastParentPath;
 527     TorrentContentModelFolder *lastParent = m_rootItem;
 528     // Iterate over files
 529     for (int i = 0; i < filesCount; ++i)
 530     {
 531         const QString path = m_contentHandler->filePath(i).data();
 532
 533         // Iterate of parts of the path to create necessary folders
 534         QList<QStringView> pathFolders = QStringView(path).split(u'/', Qt::SkipEmptyParts);
 535         const QString fileName = pathFolders.takeLast().toString();
 536
 537         if (!std::equal(lastParentPath.begin(), lastParentPath.end()
 538                         , pathFolders.begin(), pathFolders.end()))
 539         {
 540             lastParentPath.clear();
 541             lastParentPath.reserve(pathFolders.size());
 542
 543             // rebuild the path from the root
 544             lastParent = m_rootItem;
 545             for (const QStringView pathPart : asConst(pathFolders))
 546             {
 547                 const QString folderName = pathPart.toString();
 548                 lastParentPath.push_back(folderName);
 549
 550                 TorrentContentModelFolder *&newParent = folderMap[lastParent][folderName];
 551                 if (!newParent)
 552                 {
 553                     newParent = new TorrentContentModelFolder(folderName, lastParent);
 554                     lastParent->appendChild(newParent);
 555                 }
 556
 557                 lastParent = newParent;
 558             }
 559         }
 560
 561         // Actually create the file
 562         auto *fileItem = new TorrentContentModelFile(fileName, m_contentHandler->fileSize(i), lastParent, i);
 563         lastParent->appendChild(fileItem);
 564         m_filesIndex.push_back(fileItem);
 565     }
 566
 567     updateFilesProgress();
 568     updateFilesPriorities();
 569     updateFilesAvailability();
 570 }
 571
 572 void TorrentContentModel::setContentHandler(BitTorrent::TorrentContentHandler *contentHandler)
 573 {
 574     beginResetModel();
 575     [[maybe_unused]] const auto modelResetGuard = qScopeGuard([this] { endResetModel(); });
 576
 577     if (m_contentHandler)
 578     {
 579         m_filesIndex.clear();
 580         m_rootItem->deleteAllChildren();
 581     }
 582
 583     m_contentHandler = contentHandler;
 584
 585     if (m_contentHandler && m_contentHandler->hasMetadata())
 586         populate();
 587 }
 588
 589 BitTorrent::TorrentContentHandler *TorrentContentModel::contentHandler() const
 590 {
 591     return m_contentHandler;
 592 }
 593
 594 void TorrentContentModel::refresh()
 595 {
 596     if (!m_contentHandler || !m_contentHandler->hasMetadata())
 597         return;
 598
 599     if (!m_filesIndex.isEmpty())
 600     {
 601         updateFilesProgress();
 602         updateFilesPriorities();
 603         updateFilesAvailability();
 604
 605         const QList<ColumnInterval> columns =
 606         {
 607             {TorrentContentModelItem::COL_NAME, TorrentContentModelItem::COL_NAME},
 608             {TorrentContentModelItem::COL_PROGRESS, TorrentContentModelItem::COL_PROGRESS},
 609             {TorrentContentModelItem::COL_PRIO, TorrentContentModelItem::COL_PRIO},
 610             {TorrentContentModelItem::COL_AVAILABILITY, TorrentContentModelItem::COL_AVAILABILITY}
 611         };
 612         notifySubtreeUpdated(index(0, 0), columns);
 613     }
 614     else
 615     {
 616         beginResetModel();
 617         populate();
 618         endResetModel();
 619     }
 620 }
 621
 622 void TorrentContentModel::notifySubtreeUpdated(const QModelIndex &index, const QList<ColumnInterval> &columns)
 623 {
 624     // For best performance, `columns` entries should be arranged from left to right
 625
 626     Q_ASSERT(index.isValid());
 627
 628     // emit itself
 629     for (const ColumnInterval &column : columns)
 630         emit dataChanged(index.siblingAtColumn(column.first()), index.siblingAtColumn(column.last()));
 631
 632     // propagate up the model
 633     QModelIndex parentIndex = parent(index);
 634     while (parentIndex.isValid())
 635     {
 636         for (const ColumnInterval &column : columns)
 637             emit dataChanged(parentIndex.siblingAtColumn(column.first()), parentIndex.siblingAtColumn(column.last()));
 638         parentIndex = parent(parentIndex);
 639     }
 640
 641     // propagate down the model
 642     QList<QModelIndex> parentIndexes;
 643
 644     if (hasChildren(index))
 645         parentIndexes.push_back(index);
 646
 647     while (!parentIndexes.isEmpty())
 648     {
 649         const QModelIndex parent = parentIndexes.takeLast();
 650
 651         const int childCount = rowCount(parent);
 652         const QModelIndex child = this->index(0, 0, parent);
 653
 654         // emit this generation
 655         for (const ColumnInterval &column : columns)
 656         {
 657             const QModelIndex childTopLeft = child.siblingAtColumn(column.first());
 658             const QModelIndex childBottomRight = child.sibling((childCount - 1), column.last());
 659             emit dataChanged(childTopLeft, childBottomRight);
 660         }
 661
 662         // check generations further down
 663         parentIndexes.reserve(childCount);
 664         for (int i = 0; i < childCount; ++i)
 665         {
 666             const QModelIndex sibling = child.siblingAtRow(i);
 667             if (hasChildren(sibling))
 668                 parentIndexes.push_back(sibling);
 669         }
 670     }
 671 }