#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>
#ifdef HAVE_NEPOMUK
- #include "knepomukrolesprovider_p.h"
- #include "knepomukresourcewatcher_p.h"
+ #include "private/knepomukrolesprovider.h"
+ #include <Nepomuk2/ResourceWatcher>
#endif
// Required includes for subItemsCount():
m_previewShown(false),
m_enlargeSmallPreviews(true),
m_clearPreviews(false),
+ m_sortingProgress(-1),
m_model(model),
m_iconSize(),
m_firstVisibleIndex(0),
m_pendingInvisibleItems(),
m_previewJobs(),
m_changedItemsTimer(0),
- m_changedItems()
+ 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->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
+
+ // 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::setEnabledPlugins(const QStringList& list)
{
- if (m_enabledPlugins == list) {
+ if (m_enabledPlugins != list) {
m_enabledPlugins = list;
if (m_previewShown) {
updateAllPreviews();
QSetIterator<QByteArray> it(roles);
while (it.hasNext()) {
const QByteArray& role = it.next();
- if (rolesProvider.isNepomukRole(role)) {
+ if (rolesProvider.roles().contains(role)) {
hasNepomukRole = true;
break;
}
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)));
+ m_nepomukResourceWatcher = new Nepomuk2::ResourceWatcher(this);
+ connect(m_nepomukResourceWatcher, SIGNAL(propertyChanged(Nepomuk2::Resource,Nepomuk2::Types::Property,QVariantList,QVariantList)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk2::Resource)));
+ connect(m_nepomukResourceWatcher, SIGNAL(propertyRemoved(Nepomuk2::Resource,Nepomuk2::Types::Property,QVariant)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk2::Resource)));
+ connect(m_nepomukResourceWatcher, SIGNAL(propertyAdded(Nepomuk2::Resource,Nepomuk2::Types::Property,QVariant)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk2::Resource)));
+ connect(m_nepomukResourceWatcher, SIGNAL(resourceCreated(Nepomuk2::Resource,QList<QUrl>)),
+ this, SLOT(applyChangedNepomukRoles(Nepomuk2::Resource)));
} else if (!hasNepomukRole && m_nepomukResourceWatcher) {
delete m_nepomukResourceWatcher;
m_nepomukResourceWatcher = 0;
}
#endif
+ updateSortProgress();
+
if (m_paused) {
m_rolesChangedDuringPausing = true;
} else {
{
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();
+ }
+ }
+ }
+ }
+
#ifdef HAVE_NEPOMUK
if (m_nepomukResourceWatcher) {
// Don't let the ResourceWatcher watch for removed items
- if (m_model->count() == 0) {
- m_nepomukResourceWatcher->setResources(QList<Nepomuk::Resource>());
+ if (allItemsRemoved) {
+ m_nepomukResourceWatcher->setResources(QList<Nepomuk2::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();
+ QList<Nepomuk2::Resource> newResources;
+ const QList<Nepomuk2::Resource> oldResources = m_nepomukResourceWatcher->resources();
+ foreach (const Nepomuk2::Resource& resource, oldResources) {
+ const QUrl uri = resource.uri();
const KUrl itemUrl = m_nepomukUriItems.value(uri);
if (m_model->index(itemUrl) >= 0) {
newResources.append(resource);
}
}
m_nepomukResourceWatcher->setResources(newResources);
+ if (newResources.isEmpty()) {
+ Q_ASSERT(m_nepomukUriItems.isEmpty());
+ m_nepomukResourceWatcher->stop();
+ }
}
}
#endif
return;
}
- if (m_model->count() == 0) {
+ if (allItemsRemoved) {
// Most probably a directory change is done. Clear all pending items
// and also kill all ongoing preview-jobs.
resetPendingRoles();
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)
{
m_pendingVisibleItems.remove(item);
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)
m_clearPreviews = true;
applyResolvedRoles(item, ResolveAll);
m_clearPreviews = clearPreviews;
+
+ applySortProgressToModel();
}
void KFileItemModelRolesUpdater::slotPreviewJobFinished(KJob* job)
bool changed = false;
for (int i = 0; i <= 1; ++i) {
QSet<KFileItem>& pendingItems = (i == 0) ? m_pendingVisibleItems : m_pendingInvisibleItems;
- QSetIterator<KFileItem> it(pendingItems);
- while (it.hasNext() && !changed && resolvedCount < MaxResolveItemsCount) {
- const KFileItem item = it.next();
- pendingItems.remove(item);
- changed = applyResolvedRoles(item, ResolveAll);
+ QSet<KFileItem>::iterator it = pendingItems.begin();
+ while (it != pendingItems.end() && !changed && resolvedCount < MaxResolveItemsCount) {
+ changed = applyResolvedRoles(*it, ResolveAll);
+ it = pendingItems.erase(it);
++resolvedCount;
}
}
m_clearPreviews = false;
}
+ applySortProgressToModel();
+
#ifdef KFILEITEMMODELROLESUPDATER_DEBUG
static int callCount = 0;
++callCount;
startUpdating(itemRanges);
}
-void KFileItemModelRolesUpdater::applyChangedNepomukRoles(const Nepomuk::Resource& resource)
+void KFileItemModelRolesUpdater::applyChangedNepomukRoles(const Nepomuk2::Resource& resource)
{
#ifdef HAVE_NEPOMUK
- const KUrl itemUrl = m_nepomukUriItems.value(resource.resourceUri());
+ const KUrl itemUrl = m_nepomukUriItems.value(resource.uri());
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();
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 (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();
+ QSet<KFileItem>::iterator it = m_pendingVisibleItems.begin();
+ while (it != m_pendingVisibleItems.end()) {
+ const KFileItem item = *it;
const int index = m_model->index(item);
if (index < m_firstVisibleIndex || index > m_lastVisibleIndex) {
- m_pendingVisibleItems.remove(item);
+ it = m_pendingVisibleItems.erase(it);
m_pendingInvisibleItems.insert(item);
+ } else {
+ ++it;
}
}
}
// MIME-type in a fast way.
QElapsedTimer timer;
timer.start();
+
KFileItemList itemSubSet;
- for (int i = 0; i < items.count(); ++i) {
+ const int count = items.count();
+ itemSubSet.reserve(count);
+ for (int i = 0; i < count; ++i) {
KFileItem item = items.at(i);
item.determineMimeType();
- itemSubSet.append(items.at(i));
+ itemSubSet.append(item);
if (timer.elapsed() > MaxBlockTimeout) {
#ifdef KFILEITEMMODELROLESUPDATER_DEBUG
kDebug() << "Maximum time of" << MaxBlockTimeout << "ms exceeded, creating only previews for"
}
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(KFileItem,QPixmap)),
this, SLOT(slotGotPreview(KFileItem,QPixmap)));
{
int resolvedCount = 0;
- const bool hasSlowRoles = m_previewShown
- || m_roles.contains("size")
- || m_roles.contains("type")
- || m_roles.contains("isExpandable");
+ 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
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);
+ QSet<KFileItem>::iterator visibleIt = m_pendingVisibleItems.begin();
+ while (visibleIt != m_pendingVisibleItems.end()) {
+ const KFileItem item = *visibleIt;
if (!hasSlowRoles) {
Q_ASSERT(!m_pendingInvisibleItems.contains(item));
- // All roles have been resolved already by applyResolvedRoles()
- m_pendingVisibleItems.remove(item);
+ // All roles will be resolved by applyResolvedRoles()
+ visibleIt = m_pendingVisibleItems.erase(visibleIt);
+ } else {
+ ++visibleIt;
}
+ applyResolvedRoles(item, resolveHint);
++resolvedCount;
if (timer.elapsed() > MaxBlockTimeout) {
}
kDebug() << "[TIME] Resolved pending roles:" << timer.elapsed();
#endif
+
+ applySortProgressToModel();
}
void KFileItemModelRolesUpdater::resetPendingRoles()
m_pendingInvisibleItems.insert(item);
}
}
- for (int i = m_lastVisibleIndex + 1; i < m_model->count(); ++i) {
+ const int count = m_model->count();
+ for (int i = m_lastVisibleIndex + 1; i < count; ++i) {
const KFileItem item = m_model->fileItem(i);
if (!item.isNull()) {
m_pendingInvisibleItems.insert(item);
// Trigger a preview generation of all pending items. Assure that the visible
// pending items get generated first.
- QSet<KFileItem> pendingItems;
- pendingItems += m_pendingVisibleItems;
- pendingItems += m_pendingInvisibleItems;
- resetPendingRoles();
- Q_ASSERT(m_pendingVisibleItems.isEmpty());
- Q_ASSERT(m_pendingInvisibleItems.isEmpty());
+ // Step 1: Check if any items in m_pendingVisibleItems are not visible any more
+ // and move them to m_pendingInvisibleItems.
+ QSet<KFileItem>::iterator itVisible = m_pendingVisibleItems.begin();
+ while (itVisible != m_pendingVisibleItems.end()) {
+ const KFileItem item = *itVisible;
+ if (item.isNull()) {
+ itVisible = m_pendingVisibleItems.erase(itVisible);
+ continue;
+ }
- QSetIterator<KFileItem> it(pendingItems);
- while (it.hasNext()) {
- const KFileItem item = it.next();
+ const int index = m_model->index(item);
+ if (!hasValidIndexRange || (index >= m_firstVisibleIndex && index <= m_lastVisibleIndex)) {
+ ++itVisible;
+ } else {
+ itVisible = m_pendingVisibleItems.erase(itVisible);
+ m_pendingInvisibleItems.insert(item);
+ }
+ }
+
+ // Step 2: Check if any items in m_pendingInvisibleItems have become visible
+ // and move them to m_pendingVisibleItems.
+ QSet<KFileItem>::iterator itInvisible = m_pendingInvisibleItems.begin();
+ while (itInvisible != m_pendingInvisibleItems.end()) {
+ const KFileItem item = *itInvisible;
if (item.isNull()) {
+ itInvisible = m_pendingInvisibleItems.erase(itInvisible);
continue;
}
const int index = m_model->index(item);
if (!hasValidIndexRange || (index >= m_firstVisibleIndex && index <= m_lastVisibleIndex)) {
+ itInvisible = m_pendingInvisibleItems.erase(itInvisible);
m_pendingVisibleItems.insert(item);
} else {
- m_pendingInvisibleItems.insert(item);
+ ++itInvisible;
}
}
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()) {
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
}
#ifdef HAVE_NEPOMUK
if (m_nepomukResourceWatcher) {
const KNepomukRolesProvider& rolesProvider = KNepomukRolesProvider::instance();
- Nepomuk::Resource resource(item.url());
+ Nepomuk2::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();
+ QUrl uri = resource.uri();
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();
+ uri = resource.uri();
}
if (!uri.isEmpty() && !m_nepomukUriItems.contains(uri)) {
- // TODO: Calling stop()/start() is a workaround until
- // ResourceWatcher has been fixed.
- m_nepomukResourceWatcher->stop();
m_nepomukResourceWatcher->addResource(resource);
- m_nepomukResourceWatcher->start();
+
+ if (m_nepomukUriItems.isEmpty()) {
+ m_nepomukResourceWatcher->start();
+ }
m_nepomukUriItems.insert(uri, item.url());
}
int KFileItemModelRolesUpdater::subItemsCount(const QString& path) const
{
const bool countHiddenFiles = m_model->showHiddenFiles();
- const bool showFoldersOnly = m_model->showFoldersOnly();
+ const bool showFoldersOnly = m_model->showDirectoriesOnly();
#ifdef Q_WS_WIN
QDir dir(path);
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))) { // krazy:exclude=syscalls
+ while ((dirEntry = ::readdir(dir))) {
if (dirEntry->d_name[0] == '.') {
if (dirEntry->d_name[1] == '\0' || !countHiddenFiles) {
// Skip "." or hidden files
}
}
- // 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) {
+ // 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;
}
}
projects / dolphin.git / blobdiff