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
  24 #include <KConfig>
  25 #include <KConfigGroup>
  26 #include <KDebug>
  27 #include <KDirWatch>
  28 #include <KFileItem>
  29 #include <KGlobal>
  30 #include <KIO/JobUiDelegate>
  31 #include <KIO/PreviewJob>
  32
  33 #include "private/kpixmapmodifier.h"
  34
  35 #include <QApplication>
  36 #include <QPainter>
  37 #include <QPixmap>
  38 #include <QElapsedTimer>
  39 #include <QTimer>
  40
  41 #ifdef HAVE_NEPOMUK
  42     #include "private/knepomukrolesprovider.h"
  43     #include "private/nepomuk/resourcewatcher.h"
  44 #endif
  45
  46 // Required includes for subItemsCount():
  47 #ifdef Q_WS_WIN
  48     #include <QDir>
  49 #else
  50     #include <dirent.h>
  51     #include <QFile>
  52 #endif
  53
  54 // #define KFILEITEMMODELROLESUPDATER_DEBUG
  55
  56 namespace {
  57     // Maximum time in ms that the KFileItemModelRolesUpdater
  58     // may perform a blocking operation
  59     const int MaxBlockTimeout = 200;
  60
  61     // Maximum number of items that will get resolved synchronously.
  62     // The value should roughly represent the number of maximum visible
  63     // items, as it does not make sense to resolve more items synchronously
  64     // and probably reach the MaxBlockTimeout because of invisible items.
  65     const int MaxResolveItemsCount = 100;
  66 }
  67
  68 KFileItemModelRolesUpdater::KFileItemModelRolesUpdater(KFileItemModel* model, QObject* parent) :
  69     QObject(parent),
  70     m_paused(false),
  71     m_previewChangedDuringPausing(false),
  72     m_iconSizeChangedDuringPausing(false),
  73     m_rolesChangedDuringPausing(false),
  74     m_previewShown(false),
  75     m_enlargeSmallPreviews(true),
  76     m_clearPreviews(false),
  77     m_sortingProgress(-1),
  78     m_model(model),
  79     m_iconSize(),
  80     m_firstVisibleIndex(0),
  81     m_lastVisibleIndex(-1),
  82     m_roles(),
  83     m_enabledPlugins(),
  84     m_pendingVisibleItems(),
  85     m_pendingInvisibleItems(),
  86     m_previewJobs(),
  87     m_changedItemsTimer(0),
  88     m_changedItems(),
  89     m_dirWatcher(0),
  90     m_watchedDirs()
  91   #ifdef HAVE_NEPOMUK
  92   , m_nepomukResourceWatcher(0),
  93     m_nepomukUriItems()
  94   #endif
  95
  96 {
  97     Q_ASSERT(model);
  98
  99     const KConfigGroup globalConfig(KGlobal::config(), "PreviewSettings");
 100     m_enabledPlugins = globalConfig.readEntry("Plugins", QStringList()
 101                                                          << "directorythumbnail"
 102                                                          << "imagethumbnail"
 103                                                          << "jpegthumbnail");
 104
 105     connect(m_model, SIGNAL(itemsInserted(KItemRangeList)),
 106             this,    SLOT(slotItemsInserted(KItemRangeList)));
 107     connect(m_model, SIGNAL(itemsRemoved(KItemRangeList)),
 108             this,    SLOT(slotItemsRemoved(KItemRangeList)));
 109     connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 110             this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 111     connect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
 112             this,    SLOT(slotSortRoleChanged(QByteArray,QByteArray)));
 113
 114     // Use a timer to prevent that each call of slotItemsChanged() results in a synchronous
 115     // resolving of the roles. Postpone the resolving until no update has been done for 1 second.
 116     m_changedItemsTimer = new QTimer(this);
 117     m_changedItemsTimer->setInterval(1000);
 118     m_changedItemsTimer->setSingleShot(true);
 119     connect(m_changedItemsTimer, SIGNAL(timeout()), this, SLOT(resolveChangedItems()));
 120
 121     m_resolvableRoles.insert("size");
 122     m_resolvableRoles.insert("type");
 123     m_resolvableRoles.insert("isExpandable");
 124 #ifdef HAVE_NEPOMUK
 125     m_resolvableRoles += KNepomukRolesProvider::instance().roles();
 126 #endif
 127
 128     // When folders are expandable or the item-count is shown for folders, it is necessary
 129     // to watch the number of items of the sub-folder to be able to react on changes.
 130     m_dirWatcher = new KDirWatch(this);
 131     connect(m_dirWatcher, SIGNAL(dirty(QString)), this, SLOT(slotDirWatchDirty(QString)));
 132 }
 133
 134 KFileItemModelRolesUpdater::~KFileItemModelRolesUpdater()
 135 {
 136     resetPendingRoles();
 137 }
 138
 139 void KFileItemModelRolesUpdater::setIconSize(const QSize& size)
 140 {
 141     if (size != m_iconSize) {
 142         m_iconSize = size;
 143         if (m_paused) {
 144             m_iconSizeChangedDuringPausing = true;
 145         } else if (m_previewShown) {
 146             // An icon size change requires the regenerating of
 147             // all previews
 148             sortAndResolveAllRoles();
 149         } else {
 150             sortAndResolvePendingRoles();
 151         }
 152     }
 153 }
 154
 155 QSize KFileItemModelRolesUpdater::iconSize() const
 156 {
 157     return m_iconSize;
 158 }
 159
 160 void KFileItemModelRolesUpdater::setVisibleIndexRange(int index, int count)
 161 {
 162     if (index < 0) {
 163         index = 0;
 164     }
 165     if (count < 0) {
 166         count = 0;
 167     }
 168
 169     if (index == m_firstVisibleIndex && count == m_lastVisibleIndex - m_firstVisibleIndex + 1) {
 170         // The range has not been changed
 171         return;
 172     }
 173
 174     m_firstVisibleIndex = index;
 175     m_lastVisibleIndex = qMin(index + count - 1, m_model->count() - 1);
 176
 177     if (hasPendingRoles() && !m_paused) {
 178         sortAndResolvePendingRoles();
 179     }
 180 }
 181
 182 void KFileItemModelRolesUpdater::setPreviewsShown(bool show)
 183 {
 184     if (show == m_previewShown) {
 185         return;
 186     }
 187
 188     m_previewShown = show;
 189     if (!show) {
 190         m_clearPreviews = true;
 191     }
 192
 193     updateAllPreviews();
 194 }
 195
 196 bool KFileItemModelRolesUpdater::previewsShown() const
 197 {
 198     return m_previewShown;
 199 }
 200
 201 void KFileItemModelRolesUpdater::setEnlargeSmallPreviews(bool enlarge)
 202 {
 203     if (enlarge != m_enlargeSmallPreviews) {
 204         m_enlargeSmallPreviews = enlarge;
 205         if (m_previewShown) {
 206             updateAllPreviews();
 207         }
 208     }
 209 }
 210
 211 bool KFileItemModelRolesUpdater::enlargeSmallPreviews() const
 212 {
 213     return m_enlargeSmallPreviews;
 214 }
 215
 216 void KFileItemModelRolesUpdater::setEnabledPlugins(const QStringList& list)
 217 {
 218     if (m_enabledPlugins != list) {
 219         m_enabledPlugins = list;
 220         if (m_previewShown) {
 221             updateAllPreviews();
 222         }
 223     }
 224 }
 225
 226 void KFileItemModelRolesUpdater::setPaused(bool paused)
 227 {
 228     if (paused == m_paused) {
 229         return;
 230     }
 231
 232     m_paused = paused;
 233     if (paused) {
 234         if (hasPendingRoles()) {
 235             foreach (KJob* job, m_previewJobs) {
 236                 job->kill();
 237             }
 238             Q_ASSERT(m_previewJobs.isEmpty());
 239         }
 240     } else {
 241         const bool resolveAll = (m_iconSizeChangedDuringPausing && m_previewShown) ||
 242                                 m_previewChangedDuringPausing ||
 243                                 m_rolesChangedDuringPausing;
 244         if (resolveAll) {
 245             sortAndResolveAllRoles();
 246         } else {
 247             sortAndResolvePendingRoles();
 248         }
 249
 250         m_iconSizeChangedDuringPausing = false;
 251         m_previewChangedDuringPausing = false;
 252         m_rolesChangedDuringPausing = false;
 253     }
 254 }
 255
 256 void KFileItemModelRolesUpdater::setRoles(const QSet<QByteArray>& roles)
 257 {
 258     if (m_roles != roles) {
 259         m_roles = roles;
 260
 261 #ifdef HAVE_NEPOMUK
 262         // Check whether there is at least one role that must be resolved
 263         // with the help of Nepomuk. If this is the case, a (quite expensive)
 264         // resolving will be done in KFileItemModelRolesUpdater::rolesData() and
 265         // the role gets watched for changes.
 266         const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
 267         bool hasNepomukRole = false;
 268         QSetIterator<QByteArray> it(roles);
 269         while (it.hasNext()) {
 270             const QByteArray& role = it.next();
 271             if (rolesProvider.roles().contains(role)) {
 272                 hasNepomukRole = true;
 273                 break;
 274             }
 275         }
 276
 277         if (hasNepomukRole && !m_nepomukResourceWatcher) {
 278             Q_ASSERT(m_nepomukUriItems.isEmpty());
 279
 280             m_nepomukResourceWatcher = new Nepomuk::ResourceWatcher(this);
 281             connect(m_nepomukResourceWatcher, SIGNAL(propertyChanged(Nepomuk::Resource,Nepomuk::Types::Property,QVariantList,QVariantList)),
 282                     this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
 283             connect(m_nepomukResourceWatcher, SIGNAL(propertyRemoved(Nepomuk::Resource,Nepomuk::Types::Property,QVariant)),
 284                     this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
 285             connect(m_nepomukResourceWatcher, SIGNAL(propertyAdded(Nepomuk::Resource,Nepomuk::Types::Property,QVariant)),
 286                     this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
 287             connect(m_nepomukResourceWatcher, SIGNAL(resourceCreated(Nepomuk::Resource,QList<QUrl>)),
 288                     this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
 289         } else if (!hasNepomukRole && m_nepomukResourceWatcher) {
 290             delete m_nepomukResourceWatcher;
 291             m_nepomukResourceWatcher = 0;
 292             m_nepomukUriItems.clear();
 293         }
 294 #endif
 295
 296         updateSortProgress();
 297
 298         if (m_paused) {
 299             m_rolesChangedDuringPausing = true;
 300         } else {
 301             sortAndResolveAllRoles();
 302         }
 303     }
 304 }
 305
 306 QSet<QByteArray> KFileItemModelRolesUpdater::roles() const
 307 {
 308     return m_roles;
 309 }
 310
 311 bool KFileItemModelRolesUpdater::isPaused() const
 312 {
 313     return m_paused;
 314 }
 315
 316 QStringList KFileItemModelRolesUpdater::enabledPlugins() const
 317 {
 318     return m_enabledPlugins;
 319 }
 320
 321 void KFileItemModelRolesUpdater::slotItemsInserted(const KItemRangeList& itemRanges)
 322 {
 323     startUpdating(itemRanges);
 324 }
 325
 326 void KFileItemModelRolesUpdater::slotItemsRemoved(const KItemRangeList& itemRanges)
 327 {
 328     Q_UNUSED(itemRanges);
 329
 330     const bool allItemsRemoved = (m_model->count() == 0);
 331
 332     if (!m_watchedDirs.isEmpty()) {
 333         // Don't let KDirWatch watch for removed items
 334         if (allItemsRemoved) {
 335             foreach (const QString& path, m_watchedDirs) {
 336                 m_dirWatcher->removeDir(path);
 337             }
 338             m_watchedDirs.clear();
 339         } else {
 340             QMutableSetIterator<QString> it(m_watchedDirs);
 341             while (it.hasNext()) {
 342                 const QString& path = it.next();
 343                 if (m_model->index(KUrl(path)) < 0) {
 344                     m_dirWatcher->removeDir(path);
 345                     it.remove();
 346                 }
 347             }
 348         }
 349     }
 350
 351 #ifdef HAVE_NEPOMUK
 352     if (m_nepomukResourceWatcher) {
 353         // Don't let the ResourceWatcher watch for removed items
 354         if (allItemsRemoved) {
 355             m_nepomukResourceWatcher->setResources(QList<Nepomuk::Resource>());
 356             m_nepomukResourceWatcher->stop();
 357             m_nepomukUriItems.clear();
 358         } else {
 359             QList<Nepomuk::Resource> newResources;
 360             const QList<Nepomuk::Resource> oldResources = m_nepomukResourceWatcher->resources();
 361             foreach (const Nepomuk::Resource& resource, oldResources) {
 362                 const QUrl uri = resource.resourceUri();
 363                 const KUrl itemUrl = m_nepomukUriItems.value(uri);
 364                 if (m_model->index(itemUrl) >= 0) {
 365                     newResources.append(resource);
 366                 } else {
 367                     m_nepomukUriItems.remove(uri);
 368                 }
 369             }
 370             m_nepomukResourceWatcher->setResources(newResources);
 371             if (newResources.isEmpty()) {
 372                 Q_ASSERT(m_nepomukUriItems.isEmpty());
 373                 m_nepomukResourceWatcher->stop();
 374             }
 375         }
 376     }
 377 #endif
 378
 379     m_firstVisibleIndex = 0;
 380     m_lastVisibleIndex = -1;
 381     if (!hasPendingRoles()) {
 382         return;
 383     }
 384
 385     if (allItemsRemoved) {
 386         // Most probably a directory change is done. Clear all pending items
 387         // and also kill all ongoing preview-jobs.
 388         resetPendingRoles();
 389
 390         m_changedItems.clear();
 391         m_changedItemsTimer->stop();
 392     } else {
 393         // Remove all items from m_pendingVisibleItems and m_pendingInvisibleItems
 394         // that are not part of the model anymore. The items from m_changedItems
 395         // don't need to be handled here, removed items are just skipped in
 396         // resolveChangedItems().
 397         for (int i = 0; i <= 1; ++i) {
 398             QSet<KFileItem>& pendingItems = (i == 0) ? m_pendingVisibleItems : m_pendingInvisibleItems;
 399             QMutableSetIterator<KFileItem> it(pendingItems);
 400             while (it.hasNext()) {
 401                 const KFileItem item = it.next();
 402                 if (m_model->index(item) < 0) {
 403                     pendingItems.remove(item);
 404                 }
 405             }
 406         }
 407     }
 408 }
 409
 410 void KFileItemModelRolesUpdater::slotItemsChanged(const KItemRangeList& itemRanges,
 411                                                   const QSet<QByteArray>& roles)
 412 {
 413     Q_UNUSED(roles);
 414
 415     if (m_changedItemsTimer->isActive()) {
 416         // A call of slotItemsChanged() has been done recently. Postpone the resolving
 417         // of the roles until the timer has exceeded.
 418         foreach (const KItemRange& itemRange, itemRanges) {
 419             int index = itemRange.index;
 420             for (int count = itemRange.count; count > 0; --count) {
 421                 m_changedItems.insert(m_model->fileItem(index));
 422                 ++index;
 423             }
 424         }
 425     } else {
 426         // No call of slotItemsChanged() has been done recently, resolve the roles now.
 427         startUpdating(itemRanges);
 428     }
 429     m_changedItemsTimer->start();
 430 }
 431
 432 void KFileItemModelRolesUpdater::slotSortRoleChanged(const QByteArray& current,
 433                                                      const QByteArray& previous)
 434 {
 435     Q_UNUSED(current);
 436     Q_UNUSED(previous);
 437     updateSortProgress();
 438 }
 439
 440 void KFileItemModelRolesUpdater::slotGotPreview(const KFileItem& item, const QPixmap& pixmap)
 441 {
 442     const int oldNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
 443
 444     m_pendingVisibleItems.remove(item);
 445     m_pendingInvisibleItems.remove(item);
 446
 447     const int newNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
 448
 449     if (oldNumberOfPendingItems == newNumberOfPendingItems) {
 450         // 'item' could not be removed from either of the sets. It looks like
 451         // we have hit bug 304986. Replace the items in the sets by the items
 452         // in the model to work around the problem.
 453         // NOTE: This workaround is not needed any more in KDE 4.10.
 454         m_pendingVisibleItems = sortedItems(m_pendingVisibleItems).toSet();
 455         m_pendingInvisibleItems = sortedItems(m_pendingInvisibleItems).toSet();
 456     }
 457
 458     const int index = m_model->index(item);
 459     if (index < 0) {
 460         return;
 461     }
 462
 463     QPixmap scaledPixmap = pixmap;
 464
 465     const QString mimeType = item.mimetype();
 466     const int slashIndex = mimeType.indexOf(QLatin1Char('/'));
 467     const QString mimeTypeGroup = mimeType.left(slashIndex);
 468     if (mimeTypeGroup == QLatin1String("image")) {
 469         if (m_enlargeSmallPreviews) {
 470             KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
 471         } else {
 472             // Assure that small previews don't get enlarged. Instead they
 473             // should be shown centered within the frame.
 474             const QSize contentSize = KPixmapModifier::sizeInsideFrame(m_iconSize);
 475             const bool enlargingRequired = scaledPixmap.width()  < contentSize.width() &&
 476                                            scaledPixmap.height() < contentSize.height();
 477             if (enlargingRequired) {
 478                 QSize frameSize = scaledPixmap.size();
 479                 frameSize.scale(m_iconSize, Qt::KeepAspectRatio);
 480
 481                 QPixmap largeFrame(frameSize);
 482                 largeFrame.fill(Qt::transparent);
 483
 484                 KPixmapModifier::applyFrame(largeFrame, frameSize);
 485
 486                 QPainter painter(&largeFrame);
 487                 painter.drawPixmap((largeFrame.width()  - scaledPixmap.width()) / 2,
 488                                    (largeFrame.height() - scaledPixmap.height()) / 2,
 489                                    scaledPixmap);
 490                 scaledPixmap = largeFrame;
 491             } else {
 492                 // The image must be shrinked as it is too large to fit into
 493                 // the available icon size
 494                 KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
 495             }
 496         }
 497     } else {
 498         KPixmapModifier::scale(scaledPixmap, m_iconSize);
 499     }
 500
 501     QHash<QByteArray, QVariant> data = rolesData(item);
 502     data.insert("iconPixmap", scaledPixmap);
 503
 504     disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 505                this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 506     m_model->setData(index, data);
 507     connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 508             this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 509
 510     applySortProgressToModel();
 511 }
 512
 513 void KFileItemModelRolesUpdater::slotPreviewFailed(const KFileItem& item)
 514 {
 515     const int oldNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
 516
 517     m_pendingVisibleItems.remove(item);
 518     m_pendingInvisibleItems.remove(item);
 519
 520     const int newNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
 521
 522     if (oldNumberOfPendingItems == newNumberOfPendingItems) {
 523         // 'item' could not be removed from either of the sets. It looks like
 524         // we have hit bug 304986. Replace the items in the sets by the items
 525         // in the model to work around the problem.
 526         // NOTE: This workaround is not needed any more in KDE 4.10.
 527         m_pendingVisibleItems = sortedItems(m_pendingVisibleItems).toSet();
 528         m_pendingInvisibleItems = sortedItems(m_pendingInvisibleItems).toSet();
 529     }
 530
 531     const bool clearPreviews = m_clearPreviews;
 532     m_clearPreviews = true;
 533     applyResolvedRoles(item, ResolveAll);
 534     m_clearPreviews = clearPreviews;
 535
 536     applySortProgressToModel();
 537 }
 538
 539 void KFileItemModelRolesUpdater::slotPreviewJobFinished(KJob* job)
 540 {
 541 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 542     kDebug() << "Preview job finished. Pending visible:" << m_pendingVisibleItems.count() << "invisible:" << m_pendingInvisibleItems.count();
 543 #endif
 544
 545     m_previewJobs.removeOne(job);
 546     if (!m_previewJobs.isEmpty() || !hasPendingRoles()) {
 547         return;
 548     }
 549
 550     const KFileItemList visibleItems = sortedItems(m_pendingVisibleItems);
 551     startPreviewJob(visibleItems + m_pendingInvisibleItems.toList());
 552 }
 553
 554 void KFileItemModelRolesUpdater::resolveNextPendingRoles()
 555 {
 556     if (m_paused) {
 557         return;
 558     }
 559
 560     if (m_previewShown) {
 561         // The preview has been turned on since the last run. Skip
 562         // resolving further pending roles as this is done as soon
 563         // as a preview has been received.
 564         return;
 565     }
 566
 567     int resolvedCount = 0;
 568     bool changed = false;
 569     for (int i = 0; i <= 1; ++i) {
 570         QSet<KFileItem>& pendingItems = (i == 0) ? m_pendingVisibleItems : m_pendingInvisibleItems;
 571         QSetIterator<KFileItem> it(pendingItems);
 572         while (it.hasNext() && !changed && resolvedCount < MaxResolveItemsCount) {
 573             const KFileItem item = it.next();
 574             pendingItems.remove(item);
 575             changed = applyResolvedRoles(item, ResolveAll);
 576             ++resolvedCount;
 577         }
 578     }
 579
 580     if (hasPendingRoles()) {
 581         QTimer::singleShot(0, this, SLOT(resolveNextPendingRoles()));
 582     } else {
 583         m_clearPreviews = false;
 584     }
 585
 586     applySortProgressToModel();
 587
 588 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 589     static int callCount = 0;
 590     ++callCount;
 591     if (callCount % 100 == 0) {
 592         kDebug() << "Remaining visible roles to resolve:" << m_pendingVisibleItems.count()
 593                  << "invisible:" << m_pendingInvisibleItems.count();
 594     }
 595 #endif
 596 }
 597
 598 void KFileItemModelRolesUpdater::resolveChangedItems()
 599 {
 600     if (m_changedItems.isEmpty()) {
 601         return;
 602     }
 603
 604     KItemRangeList itemRanges;
 605
 606     QSetIterator<KFileItem> it(m_changedItems);
 607     while (it.hasNext()) {
 608         const KFileItem& item = it.next();
 609         const int index = m_model->index(item);
 610         if (index >= 0) {
 611             itemRanges.append(KItemRange(index, 1));
 612         }
 613     }
 614     m_changedItems.clear();
 615
 616     startUpdating(itemRanges);
 617 }
 618
 619 void KFileItemModelRolesUpdater::applyChangedNepomukRoles(const Nepomuk::Resource& resource)
 620 {
 621 #ifdef HAVE_NEPOMUK
 622     const KUrl itemUrl = m_nepomukUriItems.value(resource.resourceUri());
 623     const KFileItem item = m_model->fileItem(itemUrl);
 624
 625     if (item.isNull()) {
 626         // itemUrl is not in the model anymore, probably because
 627         // the corresponding file has been deleted in the meantime.
 628         return;
 629     }
 630
 631     QHash<QByteArray, QVariant> data = rolesData(item);
 632
 633     const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
 634     QHashIterator<QByteArray, QVariant> it(rolesProvider.roleValues(resource, m_roles));
 635     while (it.hasNext()) {
 636         it.next();
 637         data.insert(it.key(), it.value());
 638     }
 639
 640     disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 641                this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 642     const int index = m_model->index(item);
 643     m_model->setData(index, data);
 644     connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
 645             this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
 646 #else
 647 #ifndef Q_CC_MSVC
 648     Q_UNUSED(resource);
 649 #endif
 650 #endif
 651 }
 652
 653 void KFileItemModelRolesUpdater::slotDirWatchDirty(const QString& path)
 654 {
 655     const bool getSizeRole = m_roles.contains("size");
 656     const bool getIsExpandableRole = m_roles.contains("isExpandable");
 657
 658     if (getSizeRole || getIsExpandableRole) {
 659         const int index = m_model->index(KUrl(path));
 660         if (index >= 0) {
 661             QHash<QByteArray, QVariant> data;
 662
 663             const int count = subItemsCount(path);
 664             if (getSizeRole) {
 665                 data.insert("size", count);
 666             }
 667             if (getIsExpandableRole) {
 668                 data.insert("isExpandable", count > 0);
 669             }
 670
 671             m_model->setData(index, data);
 672         }
 673     }
 674 }
 675
 676 void KFileItemModelRolesUpdater::startUpdating(const KItemRangeList& itemRanges)
 677 {
 678     // If no valid index range is given assume that all items are visible.
 679     // A cleanup will be done later as soon as the index range has been set.
 680     const bool hasValidIndexRange = (m_lastVisibleIndex >= 0);
 681
 682     if (hasValidIndexRange) {
 683         // Move all current pending visible items that are not visible anymore
 684         // to the pending invisible items.
 685         QSetIterator<KFileItem> it(m_pendingVisibleItems);
 686         while (it.hasNext()) {
 687             const KFileItem item = it.next();
 688             const int index = m_model->index(item);
 689             if (index < m_firstVisibleIndex || index > m_lastVisibleIndex) {
 690                 m_pendingVisibleItems.remove(item);
 691                 m_pendingInvisibleItems.insert(item);
 692             }
 693         }
 694     }
 695
 696     int rangesCount = 0;
 697
 698     foreach (const KItemRange& range, itemRanges) {
 699         rangesCount += range.count;
 700
 701         // Add the inserted items to the pending visible and invisible items
 702         const int lastIndex = range.index + range.count - 1;
 703         for (int i = range.index; i <= lastIndex; ++i) {
 704             const KFileItem item = m_model->fileItem(i);
 705             if (!hasValidIndexRange || (i >= m_firstVisibleIndex && i <= m_lastVisibleIndex)) {
 706                 m_pendingVisibleItems.insert(item);
 707             } else {
 708                 m_pendingInvisibleItems.insert(item);
 709             }
 710         }
 711     }
 712
 713     resolvePendingRoles();
 714 }
 715
 716 void KFileItemModelRolesUpdater::startPreviewJob(const KFileItemList& items)
 717 {
 718     if (items.isEmpty() || m_paused) {
 719         return;
 720     }
 721
 722     // PreviewJob internally caches items always with the size of
 723     // 128 x 128 pixels or 256 x 256 pixels. A (slow) downscaling is done
 724     // by PreviewJob if a smaller size is requested. For images KFileItemModelRolesUpdater must
 725     // do a downscaling anyhow because of the frame, so in this case only the provided
 726     // cache sizes are requested.
 727     const QSize cacheSize = (m_iconSize.width() > 128) || (m_iconSize.height() > 128)
 728                             ? QSize(256, 256) : QSize(128, 128);
 729
 730     // KIO::filePreview() will request the MIME-type of all passed items, which (in the
 731     // worst case) might block the application for several seconds. To prevent such
 732     // a blocking the MIME-type of the items will determined until the MaxBlockTimeout
 733     // has been reached and only those items will get passed. As soon as the MIME-type
 734     // has been resolved once KIO::PreviewJob() can already access the resolved
 735     // MIME-type in a fast way.
 736     QElapsedTimer timer;
 737     timer.start();
 738     KFileItemList itemSubSet;
 739     for (int i = 0; i < items.count(); ++i) {
 740         KFileItem item = items.at(i);
 741         item.determineMimeType();
 742         itemSubSet.append(items.at(i));
 743         if (timer.elapsed() > MaxBlockTimeout) {
 744 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 745             kDebug() << "Maximum time of" << MaxBlockTimeout << "ms exceeded, creating only previews for"
 746                      << (i + 1) << "items," << (items.count() - (i + 1)) << "will be resolved later";
 747 #endif
 748             break;
 749         }
 750     }
 751     KIO::PreviewJob* job = new KIO::PreviewJob(itemSubSet, cacheSize, &m_enabledPlugins);
 752     job->setIgnoreMaximumSize(items.first().isLocalFile());
 753     if (job->ui()) {
 754         job->ui()->setWindow(qApp->activeWindow());
 755     }
 756
 757     connect(job,  SIGNAL(gotPreview(KFileItem,QPixmap)),
 758             this, SLOT(slotGotPreview(KFileItem,QPixmap)));
 759     connect(job,  SIGNAL(failed(KFileItem)),
 760             this, SLOT(slotPreviewFailed(KFileItem)));
 761     connect(job,  SIGNAL(finished(KJob*)),
 762             this, SLOT(slotPreviewJobFinished(KJob*)));
 763
 764     m_previewJobs.append(job);
 765 }
 766
 767
 768 bool KFileItemModelRolesUpdater::hasPendingRoles() const
 769 {
 770     return !m_pendingVisibleItems.isEmpty() || !m_pendingInvisibleItems.isEmpty();
 771 }
 772
 773 void KFileItemModelRolesUpdater::resolvePendingRoles()
 774 {
 775     int resolvedCount = 0;
 776
 777     bool hasSlowRoles = m_previewShown;
 778     if (!hasSlowRoles) {
 779         QSetIterator<QByteArray> it(m_roles);
 780         while (it.hasNext()) {
 781             if (m_resolvableRoles.contains(it.next())) {
 782                 hasSlowRoles = true;
 783                 break;
 784             }
 785         }
 786     }
 787
 788     const ResolveHint resolveHint = hasSlowRoles ? ResolveFast : ResolveAll;
 789
 790     // Resolving the MIME type can be expensive. Assure that not more than MaxBlockTimeout ms are
 791     // spend for resolving them synchronously. Usually this is more than enough to determine
 792     // all visible items, but there are corner cases where this limit gets easily exceeded.
 793     QElapsedTimer timer;
 794     timer.start();
 795
 796     // Resolve the MIME type of all visible items
 797     QSetIterator<KFileItem> visibleIt(m_pendingVisibleItems);
 798     while (visibleIt.hasNext()) {
 799         const KFileItem item = visibleIt.next();
 800         if (!hasSlowRoles) {
 801             Q_ASSERT(!m_pendingInvisibleItems.contains(item));
 802             // All roles will be resolved by applyResolvedRoles()
 803             m_pendingVisibleItems.remove(item);
 804         }
 805         applyResolvedRoles(item, resolveHint);
 806         ++resolvedCount;
 807
 808         if (timer.elapsed() > MaxBlockTimeout) {
 809             break;
 810         }
 811     }
 812
 813     // Resolve the MIME type of the invisible items at least until the timeout
 814     // has been exceeded or the maximum number of items has been reached
 815     KFileItemList invisibleItems;
 816     if (m_lastVisibleIndex >= 0) {
 817         // The visible range is valid, don't care about the order how the MIME
 818         // type of invisible items get resolved
 819         invisibleItems = m_pendingInvisibleItems.toList();
 820     } else {
 821         // The visible range is temporary invalid (e.g. happens when loading
 822         // a directory) so take care to sort the currently invisible items where
 823         // a part will get visible later
 824         invisibleItems = sortedItems(m_pendingInvisibleItems);
 825     }
 826
 827     int index = 0;
 828     while (resolvedCount < MaxResolveItemsCount && index < invisibleItems.count() && timer.elapsed() <= MaxBlockTimeout) {
 829         const KFileItem item = invisibleItems.at(index);
 830         applyResolvedRoles(item, resolveHint);
 831
 832         if (!hasSlowRoles) {
 833             // All roles have been resolved already by applyResolvedRoles()
 834             m_pendingInvisibleItems.remove(item);
 835         }
 836         ++index;
 837         ++resolvedCount;
 838     }
 839
 840     if (m_previewShown) {
 841         KFileItemList items = sortedItems(m_pendingVisibleItems);
 842         items += invisibleItems;
 843         startPreviewJob(items);
 844     } else {
 845         QTimer::singleShot(0, this, SLOT(resolveNextPendingRoles()));
 846     }
 847
 848 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
 849     if (timer.elapsed() > MaxBlockTimeout) {
 850         kDebug() << "Maximum time of" << MaxBlockTimeout
 851                  << "ms exceeded, skipping items... Remaining visible:" << m_pendingVisibleItems.count()
 852                  << "invisible:" << m_pendingInvisibleItems.count();
 853     }
 854     kDebug() << "[TIME] Resolved pending roles:" << timer.elapsed();
 855 #endif
 856
 857     applySortProgressToModel();
 858 }
 859
 860 void KFileItemModelRolesUpdater::resetPendingRoles()
 861 {
 862     m_pendingVisibleItems.clear();
 863     m_pendingInvisibleItems.clear();
 864
 865     foreach (KJob* job, m_previewJobs) {
 866         job->kill();
 867     }
 868     Q_ASSERT(m_previewJobs.isEmpty());
 869 }
 870
 871 void KFileItemModelRolesUpdater::sortAndResolveAllRoles()
 872 {
 873     if (m_paused) {
 874         return;
 875     }
 876
 877     resetPendingRoles();
 878     Q_ASSERT(m_pendingVisibleItems.isEmpty());
 879     Q_ASSERT(m_pendingInvisibleItems.isEmpty());
 880
 881     if (m_model->count() == 0) {
 882         return;
 883     }
 884
 885     // Determine all visible items
 886     Q_ASSERT(m_firstVisibleIndex >= 0);
 887     for (int i = m_firstVisibleIndex; i <= m_lastVisibleIndex; ++i) {
 888         const KFileItem item = m_model->fileItem(i);
 889         if (!item.isNull()) {
 890             m_pendingVisibleItems.insert(item);
 891         }
 892     }
 893
 894     // Determine all invisible items
 895     for (int i = 0; i < m_firstVisibleIndex; ++i) {
 896         const KFileItem item = m_model->fileItem(i);
 897         if (!item.isNull()) {
 898             m_pendingInvisibleItems.insert(item);
 899         }
 900     }
 901     for (int i = m_lastVisibleIndex + 1; i < m_model->count(); ++i) {
 902         const KFileItem item = m_model->fileItem(i);
 903         if (!item.isNull()) {
 904             m_pendingInvisibleItems.insert(item);
 905         }
 906     }
 907
 908     resolvePendingRoles();
 909 }
 910
 911 void KFileItemModelRolesUpdater::sortAndResolvePendingRoles()
 912 {
 913     Q_ASSERT(!m_paused);
 914     if (m_model->count() == 0) {
 915         return;
 916     }
 917
 918     // If no valid index range is given assume that all items are visible.
 919     // A cleanup will be done later as soon as the index range has been set.
 920     const bool hasValidIndexRange = (m_lastVisibleIndex >= 0);
 921
 922     // Trigger a preview generation of all pending items. Assure that the visible
 923     // pending items get generated first.
 924     QSet<KFileItem> pendingItems;
 925     pendingItems += m_pendingVisibleItems;
 926     pendingItems += m_pendingInvisibleItems;
 927
 928     resetPendingRoles();
 929     Q_ASSERT(m_pendingVisibleItems.isEmpty());
 930     Q_ASSERT(m_pendingInvisibleItems.isEmpty());
 931
 932     QSetIterator<KFileItem> it(pendingItems);
 933     while (it.hasNext()) {
 934         const KFileItem item = it.next();
 935         if (item.isNull()) {
 936             continue;
 937         }
 938
 939         const int index = m_model->index(item);
 940         if (!hasValidIndexRange || (index >= m_firstVisibleIndex && index <= m_lastVisibleIndex)) {
 941             m_pendingVisibleItems.insert(item);
 942         } else {
 943             m_pendingInvisibleItems.insert(item);
 944         }
 945     }
 946
 947     resolvePendingRoles();
 948 }
 949
 950 void KFileItemModelRolesUpdater::applySortProgressToModel()
 951 {
 952     if (m_sortingProgress < 0) {
 953         return;
 954     }
 955
 956     // Inform the model about the progress of the resolved items,
 957     // so that it can give an indication when the sorting has been finished.
 958     const int resolvedCount = m_model->count()
 959                               - m_pendingVisibleItems.count()
 960                               - m_pendingInvisibleItems.count();
 961     if (resolvedCount > 0) {
 962         m_model->emitSortProgress(resolvedCount);
 963         if (resolvedCount == m_model->count()) {
 964             m_sortingProgress = -1;
 965         }
 966     }
 967 }
 968
 969 void KFileItemModelRolesUpdater::updateSortProgress()
 970 {
 971     const QByteArray sortRole = m_model->sortRole();
 972
 973     // Optimization if the sorting is done by type: In case if all MIME-types
 974     // are known, the types have been resolved already by KFileItemModel and
 975     // no sort-progress feedback is required.
 976     const bool showProgress = (sortRole == "type")
 977                               ? hasUnknownMimeTypes()
 978                               : m_resolvableRoles.contains(sortRole);
 979
 980     if (m_sortingProgress >= 0) {
 981         // Mark the current sorting as finished
 982         m_model->emitSortProgress(m_model->count());
 983     }
 984     m_sortingProgress = showProgress ? 0 : -1;
 985 }
 986
 987 bool KFileItemModelRolesUpdater::hasUnknownMimeTypes() const
 988 {
 989     const int count = m_model->count();
 990     for (int i = 0; i < count; ++i) {
 991         const KFileItem item = m_model->fileItem(i);
 992         if (!item.isMimeTypeKnown()) {
 993             return true;
 994         }
 995     }
 996
 997     return false;
 998 }
 999
1000 bool KFileItemModelRolesUpdater::applyResolvedRoles(const KFileItem& item, ResolveHint hint)
1001 {
1002     if (item.isNull()) {
1003         return false;
1004     }
1005
1006     const bool resolveAll = (hint == ResolveAll);
1007
1008     bool mimeTypeChanged = false;
1009     if (!item.isMimeTypeKnown()) {
1010         item.determineMimeType();
1011         mimeTypeChanged = true;
1012     }
1013
1014     if (mimeTypeChanged || resolveAll || m_clearPreviews) {
1015         const int index = m_model->index(item);
1016         if (index < 0) {
1017             return false;
1018         }
1019
1020         QHash<QByteArray, QVariant> data;
1021         if (resolveAll) {
1022             data = rolesData(item);
1023         }
1024
1025         data.insert("iconName", item.iconName());
1026
1027         if (m_clearPreviews) {
1028             data.insert("iconPixmap", QPixmap());
1029         }
1030
1031         disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
1032                    this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
1033         m_model->setData(index, data);
1034         connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
1035                 this,    SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
1036         return true;
1037     }
1038
1039     return false;
1040 }
1041
1042 QHash<QByteArray, QVariant> KFileItemModelRolesUpdater::rolesData(const KFileItem& item) const
1043 {
1044     QHash<QByteArray, QVariant> data;
1045
1046     const bool getSizeRole = m_roles.contains("size");
1047     const bool getIsExpandableRole = m_roles.contains("isExpandable");
1048
1049     if ((getSizeRole || getIsExpandableRole) && item.isDir()) {
1050         if (item.isLocalFile()) {
1051             const QString path = item.localPath();
1052             const int count = subItemsCount(path);
1053             if (getSizeRole) {
1054                 data.insert("size", count);
1055             }
1056             if (getIsExpandableRole) {
1057                 data.insert("isExpandable", count > 0);
1058             }
1059
1060             if (!m_dirWatcher->contains(path)) {
1061                 m_dirWatcher->addDir(path);
1062                 m_watchedDirs.insert(path);
1063             }
1064         } else if (getSizeRole) {
1065             data.insert("size", -1); // -1 indicates an unknown number of items
1066         }
1067     }
1068
1069     if (m_roles.contains("type")) {
1070         data.insert("type", item.mimeComment());
1071     }
1072
1073     data.insert("iconOverlays", item.overlays());
1074
1075 #ifdef HAVE_NEPOMUK
1076     if (m_nepomukResourceWatcher) {
1077         const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
1078         Nepomuk::Resource resource(item.nepomukUri());
1079         QHashIterator<QByteArray, QVariant> it(rolesProvider.roleValues(resource, m_roles));
1080         while (it.hasNext()) {
1081             it.next();
1082             data.insert(it.key(), it.value());
1083         }
1084
1085         QUrl uri = resource.resourceUri();
1086         if (uri.isEmpty()) {
1087             // TODO: Is there another way to explicitly create a resource?
1088             // We need a resource to be able to track it for changes.
1089             resource.setRating(0);
1090             uri = resource.resourceUri();
1091         }
1092         if (!uri.isEmpty() && !m_nepomukUriItems.contains(uri)) {
1093             m_nepomukResourceWatcher->addResource(resource);
1094
1095             if (m_nepomukUriItems.isEmpty()) {
1096                 m_nepomukResourceWatcher->start();
1097             }
1098
1099             m_nepomukUriItems.insert(uri, item.url());
1100         }
1101     }
1102 #endif
1103
1104     return data;
1105 }
1106
1107 KFileItemList KFileItemModelRolesUpdater::sortedItems(const QSet<KFileItem>& items) const
1108 {
1109     KFileItemList itemList;
1110     if (items.isEmpty()) {
1111         return itemList;
1112     }
1113
1114 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
1115     QElapsedTimer timer;
1116     timer.start();
1117 #endif
1118
1119     QList<int> indexes;
1120     indexes.reserve(items.count());
1121
1122     QSetIterator<KFileItem> it(items);
1123     while (it.hasNext()) {
1124         const KFileItem item = it.next();
1125         const int index = m_model->index(item);
1126         if (index >= 0) {
1127             indexes.append(index);
1128         }
1129     }
1130     qSort(indexes);
1131
1132     itemList.reserve(items.count());
1133     foreach (int index, indexes) {
1134         itemList.append(m_model->fileItem(index));
1135     }
1136
1137 #ifdef KFILEITEMMODELROLESUPDATER_DEBUG
1138     kDebug() << "[TIME] Sorting of items:" << timer.elapsed();
1139 #endif
1140     return itemList;
1141 }
1142
1143 int KFileItemModelRolesUpdater::subItemsCount(const QString& path) const
1144 {
1145     const bool countHiddenFiles = m_model->showHiddenFiles();
1146     const bool showFoldersOnly  = m_model->showDirectoriesOnly();
1147
1148 #ifdef Q_WS_WIN
1149     QDir dir(path);
1150     QDir::Filters filters = QDir::NoDotAndDotDot | QDir::System;
1151     if (countHiddenFiles) {
1152         filters |= QDir::Hidden;
1153     }
1154     if (showFoldersOnly) {
1155         filters |= QDir::Dirs;
1156     } else {
1157         filters |= QDir::AllEntries;
1158     }
1159     return dir.entryList(filters).count();
1160 #else
1161     // Taken from kdelibs/kio/kio/kdirmodel.cpp
1162     // Copyright (C) 2006 David Faure <faure@kde.org>
1163
1164     int count = -1;
1165     DIR* dir = ::opendir(QFile::encodeName(path));
1166     if (dir) {  // krazy:exclude=syscalls
1167         count = 0;
1168         struct dirent *dirEntry = 0;
1169         while ((dirEntry = ::readdir(dir))) {
1170             if (dirEntry->d_name[0] == '.') {
1171                 if (dirEntry->d_name[1] == '\0' || !countHiddenFiles) {
1172                     // Skip "." or hidden files
1173                     continue;
1174                 }
1175                 if (dirEntry->d_name[1] == '.' && dirEntry->d_name[2] == '\0') {
1176                     // Skip ".."
1177                     continue;
1178                 }
1179             }
1180
1181             // If only directories are counted, consider an unknown file type and links also
1182             // as directory instead of trying to do an expensive stat()
1183             // (see bugs 292642 and 299997).
1184             const bool countEntry = !showFoldersOnly ||
1185                                     dirEntry->d_type == DT_DIR ||
1186                                     dirEntry->d_type == DT_LNK ||
1187                                     dirEntry->d_type == DT_UNKNOWN;
1188             if (countEntry) {
1189                 ++count;
1190             }
1191         }
1192         ::closedir(dir);
1193     }
1194     return count;
1195 #endif
1196 }
1197
1198 void KFileItemModelRolesUpdater::updateAllPreviews()
1199 {
1200     if (m_paused) {
1201         m_previewChangedDuringPausing = true;
1202     } else {
1203         sortAndResolveAllRoles();
1204     }
1205 }
1206
1207 #include "kfileitemmodelrolesupdater.moc"