src/kitemviews/kfileitemmodelrolesupdater.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  18  ***************************************************************************/
  19
  20 #include "kfileitemmodelrolesupdater.h"
  21
  22 #include "kfileitemmodel.h"
  23 #include "kpixmapmodifier_p.h"
  24
  25 #include <KConfig>
  26 #include <KConfigGroup>
  27 #include <KDebug>
  28 #include <KFileItem>
  29 #include <KGlobal>
  30 #include <KIO/PreviewJob>
  31 #include <QPainter>
  32 #include <QPixmap>
  33 #include <QElapsedTimer>
  34 #include <QTimer>
  35
  36 // Required includes for subDirectoriesCount():
  37 #ifdef Q_WS_WIN
  38     #include <QDir>
  39 #else
  40     #include <dirent.h>
  41     #include <QFile>
  42 #endif
  43
  44 #define KFILEITEMMODELROLESUPDATER_DEBUG
  45
  46 namespace {
  47     // Maximum time in ms that the KFileItemModelRolesUpdater
  48     // may perform a blocking operation
  49     const int MaxBlockTimeout = 200;
  50
  51     // Maximum number of items that will get resolved synchronously.
  52     // The value should roughly represent the number of maximum visible
  53     // items, as it does not make sense to resolve more items synchronously
  54     // and probably reach the MaxBlockTimeout because of invisible items.
  55     const int MaxResolveItemsCount = 100;
  56 }
  57
  58 KFileItemModelRolesUpdater::KFileItemModelRolesUpdater(KFileItemModel* model, QObject* parent) :
  59     QObject(parent),
  60     m_paused(false),
  61     m_previewChangedDuringPausing(false),
  62     m_iconSizeChangedDuringPausing(false),
  63     m_rolesChangedDuringPausing(false),
  64     m_previewShown(false),
  65     m_clearPreviews(false),
  66     m_model(model),
  67     m_iconSize(),
  68     m_firstVisibleIndex(0),
  69     m_lastVisibleIndex(-1),
  70     m_roles(),
  71     m_enabledPlugins(),
  72     m_pendingVisibleItems(),
  73     m_pendingInvisibleItems(),
  74     m_previewJobs(),
  75     m_resolvePendingRolesTimer(0)
  76 {
  77     Q_ASSERT(model);
  78
  79     const KConfigGroup globalConfig(KGlobal::config(), "PreviewSettings");
  80     m_enabledPlugins = globalConfig.readEntry("Plugins", QStringList()
  81                                                          << "directorythumbnail"
  82                                                          << "imagethumbnail"
  83                                                          << "jpegthumbnail");
  84
  85     connect(m_model, SIGNAL(itemsInserted(KItemRangeList)),
  86             this,    SLOT(slotItemsInserted(KItemRangeList)));
  87     connect(m_model, SIGNAL(itemsRemoved(KItemRangeList)),
  88             this,    SLOT(slotItemsRemoved(KItemRangeList)));
  89     connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
  90             this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
  91
  92     // A timer with a minimal timeout is used to merge several triggerPendingRolesResolving() calls
  93     // to only one call of resolvePendingRoles().
  94     m_resolvePendingRolesTimer = new QTimer(this);
  95     m_resolvePendingRolesTimer->setInterval(1);
  96     m_resolvePendingRolesTimer->setSingleShot(true);
  97     connect(m_resolvePendingRolesTimer, SIGNAL(timeout()), this, SLOT(resolvePendingRoles()));
  98 }
  99
 100 KFileItemModelRolesUpdater::~KFileItemModelRolesUpdater()
 101 {
 102 }
 103
 104 void KFileItemModelRolesUpdater::setIconSize(const QSize& size)
 105 {
 106     if (size != m_iconSize) {
 107         m_iconSize = size;
 108         if (m_paused) {
 109             m_iconSizeChangedDuringPausing = true;
 110         } else if (m_previewShown) {
 111             // An icon size change requires the regenerating of
 112             // all previews
 113             sortAndResolveAllRoles();
 114         } else {
 115             sortAndResolvePendingRoles();
 116         }
 117     }
 118 }
 119
 120 QSize KFileItemModelRolesUpdater::iconSize() const
 121 {
 122     return m_iconSize;
 123 }
 124
 125 void KFileItemModelRolesUpdater::setVisibleIndexRange(int index, int count)
 126 {
 127     if (index < 0) {
 128         index = 0;
 129     }
 130     if (count < 0) {
 131         count = 0;
 132     }
 133
 134     if (index == m_firstVisibleIndex && count == m_lastVisibleIndex - m_firstVisibleIndex + 1) {
 135         // The range has not been changed
 136         return;
 137     }
 138
 139     m_firstVisibleIndex = index;
 140     m_lastVisibleIndex = qMin(index + count - 1, m_model->count() - 1);
 141
 142     if (hasPendingRoles() && !m_paused) {
 143         sortAndResolvePendingRoles();
 144     }
 145 }
 146
 147 void KFileItemModelRolesUpdater::setPreviewShown(bool show)
 148 {
 149     if (show == m_previewShown) {
 150         return;
 151     }
 152
 153     m_previewShown = show;
 154     if (!show) {
 155         m_clearPreviews = true;
 156     }
 157
 158     if (m_paused) {
 159         m_previewChangedDuringPausing = true;
 160     } else {
 161         sortAndResolveAllRoles();
 162     }
 163 }
 164
 165 bool KFileItemModelRolesUpdater::isPreviewShown() const
 166 {
 167     return m_previewShown;
 168 }
 169
 170 void KFileItemModelRolesUpdater::setEnabledPlugins(const QStringList& list)
 171 {
 172     m_enabledPlugins = list;
 173 }
 174
 175 void KFileItemModelRolesUpdater::setPaused(bool paused)
 176 {
 177     if (paused == m_paused) {
 178         return;
 179     }
 180
 181     m_paused = paused;
 182     if (paused) {
 183         if (hasPendingRoles()) {
 184             foreach (KJob* job, m_previewJobs) {
 185                 job->kill();
 186             }
 187             Q_ASSERT(m_previewJobs.isEmpty());
 188         }
 189     } else {
 190         const bool resolveAll = (m_iconSizeChangedDuringPausing && m_previewShown) ||
 191                                 (m_previewChangedDuringPausing && !m_previewShown) ||
 192                                 m_rolesChangedDuringPausing;
 193         if (resolveAll) {
 194             sortAndResolveAllRoles();
 195         } else {
 196             sortAndResolvePendingRoles();
 197         }
 198
 199         m_iconSizeChangedDuringPausing = false;
 200         m_previewChangedDuringPausing = false;
 201         m_rolesChangedDuringPausing = false;
 202     }
 203 }
 204
 205 void KFileItemModelRolesUpdater::setRoles(const QSet<QByteArray>& roles)
 206 {
 207     if (roles.count() == m_roles.count()) {
 208         bool isEqual = true;
 209         foreach (const QByteArray& role, roles) {
 210             if (!m_roles.contains(role)) {
 211                 isEqual = false;
 212                 break;
 213             }
 214         }
 215         if (isEqual) {
 216             return;
 217         }
 218     }
 219
 220     m_roles = roles;
 221
 222     if (m_paused) {
 223         m_rolesChangedDuringPausing = true;
 224     } else {
 225         sortAndResolveAllRoles();
 226     }
 227 }
 228
 229 QSet<QByteArray> KFileItemModelRolesUpdater::roles() const
 230 {
 231     return m_roles;
 232 }
 233
 234 bool KFileItemModelRolesUpdater::isPaused() const
 235 {
 236     return m_paused;
 237 }
 238
 239 QStringList KFileItemModelRolesUpdater::enabledPlugins() const
 240 {
 241     return m_enabledPlugins;
 242 }
 243
 244 void KFileItemModelRolesUpdater::slotItemsInserted(const KItemRangeList& itemRanges)
 245 {
 246     // If no valid index range is given assume that all items are visible.
 247     // A cleanup will be done later as soon as the index range has been set.
 248     const bool hasValidIndexRange = (m_lastVisibleIndex >= 0);
 249
 250     if (hasValidIndexRange) {
 251         // Move all current pending visible items that are not visible anymore
 252         // to the pending invisible items.
 253         QSetIterator<KFileItem> it(m_pendingVisibleItems);
 254         while (it.hasNext()) {
 255             const KFileItem item = it.next();
 256             const int index = m_model->index(item);
 257             if (index < m_firstVisibleIndex || index > m_lastVisibleIndex) {
 258                 m_pendingVisibleItems.remove(item);
 259                 m_pendingInvisibleItems.insert(item);
 260             }
 261         }
 262     }
 263
 264     int rangesCount = 0;
 265
 266     foreach (const KItemRange& range, itemRanges) {
 267         rangesCount += range.count;
 268
 269         // Add the inserted items to the pending visible and invisible items
 270         const int lastIndex = range.index + range.count - 1;
 271         for (int i = range.index; i <= lastIndex; ++i) {
 272             const KFileItem item = m_model->fileItem(i);
 273             if (!hasValidIndexRange || (i >= m_firstVisibleIndex && i <= m_lastVisibleIndex)) {
 274                 m_pendingVisibleItems.insert(item);
 275             } else {
 276                 m_pendingInvisibleItems.insert(item);
 277             }
 278         }
 279     }
 280
 281     triggerPendingRolesResolving(rangesCount);
 282 }
 283
 284 void KFileItemModelRolesUpdater::slotItemsRemoved(const KItemRangeList& itemRanges)
 285 {
 286     Q_UNUSED(itemRanges);
 287     m_firstVisibleIndex = 0;
 288     m_lastVisibleIndex = -1;
 289     if (hasPendingRoles() && m_model->count() <= 0) {
 290         resetPendingRoles();
 291     }
 292 }
 293
 294 void KFileItemModelRolesUpdater::slotItemsChanged(const KItemRangeList& itemRanges,
 295                                                   const QSet<QByteArray>& roles)
 296 {
 297     Q_UNUSED(itemRanges);
 298     Q_UNUSED(roles);
 299     // TODO
 300 }
 301
 302 void KFileItemModelRolesUpdater::slotGotPreview(const KFileItem& item, const QPixmap& pixmap)
 303 {
 304     m_pendingVisibleItems.remove(item);
 305     m_pendingInvisibleItems.remove(item);
 306
 307     const int index = m_model->index(item);
 308     if (index < 0) {
 309         return;
 310     }
 311
 312     QPixmap scaledPixmap = pixmap;
 313
 314     const QString mimeType = item.mimetype();
 315     const int slashIndex = mimeType.indexOf(QLatin1Char('/'));
 316     const QString mimeTypeGroup = mimeType.left(slashIndex);
 317     if (mimeTypeGroup == QLatin1String("image")) {
 318         KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
 319     } else {
 320         KPixmapModifier::scale(scaledPixmap, m_iconSize);
 321     }
 322
 323     QHash<QByteArray, QVariant> data = rolesData(item);
 324     data.insert("iconPixmap", scaledPixmap);
 325
 326     disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 327                this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 328     m_model->setData(index, data);
 329     connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 330             this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 331 }
 332
 333 void KFileItemModelRolesUpdater::slotPreviewFailed(const KFileItem& item)
 334 {
 335     m_pendingVisibleItems.remove(item);
 336     m_pendingInvisibleItems.remove(item);
 337
 338     const bool clearPreviews = m_clearPreviews;
 339     m_clearPreviews = true;
 340     applyResolvedRoles(item, ResolveAll);
 341     m_clearPreviews = clearPreviews;
 342 }
 343
 344 void KFileItemModelRolesUpdater::slotPreviewJobFinished(KJob* job)
 345 {
 346 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 347     kDebug() << "Preview job finished. Pending visible:" << m_pendingVisibleItems.count() << "invisible:" << m_pendingInvisibleItems.count();
 348 #endif
 349
 350     m_previewJobs.removeOne(job);
 351     if (!m_previewJobs.isEmpty() || !hasPendingRoles()) {
 352         return;
 353     }
 354
 355     const KFileItemList visibleItems = sortedItems(m_pendingVisibleItems);
 356     startPreviewJob(visibleItems + m_pendingInvisibleItems.toList());
 357 }
 358
 359 void KFileItemModelRolesUpdater::resolvePendingRoles()
 360 {
 361     int resolvedCount = 0;
 362
 363     const bool hasSlowRoles = m_previewShown
 364                               || m_roles.contains("size")
 365                               || m_roles.contains("type");
 366     const ResolveHint resolveHint = hasSlowRoles ? ResolveFast : ResolveAll;
 367
 368     // Resolving the MIME type can be expensive. Assure that not more than MaxBlockTimeout ms are
 369     // spend for resolving them synchronously. Usually this is more than enough to determine
 370     // all visible items, but there are corner cases where this limit gets easily exceeded.
 371     QElapsedTimer timer;
 372     timer.start();
 373
 374     // Resolve the MIME type of all visible items
 375     QSetIterator<KFileItem> visibleIt(m_pendingVisibleItems);
 376     while (visibleIt.hasNext()) {
 377         const KFileItem item = visibleIt.next();
 378         applyResolvedRoles(item, resolveHint);
 379         if (!hasSlowRoles) {
 380             Q_ASSERT(!m_pendingInvisibleItems.contains(item));
 381             // All roles have been resolved already by applyResolvedRoles()
 382             m_pendingVisibleItems.remove(item);
 383         }
 384         ++resolvedCount;
 385
 386         if (timer.elapsed() > MaxBlockTimeout) {
 387             break;
 388         }
 389     }
 390
 391     // Resolve the MIME type of the invisible items at least until the timeout
 392     // has been exceeded or the maximum number of items has been reached
 393     KFileItemList invisibleItems;
 394     if (m_lastVisibleIndex >= 0) {
 395         // The visible range is valid, don't care about the order how the MIME
 396         // type of invisible items get resolved
 397         invisibleItems = m_pendingInvisibleItems.toList();
 398     } else {
 399         // The visible range is temporary invalid (e.g. happens when loading
 400         // a directory) so take care to sort the currently invisible items where
 401         // a part will get visible later
 402         invisibleItems = sortedItems(m_pendingInvisibleItems);
 403     }
 404
 405     int index = 0;
 406     while (resolvedCount < MaxResolveItemsCount && index < invisibleItems.count() && timer.elapsed() <= MaxBlockTimeout) {
 407         const KFileItem item = invisibleItems.at(index);
 408         applyResolvedRoles(item, resolveHint);
 409
 410         if (!hasSlowRoles) {
 411             // All roles have been resolved already by applyResolvedRoles()
 412             m_pendingInvisibleItems.remove(item);
 413         }
 414         ++index;
 415         ++resolvedCount;
 416     }
 417
 418     if (m_previewShown) {
 419         KFileItemList items = sortedItems(m_pendingVisibleItems);
 420         items += invisibleItems;
 421         startPreviewJob(items);
 422     } else {
 423         QTimer::singleShot(0, this, SLOT(resolveNextPendingRoles()));
 424     }
 425
 426 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 427     if (timer.elapsed() > MaxBlockTimeout) {
 428         kDebug() << "Maximum time of" << MaxBlockTimeout
 429                  << "ms exceeded, skipping items... Remaining visible:" << m_pendingVisibleItems.count()
 430                  << "invisible:" << m_pendingInvisibleItems.count();
 431     }
 432     kDebug() << "[TIME] Resolved pending roles:" << timer.elapsed();
 433 #endif
 434 }
 435
 436 void KFileItemModelRolesUpdater::resolveNextPendingRoles()
 437 {
 438     if (m_paused) {
 439         return;
 440     }
 441
 442     if (m_previewShown) {
 443         // The preview has been turned on since the last run. Skip
 444         // resolving further pending roles as this is done as soon
 445         // as a preview has been received.
 446         return;
 447     }
 448
 449     int resolvedCount = 0;
 450     bool changed = false;
 451     for (int i = 0; i <= 1; ++i) {
 452         QSet<KFileItem>& pendingItems = (i == 0) ? m_pendingVisibleItems : m_pendingInvisibleItems;
 453         QSetIterator<KFileItem> it(pendingItems);
 454         while (it.hasNext() && !changed && resolvedCount < MaxResolveItemsCount) {
 455             const KFileItem item = it.next();
 456             pendingItems.remove(item);
 457             changed = applyResolvedRoles(item, ResolveAll);
 458             ++resolvedCount;
 459         }
 460     }
 461
 462     if (hasPendingRoles()) {
 463         QTimer::singleShot(0, this, SLOT(resolveNextPendingRoles()));
 464     } else {
 465         m_clearPreviews = false;
 466     }
 467
 468 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 469     static int callCount = 0;
 470     ++callCount;
 471     if (callCount % 100 == 0) {
 472         kDebug() << "Remaining visible roles to resolve:" << m_pendingVisibleItems.count()
 473                  << "invisible:" << m_pendingInvisibleItems.count();
 474     }
 475 #endif
 476 }
 477
 478 void KFileItemModelRolesUpdater::startPreviewJob(const KFileItemList& items)
 479 {
 480     if (items.count() <= 0 || m_paused) {
 481         return;
 482     }
 483
 484     // PreviewJob internally caches items always with the size of
 485     // 128 x 128 pixels or 256 x 256 pixels. A (slow) downscaling is done
 486     // by PreviewJob if a smaller size is requested. For images KFileItemModelRolesUpdater must
 487     // do a downscaling anyhow because of the frame, so in this case only the provided
 488     // cache sizes are requested.
 489     const QSize cacheSize = (m_iconSize.width() > 128) || (m_iconSize.height() > 128)
 490                             ? QSize(256, 256) : QSize(128, 128);
 491
 492     // KIO::filePreview() will request the MIME-type of all passed items, which (in the
 493     // worst case) might block the application for several seconds. To prevent such
 494     // a blocking the MIME-type of the items will determined until the MaxBlockTimeout
 495     // has been reached and only those items will get passed. As soon as the MIME-type
 496     // has been resolved once KIO::filePreview() can already access the resolved
 497     // MIME-type in a fast way.
 498     QElapsedTimer timer;
 499     timer.start();
 500     KFileItemList itemSubSet;
 501     for (int i = 0; i < items.count(); ++i) {
 502         KFileItem item = items.at(i);
 503         item.determineMimeType();
 504         itemSubSet.append(items.at(i));
 505         if (timer.elapsed() > MaxBlockTimeout) {
 506 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 507             kDebug() << "Maximum time of" << MaxBlockTimeout << "ms exceeded, creating only previews for"
 508                      << (i + 1) << "items," << (items.count() - (i + 1)) << "will be resolved later";
 509 #endif
 510             break;
 511         }
 512     }
 513     KJob* job = KIO::filePreview(itemSubSet, cacheSize, &m_enabledPlugins);
 514
 515     connect(job,  SIGNAL(gotPreview(KFileItem,QPixmap)),
 516             this, SLOT(slotGotPreview(KFileItem,QPixmap)));
 517     connect(job,  SIGNAL(failed(KFileItem)),
 518             this, SLOT(slotPreviewFailed(KFileItem)));
 519     connect(job,  SIGNAL(finished(KJob*)),
 520             this, SLOT(slotPreviewJobFinished(KJob*)));
 521
 522     m_previewJobs.append(job);
 523 }
 524
 525
 526 bool KFileItemModelRolesUpdater::hasPendingRoles() const
 527 {
 528     return !m_pendingVisibleItems.isEmpty() || !m_pendingInvisibleItems.isEmpty();
 529 }
 530
 531 void KFileItemModelRolesUpdater::resetPendingRoles()
 532 {
 533     m_pendingVisibleItems.clear();
 534     m_pendingInvisibleItems.clear();
 535
 536     foreach (KJob* job, m_previewJobs) {
 537         job->kill();
 538     }
 539     Q_ASSERT(m_previewJobs.isEmpty());
 540 }
 541
 542 void KFileItemModelRolesUpdater::triggerPendingRolesResolving(int count)
 543 {
 544     Q_ASSERT(count <= m_model->count());
 545     if (count == m_model->count()) {
 546         // When initially loading a directory a synchronous resolving prevents a minor
 547         // flickering when opening directories. This is also fine from a performance point
 548         // of view as it is assured in resolvePendingRoles() to never block the event-loop
 549         // for more than 200 ms.
 550         resolvePendingRoles();
 551     } else {
 552         // Items have been added. This can be done in several small steps within one loop
 553         // because of the sorting and hence may not trigger any expensive operation.
 554         m_resolvePendingRolesTimer->start();
 555     }
 556 }
 557
 558 void KFileItemModelRolesUpdater::sortAndResolveAllRoles()
 559 {
 560     if (m_paused) {
 561         return;
 562     }
 563
 564     resetPendingRoles();
 565     Q_ASSERT(m_pendingVisibleItems.isEmpty());
 566     Q_ASSERT(m_pendingInvisibleItems.isEmpty());
 567
 568     if (m_model->count() <= 0) {
 569         return;
 570     }
 571
 572     // Determine all visible items
 573     Q_ASSERT(m_firstVisibleIndex >= 0);
 574     for (int i = m_firstVisibleIndex; i <= m_lastVisibleIndex; ++i) {
 575         const KFileItem item = m_model->fileItem(i);
 576         if (!item.isNull()) {
 577             m_pendingVisibleItems.insert(item);
 578         }
 579     }
 580
 581     // Determine all invisible items
 582     for (int i = 0; i < m_firstVisibleIndex; ++i) {
 583         const KFileItem item = m_model->fileItem(i);
 584         if (!item.isNull()) {
 585             m_pendingInvisibleItems.insert(item);
 586         }
 587     }
 588     for (int i = m_lastVisibleIndex + 1; i < m_model->count(); ++i) {
 589         const KFileItem item = m_model->fileItem(i);
 590         if (!item.isNull()) {
 591             m_pendingInvisibleItems.insert(item);
 592         }
 593     }
 594
 595     triggerPendingRolesResolving(m_pendingVisibleItems.count() +
 596                                  m_pendingInvisibleItems.count());
 597 }
 598
 599 void KFileItemModelRolesUpdater::sortAndResolvePendingRoles()
 600 {
 601     Q_ASSERT(!m_paused);
 602     if (m_model->count() <= 0) {
 603         return;
 604     }
 605
 606     // If no valid index range is given assume that all items are visible.
 607     // A cleanup will be done later as soon as the index range has been set.
 608     const bool hasValidIndexRange = (m_lastVisibleIndex >= 0);
 609
 610     // Trigger a preview generation of all pending items. Assure that the visible
 611     // pending items get generated first.
 612     QSet<KFileItem> pendingItems;
 613     pendingItems += m_pendingVisibleItems;
 614     pendingItems += m_pendingInvisibleItems;
 615
 616     resetPendingRoles();
 617     Q_ASSERT(m_pendingVisibleItems.isEmpty());
 618     Q_ASSERT(m_pendingInvisibleItems.isEmpty());
 619
 620     QSetIterator<KFileItem> it(pendingItems);
 621     while (it.hasNext()) {
 622         const KFileItem item = it.next();
 623         if (item.isNull()) {
 624             continue;
 625         }
 626
 627         const int index = m_model->index(item);
 628         if (!hasValidIndexRange || (index >= m_firstVisibleIndex && index <= m_lastVisibleIndex)) {
 629             m_pendingVisibleItems.insert(item);
 630         } else {
 631             m_pendingInvisibleItems.insert(item);
 632         }
 633     }
 634
 635     triggerPendingRolesResolving(m_pendingVisibleItems.count() +
 636                                  m_pendingInvisibleItems.count());
 637 }
 638
 639 bool KFileItemModelRolesUpdater::applyResolvedRoles(const KFileItem& item, ResolveHint hint)
 640 {
 641     const bool resolveAll = (hint == ResolveAll);
 642
 643     bool mimeTypeChanged = false;
 644     if (!item.isMimeTypeKnown()) {
 645         item.determineMimeType();
 646         mimeTypeChanged = true;
 647     }
 648
 649     if (mimeTypeChanged || resolveAll || m_clearPreviews) {
 650         const int index = m_model->index(item);
 651         if (index < 0) {
 652             return false;
 653         }
 654
 655         QHash<QByteArray, QVariant> data;
 656         if (resolveAll) {
 657             data = rolesData(item);
 658         }
 659
 660         if (mimeTypeChanged || m_clearPreviews) {
 661             data.insert("iconName", item.iconName());
 662         }
 663         if (m_clearPreviews) {
 664             data.insert("iconPixmap", QString());
 665         }
 666
 667         disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 668                    this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 669         m_model->setData(index, data);
 670         connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 671                 this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 672         return true;
 673     }
 674
 675     return false;
 676 }
 677
 678 QHash<QByteArray, QVariant> KFileItemModelRolesUpdater::rolesData(const KFileItem& item) const
 679 {
 680     QHash<QByteArray, QVariant> data;
 681
 682     if (m_roles.contains("size")) {
 683         if (item.isDir() && item.isLocalFile()) {
 684             const QString path = item.localPath();
 685             const int count = subDirectoriesCount(path);
 686             if (count >= 0) {
 687                 data.insert("size", KIO::filesize_t(count));
 688             }
 689         }
 690     }
 691
 692     if (m_roles.contains("type")) {
 693         data.insert("type", item.mimeComment());
 694     }
 695
 696     return data;
 697 }
 698
 699 KFileItemList KFileItemModelRolesUpdater::sortedItems(const QSet<KFileItem>& items) const
 700 {
 701     KFileItemList itemList;
 702     if (items.isEmpty()) {
 703         return itemList;
 704     }
 705
 706 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 707     QElapsedTimer timer;
 708     timer.start();
 709 #endif
 710
 711     QList<int> indexes;
 712     indexes.reserve(items.count());
 713
 714     QSetIterator<KFileItem> it(items);
 715     while (it.hasNext()) {
 716         const KFileItem item = it.next();
 717         const int index = m_model->index(item);
 718         indexes.append(index);
 719     }
 720     qSort(indexes);
 721
 722     itemList.reserve(items.count());
 723     foreach (int index, indexes) {
 724         itemList.append(m_model->fileItem(index));
 725     }
 726
 727 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 728     kDebug() << "[TIME] Sorting of items:" << timer.elapsed();
 729 #endif
 730     return itemList;
 731 }
 732
 733 int KFileItemModelRolesUpdater::subDirectoriesCount(const QString& path)
 734 {
 735 #ifdef Q_WS_WIN
 736     QDir dir(path);
 737     return dir.entryList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::System).count();
 738 #else
 739     // Taken from kdelibs/kio/kio/kdirmodel.cpp
 740     // Copyright (C) 2006 David Faure <faure@kde.org>
 741
 742     int count = -1;
 743     DIR* dir = ::opendir(QFile::encodeName(path));
 744     if (dir) {
 745         count = 0;
 746         struct dirent *dirEntry = 0;
 747         while ((dirEntry = ::readdir(dir))) { // krazy:exclude=syscalls
 748             if (dirEntry->d_name[0] == '.') {
 749                 if (dirEntry->d_name[1] == '\0') {
 750                     // Skip "."
 751                     continue;
 752                 }
 753                 if (dirEntry->d_name[1] == '.' && dirEntry->d_name[2] == '\0') {
 754                     // Skip ".."
 755                     continue;
 756                 }
 757             }
 758             ++count;
 759         }
 760         ::closedir(dir);
 761     }
 762     return count;
 763 #endif
 764 }
 765
 766 #include "kfileitemmodelrolesupdater.moc"