X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/422da5333326c1264ffdcd9c08215afe13807c42..6a3f8086a372ca1c21ab474c7934e8f8e4b238f5:/src/kitemviews/kfileitemmodel.cpp diff --git a/src/kitemviews/kfileitemmodel.cpp b/src/kitemviews/kfileitemmodel.cpp index 2e583d05e..231bfe077 100644 --- a/src/kitemviews/kfileitemmodel.cpp +++ b/src/kitemviews/kfileitemmodel.cpp @@ -19,23 +19,29 @@ #include "kfileitemmodel.h" -#include #include +#include #include #include #include +#include "private/kfileitemmodelsortalgorithm.h" +#include "private/kfileitemmodeldirlister.h" + +#include #include #include +#include // #define KFILEITEMMODEL_DEBUG -KFileItemModel::KFileItemModel(KDirLister* dirLister, QObject* parent) : - KItemModelBase("name", parent), - m_dirLister(dirLister), - m_naturalSorting(true), - m_sortFoldersFirst(true), +KFileItemModel::KFileItemModel(QObject* parent) : + KItemModelBase("text", parent), + m_dirLister(0), + m_naturalSorting(KGlobalSettings::naturalSorting()), + m_sortDirsFirst(true), m_sortRole(NameRole), + m_sortingProgressPercent(-1), m_roles(), m_caseSensitivity(Qt::CaseInsensitive), m_itemData(), @@ -43,40 +49,44 @@ KFileItemModel::KFileItemModel(KDirLister* dirLister, QObject* parent) : m_filter(), m_filteredItems(), m_requestRole(), - m_minimumUpdateIntervalTimer(0), m_maximumUpdateIntervalTimer(0), m_resortAllItemsTimer(0), m_pendingItemsToInsert(), - m_pendingEmitLoadingCompleted(false), m_groups(), - m_rootExpansionLevel(UninitializedRootExpansionLevel), - m_expandedUrls(), + m_expandedParentsCountRoot(UninitializedExpandedParentsCountRoot), + m_expandedDirs(), m_urlsToExpand() { + m_dirLister = new KFileItemModelDirLister(this); + m_dirLister->setAutoUpdate(true); + m_dirLister->setDelayedMimeTypes(true); + + const QWidget* parentWidget = qobject_cast(parent); + if (parentWidget) { + m_dirLister->setMainWindow(parentWidget->window()); + } + + connect(m_dirLister, SIGNAL(started(KUrl)), this, SIGNAL(directoryLoadingStarted())); + connect(m_dirLister, SIGNAL(canceled()), this, SLOT(slotCanceled())); + connect(m_dirLister, SIGNAL(completed(KUrl)), this, SLOT(slotCompleted())); + connect(m_dirLister, SIGNAL(newItems(KFileItemList)), this, SLOT(slotNewItems(KFileItemList))); + connect(m_dirLister, SIGNAL(itemsDeleted(KFileItemList)), this, SLOT(slotItemsDeleted(KFileItemList))); + connect(m_dirLister, SIGNAL(refreshItems(QList >)), this, SLOT(slotRefreshItems(QList >))); + connect(m_dirLister, SIGNAL(clear()), this, SLOT(slotClear())); + connect(m_dirLister, SIGNAL(clear(KUrl)), this, SLOT(slotClear(KUrl))); + connect(m_dirLister, SIGNAL(infoMessage(QString)), this, SIGNAL(infoMessage(QString))); + connect(m_dirLister, SIGNAL(errorMessage(QString)), this, SIGNAL(errorMessage(QString))); + connect(m_dirLister, SIGNAL(redirection(KUrl,KUrl)), this, SIGNAL(directoryRedirection(KUrl,KUrl))); + connect(m_dirLister, SIGNAL(urlIsFileError(KUrl)), this, SIGNAL(urlIsFileError(KUrl))); + // Apply default roles that should be determined resetRoles(); m_requestRole[NameRole] = true; m_requestRole[IsDirRole] = true; - m_roles.insert("name"); + m_requestRole[IsLinkRole] = true; + m_roles.insert("text"); m_roles.insert("isDir"); - - Q_ASSERT(dirLister); - - connect(dirLister, SIGNAL(canceled()), this, SLOT(slotCanceled())); - connect(dirLister, SIGNAL(completed()), this, SLOT(slotCompleted())); - connect(dirLister, SIGNAL(newItems(KFileItemList)), this, SLOT(slotNewItems(KFileItemList))); - connect(dirLister, SIGNAL(itemsDeleted(KFileItemList)), this, SLOT(slotItemsDeleted(KFileItemList))); - connect(dirLister, SIGNAL(refreshItems(QList >)), this, SLOT(slotRefreshItems(QList >))); - connect(dirLister, SIGNAL(clear()), this, SLOT(slotClear())); - connect(dirLister, SIGNAL(clear(KUrl)), this, SLOT(slotClear(KUrl))); - - // Although the layout engine of KItemListView is fast it is very inefficient to e.g. - // emit 50 itemsInserted()-signals each 100 ms. m_minimumUpdateIntervalTimer assures that updates - // are done in 1 second intervals for equal operations. - m_minimumUpdateIntervalTimer = new QTimer(this); - m_minimumUpdateIntervalTimer->setInterval(1000); - m_minimumUpdateIntervalTimer->setSingleShot(true); - connect(m_minimumUpdateIntervalTimer, SIGNAL(timeout()), this, SLOT(dispatchPendingItemsToInsert())); + m_roles.insert("isLink"); // For slow KIO-slaves like used for searching it makes sense to show results periodically even // before the completed() or canceled() signal has been emitted. @@ -84,7 +94,7 @@ KFileItemModel::KFileItemModel(KDirLister* dirLister, QObject* parent) : m_maximumUpdateIntervalTimer->setInterval(2000); m_maximumUpdateIntervalTimer->setSingleShot(true); connect(m_maximumUpdateIntervalTimer, SIGNAL(timeout()), this, SLOT(dispatchPendingItemsToInsert())); - + // When changing the value of an item which represents the sort-role a resorting must be // triggered. Especially in combination with KFileItemModelRolesUpdater this might be done // for a lot of items within a quite small timeslot. To prevent expensive resortings the @@ -94,7 +104,7 @@ KFileItemModel::KFileItemModel(KDirLister* dirLister, QObject* parent) : m_resortAllItemsTimer->setSingleShot(true); connect(m_resortAllItemsTimer, SIGNAL(timeout()), this, SLOT(resortAllItems())); - Q_ASSERT(m_minimumUpdateIntervalTimer->interval() <= m_maximumUpdateIntervalTimer->interval()); + connect(KGlobalSettings::self(), SIGNAL(naturalSortingChanged()), this, SLOT(slotNaturalSortingChanged())); } KFileItemModel::~KFileItemModel() @@ -103,6 +113,26 @@ KFileItemModel::~KFileItemModel() m_itemData.clear(); } +void KFileItemModel::loadDirectory(const KUrl& url) +{ + m_dirLister->openUrl(url); +} + +void KFileItemModel::refreshDirectory(const KUrl& url) +{ + m_dirLister->openUrl(url, KDirLister::Reload); +} + +KUrl KFileItemModel::directory() const +{ + return m_dirLister->url(); +} + +void KFileItemModel::cancelDirectoryLoading() +{ + m_dirLister->stop(); +} + int KFileItemModel::count() const { return m_itemData.count(); @@ -143,44 +173,56 @@ bool KFileItemModel::setData(int index, const QHash& value } m_itemData[index]->values = currentValues; + if (changedRoles.contains("text")) { + KUrl url = m_itemData[index]->item.url(); + url.setFileName(currentValues["text"].toString()); + m_itemData[index]->item.setUrl(url); + } + emit itemsChanged(KItemRangeList() << KItemRange(index, 1), changedRoles); if (changedRoles.contains(sortRole())) { m_resortAllItemsTimer->start(); } - + return true; } -void KFileItemModel::setSortFoldersFirst(bool foldersFirst) +void KFileItemModel::setSortDirectoriesFirst(bool dirsFirst) { - if (foldersFirst != m_sortFoldersFirst) { - m_sortFoldersFirst = foldersFirst; + if (dirsFirst != m_sortDirsFirst) { + m_sortDirsFirst = dirsFirst; resortAllItems(); } } -bool KFileItemModel::sortFoldersFirst() const +bool KFileItemModel::sortDirectoriesFirst() const { - return m_sortFoldersFirst; + return m_sortDirsFirst; } void KFileItemModel::setShowHiddenFiles(bool show) { - KDirLister* dirLister = m_dirLister.data(); - if (dirLister) { - dirLister->setShowingDotFiles(show); - dirLister->emitChanges(); - if (show) { - slotCompleted(); - } + m_dirLister->setShowingDotFiles(show); + m_dirLister->emitChanges(); + if (show) { + slotCompleted(); } } bool KFileItemModel::showHiddenFiles() const { - const KDirLister* dirLister = m_dirLister.data(); - return dirLister ? dirLister->showingDotFiles() : false; + return m_dirLister->showingDotFiles(); +} + +void KFileItemModel::setShowDirectoriesOnly(bool enabled) +{ + m_dirLister->setDirOnlyMode(enabled); +} + +bool KFileItemModel::showDirectoriesOnly() const +{ + return m_dirLister->dirOnlyMode(); } QMimeData* KFileItemModel::createMimeData(const QSet& indexes) const @@ -225,12 +267,12 @@ int KFileItemModel::indexForKeyboardSearch(const QString& text, int startFromInd { startFromIndex = qMax(0, startFromIndex); for (int i = startFromIndex; i < count(); ++i) { - if (data(i)["name"].toString().startsWith(text, Qt::CaseInsensitive)) { + if (data(i)["text"].toString().startsWith(text, Qt::CaseInsensitive)) { return i; } } for (int i = 0; i < startFromIndex; ++i) { - if (data(i)["name"].toString().startsWith(text, Qt::CaseInsensitive)) { + if (data(i)["text"].toString().startsWith(text, Qt::CaseInsensitive)) { return i; } } @@ -240,34 +282,21 @@ int KFileItemModel::indexForKeyboardSearch(const QString& text, int startFromInd bool KFileItemModel::supportsDropping(int index) const { const KFileItem item = fileItem(index); - return item.isNull() ? false : item.isDir(); + return !item.isNull() && (item.isDir() || item.isDesktopFile()); } QString KFileItemModel::roleDescription(const QByteArray& role) const { - QString descr; - - switch (roleIndex(role)) { - case NameRole: descr = i18nc("@item:intable", "Name"); break; - case SizeRole: descr = i18nc("@item:intable", "Size"); break; - case DateRole: descr = i18nc("@item:intable", "Date"); break; - case PermissionsRole: descr = i18nc("@item:intable", "Permissions"); break; - case OwnerRole: descr = i18nc("@item:intable", "Owner"); break; - case GroupRole: descr = i18nc("@item:intable", "Group"); break; - case TypeRole: descr = i18nc("@item:intable", "Type"); break; - case DestinationRole: descr = i18nc("@item:intable", "Destination"); break; - case PathRole: descr = i18nc("@item:intable", "Path"); break; - case CommentRole: descr = i18nc("@item:intable", "Comment"); break; - case TagsRole: descr = i18nc("@item:intable", "Tags"); break; - case RatingRole: descr = i18nc("@item:intable", "Rating"); break; - case NoRole: break; - case IsDirRole: break; - case IsExpandedRole: break; - case ExpansionLevelRole: break; - default: Q_ASSERT(false); break; + static QHash description; + if (description.isEmpty()) { + int count = 0; + const RoleInfoMap* map = rolesInfoMap(count); + for (int i = 0; i < count; ++i) { + description.insert(map[i].role, i18nc(map[i].roleTranslationContext, map[i].roleTranslation)); + } } - return descr; + return description.value(role); } QList > KFileItemModel::groups() const @@ -277,24 +306,13 @@ QList > KFileItemModel::groups() const QElapsedTimer timer; timer.start(); #endif - switch (roleIndex(sortRole())) { - case NameRole: m_groups = nameRoleGroups(); break; - case SizeRole: m_groups = sizeRoleGroups(); break; - case DateRole: m_groups = dateRoleGroups(); break; - case PermissionsRole: m_groups = permissionRoleGroups(); break; - case OwnerRole: m_groups = genericStringRoleGroups("owner"); break; - case GroupRole: m_groups = genericStringRoleGroups("group"); break; - case TypeRole: m_groups = genericStringRoleGroups("type"); break; - case DestinationRole: m_groups = genericStringRoleGroups("destination"); break; - case PathRole: m_groups = genericStringRoleGroups("path"); break; - case CommentRole: m_groups = genericStringRoleGroups("comment"); break; - case TagsRole: m_groups = genericStringRoleGroups("tags"); break; - case RatingRole: m_groups = ratingRoleGroups(); break; - case NoRole: break; - case IsDirRole: break; - case IsExpandedRole: break; - case ExpansionLevelRole: break; - default: Q_ASSERT(false); break; + switch (typeForRole(sortRole())) { + case NameRole: m_groups = nameRoleGroups(); break; + case SizeRole: m_groups = sizeRoleGroups(); break; + case DateRole: m_groups = dateRoleGroups(); break; + case PermissionsRole: m_groups = permissionRoleGroups(); break; + case RatingRole: m_groups = ratingRoleGroups(); break; + default: m_groups = genericStringRoleGroups(sortRole()); break; } #ifdef KFILEITEMMODEL_DEBUG @@ -341,11 +359,7 @@ int KFileItemModel::index(const KUrl& url) const KFileItem KFileItemModel::rootItem() const { - const KDirLister* dirLister = m_dirLister.data(); - if (dirLister) { - return dirLister->rootItem(); - } - return KFileItem(); + return m_dirLister->rootItem(); } void KFileItemModel::clear() @@ -355,11 +369,14 @@ void KFileItemModel::clear() void KFileItemModel::setRoles(const QSet& roles) { + if (m_roles == roles) { + return; + } m_roles = roles; if (count() > 0) { - const bool supportedExpanding = m_requestRole[IsExpandedRole] && m_requestRole[ExpansionLevelRole]; - const bool willSupportExpanding = roles.contains("isExpanded") && roles.contains("expansionLevel"); + const bool supportedExpanding = m_requestRole[ExpandedParentsCountRole]; + const bool willSupportExpanding = roles.contains("expandedParentsCount"); if (supportedExpanding && !willSupportExpanding) { // No expanding is supported anymore. Take care to delete all items that have an expansion level // that is not 0 (and hence are part of an expanded item). @@ -367,12 +384,13 @@ void KFileItemModel::setRoles(const QSet& roles) } } + m_groups.clear(); resetRoles(); QSetIterator it(roles); while (it.hasNext()) { const QByteArray& role = it.next(); - m_requestRole[roleIndex(role)] = true; + m_requestRole[typeForRole(role)] = true; } if (count() > 0) { @@ -394,7 +412,7 @@ QSet KFileItemModel::roles() const bool KFileItemModel::setExpanded(int index, bool expanded) { - if (isExpanded(index) == expanded || index < 0 || index >= count()) { + if (!isExpandable(index) || isExpanded(index) == expanded) { return false; } @@ -404,34 +422,26 @@ bool KFileItemModel::setExpanded(int index, bool expanded) return false; } - KDirLister* dirLister = m_dirLister.data(); const KUrl url = m_itemData.at(index)->item.url(); if (expanded) { - m_expandedUrls.insert(url); - - if (dirLister) { - dirLister->openUrl(url, KDirLister::Keep); - return true; - } + m_expandedDirs.insert(url); + m_dirLister->openUrl(url, KDirLister::Keep); } else { - m_expandedUrls.remove(url); + m_expandedDirs.remove(url); + m_dirLister->stop(url); - if (dirLister) { - dirLister->stop(url); - } KFileItemList itemsToRemove; - const int expansionLevel = data(index)["expansionLevel"].toInt(); + const int expandedParentsCount = data(index)["expandedParentsCount"].toInt(); ++index; - while (index < count() && data(index)["expansionLevel"].toInt() > expansionLevel) { + while (index < count() && data(index)["expandedParentsCount"].toInt() > expandedParentsCount) { itemsToRemove.append(m_itemData.at(index)->item); ++index; } removeItems(itemsToRemove); - return true; } - return false; + return true; } bool KFileItemModel::isExpanded(int index) const @@ -445,45 +455,45 @@ bool KFileItemModel::isExpanded(int index) const bool KFileItemModel::isExpandable(int index) const { if (index >= 0 && index < count()) { - return m_itemData.at(index)->item.isDir(); + return m_itemData.at(index)->values.value("isExpandable").toBool(); } return false; } -QSet KFileItemModel::expandedUrls() const +int KFileItemModel::expandedParentsCount(int index) const +{ + if (index >= 0 && index < count()) { + const int parentsCount = m_itemData.at(index)->values.value("expandedParentsCount").toInt(); + if (parentsCount > 0) { + return parentsCount; + } + } + return 0; +} + +QSet KFileItemModel::expandedDirectories() const { - return m_expandedUrls; + return m_expandedDirs; } -void KFileItemModel::restoreExpandedUrls(const QSet& urls) +void KFileItemModel::restoreExpandedDirectories(const QSet& urls) { m_urlsToExpand = urls; } -void KFileItemModel::setExpanded(const QSet& urls) +void KFileItemModel::expandParentDirectories(const KUrl& url) { + const int pos = m_dirLister->url().path().length(); - const KDirLister* dirLister = m_dirLister.data(); - if (!dirLister) { - return; - } - - const int pos = dirLister->url().url().length(); - - // Assure that each sub-path of the URLs that should be - // expanded is added to m_urlsToExpand too. KDirLister + // Assure that each sub-path of the URL that should be + // expanded is added to m_urlsToExpand. KDirLister // does not care whether the parent-URL has already been // expanded. - QSetIterator it1(urls); - while (it1.hasNext()) { - const KUrl& url = it1.next(); - - KUrl urlToExpand = dirLister->url(); - const QStringList subDirs = url.url().mid(pos).split(QDir::separator()); - for (int i = 0; i < subDirs.count(); ++i) { - urlToExpand.addPath(subDirs.at(i)); - m_urlsToExpand.insert(urlToExpand); - } + KUrl urlToExpand = m_dirLister->url(); + const QStringList subDirs = url.path().mid(pos).split(QDir::separator()); + for (int i = 0; i < subDirs.count() - 1; ++i) { + urlToExpand.addPath(subDirs.at(i)); + m_urlsToExpand.insert(urlToExpand); } // KDirLister::open() must called at least once to trigger an initial @@ -503,46 +513,93 @@ void KFileItemModel::setNameFilter(const QString& nameFilter) { if (m_filter.pattern() != nameFilter) { dispatchPendingItemsToInsert(); - m_filter.setPattern(nameFilter); + applyFilters(); + } +} - // Check which shown items from m_itemData must get - // hidden and hence moved to m_filteredItems. - KFileItemList newFilteredItems; +QString KFileItemModel::nameFilter() const +{ + return m_filter.pattern(); +} + +void KFileItemModel::setMimeTypeFilters(const QStringList& filters) +{ + if (m_filter.mimeTypes() != filters) { + dispatchPendingItemsToInsert(); + m_filter.setMimeTypes(filters); + applyFilters(); + } +} - foreach (ItemData* itemData, m_itemData) { +QStringList KFileItemModel::mimeTypeFilters() const +{ + return m_filter.mimeTypes(); +} + + +void KFileItemModel::applyFilters() +{ + // Check which shown items from m_itemData must get + // hidden and hence moved to m_filteredItems. + KFileItemList newFilteredItems; + + foreach (ItemData* itemData, m_itemData) { + // Only filter non-expanded items as child items may never + // exist without a parent item + if (!itemData->values.value("isExpanded").toBool()) { if (!m_filter.matches(itemData->item)) { - // Only filter non-expanded items as child items may never - // exist without a parent item - if (!itemData->values.value("isExpanded").toBool()) { - newFilteredItems.append(itemData->item); - m_filteredItems.insert(itemData->item); - } + newFilteredItems.append(itemData->item); + m_filteredItems.insert(itemData->item); } } + } - removeItems(newFilteredItems); + removeItems(newFilteredItems); - // Check which hidden items from m_filteredItems should - // get visible again and hence removed from m_filteredItems. - KFileItemList newVisibleItems; + // Check which hidden items from m_filteredItems should + // get visible again and hence removed from m_filteredItems. + KFileItemList newVisibleItems; - QMutableSetIterator it(m_filteredItems); - while (it.hasNext()) { - const KFileItem item = it.next(); - if (m_filter.matches(item)) { - newVisibleItems.append(item); - m_filteredItems.remove(item); - } + QMutableSetIterator it(m_filteredItems); + while (it.hasNext()) { + const KFileItem item = it.next(); + if (m_filter.matches(item)) { + newVisibleItems.append(item); + it.remove(); } - - insertItems(newVisibleItems); } + + insertItems(newVisibleItems); } -QString KFileItemModel::nameFilter() const +QList KFileItemModel::rolesInformation() { - return m_filter.pattern(); + static QList rolesInfo; + if (rolesInfo.isEmpty()) { + int count = 0; + const RoleInfoMap* map = rolesInfoMap(count); + for (int i = 0; i < count; ++i) { + if (map[i].roleType != NoRole) { + RoleInfo info; + info.role = map[i].role; + info.translation = i18nc(map[i].roleTranslationContext, map[i].roleTranslation); + if (map[i].groupTranslation) { + info.group = i18nc(map[i].groupTranslationContext, map[i].groupTranslation); + } else { + // For top level roles, groupTranslation is 0. We must make sure that + // info.group is an empty string then because the code that generates + // menus tries to put the actions into sub menus otherwise. + info.group = QString(); + } + info.requiresNepomuk = map[i].requiresNepomuk; + info.requiresIndexer = map[i].requiresIndexer; + rolesInfo.append(info); + } + } + } + + return rolesInfo; } void KFileItemModel::onGroupedSortingChanged(bool current) @@ -554,7 +611,7 @@ void KFileItemModel::onGroupedSortingChanged(bool current) void KFileItemModel::onSortRoleChanged(const QByteArray& current, const QByteArray& previous) { Q_UNUSED(previous); - m_sortRole = roleIndex(current); + m_sortRole = typeForRole(current); #ifdef KFILEITEMMODEL_DEBUG if (!m_requestRole[m_sortRole]) { @@ -569,13 +626,13 @@ void KFileItemModel::onSortOrderChanged(Qt::SortOrder current, Qt::SortOrder pre { Q_UNUSED(current); Q_UNUSED(previous); - resortAllItems(); + resortAllItems(); } void KFileItemModel::resortAllItems() { m_resortAllItemsTimer->stop(); - + const int itemCount = count(); if (itemCount <= 0) { return; @@ -596,47 +653,38 @@ void KFileItemModel::resortAllItems() foreach (const ItemData* itemData, m_itemData) { oldUrls.append(itemData->item.url()); } - + m_groups.clear(); m_items.clear(); - + // Resort the items - sort(m_itemData.begin(), m_itemData.end()); + KFileItemModelSortAlgorithm::sort(this, m_itemData.begin(), m_itemData.end()); for (int i = 0; i < itemCount; ++i) { m_items.insert(m_itemData.at(i)->item.url(), i); } - + // Determine the indexes that have been moved - bool emitItemsMoved = false; QList movedToIndexes; movedToIndexes.reserve(itemCount); for (int i = 0; i < itemCount; i++) { const int newIndex = m_items.value(oldUrls.at(i).url()); movedToIndexes.append(newIndex); - if (!emitItemsMoved && newIndex != i) { - emitItemsMoved = true; - } - } - - if (emitItemsMoved) { - emit itemsMoved(KItemRange(0, itemCount), movedToIndexes); } - + + // Don't check whether items have really been moved and always emit a + // itemsMoved() signal after resorting: In case of grouped items + // the groups might change even if the items themselves don't change their + // position. Let the receiver of the signal decide whether a check for moved + // items makes sense. + emit itemsMoved(KItemRange(0, itemCount), movedToIndexes); + #ifdef KFILEITEMMODEL_DEBUG kDebug() << "[TIME] Resorting of" << itemCount << "items:" << timer.elapsed(); -#endif +#endif } void KFileItemModel::slotCompleted() { - if (m_urlsToExpand.isEmpty() && m_minimumUpdateIntervalTimer->isActive()) { - // dispatchPendingItems() will be called when the timer - // has been expired. - m_pendingEmitLoadingCompleted = true; - return; - } - - m_pendingEmitLoadingCompleted = false; dispatchPendingItemsToInsert(); if (!m_urlsToExpand.isEmpty()) { @@ -644,7 +692,7 @@ void KFileItemModel::slotCompleted() // Note that the parent folder must be expanded before any of its subfolders become visible. // Therefore, some URLs in m_restoredExpandedUrls might not be visible yet // -> we expand the first visible URL we find in m_restoredExpandedUrls. - foreach(const KUrl& url, m_urlsToExpand) { + foreach (const KUrl& url, m_urlsToExpand) { const int index = m_items.value(url, -1); if (index >= 0) { m_urlsToExpand.remove(url); @@ -661,39 +709,55 @@ void KFileItemModel::slotCompleted() m_urlsToExpand.clear(); } - emit loadingCompleted(); - m_minimumUpdateIntervalTimer->start(); + emit directoryLoadingCompleted(); } void KFileItemModel::slotCanceled() { - m_minimumUpdateIntervalTimer->stop(); m_maximumUpdateIntervalTimer->stop(); dispatchPendingItemsToInsert(); + + emit directoryLoadingCanceled(); } void KFileItemModel::slotNewItems(const KFileItemList& items) { - if (m_requestRole[ExpansionLevelRole] && m_rootExpansionLevel >= 0) { - // If the expanding of items is enabled in the model, it might be - // possible that the call dirLister->openUrl(url, KDirLister::Keep) in - // KFileItemModel::setExpanded() results in emitting of the same items - // twice due to the Keep-parameter. This case happens if an item gets - // expanded, collapsed and expanded again before the items could be loaded - // for the first expansion. - foreach (const KFileItem& item, items) { - const int index = m_items.value(item.url(), -1); - if (index >= 0) { - // The items are already part of the model. - return; - } + Q_ASSERT(!items.isEmpty()); + + if (m_requestRole[ExpandedParentsCountRole] && m_expandedParentsCountRoot >= 0) { + // To be able to compare whether the new items may be inserted as children + // of a parent item the pending items must be added to the model first. + dispatchPendingItemsToInsert(); + + KFileItem item = items.first(); + + // If the expanding of items is enabled, the call + // dirLister->openUrl(url, KDirLister::Keep) in KFileItemModel::setExpanded() + // might result in emitting the same items twice due to the Keep-parameter. + // This case happens if an item gets expanded, collapsed and expanded again + // before the items could be loaded for the first expansion. + const int index = m_items.value(item.url(), -1); + if (index >= 0) { + // The items are already part of the model. + return; + } + + // KDirLister keeps the children of items that got expanded once even if + // they got collapsed again with KFileItemModel::setExpanded(false). So it must be + // checked whether the parent for new items is still expanded. + KUrl parentUrl = item.url().upUrl(); + parentUrl.adjustPath(KUrl::RemoveTrailingSlash); + const int parentIndex = m_items.value(parentUrl, -1); + if (parentIndex >= 0 && !m_itemData[parentIndex]->values.value("isExpanded").toBool()) { + // The parent is not expanded. + return; } } - if (m_filter.pattern().isEmpty()) { + if (!m_filter.hasSetFilters()) { m_pendingItemsToInsert.append(items); } else { - // The name-filter is active. Hide filtered items + // The name or type filter is active. Hide filtered items // before inserting them into the model and remember // the filtered items in m_filteredItems. KFileItemList filteredItems; @@ -719,13 +783,21 @@ void KFileItemModel::slotItemsDeleted(const KFileItemList& items) { dispatchPendingItemsToInsert(); - if (!m_filteredItems.isEmpty()) { + KFileItemList itemsToRemove = items; + if (m_requestRole[ExpandedParentsCountRole] && m_expandedParentsCountRoot >= 0) { + // Assure that removing a parent item also results in removing all children foreach (const KFileItem& item, items) { + itemsToRemove.append(childItems(item)); + } + } + + if (!m_filteredItems.isEmpty()) { + foreach (const KFileItem& item, itemsToRemove) { m_filteredItems.remove(item); } } - removeItems(items); + removeItems(itemsToRemove); } void KFileItemModel::slotRefreshItems(const QList >& items) @@ -749,7 +821,15 @@ void KFileItemModel::slotRefreshItems(const QList >& const int index = m_items.value(oldItem.url(), -1); if (index >= 0) { m_itemData[index]->item = newItem; - m_itemData[index]->values = retrieveData(newItem); + + // Keep old values as long as possible if they could not retrieved synchronously yet. + // The update of the values will be done asynchronously by KFileItemModelRolesUpdater. + QHashIterator it(retrieveData(newItem)); + while (it.hasNext()) { + it.next(); + m_itemData[index]->values.insert(it.key(), it.value()); + } + m_items.remove(oldItem.url()); m_items.insert(newItem.url(), index); indexes.append(index); @@ -802,12 +882,11 @@ void KFileItemModel::slotClear() m_filteredItems.clear(); m_groups.clear(); - m_minimumUpdateIntervalTimer->stop(); m_maximumUpdateIntervalTimer->stop(); m_resortAllItemsTimer->stop(); m_pendingItemsToInsert.clear(); - m_rootExpansionLevel = UninitializedRootExpansionLevel; + m_expandedParentsCountRoot = UninitializedExpandedParentsCountRoot; const int removedCount = m_itemData.count(); if (removedCount > 0) { @@ -817,7 +896,7 @@ void KFileItemModel::slotClear() emit itemsRemoved(KItemRangeList() << KItemRange(0, removedCount)); } - m_expandedUrls.clear(); + m_expandedDirs.clear(); } void KFileItemModel::slotClear(const KUrl& url) @@ -825,16 +904,18 @@ void KFileItemModel::slotClear(const KUrl& url) Q_UNUSED(url); } +void KFileItemModel::slotNaturalSortingChanged() +{ + m_naturalSorting = KGlobalSettings::naturalSorting(); + resortAllItems(); +} + void KFileItemModel::dispatchPendingItemsToInsert() { if (!m_pendingItemsToInsert.isEmpty()) { insertItems(m_pendingItemsToInsert); m_pendingItemsToInsert.clear(); } - - if (m_pendingEmitLoadingCompleted) { - emit loadingCompleted(); - } } void KFileItemModel::insertItems(const KFileItemList& items) @@ -843,6 +924,13 @@ void KFileItemModel::insertItems(const KFileItemList& items) return; } + if (m_sortRole == TypeRole) { + // Try to resolve the MIME-types synchronously to prevent a reordering of + // the items when sorting by type (per default MIME-types are resolved + // asynchronously by KFileItemModelRolesUpdater). + determineMimeTypes(items, 200); + } + #ifdef KFILEITEMMODEL_DEBUG QElapsedTimer timer; timer.start(); @@ -853,7 +941,7 @@ void KFileItemModel::insertItems(const KFileItemList& items) m_groups.clear(); QList sortedItems = createItemDataList(items); - sort(sortedItems.begin(), sortedItems.end()); + KFileItemModelSortAlgorithm::sort(this, sortedItems.begin(), sortedItems.end()); #ifdef KFILEITEMMODEL_DEBUG kDebug() << "[TIME] Sorting:" << timer.elapsed(); @@ -883,10 +971,10 @@ void KFileItemModel::insertItems(const KFileItemList& items) insertedCount = 0; } - // Insert item at the position targetIndex by transfering + // Insert item at the position targetIndex by transferring // the ownership of the item-data from sortedItems to m_itemData. // m_items will be inserted after the loop (see comment below) - m_itemData.insert(targetIndex, sortedItems.at(sourceIndex)); + m_itemData.insert(targetIndex, sortedItems.at(sourceIndex)); ++insertedCount; if (insertedAtIndex < 0) { @@ -932,7 +1020,7 @@ void KFileItemModel::removeItems(const KFileItemList& items) sortedItems.append(m_itemData.at(index)); } } - sort(sortedItems.begin(), sortedItems.end()); + KFileItemModelSortAlgorithm::sort(this, sortedItems.begin(), sortedItems.end()); QList indexesToRemove; indexesToRemove.reserve(items.count()); @@ -944,7 +1032,7 @@ void KFileItemModel::removeItems(const KFileItemList& items) int targetIndex = 0; foreach (const ItemData* itemData, sortedItems) { const KFileItem& itemToRemove = itemData->item; - + const int previousTargetIndex = targetIndex; while (targetIndex < m_itemData.count()) { if (m_itemData.at(targetIndex)->item.url() == itemToRemove.url()) { @@ -990,7 +1078,7 @@ void KFileItemModel::removeItems(const KFileItemList& items) } if (count() <= 0) { - m_rootExpansionLevel = UninitializedRootExpansionLevel; + m_expandedParentsCountRoot = UninitializedExpandedParentsCountRoot; } itemRanges << KItemRange(removedAtIndex, removedCount); @@ -1008,8 +1096,8 @@ QList KFileItemModel::createItemDataList(const KFileI itemData->values = retrieveData(item); itemData->parent = 0; - const bool determineParent = m_requestRole[ExpansionLevelRole] - && itemData->values["expansionLevel"].toInt() > 0; + const bool determineParent = m_requestRole[ExpandedParentsCountRole] + && itemData->values["expandedParentsCount"].toInt() > 0; if (determineParent) { KUrl parentUrl = item.url().upUrl(); parentUrl.adjustPath(KUrl::RemoveTrailingSlash); @@ -1023,7 +1111,7 @@ QList KFileItemModel::createItemDataList(const KFileI itemDataList.append(itemData); } - + return itemDataList; } @@ -1034,18 +1122,17 @@ void KFileItemModel::removeExpandedItems() const int maxIndex = m_itemData.count() - 1; for (int i = 0; i <= maxIndex; ++i) { const ItemData* itemData = m_itemData.at(i); - if (itemData->values.value("expansionLevel").toInt() > 0) { + if (itemData->values.value("expandedParentsCount").toInt() > 0) { expandedItems.append(itemData->item); } } - // The m_rootExpansionLevel may not get reset before all items with - // a bigger expansionLevel have been removed. - Q_ASSERT(m_rootExpansionLevel >= 0); + // The m_expandedParentsCountRoot may not get reset before all items with + // a bigger count have been removed. removeItems(expandedItems); - m_rootExpansionLevel = UninitializedRootExpansionLevel; - m_expandedUrls.clear(); + m_expandedParentsCountRoot = UninitializedExpandedParentsCountRoot; + m_expandedDirs.clear(); } void KFileItemModel::resetRoles() @@ -1055,36 +1142,64 @@ void KFileItemModel::resetRoles() } } -KFileItemModel::Role KFileItemModel::roleIndex(const QByteArray& role) const +KFileItemModel::RoleType KFileItemModel::typeForRole(const QByteArray& role) const { - static QHash rolesHash; - if (rolesHash.isEmpty()) { - rolesHash.insert("name", NameRole); - rolesHash.insert("size", SizeRole); - rolesHash.insert("date", DateRole); - rolesHash.insert("permissions", PermissionsRole); - rolesHash.insert("owner", OwnerRole); - rolesHash.insert("group", GroupRole); - rolesHash.insert("type", TypeRole); - rolesHash.insert("destination", DestinationRole); - rolesHash.insert("path", PathRole); - rolesHash.insert("comment", CommentRole); - rolesHash.insert("tags", TagsRole); - rolesHash.insert("rating", RatingRole); - rolesHash.insert("isDir", IsDirRole); - rolesHash.insert("isExpanded", IsExpandedRole); - rolesHash.insert("expansionLevel", ExpansionLevelRole); + static QHash roles; + if (roles.isEmpty()) { + // Insert user visible roles that can be accessed with + // KFileItemModel::roleInformation() + int count = 0; + const RoleInfoMap* map = rolesInfoMap(count); + for (int i = 0; i < count; ++i) { + roles.insert(map[i].role, map[i].roleType); + } + + // Insert internal roles (take care to synchronize the implementation + // with KFileItemModel::roleForType() in case if a change is done). + roles.insert("isDir", IsDirRole); + roles.insert("isLink", IsLinkRole); + roles.insert("isExpanded", IsExpandedRole); + roles.insert("isExpandable", IsExpandableRole); + roles.insert("expandedParentsCount", ExpandedParentsCountRole); + + Q_ASSERT(roles.count() == RolesCount); } - return rolesHash.value(role, NoRole); + + return roles.value(role, NoRole); +} + +QByteArray KFileItemModel::roleForType(RoleType roleType) const +{ + static QHash roles; + if (roles.isEmpty()) { + // Insert user visible roles that can be accessed with + // KFileItemModel::roleInformation() + int count = 0; + const RoleInfoMap* map = rolesInfoMap(count); + for (int i = 0; i < count; ++i) { + roles.insert(map[i].roleType, map[i].role); + } + + // Insert internal roles (take care to synchronize the implementation + // with KFileItemModel::typeForRole() in case if a change is done). + roles.insert(IsDirRole, "isDir"); + roles.insert(IsLinkRole, "isLink"); + roles.insert(IsExpandedRole, "isExpanded"); + roles.insert(IsExpandableRole, "isExpandable"); + roles.insert(ExpandedParentsCountRole, "expandedParentsCount"); + + Q_ASSERT(roles.count() == RolesCount); + }; + + return roles.value(roleType); } QHash KFileItemModel::retrieveData(const KFileItem& item) const -{ +{ // It is important to insert only roles that are fast to retrieve. E.g. // KFileItem::iconName() can be very expensive if the MIME-type is unknown // and hence will be retrieved asynchronously by KFileItemModelRolesUpdater. QHash data; - data.insert("iconPixmap", QPixmap()); data.insert("url", item.url()); const bool isDir = item.isDir(); @@ -1092,8 +1207,13 @@ QHash KFileItemModel::retrieveData(const KFileItem& item) data.insert("isDir", isDir); } + if (m_requestRole[IsLinkRole]) { + const bool isLink = item.isLink(); + data.insert("isLink", isLink); + } + if (m_requestRole[NameRole]) { - data.insert("name", item.text()); + data.insert("text", item.text()); } if (m_requestRole[SizeRole]) { @@ -1127,49 +1247,64 @@ QHash KFileItemModel::retrieveData(const KFileItem& item) if (m_requestRole[DestinationRole]) { QString destination = item.linkDest(); if (destination.isEmpty()) { - destination = i18nc("@item:intable", "No destination"); + destination = QLatin1String("-"); } data.insert("destination", destination); } if (m_requestRole[PathRole]) { + QString path; if (item.url().protocol() == QLatin1String("trash")) { - const KIO::UDSEntry udsEntry = item.entry(); - data.insert("path", udsEntry.stringValue(KIO::UDSEntry::UDS_EXTRA)); + path = item.entry().stringValue(KIO::UDSEntry::UDS_EXTRA); } else { - data.insert("path", item.localPath()); + // For performance reasons cache the home-path in a static QString + // (see QDir::homePath() for more details) + static QString homePath; + if (homePath.isEmpty()) { + homePath = QDir::homePath(); + } + + path = item.localPath(); + if (path.startsWith(homePath)) { + path.replace(0, homePath.length(), QLatin1Char('~')); + } } + + const int index = path.lastIndexOf(item.text()); + path = path.mid(0, index - 1); + data.insert("path", path); } if (m_requestRole[IsExpandedRole]) { data.insert("isExpanded", false); } - if (m_requestRole[ExpansionLevelRole]) { - if (m_rootExpansionLevel == UninitializedRootExpansionLevel && m_dirLister.data()) { - const KUrl rootUrl = m_dirLister.data()->url(); + if (m_requestRole[IsExpandableRole]) { + data.insert("isExpandable", item.isDir() && item.url() == item.targetUrl()); + } + + if (m_requestRole[ExpandedParentsCountRole]) { + if (m_expandedParentsCountRoot == UninitializedExpandedParentsCountRoot) { + const KUrl rootUrl = m_dirLister->url(); const QString protocol = rootUrl.protocol(); - const bool forceRootExpansionLevel = (protocol == QLatin1String("trash") || - protocol == QLatin1String("nepomuk") || - protocol.contains(QLatin1String("search"))); - if (forceRootExpansionLevel) { - m_rootExpansionLevel = ForceRootExpansionLevel; + const bool forceExpandedParentsCountRoot = (protocol == QLatin1String("trash") || + protocol == QLatin1String("nepomuk") || + protocol == QLatin1String("remote") || + protocol.contains(QLatin1String("search"))); + if (forceExpandedParentsCountRoot) { + m_expandedParentsCountRoot = ForceExpandedParentsCountRoot; } else { - const QString rootDir = rootUrl.directory(KUrl::AppendTrailingSlash); - m_rootExpansionLevel = rootDir.count('/'); - if (m_rootExpansionLevel == 1) { - // Special case: The root is already reached and no parent is available - --m_rootExpansionLevel; - } + const QString rootDir = rootUrl.path(KUrl::AddTrailingSlash); + m_expandedParentsCountRoot = rootDir.count('/'); } } - if (m_rootExpansionLevel == ForceRootExpansionLevel) { - data.insert("expansionLevel", -1); + if (m_expandedParentsCountRoot == ForceExpandedParentsCountRoot) { + data.insert("expandedParentsCount", -1); } else { const QString dir = item.url().directory(KUrl::AppendTrailingSlash); - const int level = dir.count('/') - m_rootExpansionLevel - 1; - data.insert("expansionLevel", level); + const int level = dir.count('/') - m_expandedParentsCountRoot; + data.insert("expandedParentsCount", level); } } @@ -1188,15 +1323,15 @@ bool KFileItemModel::lessThan(const ItemData* a, const ItemData* b) const { int result = 0; - if (m_rootExpansionLevel >= 0) { - result = expansionLevelsCompare(a, b); + if (m_expandedParentsCountRoot >= 0) { + result = expandedParentsCountCompare(a, b); if (result != 0) { // The items have parents with different expansion levels return (sortOrder() == Qt::AscendingOrder) ? result < 0 : result > 0; } } - if (m_sortFoldersFirst || m_sortRole == SizeRole) { + if (m_sortDirsFirst || m_sortRole == SizeRole) { const bool isDirA = a->item.isDir(); const bool isDirB = b->item.isDir(); if (isDirA && !isDirB) { @@ -1223,63 +1358,70 @@ int KFileItemModel::sortRoleCompare(const ItemData* a, const ItemData* b) const // The name role is handled as default fallback after the switch break; - case DateRole: { - const KDateTime dateTimeA = itemA.time(KFileItem::ModificationTime); - const KDateTime dateTimeB = itemB.time(KFileItem::ModificationTime); - if (dateTimeA < dateTimeB) { - result = -1; - } else if (dateTimeA > dateTimeB) { - result = +1; - } - break; - } - case SizeRole: { if (itemA.isDir()) { - Q_ASSERT(itemB.isDir()); // see "if (m_sortFoldersFirst || m_sortRole == SizeRole)" above + // See "if (m_sortFoldersFirst || m_sortRole == SizeRole)" in KFileItemModel::lessThan(): + Q_ASSERT(itemB.isDir()); const QVariant valueA = a->values.value("size"); const QVariant valueB = b->values.value("size"); - - if (valueA.isNull()) { + if (valueA.isNull() && valueB.isNull()) { + result = 0; + } else if (valueA.isNull()) { result = -1; } else if (valueB.isNull()) { result = +1; } else { - result = valueA.value() - valueB.value(); + result = valueA.toInt() - valueB.toInt(); } } else { - Q_ASSERT(!itemB.isDir()); // see "if (m_sortFoldersFirst || m_sortRole == SizeRole)" above - result = itemA.size() - itemB.size(); + // See "if (m_sortFoldersFirst || m_sortRole == SizeRole)" in KFileItemModel::lessThan(): + Q_ASSERT(!itemB.isDir()); + const KIO::filesize_t sizeA = itemA.size(); + const KIO::filesize_t sizeB = itemB.size(); + if (sizeA > sizeB) { + result = +1; + } else if (sizeA < sizeB) { + result = -1; + } else { + result = 0; + } } break; } - case TypeRole: { - result = QString::compare(a->values.value("type").toString(), - b->values.value("type").toString()); + case DateRole: { + const KDateTime dateTimeA = itemA.time(KFileItem::ModificationTime); + const KDateTime dateTimeB = itemB.time(KFileItem::ModificationTime); + if (dateTimeA < dateTimeB) { + result = -1; + } else if (dateTimeA > dateTimeB) { + result = +1; + } break; } - case CommentRole: { - result = QString::compare(a->values.value("comment").toString(), - b->values.value("comment").toString()); + case RatingRole: { + result = a->values.value("rating").toInt() - b->values.value("rating").toInt(); break; } - case TagsRole: { - result = QString::compare(a->values.value("tags").toString(), - b->values.value("tags").toString()); + case ImageSizeRole: { + // Alway use a natural comparing to interpret the numbers of a string like + // "1600 x 1200" for having a correct sorting. + result = KStringHandler::naturalCompare(a->values.value("imageSize").toString(), + b->values.value("imageSize").toString(), + Qt::CaseSensitive); break; } - case RatingRole: { - result = a->values.value("rating").toInt() - b->values.value("rating").toInt(); + default: { + const QByteArray role = roleForType(m_sortRole); + result = QString::compare(a->values.value(role).toString(), + b->values.value(role).toString()); break; } - default: - break; } if (result != 0) { @@ -1306,128 +1448,6 @@ int KFileItemModel::sortRoleCompare(const ItemData* a, const ItemData* b) const return QString::compare(itemA.url().url(), itemB.url().url(), Qt::CaseSensitive); } -void KFileItemModel::sort(QList::iterator begin, - QList::iterator end) -{ - // The implementation is based on qStableSortHelper() from qalgorithms.h - // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). - // In opposite to qStableSort() it allows to use a member-function for the comparison of elements. - - const int span = end - begin; - if (span < 2) { - return; - } - - const QList::iterator middle = begin + span / 2; - sort(begin, middle); - sort(middle, end); - merge(begin, middle, end); -} - -void KFileItemModel::merge(QList::iterator begin, - QList::iterator pivot, - QList::iterator end) -{ - // The implementation is based on qMerge() from qalgorithms.h - // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). - - const int len1 = pivot - begin; - const int len2 = end - pivot; - - if (len1 == 0 || len2 == 0) { - return; - } - - if (len1 + len2 == 2) { - if (lessThan(*(begin + 1), *(begin))) { - qSwap(*begin, *(begin + 1)); - } - return; - } - - QList::iterator firstCut; - QList::iterator secondCut; - int len2Half; - if (len1 > len2) { - const int len1Half = len1 / 2; - firstCut = begin + len1Half; - secondCut = lowerBound(pivot, end, *firstCut); - len2Half = secondCut - pivot; - } else { - len2Half = len2 / 2; - secondCut = pivot + len2Half; - firstCut = upperBound(begin, pivot, *secondCut); - } - - reverse(firstCut, pivot); - reverse(pivot, secondCut); - reverse(firstCut, secondCut); - - const QList::iterator newPivot = firstCut + len2Half; - merge(begin, firstCut, newPivot); - merge(newPivot, secondCut, end); -} - -QList::iterator KFileItemModel::lowerBound(QList::iterator begin, - QList::iterator end, - const ItemData* value) -{ - // The implementation is based on qLowerBound() from qalgorithms.h - // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). - - QList::iterator middle; - int n = int(end - begin); - int half; - - while (n > 0) { - half = n >> 1; - middle = begin + half; - if (lessThan(*middle, value)) { - begin = middle + 1; - n -= half + 1; - } else { - n = half; - } - } - return begin; -} - -QList::iterator KFileItemModel::upperBound(QList::iterator begin, - QList::iterator end, - const ItemData* value) -{ - // The implementation is based on qUpperBound() from qalgorithms.h - // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). - - QList::iterator middle; - int n = end - begin; - int half; - - while (n > 0) { - half = n >> 1; - middle = begin + half; - if (lessThan(value, *middle)) { - n = half; - } else { - begin = middle + 1; - n -= half + 1; - } - } - return begin; -} - -void KFileItemModel::reverse(QList::iterator begin, - QList::iterator end) -{ - // The implementation is based on qReverse() from qalgorithms.h - // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). - - --end; - while (begin < end) { - qSwap(*begin++, *end--); - } -} - int KFileItemModel::stringCompare(const QString& a, const QString& b) const { // Taken from KDirSortFilterProxyModel (kdelibs/kfile/kdirsortfilterproxymodel.*) @@ -1450,7 +1470,7 @@ int KFileItemModel::stringCompare(const QString& a, const QString& b) const : QString::compare(a, b, Qt::CaseSensitive); } -int KFileItemModel::expansionLevelsCompare(const ItemData* a, const ItemData* b) const +int KFileItemModel::expandedParentsCountCompare(const ItemData* a, const ItemData* b) const { const KUrl urlA = a->item.url(); const KUrl urlB = b->item.url(); @@ -1490,24 +1510,26 @@ int KFileItemModel::expansionLevelsCompare(const ItemData* a, const ItemData* b) bool isDirB = true; const QString subPathB = subPath(b->item, pathB, index, &isDirB); - if (isDirA && !isDirB) { - return (sortOrder() == Qt::AscendingOrder) ? -1 : +1; - } else if (!isDirA && isDirB) { - return (sortOrder() == Qt::AscendingOrder) ? +1 : -1; + if (m_sortDirsFirst || m_sortRole == SizeRole) { + if (isDirA && !isDirB) { + return (sortOrder() == Qt::AscendingOrder) ? -1 : +1; + } else if (!isDirA && isDirB) { + return (sortOrder() == Qt::AscendingOrder) ? +1 : -1; + } } // Compare the items of the parents that represent the first // different path after the common path. - const KUrl parentUrlA(pathA.left(index) + subPathA); - const KUrl parentUrlB(pathB.left(index) + subPathB); + const QString parentPathA = pathA.left(index) + subPathA; + const QString parentPathB = pathB.left(index) + subPathB; const ItemData* parentA = a; - while (parentA && parentA->item.url() != parentUrlA) { + while (parentA && parentA->item.url().path() != parentPathA) { parentA = parentA->parent; } const ItemData* parentB = b; - while (parentB && parentB->item.url() != parentUrlB) { + while (parentB && parentB->item.url().path() != parentPathB) { parentB = parentB->parent; } @@ -1532,8 +1554,7 @@ QString KFileItemModel::subPath(const KFileItem& item, bool KFileItemModel::useMaximumUpdateInterval() const { - const KDirLister* dirLister = m_dirLister.data(); - return dirLister && !dirLister->url().isLocalFile(); + return !m_dirLister->url().isLocalFile(); } QList > KFileItemModel::nameRoleGroups() const @@ -1551,12 +1572,12 @@ QList > KFileItemModel::nameRoleGroups() const continue; } - const QString name = m_itemData.at(i)->values.value("name").toString(); + const QString name = m_itemData.at(i)->values.value("text").toString(); // Use the first character of the name as group indication QChar newFirstChar = name.at(0).toUpper(); if (newFirstChar == QLatin1Char('~') && name.length() > 1) { - newFirstChar = name.at(1); + newFirstChar = name.at(1).toUpper(); } if (firstChar != newFirstChar) { @@ -1812,12 +1833,12 @@ QList > KFileItemModel::ratingRoleGroups() const const int maxIndex = count() - 1; QList > groups; - int groupValue; + int groupValue = -1; for (int i = 0; i <= maxIndex; ++i) { if (isChildItem(i)) { continue; } - const int newGroupValue = m_itemData.at(i)->values.value("rating").toInt(); + const int newGroupValue = m_itemData.at(i)->values.value("rating", 0).toInt(); if (newGroupValue != groupValue) { groupValue = newGroupValue; groups.append(QPair(i, newGroupValue)); @@ -1834,19 +1855,112 @@ QList > KFileItemModel::genericStringRoleGroups(const QByte const int maxIndex = count() - 1; QList > groups; + bool isFirstGroupValue = true; QString groupValue; for (int i = 0; i <= maxIndex; ++i) { if (isChildItem(i)) { continue; } const QString newGroupValue = m_itemData.at(i)->values.value(role).toString(); - if (newGroupValue != groupValue) { + if (newGroupValue != groupValue || isFirstGroupValue) { groupValue = newGroupValue; groups.append(QPair(i, newGroupValue)); + isFirstGroupValue = false; } } return groups; } +KFileItemList KFileItemModel::childItems(const KFileItem& item) const +{ + KFileItemList items; + + int index = m_items.value(item.url(), -1); + if (index >= 0) { + const int parentLevel = m_itemData.at(index)->values.value("expandedParentsCount").toInt(); + ++index; + while (index < m_itemData.count() && m_itemData.at(index)->values.value("expandedParentsCount").toInt() > parentLevel) { + items.append(m_itemData.at(index)->item); + ++index; + } + } + + return items; +} + +void KFileItemModel::emitSortProgress(int resolvedCount) +{ + // Be tolerant against a resolvedCount with a wrong range. + // Although there should not be a case where KFileItemModelRolesUpdater + // (= caller) provides a wrong range, it is important to emit + // a useful progress information even if there is an unexpected + // implementation issue. + + const int itemCount = count(); + if (resolvedCount >= itemCount) { + m_sortingProgressPercent = -1; + if (m_resortAllItemsTimer->isActive()) { + m_resortAllItemsTimer->stop(); + resortAllItems(); + } + + emit directorySortingProgress(100); + } else if (itemCount > 0) { + resolvedCount = qBound(0, resolvedCount, itemCount); + + const int progress = resolvedCount * 100 / itemCount; + if (m_sortingProgressPercent != progress) { + m_sortingProgressPercent = progress; + emit directorySortingProgress(progress); + } + } +} + +const KFileItemModel::RoleInfoMap* KFileItemModel::rolesInfoMap(int& count) +{ + static const RoleInfoMap rolesInfoMap[] = { + // | role | roleType | role translation | group translation | requires Nepomuk | requires indexer + { 0, NoRole, 0, 0, 0, 0, false, false }, + { "text", NameRole, I18N_NOOP2_NOSTRIP("@label", "Name"), 0, 0, false, false }, + { "size", SizeRole, I18N_NOOP2_NOSTRIP("@label", "Size"), 0, 0, false, false }, + { "date", DateRole, I18N_NOOP2_NOSTRIP("@label", "Date"), 0, 0, false, false }, + { "type", TypeRole, I18N_NOOP2_NOSTRIP("@label", "Type"), 0, 0, false, false }, + { "rating", RatingRole, I18N_NOOP2_NOSTRIP("@label", "Rating"), 0, 0, true, false }, + { "tags", TagsRole, I18N_NOOP2_NOSTRIP("@label", "Tags"), 0, 0, true, false }, + { "comment", CommentRole, I18N_NOOP2_NOSTRIP("@label", "Comment"), 0, 0, true, false }, + { "wordCount", WordCountRole, I18N_NOOP2_NOSTRIP("@label", "Word Count"), I18N_NOOP2_NOSTRIP("@label", "Document"), true, true }, + { "lineCount", LineCountRole, I18N_NOOP2_NOSTRIP("@label", "Line Count"), I18N_NOOP2_NOSTRIP("@label", "Document"), true, true }, + { "imageSize", ImageSizeRole, I18N_NOOP2_NOSTRIP("@label", "Image Size"), I18N_NOOP2_NOSTRIP("@label", "Image"), true, true }, + { "orientation", OrientationRole, I18N_NOOP2_NOSTRIP("@label", "Orientation"), I18N_NOOP2_NOSTRIP("@label", "Image"), true, true }, + { "artist", ArtistRole, I18N_NOOP2_NOSTRIP("@label", "Artist"), I18N_NOOP2_NOSTRIP("@label", "Audio"), true, true }, + { "album", AlbumRole, I18N_NOOP2_NOSTRIP("@label", "Album"), I18N_NOOP2_NOSTRIP("@label", "Audio"), true, true }, + { "duration", DurationRole, I18N_NOOP2_NOSTRIP("@label", "Duration"), I18N_NOOP2_NOSTRIP("@label", "Audio"), true, true }, + { "track", TrackRole, I18N_NOOP2_NOSTRIP("@label", "Track"), I18N_NOOP2_NOSTRIP("@label", "Audio"), true, true }, + { "path", PathRole, I18N_NOOP2_NOSTRIP("@label", "Path"), I18N_NOOP2_NOSTRIP("@label", "Other"), false, false }, + { "destination", DestinationRole, I18N_NOOP2_NOSTRIP("@label", "Link Destination"), I18N_NOOP2_NOSTRIP("@label", "Other"), false, false }, + { "copiedFrom", CopiedFromRole, I18N_NOOP2_NOSTRIP("@label", "Copied From"), I18N_NOOP2_NOSTRIP("@label", "Other"), true, false }, + { "permissions", PermissionsRole, I18N_NOOP2_NOSTRIP("@label", "Permissions"), I18N_NOOP2_NOSTRIP("@label", "Other"), false, false }, + { "owner", OwnerRole, I18N_NOOP2_NOSTRIP("@label", "Owner"), I18N_NOOP2_NOSTRIP("@label", "Other"), false, false }, + { "group", GroupRole, I18N_NOOP2_NOSTRIP("@label", "User Group"), I18N_NOOP2_NOSTRIP("@label", "Other"), false, false }, + }; + + count = sizeof(rolesInfoMap) / sizeof(RoleInfoMap); + return rolesInfoMap; +} + +void KFileItemModel::determineMimeTypes(const KFileItemList& items, int timeout) +{ + QElapsedTimer timer; + timer.start(); + foreach (KFileItem item, items) { // krazy:exclude=foreach + item.determineMimeType(); + if (timer.elapsed() > timeout) { + // Don't block the user interface, let the remaining items + // be resolved asynchronously. + return; + } + } +} + #include "kfileitemmodel.moc"