#include "kfileitemmodelrolesupdater.h"
#include "kfileitemmodel.h"
-#include "kpixmapmodifier_p.h"
#include <KConfig>
#include <KConfigGroup>
#include <KDebug>
+#include <KDirWatch>
#include <KFileItem>
#include <KGlobal>
+#include <KIO/JobUiDelegate>
#include <KIO/PreviewJob>
+
+#include "private/kpixmapmodifier.h"
+
+#include <QApplication>
#include <QPainter>
#include <QPixmap>
#include <QElapsedTimer>
#include <QTimer>
-// Required includes for subDirectoriesCount():
+#ifdef HAVE_NEPOMUK
+ #include "private/knepomukrolesprovider.h"
+ #include "private/nepomuk/resourcewatcher.h"
+#endif
+
+// Required includes for subItemsCount():
#ifdef Q_WS_WIN
#include <QDir>
#else
#include <QFile>
#endif
-#define KFILEITEMMODELROLESUPDATER_DEBUG
+// #define KFILEITEMMODELROLESUPDATER_DEBUG
namespace {
+ // Maximum time in ms that the KFileItemModelRolesUpdater
+ // may perform a blocking operation
+ const int MaxBlockTimeout = 200;
+
+ // Maximum number of items that will get resolved synchronously.
+ // The value should roughly represent the number of maximum visible
+ // items, as it does not make sense to resolve more items synchronously
+ // and probably reach the MaxBlockTimeout because of invisible items.
const int MaxResolveItemsCount = 100;
}
m_iconSizeChangedDuringPausing(false),
m_rolesChangedDuringPausing(false),
m_previewShown(false),
+ m_enlargeSmallPreviews(true),
m_clearPreviews(false),
+ m_sortingProgress(-1),
m_model(model),
m_iconSize(),
m_firstVisibleIndex(0),
m_pendingVisibleItems(),
m_pendingInvisibleItems(),
m_previewJobs(),
- m_resolvePendingRolesTimer(0)
+ m_changedItemsTimer(0),
+ m_changedItems(),
+ m_dirWatcher(0),
+ m_watchedDirs()
+ #ifdef HAVE_NEPOMUK
+ , m_nepomukResourceWatcher(0),
+ m_nepomukUriItems()
+ #endif
+
{
Q_ASSERT(model);
this, SLOT(slotItemsRemoved(KItemRangeList)));
connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
this, SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+ connect(m_model, SIGNAL(sortRoleChanged(QByteArray,QByteArray)),
+ this, SLOT(slotSortRoleChanged(QByteArray,QByteArray)));
+
+ // Use a timer to prevent that each call of slotItemsChanged() results in a synchronous
+ // resolving of the roles. Postpone the resolving until no update has been done for 1 second.
+ m_changedItemsTimer = new QTimer(this);
+ m_changedItemsTimer->setInterval(1000);
+ m_changedItemsTimer->setSingleShot(true);
+ connect(m_changedItemsTimer, SIGNAL(timeout()), this, SLOT(resolveChangedItems()));
+
+ m_resolvableRoles.insert("size");
+ m_resolvableRoles.insert("type");
+ m_resolvableRoles.insert("isExpandable");
+#ifdef HAVE_NEPOMUK
+ m_resolvableRoles += KNepomukRolesProvider::instance().roles();
+#endif
- // A timer with a minimal timeout is used to merge several triggerPendingRolesResolving() calls
- // to only one call of resolvePendingRoles().
- m_resolvePendingRolesTimer = new QTimer(this);
- m_resolvePendingRolesTimer->setInterval(1);
- m_resolvePendingRolesTimer->setSingleShot(true);
- connect(m_resolvePendingRolesTimer, SIGNAL(timeout()), this, SLOT(resolvePendingRoles()));
+ // When folders are expandable or the item-count is shown for folders, it is necessary
+ // to watch the number of items of the sub-folder to be able to react on changes.
+ m_dirWatcher = new KDirWatch(this);
+ connect(m_dirWatcher, SIGNAL(dirty(QString)), this, SLOT(slotDirWatchDirty(QString)));
}
KFileItemModelRolesUpdater::~KFileItemModelRolesUpdater()
{
+ resetPendingRoles();
}
void KFileItemModelRolesUpdater::setIconSize(const QSize& size)
}
}
-void KFileItemModelRolesUpdater::setPreviewShown(bool show)
+void KFileItemModelRolesUpdater::setPreviewsShown(bool show)
{
if (show == m_previewShown) {
return;
m_clearPreviews = true;
}
- if (m_paused) {
- m_previewChangedDuringPausing = true;
- } else {
- sortAndResolveAllRoles();
- }
+ updateAllPreviews();
}
-bool KFileItemModelRolesUpdater::isPreviewShown() const
+bool KFileItemModelRolesUpdater::previewsShown() const
{
return m_previewShown;
}
+void KFileItemModelRolesUpdater::setEnlargeSmallPreviews(bool enlarge)
+{
+ if (enlarge != m_enlargeSmallPreviews) {
+ m_enlargeSmallPreviews = enlarge;
+ if (m_previewShown) {
+ updateAllPreviews();
+ }
+ }
+}
+
+bool KFileItemModelRolesUpdater::enlargeSmallPreviews() const
+{
+ return m_enlargeSmallPreviews;
+}
+
void KFileItemModelRolesUpdater::setEnabledPlugins(const QStringList& list)
{
- m_enabledPlugins = list;
+ if (m_enabledPlugins != list) {
+ m_enabledPlugins = list;
+ if (m_previewShown) {
+ updateAllPreviews();
+ }
+ }
}
void KFileItemModelRolesUpdater::setPaused(bool paused)
}
} else {
const bool resolveAll = (m_iconSizeChangedDuringPausing && m_previewShown) ||
- (m_previewChangedDuringPausing && !m_previewShown) ||
+ m_previewChangedDuringPausing ||
m_rolesChangedDuringPausing;
if (resolveAll) {
sortAndResolveAllRoles();
void KFileItemModelRolesUpdater::setRoles(const QSet<QByteArray>& roles)
{
- if (roles.count() == m_roles.count()) {
- bool isEqual = true;
- foreach (const QByteArray& role, roles) {
- if (!m_roles.contains(role)) {
- isEqual = false;
+ if (m_roles != roles) {
+ m_roles = roles;
+
+#ifdef HAVE_NEPOMUK
+ // Check whether there is at least one role that must be resolved
+ // with the help of Nepomuk. If this is the case, a (quite expensive)
+ // resolving will be done in KFileItemModelRolesUpdater::rolesData() and
+ // the role gets watched for changes.
+ const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
+ bool hasNepomukRole = false;
+ QSetIterator<QByteArray> it(roles);
+ while (it.hasNext()) {
+ const QByteArray& role = it.next();
+ if (rolesProvider.roles().contains(role)) {
+ hasNepomukRole = true;
break;
}
}
- if (isEqual) {
- return;
+
+ if (hasNepomukRole && !m_nepomukResourceWatcher) {
+ Q_ASSERT(m_nepomukUriItems.isEmpty());
+
+ m_nepomukResourceWatcher = new Nepomuk::ResourceWatcher(this);
+ connect(m_nepomukResourceWatcher, SIGNAL(propertyChanged(Nepomuk::Resource,Nepomuk::Types::Property,QVariantList,QVariantList)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
+ connect(m_nepomukResourceWatcher, SIGNAL(propertyRemoved(Nepomuk::Resource,Nepomuk::Types::Property,QVariant)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
+ connect(m_nepomukResourceWatcher, SIGNAL(propertyAdded(Nepomuk::Resource,Nepomuk::Types::Property,QVariant)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
+ connect(m_nepomukResourceWatcher, SIGNAL(resourceCreated(Nepomuk::Resource,QList<QUrl>)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk::Resource)));
+ } else if (!hasNepomukRole && m_nepomukResourceWatcher) {
+ delete m_nepomukResourceWatcher;
+ m_nepomukResourceWatcher = 0;
+ m_nepomukUriItems.clear();
}
- }
+#endif
- m_roles = roles;
+ updateSortProgress();
- if (m_paused) {
- m_rolesChangedDuringPausing = true;
- } else {
- sortAndResolveAllRoles();
+ if (m_paused) {
+ m_rolesChangedDuringPausing = true;
+ } else {
+ sortAndResolveAllRoles();
+ }
}
}
void KFileItemModelRolesUpdater::slotItemsInserted(const KItemRangeList& itemRanges)
{
- // If no valid index range is given assume that all items are visible.
- // A cleanup will be done later as soon as the index range has been set.
- const bool hasValidIndexRange = (m_lastVisibleIndex >= 0);
+ startUpdating(itemRanges);
+}
- if (hasValidIndexRange) {
- // Move all current pending visible items that are not visible anymore
- // to the pending invisible items.
- QSetIterator<KFileItem> it(m_pendingVisibleItems);
- while (it.hasNext()) {
- const KFileItem item = it.next();
- const int index = m_model->index(item);
- if (index < m_firstVisibleIndex || index > m_lastVisibleIndex) {
- m_pendingVisibleItems.remove(item);
- m_pendingInvisibleItems.insert(item);
+void KFileItemModelRolesUpdater::slotItemsRemoved(const KItemRangeList& itemRanges)
+{
+ Q_UNUSED(itemRanges);
+
+ const bool allItemsRemoved = (m_model->count() == 0);
+
+ if (!m_watchedDirs.isEmpty()) {
+ // Don't let KDirWatch watch for removed items
+ if (allItemsRemoved) {
+ foreach (const QString& path, m_watchedDirs) {
+ m_dirWatcher->removeDir(path);
+ }
+ m_watchedDirs.clear();
+ } else {
+ QMutableSetIterator<QString> it(m_watchedDirs);
+ while (it.hasNext()) {
+ const QString& path = it.next();
+ if (m_model->index(KUrl(path)) < 0) {
+ m_dirWatcher->removeDir(path);
+ it.remove();
+ }
}
}
}
- int rangesCount = 0;
-
- foreach (const KItemRange& range, itemRanges) {
- rangesCount += range.count;
-
- // Add the inserted items to the pending visible and invisible items
- const int lastIndex = range.index + range.count - 1;
- for (int i = range.index; i <= lastIndex; ++i) {
- const KFileItem item = m_model->fileItem(i);
- if (!hasValidIndexRange || (i >= m_firstVisibleIndex && i <= m_lastVisibleIndex)) {
- m_pendingVisibleItems.insert(item);
- } else {
- m_pendingInvisibleItems.insert(item);
+#ifdef HAVE_NEPOMUK
+ if (m_nepomukResourceWatcher) {
+ // Don't let the ResourceWatcher watch for removed items
+ if (allItemsRemoved) {
+ m_nepomukResourceWatcher->setResources(QList<Nepomuk::Resource>());
+ m_nepomukResourceWatcher->stop();
+ m_nepomukUriItems.clear();
+ } else {
+ QList<Nepomuk::Resource> newResources;
+ const QList<Nepomuk::Resource> oldResources = m_nepomukResourceWatcher->resources();
+ foreach (const Nepomuk::Resource& resource, oldResources) {
+ const QUrl uri = resource.resourceUri();
+ const KUrl itemUrl = m_nepomukUriItems.value(uri);
+ if (m_model->index(itemUrl) >= 0) {
+ newResources.append(resource);
+ } else {
+ m_nepomukUriItems.remove(uri);
+ }
+ }
+ m_nepomukResourceWatcher->setResources(newResources);
+ if (newResources.isEmpty()) {
+ Q_ASSERT(m_nepomukUriItems.isEmpty());
+ m_nepomukResourceWatcher->stop();
}
}
}
+#endif
- triggerPendingRolesResolving(rangesCount);
-}
-
-void KFileItemModelRolesUpdater::slotItemsRemoved(const KItemRangeList& itemRanges)
-{
- Q_UNUSED(itemRanges);
m_firstVisibleIndex = 0;
m_lastVisibleIndex = -1;
- if (hasPendingRoles() && m_model->count() <= 0) {
+ if (!hasPendingRoles()) {
+ return;
+ }
+
+ if (allItemsRemoved) {
+ // Most probably a directory change is done. Clear all pending items
+ // and also kill all ongoing preview-jobs.
resetPendingRoles();
+
+ m_changedItems.clear();
+ m_changedItemsTimer->stop();
+ } else {
+ // Remove all items from m_pendingVisibleItems and m_pendingInvisibleItems
+ // that are not part of the model anymore. The items from m_changedItems
+ // don't need to be handled here, removed items are just skipped in
+ // resolveChangedItems().
+ for (int i = 0; i <= 1; ++i) {
+ QSet<KFileItem>& pendingItems = (i == 0) ? m_pendingVisibleItems : m_pendingInvisibleItems;
+ QMutableSetIterator<KFileItem> it(pendingItems);
+ while (it.hasNext()) {
+ const KFileItem item = it.next();
+ if (m_model->index(item) < 0) {
+ pendingItems.remove(item);
+ }
+ }
+ }
}
}
void KFileItemModelRolesUpdater::slotItemsChanged(const KItemRangeList& itemRanges,
const QSet<QByteArray>& roles)
{
- Q_UNUSED(itemRanges);
Q_UNUSED(roles);
- // TODO
+
+ if (m_changedItemsTimer->isActive()) {
+ // A call of slotItemsChanged() has been done recently. Postpone the resolving
+ // of the roles until the timer has exceeded.
+ foreach (const KItemRange& itemRange, itemRanges) {
+ int index = itemRange.index;
+ for (int count = itemRange.count; count > 0; --count) {
+ m_changedItems.insert(m_model->fileItem(index));
+ ++index;
+ }
+ }
+ } else {
+ // No call of slotItemsChanged() has been done recently, resolve the roles now.
+ startUpdating(itemRanges);
+ }
+ m_changedItemsTimer->start();
+}
+
+void KFileItemModelRolesUpdater::slotSortRoleChanged(const QByteArray& current,
+ const QByteArray& previous)
+{
+ Q_UNUSED(current);
+ Q_UNUSED(previous);
+ updateSortProgress();
}
void KFileItemModelRolesUpdater::slotGotPreview(const KFileItem& item, const QPixmap& pixmap)
{
+ const int oldNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
+
m_pendingVisibleItems.remove(item);
m_pendingInvisibleItems.remove(item);
+ const int newNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
+
+ if (oldNumberOfPendingItems == newNumberOfPendingItems) {
+ // 'item' could not be removed from either of the sets. It looks like
+ // we have hit bug 304986. Replace the items in the sets by the items
+ // in the model to work around the problem.
+ // NOTE: This workaround is not needed any more in KDE 4.10.
+ m_pendingVisibleItems = sortedItems(m_pendingVisibleItems).toSet();
+ m_pendingInvisibleItems = sortedItems(m_pendingInvisibleItems).toSet();
+ }
+
const int index = m_model->index(item);
if (index < 0) {
return;
const int slashIndex = mimeType.indexOf(QLatin1Char('/'));
const QString mimeTypeGroup = mimeType.left(slashIndex);
if (mimeTypeGroup == QLatin1String("image")) {
- KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
+ if (m_enlargeSmallPreviews) {
+ KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
+ } else {
+ // Assure that small previews don't get enlarged. Instead they
+ // should be shown centered within the frame.
+ const QSize contentSize = KPixmapModifier::sizeInsideFrame(m_iconSize);
+ const bool enlargingRequired = scaledPixmap.width() < contentSize.width() &&
+ scaledPixmap.height() < contentSize.height();
+ if (enlargingRequired) {
+ QSize frameSize = scaledPixmap.size();
+ frameSize.scale(m_iconSize, Qt::KeepAspectRatio);
+
+ QPixmap largeFrame(frameSize);
+ largeFrame.fill(Qt::transparent);
+
+ KPixmapModifier::applyFrame(largeFrame, frameSize);
+
+ QPainter painter(&largeFrame);
+ painter.drawPixmap((largeFrame.width() - scaledPixmap.width()) / 2,
+ (largeFrame.height() - scaledPixmap.height()) / 2,
+ scaledPixmap);
+ scaledPixmap = largeFrame;
+ } else {
+ // The image must be shrinked as it is too large to fit into
+ // the available icon size
+ KPixmapModifier::applyFrame(scaledPixmap, m_iconSize);
+ }
+ }
} else {
KPixmapModifier::scale(scaledPixmap, m_iconSize);
}
m_model->setData(index, data);
connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
this, SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+
+ applySortProgressToModel();
}
void KFileItemModelRolesUpdater::slotPreviewFailed(const KFileItem& item)
{
+ const int oldNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
+
m_pendingVisibleItems.remove(item);
m_pendingInvisibleItems.remove(item);
+ const int newNumberOfPendingItems = m_pendingVisibleItems.count() + m_pendingInvisibleItems.count();
+
+ if (oldNumberOfPendingItems == newNumberOfPendingItems) {
+ // 'item' could not be removed from either of the sets. It looks like
+ // we have hit bug 304986. Replace the items in the sets by the items
+ // in the model to work around the problem.
+ // NOTE: This workaround is not needed any more in KDE 4.10.
+ m_pendingVisibleItems = sortedItems(m_pendingVisibleItems).toSet();
+ m_pendingInvisibleItems = sortedItems(m_pendingInvisibleItems).toSet();
+ }
+
const bool clearPreviews = m_clearPreviews;
m_clearPreviews = true;
applyResolvedRoles(item, ResolveAll);
m_clearPreviews = clearPreviews;
+
+ applySortProgressToModel();
}
void KFileItemModelRolesUpdater::slotPreviewJobFinished(KJob* job)
return;
}
- const KFileItemList visibleItems = sortedItems(m_pendingVisibleItems);
- const KFileItemList invisibleItems = itemSubSet(m_pendingInvisibleItems, MaxResolveItemsCount - visibleItems.count());
- startPreviewJob(visibleItems + invisibleItems);
-}
-
-void KFileItemModelRolesUpdater::resolvePendingRoles()
-{
- int resolvedCount = 0;
-
- const bool hasSlowRoles = m_previewShown
- || m_roles.contains("size")
- || m_roles.contains("type");
- const ResolveHint resolveHint = hasSlowRoles ? ResolveFast : ResolveAll;
-
- // Resolving the MIME type can be expensive. Assure that not more than 200 ms are
- // spend for resolving them synchronously. Usually this is more than enough to determine
- // all visible items, but there are corner cases where this limit gets easily exceeded.
- const int MaxTime = 200;
- QElapsedTimer timer;
- timer.start();
-
- // Resolve the MIME type of all visible items
- QSetIterator<KFileItem> visibleIt(m_pendingVisibleItems);
- while (visibleIt.hasNext()) {
- const KFileItem item = visibleIt.next();
- applyResolvedRoles(item, resolveHint);
- if (!hasSlowRoles) {
- Q_ASSERT(!m_pendingInvisibleItems.contains(item));
- // All roles have been resolved already by applyResolvedRoles()
- m_pendingVisibleItems.remove(item);
- }
- ++resolvedCount;
-
- if (timer.elapsed() > MaxTime) {
- break;
- }
- }
-
- // Resolve the MIME type of the invisible items at least until the timeout
- // has been exceeded or the maximum number of items has been reached
- KFileItemList invisibleItems;
- if (m_lastVisibleIndex >= 0) {
- // The visible range is valid, don't care about the order how the MIME
- // type of invisible items get resolved
- invisibleItems = m_pendingInvisibleItems.toList();
- } else {
- // The visible range is temporary invalid (e.g. happens when loading
- // a directory) so take care to sort the currently invisible items where
- // a part will get visible later
- invisibleItems = sortedItems(m_pendingInvisibleItems);
- }
-
- int index = 0;
- while (resolvedCount < MaxResolveItemsCount && index < invisibleItems.count() && timer.elapsed() <= MaxTime) {
- const KFileItem item = invisibleItems.at(index);
- applyResolvedRoles(item, resolveHint);
-
- if (!hasSlowRoles) {
- // All roles have been resolved already by applyResolvedRoles()
- m_pendingInvisibleItems.remove(item);
- }
- ++index;
- ++resolvedCount;
- }
-
- if (m_previewShown) {
- KFileItemList items = sortedItems(m_pendingVisibleItems);
- items += invisibleItems;
- startPreviewJob(items);
- } else {
- QTimer::singleShot(0, this, SLOT(resolveNextPendingRoles()));
- }
-
-#ifdef KFILEITEMMODELROLESUPDATER_DEBUG
- if (timer.elapsed() > MaxTime) {
- kDebug() << "Maximum time exceeded, skipping items... Remaining visible:" << m_pendingVisibleItems.count()
- << "invisible:" << m_pendingInvisibleItems.count();
- }
- kDebug() << "[TIME] Resolved pending roles:" << timer.elapsed();
-#endif
+ const KFileItemList visibleItems = sortedItems(m_pendingVisibleItems);
+ startPreviewJob(visibleItems + m_pendingInvisibleItems.toList());
}
void KFileItemModelRolesUpdater::resolveNextPendingRoles()
m_clearPreviews = false;
}
+ applySortProgressToModel();
+
#ifdef KFILEITEMMODELROLESUPDATER_DEBUG
static int callCount = 0;
++callCount;
#endif
}
+void KFileItemModelRolesUpdater::resolveChangedItems()
+{
+ if (m_changedItems.isEmpty()) {
+ return;
+ }
+
+ KItemRangeList itemRanges;
+
+ QSetIterator<KFileItem> it(m_changedItems);
+ while (it.hasNext()) {
+ const KFileItem& item = it.next();
+ const int index = m_model->index(item);
+ if (index >= 0) {
+ itemRanges.append(KItemRange(index, 1));
+ }
+ }
+ m_changedItems.clear();
+
+ startUpdating(itemRanges);
+}
+
+void KFileItemModelRolesUpdater::applyChangedNepomukRoles(const Nepomuk::Resource& resource)
+{
+#ifdef HAVE_NEPOMUK
+ const KUrl itemUrl = m_nepomukUriItems.value(resource.resourceUri());
+ const KFileItem item = m_model->fileItem(itemUrl);
+
+ if (item.isNull()) {
+ // itemUrl is not in the model anymore, probably because
+ // the corresponding file has been deleted in the meantime.
+ return;
+ }
+
+ QHash<QByteArray, QVariant> data = rolesData(item);
+
+ const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
+ QHashIterator<QByteArray, QVariant> it(rolesProvider.roleValues(resource, m_roles));
+ while (it.hasNext()) {
+ it.next();
+ data.insert(it.key(), it.value());
+ }
+
+ disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
+ this, SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+ const int index = m_model->index(item);
+ m_model->setData(index, data);
+ connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
+ this, SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
+#else
+#ifndef Q_CC_MSVC
+ Q_UNUSED(resource);
+#endif
+#endif
+}
+
+void KFileItemModelRolesUpdater::slotDirWatchDirty(const QString& path)
+{
+ const bool getSizeRole = m_roles.contains("size");
+ const bool getIsExpandableRole = m_roles.contains("isExpandable");
+
+ if (getSizeRole || getIsExpandableRole) {
+ const int index = m_model->index(KUrl(path));
+ if (index >= 0) {
+ QHash<QByteArray, QVariant> data;
+
+ const int count = subItemsCount(path);
+ if (getSizeRole) {
+ data.insert("size", count);
+ }
+ if (getIsExpandableRole) {
+ data.insert("isExpandable", count > 0);
+ }
+
+ m_model->setData(index, data);
+ }
+ }
+}
+
+void KFileItemModelRolesUpdater::startUpdating(const KItemRangeList& itemRanges)
+{
+ // If no valid index range is given assume that all items are visible.
+ // A cleanup will be done later as soon as the index range has been set.
+ const bool hasValidIndexRange = (m_lastVisibleIndex >= 0);
+
+ if (hasValidIndexRange) {
+ // Move all current pending visible items that are not visible anymore
+ // to the pending invisible items.
+ QSetIterator<KFileItem> it(m_pendingVisibleItems);
+ while (it.hasNext()) {
+ const KFileItem item = it.next();
+ const int index = m_model->index(item);
+ if (index < m_firstVisibleIndex || index > m_lastVisibleIndex) {
+ m_pendingVisibleItems.remove(item);
+ m_pendingInvisibleItems.insert(item);
+ }
+ }
+ }
+
+ int rangesCount = 0;
+
+ foreach (const KItemRange& range, itemRanges) {
+ rangesCount += range.count;
+
+ // Add the inserted items to the pending visible and invisible items
+ const int lastIndex = range.index + range.count - 1;
+ for (int i = range.index; i <= lastIndex; ++i) {
+ const KFileItem item = m_model->fileItem(i);
+ if (!hasValidIndexRange || (i >= m_firstVisibleIndex && i <= m_lastVisibleIndex)) {
+ m_pendingVisibleItems.insert(item);
+ } else {
+ m_pendingInvisibleItems.insert(item);
+ }
+ }
+ }
+
+ resolvePendingRoles();
+}
+
void KFileItemModelRolesUpdater::startPreviewJob(const KFileItemList& items)
{
- if (items.count() <= 0 || m_paused) {
+ if (items.isEmpty() || m_paused) {
return;
}
const QSize cacheSize = (m_iconSize.width() > 128) || (m_iconSize.height() > 128)
? QSize(256, 256) : QSize(128, 128);
- KJob* job;
- if (items.count() <= MaxResolveItemsCount) {
- job = KIO::filePreview(items, cacheSize, &m_enabledPlugins);
- } else {
- KFileItemList itemsSubSet;
- for (int i = 0; i <= MaxResolveItemsCount; ++i) {
- itemsSubSet.append(items.at(i));
+ // KIO::filePreview() will request the MIME-type of all passed items, which (in the
+ // worst case) might block the application for several seconds. To prevent such
+ // a blocking the MIME-type of the items will determined until the MaxBlockTimeout
+ // has been reached and only those items will get passed. As soon as the MIME-type
+ // has been resolved once KIO::PreviewJob() can already access the resolved
+ // MIME-type in a fast way.
+ QElapsedTimer timer;
+ timer.start();
+ KFileItemList itemSubSet;
+ for (int i = 0; i < items.count(); ++i) {
+ KFileItem item = items.at(i);
+ item.determineMimeType();
+ itemSubSet.append(items.at(i));
+ if (timer.elapsed() > MaxBlockTimeout) {
+#ifdef KFILEITEMMODELROLESUPDATER_DEBUG
+ kDebug() << "Maximum time of" << MaxBlockTimeout << "ms exceeded, creating only previews for"
+ << (i + 1) << "items," << (items.count() - (i + 1)) << "will be resolved later";
+#endif
+ break;
}
- job = KIO::filePreview(itemsSubSet, cacheSize, &m_enabledPlugins);
+ }
+ KIO::PreviewJob* job = new KIO::PreviewJob(itemSubSet, cacheSize, &m_enabledPlugins);
+ job->setIgnoreMaximumSize(items.first().isLocalFile());
+ if (job->ui()) {
+ job->ui()->setWindow(qApp->activeWindow());
}
- connect(job, SIGNAL(gotPreview(const KFileItem&, const QPixmap&)),
- this, SLOT(slotGotPreview(const KFileItem&, const QPixmap&)));
+ connect(job, SIGNAL(gotPreview(KFileItem,QPixmap)),
+ this, SLOT(slotGotPreview(KFileItem,QPixmap)));
connect(job, SIGNAL(failed(KFileItem)),
this, SLOT(slotPreviewFailed(KFileItem)));
connect(job, SIGNAL(finished(KJob*)),
return !m_pendingVisibleItems.isEmpty() || !m_pendingInvisibleItems.isEmpty();
}
+void KFileItemModelRolesUpdater::resolvePendingRoles()
+{
+ int resolvedCount = 0;
+
+ bool hasSlowRoles = m_previewShown;
+ if (!hasSlowRoles) {
+ QSetIterator<QByteArray> it(m_roles);
+ while (it.hasNext()) {
+ if (m_resolvableRoles.contains(it.next())) {
+ hasSlowRoles = true;
+ break;
+ }
+ }
+ }
+
+ const ResolveHint resolveHint = hasSlowRoles ? ResolveFast : ResolveAll;
+
+ // Resolving the MIME type can be expensive. Assure that not more than MaxBlockTimeout ms are
+ // spend for resolving them synchronously. Usually this is more than enough to determine
+ // all visible items, but there are corner cases where this limit gets easily exceeded.
+ QElapsedTimer timer;
+ timer.start();
+
+ // Resolve the MIME type of all visible items
+ QSetIterator<KFileItem> visibleIt(m_pendingVisibleItems);
+ while (visibleIt.hasNext()) {
+ const KFileItem item = visibleIt.next();
+ if (!hasSlowRoles) {
+ Q_ASSERT(!m_pendingInvisibleItems.contains(item));
+ // All roles will be resolved by applyResolvedRoles()
+ m_pendingVisibleItems.remove(item);
+ }
+ applyResolvedRoles(item, resolveHint);
+ ++resolvedCount;
+
+ if (timer.elapsed() > MaxBlockTimeout) {
+ break;
+ }
+ }
+
+ // Resolve the MIME type of the invisible items at least until the timeout
+ // has been exceeded or the maximum number of items has been reached
+ KFileItemList invisibleItems;
+ if (m_lastVisibleIndex >= 0) {
+ // The visible range is valid, don't care about the order how the MIME
+ // type of invisible items get resolved
+ invisibleItems = m_pendingInvisibleItems.toList();
+ } else {
+ // The visible range is temporary invalid (e.g. happens when loading
+ // a directory) so take care to sort the currently invisible items where
+ // a part will get visible later
+ invisibleItems = sortedItems(m_pendingInvisibleItems);
+ }
+
+ int index = 0;
+ while (resolvedCount < MaxResolveItemsCount && index < invisibleItems.count() && timer.elapsed() <= MaxBlockTimeout) {
+ const KFileItem item = invisibleItems.at(index);
+ applyResolvedRoles(item, resolveHint);
+
+ if (!hasSlowRoles) {
+ // All roles have been resolved already by applyResolvedRoles()
+ m_pendingInvisibleItems.remove(item);
+ }
+ ++index;
+ ++resolvedCount;
+ }
+
+ if (m_previewShown) {
+ KFileItemList items = sortedItems(m_pendingVisibleItems);
+ items += invisibleItems;
+ startPreviewJob(items);
+ } else {
+ QTimer::singleShot(0, this, SLOT(resolveNextPendingRoles()));
+ }
+
+#ifdef KFILEITEMMODELROLESUPDATER_DEBUG
+ if (timer.elapsed() > MaxBlockTimeout) {
+ kDebug() << "Maximum time of" << MaxBlockTimeout
+ << "ms exceeded, skipping items... Remaining visible:" << m_pendingVisibleItems.count()
+ << "invisible:" << m_pendingInvisibleItems.count();
+ }
+ kDebug() << "[TIME] Resolved pending roles:" << timer.elapsed();
+#endif
+
+ applySortProgressToModel();
+}
+
void KFileItemModelRolesUpdater::resetPendingRoles()
{
m_pendingVisibleItems.clear();
Q_ASSERT(m_previewJobs.isEmpty());
}
-void KFileItemModelRolesUpdater::triggerPendingRolesResolving(int count)
-{
- Q_ASSERT(count <= m_model->count());
- if (count == m_model->count()) {
- // When initially loading a directory a synchronous resolving prevents a minor
- // flickering when opening directories. This is also fine from a performance point
- // of view as it is assured in resolvePendingRoles() to never block the event-loop
- // for more than 200 ms.
- resolvePendingRoles();
- } else {
- // Items have been added. This can be done in several small steps within one loop
- // because of the sorting and hence may not trigger any expensive operation.
- m_resolvePendingRolesTimer->start();
- }
-}
-
void KFileItemModelRolesUpdater::sortAndResolveAllRoles()
{
if (m_paused) {
Q_ASSERT(m_pendingVisibleItems.isEmpty());
Q_ASSERT(m_pendingInvisibleItems.isEmpty());
- if (m_model->count() <= 0) {
+ if (m_model->count() == 0) {
return;
}
}
}
- triggerPendingRolesResolving(m_pendingVisibleItems.count() +
- m_pendingInvisibleItems.count());
+ resolvePendingRoles();
}
void KFileItemModelRolesUpdater::sortAndResolvePendingRoles()
{
Q_ASSERT(!m_paused);
- if (m_model->count() <= 0) {
+ if (m_model->count() == 0) {
return;
}
}
}
- triggerPendingRolesResolving(m_pendingVisibleItems.count() +
- m_pendingInvisibleItems.count());
+ resolvePendingRoles();
+}
+
+void KFileItemModelRolesUpdater::applySortProgressToModel()
+{
+ if (m_sortingProgress < 0) {
+ return;
+ }
+
+ // Inform the model about the progress of the resolved items,
+ // so that it can give an indication when the sorting has been finished.
+ const int resolvedCount = m_model->count()
+ - m_pendingVisibleItems.count()
+ - m_pendingInvisibleItems.count();
+ if (resolvedCount > 0) {
+ m_model->emitSortProgress(resolvedCount);
+ if (resolvedCount == m_model->count()) {
+ m_sortingProgress = -1;
+ }
+ }
+}
+
+void KFileItemModelRolesUpdater::updateSortProgress()
+{
+ const QByteArray sortRole = m_model->sortRole();
+
+ // Optimization if the sorting is done by type: In case if all MIME-types
+ // are known, the types have been resolved already by KFileItemModel and
+ // no sort-progress feedback is required.
+ const bool showProgress = (sortRole == "type")
+ ? hasUnknownMimeTypes()
+ : m_resolvableRoles.contains(sortRole);
+
+ if (m_sortingProgress >= 0) {
+ // Mark the current sorting as finished
+ m_model->emitSortProgress(m_model->count());
+ }
+ m_sortingProgress = showProgress ? 0 : -1;
+}
+
+bool KFileItemModelRolesUpdater::hasUnknownMimeTypes() const
+{
+ const int count = m_model->count();
+ for (int i = 0; i < count; ++i) {
+ const KFileItem item = m_model->fileItem(i);
+ if (!item.isMimeTypeKnown()) {
+ return true;
+ }
+ }
+
+ return false;
}
bool KFileItemModelRolesUpdater::applyResolvedRoles(const KFileItem& item, ResolveHint hint)
{
+ if (item.isNull()) {
+ return false;
+ }
+
const bool resolveAll = (hint == ResolveAll);
bool mimeTypeChanged = false;
data = rolesData(item);
}
- if (mimeTypeChanged || m_clearPreviews) {
- data.insert("iconName", item.iconName());
- }
+ data.insert("iconName", item.iconName());
+
if (m_clearPreviews) {
- data.insert("iconPixmap", QString());
+ data.insert("iconPixmap", QPixmap());
}
disconnect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
{
QHash<QByteArray, QVariant> data;
- if (m_roles.contains("size")) {
- if (item.isDir() && item.isLocalFile()) {
+ const bool getSizeRole = m_roles.contains("size");
+ const bool getIsExpandableRole = m_roles.contains("isExpandable");
+
+ if ((getSizeRole || getIsExpandableRole) && item.isDir()) {
+ if (item.isLocalFile()) {
const QString path = item.localPath();
- const int count = subDirectoriesCount(path);
- if (count >= 0) {
- data.insert("size", KIO::filesize_t(count));
+ const int count = subItemsCount(path);
+ if (getSizeRole) {
+ data.insert("size", count);
+ }
+ if (getIsExpandableRole) {
+ data.insert("isExpandable", count > 0);
+ }
+
+ if (!m_dirWatcher->contains(path)) {
+ m_dirWatcher->addDir(path);
+ m_watchedDirs.insert(path);
}
+ } else if (getSizeRole) {
+ data.insert("size", -1); // -1 indicates an unknown number of items
}
}
data.insert("type", item.mimeComment());
}
+ data.insert("iconOverlays", item.overlays());
+
+#ifdef HAVE_NEPOMUK
+ if (m_nepomukResourceWatcher) {
+ const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
+ Nepomuk::Resource resource(item.nepomukUri());
+ QHashIterator<QByteArray, QVariant> it(rolesProvider.roleValues(resource, m_roles));
+ while (it.hasNext()) {
+ it.next();
+ data.insert(it.key(), it.value());
+ }
+
+ QUrl uri = resource.resourceUri();
+ if (uri.isEmpty()) {
+ // TODO: Is there another way to explicitly create a resource?
+ // We need a resource to be able to track it for changes.
+ resource.setRating(0);
+ uri = resource.resourceUri();
+ }
+ if (!uri.isEmpty() && !m_nepomukUriItems.contains(uri)) {
+ m_nepomukResourceWatcher->addResource(resource);
+
+ if (m_nepomukUriItems.isEmpty()) {
+ m_nepomukResourceWatcher->start();
+ }
+
+ m_nepomukUriItems.insert(uri, item.url());
+ }
+ }
+#endif
+
return data;
}
while (it.hasNext()) {
const KFileItem item = it.next();
const int index = m_model->index(item);
- indexes.append(index);
+ if (index >= 0) {
+ indexes.append(index);
+ }
}
qSort(indexes);
return itemList;
}
-KFileItemList KFileItemModelRolesUpdater::itemSubSet(const QSet<KFileItem>& items, int count)
+int KFileItemModelRolesUpdater::subItemsCount(const QString& path) const
{
- KFileItemList itemList;
+ const bool countHiddenFiles = m_model->showHiddenFiles();
+ const bool showFoldersOnly = m_model->showDirectoriesOnly();
- int index = 0;
- QSetIterator<KFileItem> it(items);
- while (it.hasNext() && index < count) {
- const KFileItem item = it.next();
- if (item.isNull()) {
- continue;
- }
- itemList.append(item);
- ++index;
- }
-
- return itemList;
-}
-
-int KFileItemModelRolesUpdater::subDirectoriesCount(const QString& path)
-{
#ifdef Q_WS_WIN
QDir dir(path);
- return dir.entryList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::System).count();
+ QDir::Filters filters = QDir::NoDotAndDotDot | QDir::System;
+ if (countHiddenFiles) {
+ filters |= QDir::Hidden;
+ }
+ if (showFoldersOnly) {
+ filters |= QDir::Dirs;
+ } else {
+ filters |= QDir::AllEntries;
+ }
+ return dir.entryList(filters).count();
#else
// Taken from kdelibs/kio/kio/kdirmodel.cpp
// Copyright (C) 2006 David Faure <faure@kde.org>
int count = -1;
DIR* dir = ::opendir(QFile::encodeName(path));
- if (dir) {
+ if (dir) { // krazy:exclude=syscalls
count = 0;
struct dirent *dirEntry = 0;
while ((dirEntry = ::readdir(dir))) {
if (dirEntry->d_name[0] == '.') {
- if (dirEntry->d_name[1] == '\0') {
- // Skip "."
+ if (dirEntry->d_name[1] == '\0' || !countHiddenFiles) {
+ // Skip "." or hidden files
continue;
}
if (dirEntry->d_name[1] == '.' && dirEntry->d_name[2] == '\0') {
continue;
}
}
- ++count;
+
+ // If only directories are counted, consider an unknown file type and links also
+ // as directory instead of trying to do an expensive stat()
+ // (see bugs 292642 and 299997).
+ const bool countEntry = !showFoldersOnly ||
+ dirEntry->d_type == DT_DIR ||
+ dirEntry->d_type == DT_LNK ||
+ dirEntry->d_type == DT_UNKNOWN;
+ if (countEntry) {
+ ++count;
+ }
}
::closedir(dir);
}
#endif
}
+void KFileItemModelRolesUpdater::updateAllPreviews()
+{
+ if (m_paused) {
+ m_previewChangedDuringPausing = true;
+ } else {
+ sortAndResolveAllRoles();
+ }
+}
+
#include "kfileitemmodelrolesupdater.moc"
projects / dolphin.git / blobdiff