#include <QElapsedTimer>
#include <QTimer>
-// Required includes for subDirectoriesCount():
+// Required includes for subItemsCount():
#ifdef Q_WS_WIN
#include <QDir>
#else
m_pendingVisibleItems(),
m_pendingInvisibleItems(),
m_previewJobs(),
- m_resolvePendingRolesTimer(0)
+ m_changedItemsTimer(0),
+ m_changedItems()
{
Q_ASSERT(model);
connect(m_model, SIGNAL(itemsChanged(KItemRangeList,QSet<QByteArray>)),
this, SLOT(slotItemsChanged(KItemRangeList,QSet<QByteArray>)));
- // 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()));
+ // 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 2 seconds.
+ m_changedItemsTimer = new QTimer(this);
+ m_changedItemsTimer->setInterval(2000);
+ m_changedItemsTimer->setSingleShot(true);
+ connect(m_changedItemsTimer, SIGNAL(timeout()), this, SLOT(resolveChangedItems()));
}
KFileItemModelRolesUpdater::~KFileItemModelRolesUpdater()
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;
- break;
- }
- }
- if (isEqual) {
- return;
- }
- }
+ if (m_roles != roles) {
+ m_roles = roles;
- m_roles = roles;
-
- if (m_paused) {
- m_rolesChangedDuringPausing = true;
- } else {
- sortAndResolveAllRoles();
+ if (m_paused) {
+ m_rolesChangedDuringPausing = true;
+ } else {
+ sortAndResolveAllRoles();
+ }
}
}
{
Q_UNUSED(itemRanges);
m_firstVisibleIndex = 0;
- m_lastVisibleIndex = -1;
+ m_lastVisibleIndex = -1;
if (!hasPendingRoles()) {
return;
}
// 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.
+ // 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);
const QSet<QByteArray>& roles)
{
Q_UNUSED(roles);
- startUpdating(itemRanges);
+
+ 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::slotGotPreview(const KFileItem& item, const QPixmap& pixmap)
startPreviewJob(visibleItems + m_pendingInvisibleItems.toList());
}
-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 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();
- 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() > 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
-}
-
void KFileItemModelRolesUpdater::resolveNextPendingRoles()
{
if (m_paused) {
#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));
+ }
+ }
+
+ startUpdating(itemRanges);
+}
+
void KFileItemModelRolesUpdater::startUpdating(const KItemRangeList& itemRanges)
{
// If no valid index range is given assume that all items are visible.
}
}
- triggerPendingRolesResolving(rangesCount);
+ resolvePendingRoles();
}
void KFileItemModelRolesUpdater::startPreviewJob(const KFileItemList& items)
return !m_pendingVisibleItems.isEmpty() || !m_pendingInvisibleItems.isEmpty();
}
+void KFileItemModelRolesUpdater::resolvePendingRoles()
+{
+ int resolvedCount = 0;
+
+ const bool hasSlowRoles = m_previewShown
+ || m_roles.contains("size")
+ || m_roles.contains("type")
+ || m_roles.contains("isExpandable");
+ 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();
+ 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() > 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
+}
+
void KFileItemModelRolesUpdater::resetPendingRoles()
{
m_pendingVisibleItems.clear();
Q_ASSERT(m_previewJobs.isEmpty());
}
-void KFileItemModelRolesUpdater::triggerPendingRolesResolving(int 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) {
}
}
- triggerPendingRolesResolving(m_pendingVisibleItems.count() +
- m_pendingInvisibleItems.count());
+ resolvePendingRoles();
}
void KFileItemModelRolesUpdater::sortAndResolvePendingRoles()
}
}
- triggerPendingRolesResolving(m_pendingVisibleItems.count() +
- m_pendingInvisibleItems.count());
+ resolvePendingRoles();
}
bool KFileItemModelRolesUpdater::applyResolvedRoles(const KFileItem& item, ResolveHint hint)
{
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);
}
+ } else if (getSizeRole) {
+ data.insert("size", -1); // -1 indicates an unknown number of items
}
}
return itemList;
}
-int KFileItemModelRolesUpdater::subDirectoriesCount(const QString& path)
+int KFileItemModelRolesUpdater::subItemsCount(const QString& path) const
{
+ const bool countHiddenFiles = m_model->showHiddenFiles();
+ const bool showFoldersOnly = m_model->showFoldersOnly();
+
#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>
struct dirent *dirEntry = 0;
while ((dirEntry = ::readdir(dir))) { // krazy:exclude=syscalls
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 also
+ // as directory instead of trying to do an expensive stat() (see bug 292642).
+ if (!showFoldersOnly || dirEntry->d_type == DT_DIR || dirEntry->d_type == DT_UNKNOWN) {
+ ++count;
+ }
}
::closedir(dir);
}
projects / dolphin.git / blobdiff