src/kitemviews/kfileitemmodel.cpp

   1 /*****************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>               *
   3  *   Copyright (C) 2013 by Frank Reininghaus <frank78ac@googlemail.com>      *
   4  *   Copyright (C) 2013 by Emmanuel Pescosta <emmanuelpescosta099@gmail.com> *
   5  *                                                                           *
   6  *   This program is free software; you can redistribute it and/or modify    *
   7  *   it under the terms of the GNU General Public License as published by    *
   8  *   the Free Software Foundation; either version 2 of the License, or       *
   9  *   (at your option) any later version.                                     *
  10  *                                                                           *
  11  *   This program is distributed in the hope that it will be useful,         *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  14  *   GNU General Public License for more details.                            *
  15  *                                                                           *
  16  *   You should have received a copy of the GNU General Public License       *
  17  *   along with this program; if not, write to the                           *
  18  *   Free Software Foundation, Inc.,                                         *
  19  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA              *
  20  *****************************************************************************/
  21
  22 #include "kfileitemmodel.h"
  23
  24 #include <KDirModel>
  25 #include <KGlobalSettings>
  26 #include <KLocale>
  27 #include <KStringHandler>
  28 #include <KDebug>
  29
  30 #include "private/kfileitemmodelsortalgorithm.h"
  31 #include "private/kfileitemmodeldirlister.h"
  32
  33 #include <QApplication>
  34 #include <QMimeData>
  35 #include <QTimer>
  36 #include <QWidget>
  37
  38 #include <algorithm>
  39 #include <vector>
  40
  41 // #define KFILEITEMMODEL_DEBUG
  42
  43 KFileItemModel::KFileItemModel(QObject* parent) :
  44     KItemModelBase("text", parent),
  45     m_dirLister(0),
  46     m_naturalSorting(KGlobalSettings::naturalSorting()),
  47     m_sortDirsFirst(true),
  48     m_sortRole(NameRole),
  49     m_sortingProgressPercent(-1),
  50     m_roles(),
  51     m_caseSensitivity(Qt::CaseInsensitive),
  52     m_itemData(),
  53     m_items(),
  54     m_filter(),
  55     m_filteredItems(),
  56     m_requestRole(),
  57     m_maximumUpdateIntervalTimer(0),
  58     m_resortAllItemsTimer(0),
  59     m_pendingItemsToInsert(),
  60     m_groups(),
  61     m_expandedDirs(),
  62     m_urlsToExpand()
  63 {
  64     m_dirLister = new KFileItemModelDirLister(this);
  65     m_dirLister->setDelayedMimeTypes(true);
  66
  67     const QWidget* parentWidget = qobject_cast<QWidget*>(parent);
  68     if (parentWidget) {
  69         m_dirLister->setMainWindow(parentWidget->window());
  70     }
  71
  72     connect(m_dirLister, SIGNAL(started(KUrl)), this, SIGNAL(directoryLoadingStarted()));
  73     connect(m_dirLister, SIGNAL(canceled()), this, SLOT(slotCanceled()));
  74     connect(m_dirLister, SIGNAL(completed(KUrl)), this, SLOT(slotCompleted()));
  75     connect(m_dirLister, SIGNAL(itemsAdded(KUrl,KFileItemList)), this, SLOT(slotItemsAdded(KUrl,KFileItemList)));
  76     connect(m_dirLister, SIGNAL(itemsDeleted(KFileItemList)), this, SLOT(slotItemsDeleted(KFileItemList)));
  77     connect(m_dirLister, SIGNAL(refreshItems(QList<QPair<KFileItem,KFileItem> >)), this, SLOT(slotRefreshItems(QList<QPair<KFileItem,KFileItem> >)));
  78     connect(m_dirLister, SIGNAL(clear()), this, SLOT(slotClear()));
  79     connect(m_dirLister, SIGNAL(clear(KUrl)), this, SLOT(slotClear(KUrl)));
  80     connect(m_dirLister, SIGNAL(infoMessage(QString)), this, SIGNAL(infoMessage(QString)));
  81     connect(m_dirLister, SIGNAL(errorMessage(QString)), this, SIGNAL(errorMessage(QString)));
  82     connect(m_dirLister, SIGNAL(redirection(KUrl,KUrl)), this, SIGNAL(directoryRedirection(KUrl,KUrl)));
  83     connect(m_dirLister, SIGNAL(urlIsFileError(KUrl)), this, SIGNAL(urlIsFileError(KUrl)));
  84
  85     // Apply default roles that should be determined
  86     resetRoles();
  87     m_requestRole[NameRole] = true;
  88     m_requestRole[IsDirRole] = true;
  89     m_requestRole[IsLinkRole] = true;
  90     m_roles.insert("text");
  91     m_roles.insert("isDir");
  92     m_roles.insert("isLink");
  93
  94     // For slow KIO-slaves like used for searching it makes sense to show results periodically even
  95     // before the completed() or canceled() signal has been emitted.
  96     m_maximumUpdateIntervalTimer = new QTimer(this);
  97     m_maximumUpdateIntervalTimer->setInterval(2000);
  98     m_maximumUpdateIntervalTimer->setSingleShot(true);
  99     connect(m_maximumUpdateIntervalTimer, SIGNAL(timeout()), this, SLOT(dispatchPendingItemsToInsert()));
 100
 101     // When changing the value of an item which represents the sort-role a resorting must be
 102     // triggered. Especially in combination with KFileItemModelRolesUpdater this might be done
 103     // for a lot of items within a quite small timeslot. To prevent expensive resortings the
 104     // resorting is postponed until the timer has been exceeded.
 105     m_resortAllItemsTimer = new QTimer(this);
 106     m_resortAllItemsTimer->setInterval(500);
 107     m_resortAllItemsTimer->setSingleShot(true);
 108     connect(m_resortAllItemsTimer, SIGNAL(timeout()), this, SLOT(resortAllItems()));
 109
 110     connect(KGlobalSettings::self(), SIGNAL(naturalSortingChanged()), this, SLOT(slotNaturalSortingChanged()));
 111 }
 112
 113 KFileItemModel::~KFileItemModel()
 114 {
 115     qDeleteAll(m_itemData);
 116     qDeleteAll(m_filteredItems.values());
 117     qDeleteAll(m_pendingItemsToInsert);
 118 }
 119
 120 void KFileItemModel::loadDirectory(const KUrl& url)
 121 {
 122     m_dirLister->openUrl(url);
 123 }
 124
 125 void KFileItemModel::refreshDirectory(const KUrl& url)
 126 {
 127     // Refresh all expanded directories first (Bug 295300)
 128     QHashIterator<KUrl, KUrl> expandedDirs(m_expandedDirs);
 129     while (expandedDirs.hasNext()) {
 130         expandedDirs.next();
 131         m_dirLister->openUrl(expandedDirs.value(), KDirLister::Reload);
 132     }
 133
 134     m_dirLister->openUrl(url, KDirLister::Reload);
 135 }
 136
 137 KUrl KFileItemModel::directory() const
 138 {
 139     return m_dirLister->url();
 140 }
 141
 142 void KFileItemModel::cancelDirectoryLoading()
 143 {
 144     m_dirLister->stop();
 145 }
 146
 147 int KFileItemModel::count() const
 148 {
 149     return m_itemData.count();
 150 }
 151
 152 QHash<QByteArray, QVariant> KFileItemModel::data(int index) const
 153 {
 154     if (index >= 0 && index < count()) {
 155         return m_itemData.at(index)->values;
 156     }
 157     return QHash<QByteArray, QVariant>();
 158 }
 159
 160 bool KFileItemModel::setData(int index, const QHash<QByteArray, QVariant>& values)
 161 {
 162     if (index < 0 || index >= count()) {
 163         return false;
 164     }
 165
 166     QHash<QByteArray, QVariant> currentValues = m_itemData.at(index)->values;
 167
 168     // Determine which roles have been changed
 169     QSet<QByteArray> changedRoles;
 170     QHashIterator<QByteArray, QVariant> it(values);
 171     while (it.hasNext()) {
 172         it.next();
 173         const QByteArray role = sharedValue(it.key());
 174         const QVariant value = it.value();
 175
 176         if (currentValues[role] != value) {
 177             currentValues[role] = value;
 178             changedRoles.insert(role);
 179         }
 180     }
 181
 182     if (changedRoles.isEmpty()) {
 183         return false;
 184     }
 185
 186     m_itemData[index]->values = currentValues;
 187     if (changedRoles.contains("text")) {
 188         KUrl url = m_itemData[index]->item.url();
 189         url.setFileName(currentValues["text"].toString());
 190         m_itemData[index]->item.setUrl(url);
 191     }
 192
 193     emit itemsChanged(KItemRangeList() << KItemRange(index, 1), changedRoles);
 194
 195     if (changedRoles.contains(sortRole())) {
 196         m_resortAllItemsTimer->start();
 197     }
 198
 199     return true;
 200 }
 201
 202 void KFileItemModel::setSortDirectoriesFirst(bool dirsFirst)
 203 {
 204     if (dirsFirst != m_sortDirsFirst) {
 205         m_sortDirsFirst = dirsFirst;
 206         resortAllItems();
 207     }
 208 }
 209
 210 bool KFileItemModel::sortDirectoriesFirst() const
 211 {
 212     return m_sortDirsFirst;
 213 }
 214
 215 void KFileItemModel::setShowHiddenFiles(bool show)
 216 {
 217     m_dirLister->setShowingDotFiles(show);
 218     m_dirLister->emitChanges();
 219     if (show) {
 220         slotCompleted();
 221     }
 222 }
 223
 224 bool KFileItemModel::showHiddenFiles() const
 225 {
 226     return m_dirLister->showingDotFiles();
 227 }
 228
 229 void KFileItemModel::setShowDirectoriesOnly(bool enabled)
 230 {
 231     m_dirLister->setDirOnlyMode(enabled);
 232 }
 233
 234 bool KFileItemModel::showDirectoriesOnly() const
 235 {
 236     return m_dirLister->dirOnlyMode();
 237 }
 238
 239 QMimeData* KFileItemModel::createMimeData(const QSet<int>& indexes) const
 240 {
 241     QMimeData* data = new QMimeData();
 242
 243     // The following code has been taken from KDirModel::mimeData()
 244     // (kdelibs/kio/kio/kdirmodel.cpp)
 245     // Copyright (C) 2006 David Faure <faure@kde.org>
 246     KUrl::List urls;
 247     KUrl::List mostLocalUrls;
 248     bool canUseMostLocalUrls = true;
 249
 250     QSetIterator<int> it(indexes);
 251     while (it.hasNext()) {
 252         const int index = it.next();
 253         const KFileItem item = fileItem(index);
 254         if (!item.isNull()) {
 255             urls << item.targetUrl();
 256
 257             bool isLocal;
 258             mostLocalUrls << item.mostLocalUrl(isLocal);
 259             if (!isLocal) {
 260                 canUseMostLocalUrls = false;
 261             }
 262         }
 263     }
 264
 265     const bool different = canUseMostLocalUrls && mostLocalUrls != urls;
 266     urls = KDirModel::simplifiedUrlList(urls); // TODO: Check if we still need KDirModel for this in KDE 5.0
 267     if (different) {
 268         mostLocalUrls = KDirModel::simplifiedUrlList(mostLocalUrls);
 269         urls.populateMimeData(mostLocalUrls, data);
 270     } else {
 271         urls.populateMimeData(data);
 272     }
 273
 274     return data;
 275 }
 276
 277 int KFileItemModel::indexForKeyboardSearch(const QString& text, int startFromIndex) const
 278 {
 279     startFromIndex = qMax(0, startFromIndex);
 280     for (int i = startFromIndex; i < count(); ++i) {
 281         if (data(i)["text"].toString().startsWith(text, Qt::CaseInsensitive)) {
 282             return i;
 283         }
 284     }
 285     for (int i = 0; i < startFromIndex; ++i) {
 286         if (data(i)["text"].toString().startsWith(text, Qt::CaseInsensitive)) {
 287             return i;
 288         }
 289     }
 290     return -1;
 291 }
 292
 293 bool KFileItemModel::supportsDropping(int index) const
 294 {
 295     const KFileItem item = fileItem(index);
 296     return !item.isNull() && (item.isDir() || item.isDesktopFile());
 297 }
 298
 299 QString KFileItemModel::roleDescription(const QByteArray& role) const
 300 {
 301     static QHash<QByteArray, QString> description;
 302     if (description.isEmpty()) {
 303         int count = 0;
 304         const RoleInfoMap* map = rolesInfoMap(count);
 305         for (int i = 0; i < count; ++i) {
 306             description.insert(map[i].role, i18nc(map[i].roleTranslationContext, map[i].roleTranslation));
 307         }
 308     }
 309
 310     return description.value(role);
 311 }
 312
 313 QList<QPair<int, QVariant> > KFileItemModel::groups() const
 314 {
 315     if (!m_itemData.isEmpty() && m_groups.isEmpty()) {
 316 #ifdef KFILEITEMMODEL_DEBUG
 317         QElapsedTimer timer;
 318         timer.start();
 319 #endif
 320         switch (typeForRole(sortRole())) {
 321         case NameRole:        m_groups = nameRoleGroups(); break;
 322         case SizeRole:        m_groups = sizeRoleGroups(); break;
 323         case DateRole:        m_groups = dateRoleGroups(); break;
 324         case PermissionsRole: m_groups = permissionRoleGroups(); break;
 325         case RatingRole:      m_groups = ratingRoleGroups(); break;
 326         default:              m_groups = genericStringRoleGroups(sortRole()); break;
 327         }
 328
 329 #ifdef KFILEITEMMODEL_DEBUG
 330         kDebug() << "[TIME] Calculating groups for" << count() << "items:" << timer.elapsed();
 331 #endif
 332     }
 333
 334     return m_groups;
 335 }
 336
 337 KFileItem KFileItemModel::fileItem(int index) const
 338 {
 339     if (index >= 0 && index < count()) {
 340         return m_itemData.at(index)->item;
 341     }
 342
 343     return KFileItem();
 344 }
 345
 346 KFileItem KFileItemModel::fileItem(const KUrl& url) const
 347 {
 348     const int index = m_items.value(url, -1);
 349     if (index >= 0) {
 350         return m_itemData.at(index)->item;
 351     }
 352     return KFileItem();
 353 }
 354
 355 int KFileItemModel::index(const KFileItem& item) const
 356 {
 357     if (item.isNull()) {
 358         return -1;
 359     }
 360
 361     return m_items.value(item.url(), -1);
 362 }
 363
 364 int KFileItemModel::index(const KUrl& url) const
 365 {
 366     KUrl urlToFind = url;
 367     urlToFind.adjustPath(KUrl::RemoveTrailingSlash);
 368     return m_items.value(urlToFind, -1);
 369 }
 370
 371 KFileItem KFileItemModel::rootItem() const
 372 {
 373     return m_dirLister->rootItem();
 374 }
 375
 376 void KFileItemModel::clear()
 377 {
 378     slotClear();
 379 }
 380
 381 void KFileItemModel::setRoles(const QSet<QByteArray>& roles)
 382 {
 383     if (m_roles == roles) {
 384         return;
 385     }
 386     m_roles = roles;
 387
 388     if (count() > 0) {
 389         const bool supportedExpanding = m_requestRole[ExpandedParentsCountRole];
 390         const bool willSupportExpanding = roles.contains("expandedParentsCount");
 391         if (supportedExpanding && !willSupportExpanding) {
 392             // No expanding is supported anymore. Take care to delete all items that have an expansion level
 393             // that is not 0 (and hence are part of an expanded item).
 394             removeExpandedItems();
 395         }
 396     }
 397
 398     m_groups.clear();
 399     resetRoles();
 400
 401     QSetIterator<QByteArray> it(roles);
 402     while (it.hasNext()) {
 403         const QByteArray& role = it.next();
 404         m_requestRole[typeForRole(role)] = true;
 405     }
 406
 407     if (count() > 0) {
 408         // Update m_data with the changed requested roles
 409         const int maxIndex = count() - 1;
 410         for (int i = 0; i <= maxIndex; ++i) {
 411             m_itemData[i]->values = retrieveData(m_itemData.at(i)->item, m_itemData.at(i)->parent);
 412         }
 413
 414         kWarning() << "TODO: Emitting itemsChanged() with no information what has changed!";
 415         emit itemsChanged(KItemRangeList() << KItemRange(0, count()), QSet<QByteArray>());
 416     }
 417 }
 418
 419 QSet<QByteArray> KFileItemModel::roles() const
 420 {
 421     return m_roles;
 422 }
 423
 424 bool KFileItemModel::setExpanded(int index, bool expanded)
 425 {
 426     if (!isExpandable(index) || isExpanded(index) == expanded) {
 427         return false;
 428     }
 429
 430     QHash<QByteArray, QVariant> values;
 431     values.insert(sharedValue("isExpanded"), expanded);
 432     if (!setData(index, values)) {
 433         return false;
 434     }
 435
 436     const KFileItem item = m_itemData.at(index)->item;
 437     const KUrl url = item.url();
 438     const KUrl targetUrl = item.targetUrl();
 439     if (expanded) {
 440         m_expandedDirs.insert(targetUrl, url);
 441         m_dirLister->openUrl(url, KDirLister::Keep);
 442     } else {
 443         m_expandedDirs.remove(targetUrl);
 444         m_dirLister->stop(url);
 445
 446         removeFilteredChildren(KFileItemList() << item);
 447
 448         const KFileItemList itemsToRemove = childItems(item);
 449         removeFilteredChildren(itemsToRemove);
 450         removeItems(itemsToRemove, DeleteItemData);
 451     }
 452
 453     return true;
 454 }
 455
 456 bool KFileItemModel::isExpanded(int index) const
 457 {
 458     if (index >= 0 && index < count()) {
 459         return m_itemData.at(index)->values.value("isExpanded").toBool();
 460     }
 461     return false;
 462 }
 463
 464 bool KFileItemModel::isExpandable(int index) const
 465 {
 466     if (index >= 0 && index < count()) {
 467         return m_itemData.at(index)->values.value("isExpandable").toBool();
 468     }
 469     return false;
 470 }
 471
 472 int KFileItemModel::expandedParentsCount(int index) const
 473 {
 474     if (index >= 0 && index < count()) {
 475         const int parentsCount = m_itemData.at(index)->values.value("expandedParentsCount").toInt();
 476         if (parentsCount > 0) {
 477             return parentsCount;
 478         }
 479     }
 480     return 0;
 481 }
 482
 483 QSet<KUrl> KFileItemModel::expandedDirectories() const
 484 {
 485     return m_expandedDirs.values().toSet();
 486 }
 487
 488 void KFileItemModel::restoreExpandedDirectories(const QSet<KUrl>& urls)
 489 {
 490     m_urlsToExpand = urls;
 491 }
 492
 493 void KFileItemModel::expandParentDirectories(const KUrl& url)
 494 {
 495     const int pos = m_dirLister->url().path().length();
 496
 497     // Assure that each sub-path of the URL that should be
 498     // expanded is added to m_urlsToExpand. KDirLister
 499     // does not care whether the parent-URL has already been
 500     // expanded.
 501     KUrl urlToExpand = m_dirLister->url();
 502     const QStringList subDirs = url.path().mid(pos).split(QDir::separator());
 503     for (int i = 0; i < subDirs.count() - 1; ++i) {
 504         urlToExpand.addPath(subDirs.at(i));
 505         m_urlsToExpand.insert(urlToExpand);
 506     }
 507
 508     // KDirLister::open() must called at least once to trigger an initial
 509     // loading. The pending URLs that must be restored are handled
 510     // in slotCompleted().
 511     QSetIterator<KUrl> it2(m_urlsToExpand);
 512     while (it2.hasNext()) {
 513         const int idx = index(it2.next());
 514         if (idx >= 0 && !isExpanded(idx)) {
 515             setExpanded(idx, true);
 516             break;
 517         }
 518     }
 519 }
 520
 521 void KFileItemModel::setNameFilter(const QString& nameFilter)
 522 {
 523     if (m_filter.pattern() != nameFilter) {
 524         dispatchPendingItemsToInsert();
 525         m_filter.setPattern(nameFilter);
 526         applyFilters();
 527     }
 528 }
 529
 530 QString KFileItemModel::nameFilter() const
 531 {
 532     return m_filter.pattern();
 533 }
 534
 535 void KFileItemModel::setMimeTypeFilters(const QStringList& filters)
 536 {
 537     if (m_filter.mimeTypes() != filters) {
 538         dispatchPendingItemsToInsert();
 539         m_filter.setMimeTypes(filters);
 540         applyFilters();
 541     }
 542 }
 543
 544 QStringList KFileItemModel::mimeTypeFilters() const
 545 {
 546     return m_filter.mimeTypes();
 547 }
 548
 549
 550 void KFileItemModel::applyFilters()
 551 {
 552     // Check which shown items from m_itemData must get
 553     // hidden and hence moved to m_filteredItems.
 554     KFileItemList newFilteredItems;
 555
 556     foreach (ItemData* itemData, m_itemData) {
 557         // Only filter non-expanded items as child items may never
 558         // exist without a parent item
 559         if (!itemData->values.value("isExpanded").toBool()) {
 560             const KFileItem item = itemData->item;
 561             if (!m_filter.matches(item)) {
 562                 newFilteredItems.append(item);
 563                 m_filteredItems.insert(item, itemData);
 564             }
 565         }
 566     }
 567
 568     removeItems(newFilteredItems, KeepItemData);
 569
 570     // Check which hidden items from m_filteredItems should
 571     // get visible again and hence removed from m_filteredItems.
 572     QList<ItemData*> newVisibleItems;
 573
 574     QHash<KFileItem, ItemData*>::iterator it = m_filteredItems.begin();
 575     while (it != m_filteredItems.end()) {
 576         if (m_filter.matches(it.key())) {
 577             newVisibleItems.append(it.value());
 578             it = m_filteredItems.erase(it);
 579         } else {
 580             ++it;
 581         }
 582     }
 583
 584     insertItems(newVisibleItems);
 585 }
 586
 587 void KFileItemModel::removeFilteredChildren(const KFileItemList& parentsList)
 588 {
 589     if (m_filteredItems.isEmpty()) {
 590         return;
 591     }
 592
 593     // First, we put the parent items into a set to provide fast lookup
 594     // while iterating over m_filteredItems and prevent quadratic
 595     // complexity if there are N parents and N filtered items.
 596     const QSet<KFileItem> parents = parentsList.toSet();
 597
 598     QHash<KFileItem, ItemData*>::iterator it = m_filteredItems.begin();
 599     while (it != m_filteredItems.end()) {
 600         const ItemData* parent = it.value()->parent;
 601
 602         if (parent && parents.contains(parent->item)) {
 603             delete it.value();
 604             it = m_filteredItems.erase(it);
 605         } else {
 606             ++it;
 607         }
 608     }
 609 }
 610
 611 QList<KFileItemModel::RoleInfo> KFileItemModel::rolesInformation()
 612 {
 613     static QList<RoleInfo> rolesInfo;
 614     if (rolesInfo.isEmpty()) {
 615         int count = 0;
 616         const RoleInfoMap* map = rolesInfoMap(count);
 617         for (int i = 0; i < count; ++i) {
 618             if (map[i].roleType != NoRole) {
 619                 RoleInfo info;
 620                 info.role = map[i].role;
 621                 info.translation = i18nc(map[i].roleTranslationContext, map[i].roleTranslation);
 622                 if (map[i].groupTranslation) {
 623                     info.group = i18nc(map[i].groupTranslationContext, map[i].groupTranslation);
 624                 } else {
 625                     // For top level roles, groupTranslation is 0. We must make sure that
 626                     // info.group is an empty string then because the code that generates
 627                     // menus tries to put the actions into sub menus otherwise.
 628                     info.group = QString();
 629                 }
 630                 info.requiresNepomuk = map[i].requiresNepomuk;
 631                 info.requiresIndexer = map[i].requiresIndexer;
 632                 rolesInfo.append(info);
 633             }
 634         }
 635     }
 636
 637     return rolesInfo;
 638 }
 639
 640 void KFileItemModel::onGroupedSortingChanged(bool current)
 641 {
 642     Q_UNUSED(current);
 643     m_groups.clear();
 644 }
 645
 646 void KFileItemModel::onSortRoleChanged(const QByteArray& current, const QByteArray& previous)
 647 {
 648     Q_UNUSED(previous);
 649     m_sortRole = typeForRole(current);
 650
 651     if (!m_requestRole[m_sortRole]) {
 652         QSet<QByteArray> newRoles = m_roles;
 653         newRoles << current;
 654         setRoles(newRoles);
 655     }
 656
 657     resortAllItems();
 658 }
 659
 660 void KFileItemModel::onSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
 661 {
 662     Q_UNUSED(current);
 663     Q_UNUSED(previous);
 664     resortAllItems();
 665 }
 666
 667 void KFileItemModel::resortAllItems()
 668 {
 669     m_resortAllItemsTimer->stop();
 670
 671     const int itemCount = count();
 672     if (itemCount <= 0) {
 673         return;
 674     }
 675
 676 #ifdef KFILEITEMMODEL_DEBUG
 677     QElapsedTimer timer;
 678     timer.start();
 679     kDebug() << "===========================================================";
 680     kDebug() << "Resorting" << itemCount << "items";
 681 #endif
 682
 683     // Remember the order of the current URLs so
 684     // that it can be determined which indexes have
 685     // been moved because of the resorting.
 686     QList<KUrl> oldUrls;
 687     oldUrls.reserve(itemCount);
 688     foreach (const ItemData* itemData, m_itemData) {
 689         oldUrls.append(itemData->item.url());
 690     }
 691
 692     m_groups.clear();
 693     m_items.clear();
 694
 695     // Resort the items
 696     sort(m_itemData.begin(), m_itemData.end());
 697     for (int i = 0; i < itemCount; ++i) {
 698         m_items.insert(m_itemData.at(i)->item.url(), i);
 699     }
 700
 701     // Determine the indexes that have been moved
 702     QList<int> movedToIndexes;
 703     movedToIndexes.reserve(itemCount);
 704     for (int i = 0; i < itemCount; i++) {
 705         const int newIndex = m_items.value(oldUrls.at(i).url());
 706         movedToIndexes.append(newIndex);
 707     }
 708
 709     // Don't check whether items have really been moved and always emit a
 710     // itemsMoved() signal after resorting: In case of grouped items
 711     // the groups might change even if the items themselves don't change their
 712     // position. Let the receiver of the signal decide whether a check for moved
 713     // items makes sense.
 714     emit itemsMoved(KItemRange(0, itemCount), movedToIndexes);
 715
 716 #ifdef KFILEITEMMODEL_DEBUG
 717     kDebug() << "[TIME] Resorting of" << itemCount << "items:" << timer.elapsed();
 718 #endif
 719 }
 720
 721 void KFileItemModel::slotCompleted()
 722 {
 723     dispatchPendingItemsToInsert();
 724
 725     if (!m_urlsToExpand.isEmpty()) {
 726         // Try to find a URL that can be expanded.
 727         // Note that the parent folder must be expanded before any of its subfolders become visible.
 728         // Therefore, some URLs in m_restoredExpandedUrls might not be visible yet
 729         // -> we expand the first visible URL we find in m_restoredExpandedUrls.
 730         foreach (const KUrl& url, m_urlsToExpand) {
 731             const int index = m_items.value(url, -1);
 732             if (index >= 0) {
 733                 m_urlsToExpand.remove(url);
 734                 if (setExpanded(index, true)) {
 735                     // The dir lister has been triggered. This slot will be called
 736                     // again after the directory has been expanded.
 737                     return;
 738                 }
 739             }
 740         }
 741
 742         // None of the URLs in m_restoredExpandedUrls could be found in the model. This can happen
 743         // if these URLs have been deleted in the meantime.
 744         m_urlsToExpand.clear();
 745     }
 746
 747     emit directoryLoadingCompleted();
 748 }
 749
 750 void KFileItemModel::slotCanceled()
 751 {
 752     m_maximumUpdateIntervalTimer->stop();
 753     dispatchPendingItemsToInsert();
 754
 755     emit directoryLoadingCanceled();
 756 }
 757
 758 void KFileItemModel::slotItemsAdded(const KUrl& directoryUrl, const KFileItemList& items)
 759 {
 760     Q_ASSERT(!items.isEmpty());
 761
 762     KUrl parentUrl;
 763     if (m_expandedDirs.contains(directoryUrl)) {
 764         parentUrl = m_expandedDirs.value(directoryUrl);
 765     } else {
 766         parentUrl = directoryUrl;
 767         parentUrl.adjustPath(KUrl::RemoveTrailingSlash);
 768     }
 769
 770     if (m_requestRole[ExpandedParentsCountRole]) {
 771         KFileItem item = items.first();
 772
 773         // If the expanding of items is enabled, the call
 774         // dirLister->openUrl(url, KDirLister::Keep) in KFileItemModel::setExpanded()
 775         // might result in emitting the same items twice due to the Keep-parameter.
 776         // This case happens if an item gets expanded, collapsed and expanded again
 777         // before the items could be loaded for the first expansion.
 778         const int index = m_items.value(item.url(), -1);
 779         if (index >= 0) {
 780             // The items are already part of the model.
 781             return;
 782         }
 783
 784         if (directoryUrl != directory()) {
 785             // To be able to compare whether the new items may be inserted as children
 786             // of a parent item the pending items must be added to the model first.
 787             dispatchPendingItemsToInsert();
 788         }
 789
 790         // KDirLister keeps the children of items that got expanded once even if
 791         // they got collapsed again with KFileItemModel::setExpanded(false). So it must be
 792         // checked whether the parent for new items is still expanded.
 793         const int parentIndex = m_items.value(parentUrl, -1);
 794         if (parentIndex >= 0 && !m_itemData[parentIndex]->values.value("isExpanded").toBool()) {
 795             // The parent is not expanded.
 796             return;
 797         }
 798     }
 799
 800     QList<ItemData*> itemDataList = createItemDataList(parentUrl, items);
 801
 802     if (!m_filter.hasSetFilters()) {
 803         m_pendingItemsToInsert.append(itemDataList);
 804     } else {
 805         // The name or type filter is active. Hide filtered items
 806         // before inserting them into the model and remember
 807         // the filtered items in m_filteredItems.
 808         foreach (ItemData* itemData, itemDataList) {
 809             if (m_filter.matches(itemData->item)) {
 810                 m_pendingItemsToInsert.append(itemData);
 811             } else {
 812                 m_filteredItems.insert(itemData->item, itemData);
 813             }
 814         }
 815     }
 816
 817     if (useMaximumUpdateInterval() && !m_maximumUpdateIntervalTimer->isActive()) {
 818         // Assure that items get dispatched if no completed() or canceled() signal is
 819         // emitted during the maximum update interval.
 820         m_maximumUpdateIntervalTimer->start();
 821     }
 822 }
 823
 824 void KFileItemModel::slotItemsDeleted(const KFileItemList& items)
 825 {
 826     dispatchPendingItemsToInsert();
 827
 828     KFileItemList itemsToRemove = items;
 829     if (m_requestRole[ExpandedParentsCountRole]) {
 830         // Assure that removing a parent item also results in removing all children
 831         foreach (const KFileItem& item, items) {
 832             itemsToRemove.append(childItems(item));
 833         }
 834     }
 835
 836     if (!m_filteredItems.isEmpty()) {
 837         foreach (const KFileItem& item, itemsToRemove) {
 838             QHash<KFileItem, ItemData*>::iterator it = m_filteredItems.find(item);
 839             if (it != m_filteredItems.end()) {
 840                 delete it.value();
 841                 m_filteredItems.erase(it);
 842             }
 843         }
 844
 845         if (m_requestRole[ExpandedParentsCountRole]) {
 846             removeFilteredChildren(itemsToRemove);
 847         }
 848     }
 849
 850     removeItems(itemsToRemove, DeleteItemData);
 851 }
 852
 853 void KFileItemModel::slotRefreshItems(const QList<QPair<KFileItem, KFileItem> >& items)
 854 {
 855     Q_ASSERT(!items.isEmpty());
 856 #ifdef KFILEITEMMODEL_DEBUG
 857     kDebug() << "Refreshing" << items.count() << "items";
 858 #endif
 859
 860     // Get the indexes of all items that have been refreshed
 861     QList<int> indexes;
 862     indexes.reserve(items.count());
 863
 864     QSet<QByteArray> changedRoles;
 865
 866     QListIterator<QPair<KFileItem, KFileItem> > it(items);
 867     while (it.hasNext()) {
 868         const QPair<KFileItem, KFileItem>& itemPair = it.next();
 869         const KFileItem& oldItem = itemPair.first;
 870         const KFileItem& newItem = itemPair.second;
 871         const int index = m_items.value(oldItem.url(), -1);
 872         if (index >= 0) {
 873             m_itemData[index]->item = newItem;
 874
 875             // Keep old values as long as possible if they could not retrieved synchronously yet.
 876             // The update of the values will be done asynchronously by KFileItemModelRolesUpdater.
 877             QHashIterator<QByteArray, QVariant> it(retrieveData(newItem, m_itemData.at(index)->parent));
 878             QHash<QByteArray, QVariant>& values = m_itemData[index]->values;
 879             while (it.hasNext()) {
 880                 it.next();
 881                 const QByteArray& role = it.key();
 882                 if (values.value(role) != it.value()) {
 883                     values.insert(role, it.value());
 884                     changedRoles.insert(role);
 885                 }
 886             }
 887
 888             m_items.remove(oldItem.url());
 889             m_items.insert(newItem.url(), index);
 890             indexes.append(index);
 891         }
 892     }
 893
 894     // If the changed items have been created recently, they might not be in m_items yet.
 895     // In that case, the list 'indexes' might be empty.
 896     if (indexes.isEmpty()) {
 897         return;
 898     }
 899
 900     // Extract the item-ranges out of the changed indexes
 901     qSort(indexes);
 902
 903     KItemRangeList itemRangeList;
 904     int previousIndex = indexes.at(0);
 905     int rangeIndex = previousIndex;
 906     int rangeCount = 1;
 907
 908     const int maxIndex = indexes.count() - 1;
 909     for (int i = 1; i <= maxIndex; ++i) {
 910         const int currentIndex = indexes.at(i);
 911         if (currentIndex == previousIndex + 1) {
 912             ++rangeCount;
 913         } else {
 914             itemRangeList.append(KItemRange(rangeIndex, rangeCount));
 915
 916             rangeIndex = currentIndex;
 917             rangeCount = 1;
 918         }
 919         previousIndex = currentIndex;
 920     }
 921
 922     if (rangeCount > 0) {
 923         itemRangeList.append(KItemRange(rangeIndex, rangeCount));
 924     }
 925
 926     emit itemsChanged(itemRangeList, changedRoles);
 927
 928     if (changedRoles.contains(sortRole())) {
 929         resortAllItems();
 930     }
 931 }
 932
 933 void KFileItemModel::slotClear()
 934 {
 935 #ifdef KFILEITEMMODEL_DEBUG
 936     kDebug() << "Clearing all items";
 937 #endif
 938
 939     qDeleteAll(m_filteredItems.values());
 940     m_filteredItems.clear();
 941     m_groups.clear();
 942
 943     m_maximumUpdateIntervalTimer->stop();
 944     m_resortAllItemsTimer->stop();
 945
 946     qDeleteAll(m_pendingItemsToInsert);
 947     m_pendingItemsToInsert.clear();
 948
 949     const int removedCount = m_itemData.count();
 950     if (removedCount > 0) {
 951         qDeleteAll(m_itemData);
 952         m_itemData.clear();
 953         m_items.clear();
 954         emit itemsRemoved(KItemRangeList() << KItemRange(0, removedCount));
 955     }
 956
 957     m_expandedDirs.clear();
 958 }
 959
 960 void KFileItemModel::slotClear(const KUrl& url)
 961 {
 962     Q_UNUSED(url);
 963 }
 964
 965 void KFileItemModel::slotNaturalSortingChanged()
 966 {
 967     m_naturalSorting = KGlobalSettings::naturalSorting();
 968     resortAllItems();
 969 }
 970
 971 void KFileItemModel::dispatchPendingItemsToInsert()
 972 {
 973     if (!m_pendingItemsToInsert.isEmpty()) {
 974         insertItems(m_pendingItemsToInsert);
 975         m_pendingItemsToInsert.clear();
 976     }
 977 }
 978
 979 void KFileItemModel::insertItems(QList<ItemData*>& newItems)
 980 {
 981     if (newItems.isEmpty()) {
 982         return;
 983     }
 984
 985 #ifdef KFILEITEMMODEL_DEBUG
 986     QElapsedTimer timer;
 987     timer.start();
 988     kDebug() << "===========================================================";
 989     kDebug() << "Inserting" << newItems.count() << "items";
 990 #endif
 991
 992     m_groups.clear();
 993
 994     sort(newItems.begin(), newItems.end());
 995
 996 #ifdef KFILEITEMMODEL_DEBUG
 997     kDebug() << "[TIME] Sorting:" << timer.elapsed();
 998 #endif
 999
1000     KItemRangeList itemRanges;
1001     const int existingItemCount = m_itemData.count();
1002     const int newItemCount = newItems.count();
1003     const int totalItemCount = existingItemCount + newItemCount;
1004
1005     if (existingItemCount == 0) {
1006         // Optimization for the common special case that there are no
1007         // items in the model yet. Happens, e.g., when entering a folder.
1008         m_itemData = newItems;
1009         itemRanges << KItemRange(0, newItemCount);
1010     } else {
1011         m_itemData.reserve(totalItemCount);
1012         for (int i = existingItemCount; i < totalItemCount; ++i) {
1013             m_itemData.append(0);
1014         }
1015
1016         // We build the new list m_items in reverse order to minimize
1017         // the number of moves and guarantee O(N) complexity.
1018         int targetIndex = totalItemCount - 1;
1019         int sourceIndexExistingItems = existingItemCount - 1;
1020         int sourceIndexNewItems = newItemCount - 1;
1021
1022         int rangeCount = 0;
1023
1024         while (sourceIndexNewItems >= 0) {
1025             ItemData* newItem = newItems.at(sourceIndexNewItems);
1026             if (sourceIndexExistingItems >= 0 && lessThan(newItem, m_itemData.at(sourceIndexExistingItems))) {
1027                 // Move an existing item to its new position. If any new items
1028                 // are behind it, push the item range to itemRanges.
1029                 if (rangeCount > 0) {
1030                     itemRanges << KItemRange(sourceIndexExistingItems + 1, rangeCount);
1031                     rangeCount = 0;
1032                 }
1033
1034                 m_itemData[targetIndex] = m_itemData.at(sourceIndexExistingItems);
1035                 --sourceIndexExistingItems;
1036             } else {
1037                 // Insert a new item into the list.
1038                 ++rangeCount;
1039                 m_itemData[targetIndex] = newItem;
1040                 --sourceIndexNewItems;
1041             }
1042             --targetIndex;
1043         }
1044
1045         // Push the final item range to itemRanges.
1046         if (rangeCount > 0) {
1047             itemRanges << KItemRange(sourceIndexExistingItems + 1, rangeCount);
1048         }
1049
1050         // Note that itemRanges is still sorted in reverse order.
1051         std::reverse(itemRanges.begin(), itemRanges.end());
1052     }
1053
1054     // The indexes starting from the first inserted item must be adjusted.
1055     m_items.reserve(totalItemCount);
1056     for (int i = itemRanges.front().index; i < totalItemCount; ++i) {
1057         m_items.insert(m_itemData.at(i)->item.url(), i);
1058     }
1059
1060     emit itemsInserted(itemRanges);
1061
1062 #ifdef KFILEITEMMODEL_DEBUG
1063     kDebug() << "[TIME] Inserting of" << newItems.count() << "items:" << timer.elapsed();
1064 #endif
1065 }
1066
1067 static KItemRangeList sortedIndexesToKItemRangeList(const QList<int>& sortedNumbers)
1068 {
1069     if (sortedNumbers.empty()) {
1070         return KItemRangeList();
1071     }
1072
1073     KItemRangeList result;
1074
1075     QList<int>::const_iterator it = sortedNumbers.begin();
1076     int index = *it;
1077     int count = 1;
1078
1079     ++it;
1080
1081     QList<int>::const_iterator end = sortedNumbers.end();
1082     while (it != end) {
1083         if (*it == index + count) {
1084             ++count;
1085         } else {
1086             result << KItemRange(index, count);
1087             index = *it;
1088             count = 1;
1089         }
1090         ++it;
1091     }
1092
1093     result << KItemRange(index, count);
1094     return result;
1095 }
1096
1097 void KFileItemModel::removeItems(const KFileItemList& items, RemoveItemsBehavior behavior)
1098 {
1099 #ifdef KFILEITEMMODEL_DEBUG
1100     kDebug() << "Removing " << items.count() << "items";
1101 #endif
1102
1103     m_groups.clear();
1104
1105     // Step 1: Determine the indexes of the removed items, remove them from
1106     //         the hash m_items, and free the ItemData.
1107     QList<int> indexesToRemove;
1108     indexesToRemove.reserve(items.count());
1109     foreach (const KFileItem& item, items) {
1110         const KUrl url = item.url();
1111         const int index = m_items.value(url, -1);
1112         if (index >= 0) {
1113             indexesToRemove.append(index);
1114
1115             // Prevent repeated expensive rehashing by using QHash::erase(),
1116             // rather than QHash::remove().
1117             QHash<KUrl, int>::iterator it = m_items.find(url);
1118             m_items.erase(it);
1119
1120             if (behavior == DeleteItemData) {
1121                 delete m_itemData.at(index);
1122             }
1123
1124             m_itemData[index] = 0;
1125         }
1126     }
1127
1128     if (indexesToRemove.isEmpty()) {
1129         return;
1130     }
1131
1132     std::sort(indexesToRemove.begin(), indexesToRemove.end());
1133
1134     // Step 2: Remove the ItemData pointers from the list m_itemData.
1135     const KItemRangeList itemRanges = sortedIndexesToKItemRangeList(indexesToRemove);
1136     int target = itemRanges.at(0).index;
1137     int source = itemRanges.at(0).index + itemRanges.at(0).count;
1138     int nextRange = 1;
1139
1140     const int oldItemDataCount = m_itemData.count();
1141     while (source < oldItemDataCount) {
1142         m_itemData[target] = m_itemData[source];
1143         ++target;
1144         ++source;
1145
1146         if (nextRange < itemRanges.count() && source == itemRanges.at(nextRange).index) {
1147             // Skip the items in the next removed range.
1148             source += itemRanges.at(nextRange).count;
1149             ++nextRange;
1150         }
1151     }
1152
1153     m_itemData.erase(m_itemData.end() - indexesToRemove.count(), m_itemData.end());
1154
1155     // Step 3: Adjust indexes in the hash m_items, starting from the
1156     //         index of the first removed item.
1157     const int newItemDataCount = m_itemData.count();
1158     for (int i = itemRanges.front().index; i < newItemDataCount; ++i) {
1159         m_items.insert(m_itemData.at(i)->item.url(), i);
1160     }
1161
1162     emit itemsRemoved(itemRanges);
1163 }
1164
1165 QList<KFileItemModel::ItemData*> KFileItemModel::createItemDataList(const KUrl& parentUrl, const KFileItemList& items) const
1166 {
1167     if (m_sortRole == TypeRole) {
1168         // Try to resolve the MIME-types synchronously to prevent a reordering of
1169         // the items when sorting by type (per default MIME-types are resolved
1170         // asynchronously by KFileItemModelRolesUpdater).
1171         determineMimeTypes(items, 200);
1172     }
1173
1174     const int parentIndex = m_items.value(parentUrl, -1);
1175     ItemData* parentItem = parentIndex < 0 ? 0 : m_itemData.at(parentIndex);
1176
1177     QList<ItemData*> itemDataList;
1178     itemDataList.reserve(items.count());
1179
1180     foreach (const KFileItem& item, items) {
1181         ItemData* itemData = new ItemData();
1182         itemData->item = item;
1183         itemData->values = retrieveData(item, parentItem);
1184         itemData->parent = parentItem;
1185         itemDataList.append(itemData);
1186     }
1187
1188     return itemDataList;
1189 }
1190
1191 void KFileItemModel::removeExpandedItems()
1192 {
1193     KFileItemList expandedItems;
1194
1195     const int maxIndex = m_itemData.count() - 1;
1196     for (int i = 0; i <= maxIndex; ++i) {
1197         const ItemData* itemData = m_itemData.at(i);
1198         if (itemData->values.value("expandedParentsCount").toInt() > 0) {
1199             expandedItems.append(itemData->item);
1200         }
1201     }
1202
1203     // The m_expandedParentsCountRoot may not get reset before all items with
1204     // a bigger count have been removed.
1205     removeItems(expandedItems, DeleteItemData);
1206
1207     m_expandedDirs.clear();
1208 }
1209
1210 void KFileItemModel::resetRoles()
1211 {
1212     for (int i = 0; i < RolesCount; ++i) {
1213         m_requestRole[i] = false;
1214     }
1215 }
1216
1217 KFileItemModel::RoleType KFileItemModel::typeForRole(const QByteArray& role) const
1218 {
1219     static QHash<QByteArray, RoleType> roles;
1220     if (roles.isEmpty()) {
1221         // Insert user visible roles that can be accessed with
1222         // KFileItemModel::roleInformation()
1223         int count = 0;
1224         const RoleInfoMap* map = rolesInfoMap(count);
1225         for (int i = 0; i < count; ++i) {
1226             roles.insert(map[i].role, map[i].roleType);
1227         }
1228
1229         // Insert internal roles (take care to synchronize the implementation
1230         // with KFileItemModel::roleForType() in case if a change is done).
1231         roles.insert("isDir", IsDirRole);
1232         roles.insert("isLink", IsLinkRole);
1233         roles.insert("isExpanded", IsExpandedRole);
1234         roles.insert("isExpandable", IsExpandableRole);
1235         roles.insert("expandedParentsCount", ExpandedParentsCountRole);
1236
1237         Q_ASSERT(roles.count() == RolesCount);
1238     }
1239
1240     return roles.value(role, NoRole);
1241 }
1242
1243 QByteArray KFileItemModel::roleForType(RoleType roleType) const
1244 {
1245     static QHash<RoleType, QByteArray> roles;
1246     if (roles.isEmpty()) {
1247         // Insert user visible roles that can be accessed with
1248         // KFileItemModel::roleInformation()
1249         int count = 0;
1250         const RoleInfoMap* map = rolesInfoMap(count);
1251         for (int i = 0; i < count; ++i) {
1252             roles.insert(map[i].roleType, map[i].role);
1253         }
1254
1255         // Insert internal roles (take care to synchronize the implementation
1256         // with KFileItemModel::typeForRole() in case if a change is done).
1257         roles.insert(IsDirRole, "isDir");
1258         roles.insert(IsLinkRole, "isLink");
1259         roles.insert(IsExpandedRole, "isExpanded");
1260         roles.insert(IsExpandableRole, "isExpandable");
1261         roles.insert(ExpandedParentsCountRole, "expandedParentsCount");
1262
1263         Q_ASSERT(roles.count() == RolesCount);
1264     };
1265
1266     return roles.value(roleType);
1267 }
1268
1269 QHash<QByteArray, QVariant> KFileItemModel::retrieveData(const KFileItem& item, const ItemData* parent) const
1270 {
1271     // It is important to insert only roles that are fast to retrieve. E.g.
1272     // KFileItem::iconName() can be very expensive if the MIME-type is unknown
1273     // and hence will be retrieved asynchronously by KFileItemModelRolesUpdater.
1274     QHash<QByteArray, QVariant> data;
1275     data.insert(sharedValue("url"), item.url());
1276
1277     const bool isDir = item.isDir();
1278     if (m_requestRole[IsDirRole]) {
1279         data.insert(sharedValue("isDir"), isDir);
1280     }
1281
1282     if (m_requestRole[IsLinkRole]) {
1283         const bool isLink = item.isLink();
1284         data.insert(sharedValue("isLink"), isLink);
1285     }
1286
1287     if (m_requestRole[NameRole]) {
1288         data.insert(sharedValue("text"), item.text());
1289     }
1290
1291     if (m_requestRole[SizeRole]) {
1292         if (isDir) {
1293             data.insert(sharedValue("size"), QVariant());
1294         } else {
1295             data.insert(sharedValue("size"), item.size());
1296         }
1297     }
1298
1299     if (m_requestRole[DateRole]) {
1300         // Don't use KFileItem::timeString() as this is too expensive when
1301         // having several thousands of items. Instead the formatting of the
1302         // date-time will be done on-demand by the view when the date will be shown.
1303         const KDateTime dateTime = item.time(KFileItem::ModificationTime);
1304         data.insert(sharedValue("date"), dateTime.dateTime());
1305     }
1306
1307     if (m_requestRole[PermissionsRole]) {
1308         data.insert(sharedValue("permissions"), item.permissionsString());
1309     }
1310
1311     if (m_requestRole[OwnerRole]) {
1312         data.insert(sharedValue("owner"), item.user());
1313     }
1314
1315     if (m_requestRole[GroupRole]) {
1316         data.insert(sharedValue("group"), item.group());
1317     }
1318
1319     if (m_requestRole[DestinationRole]) {
1320         QString destination = item.linkDest();
1321         if (destination.isEmpty()) {
1322             destination = QLatin1String("-");
1323         }
1324         data.insert(sharedValue("destination"), destination);
1325     }
1326
1327     if (m_requestRole[PathRole]) {
1328         QString path;
1329         if (item.url().protocol() == QLatin1String("trash")) {
1330             path = item.entry().stringValue(KIO::UDSEntry::UDS_EXTRA);
1331         } else {
1332             // For performance reasons cache the home-path in a static QString
1333             // (see QDir::homePath() for more details)
1334             static QString homePath;
1335             if (homePath.isEmpty()) {
1336                 homePath = QDir::homePath();
1337             }
1338
1339             path = item.localPath();
1340             if (path.startsWith(homePath)) {
1341                 path.replace(0, homePath.length(), QLatin1Char('~'));
1342             }
1343         }
1344
1345         const int index = path.lastIndexOf(item.text());
1346         path = path.mid(0, index - 1);
1347         data.insert(sharedValue("path"), path);
1348     }
1349
1350     if (m_requestRole[IsExpandableRole]) {
1351         data.insert(sharedValue("isExpandable"), item.isDir());
1352     }
1353
1354     if (m_requestRole[ExpandedParentsCountRole]) {
1355         int level = 0;
1356         if (parent) {
1357             level = parent->values["expandedParentsCount"].toInt() + 1;
1358         }
1359
1360         data.insert(sharedValue("expandedParentsCount"), level);
1361     }
1362
1363     if (item.isMimeTypeKnown()) {
1364         data.insert(sharedValue("iconName"), item.iconName());
1365
1366         if (m_requestRole[TypeRole]) {
1367             data.insert(sharedValue("type"), item.mimeComment());
1368         }
1369     }
1370
1371     return data;
1372 }
1373
1374 bool KFileItemModel::lessThan(const ItemData* a, const ItemData* b) const
1375 {
1376     int result = 0;
1377
1378     if (a->parent != b->parent) {
1379         const int expansionLevelA = a->values.value("expandedParentsCount").toInt();
1380         const int expansionLevelB = b->values.value("expandedParentsCount").toInt();
1381
1382         // If b has a higher expansion level than a, check if a is a parent
1383         // of b, and make sure that both expansion levels are equal otherwise.
1384         for (int i = expansionLevelB; i > expansionLevelA; --i) {
1385             if (b->parent == a) {
1386                 return true;
1387             }
1388             b = b->parent;
1389         }
1390
1391         // If a has a higher expansion level than a, check if b is a parent
1392         // of a, and make sure that both expansion levels are equal otherwise.
1393         for (int i = expansionLevelA; i > expansionLevelB; --i) {
1394             if (a->parent == b) {
1395                 return false;
1396             }
1397             a = a->parent;
1398         }
1399
1400         Q_ASSERT(a->values.value("expandedParentsCount").toInt() == b->values.value("expandedParentsCount").toInt());
1401
1402         // Compare the last parents of a and b which are different.
1403         while (a->parent != b->parent) {
1404             a = a->parent;
1405             b = b->parent;
1406         }
1407     }
1408
1409     if (m_sortDirsFirst || m_sortRole == SizeRole) {
1410         const bool isDirA = a->item.isDir();
1411         const bool isDirB = b->item.isDir();
1412         if (isDirA && !isDirB) {
1413             return true;
1414         } else if (!isDirA && isDirB) {
1415             return false;
1416         }
1417     }
1418
1419     result = sortRoleCompare(a, b);
1420
1421     return (sortOrder() == Qt::AscendingOrder) ? result < 0 : result > 0;
1422 }
1423
1424 /**
1425  * Helper class for KFileItemModel::sort().
1426  */
1427 class KFileItemModelLessThan
1428 {
1429 public:
1430     KFileItemModelLessThan(const KFileItemModel* model) :
1431         m_model(model)
1432     {
1433     }
1434
1435     bool operator()(const KFileItemModel::ItemData* a, const KFileItemModel::ItemData* b) const
1436     {
1437         return m_model->lessThan(a, b);
1438     }
1439
1440 private:
1441     const KFileItemModel* m_model;
1442 };
1443
1444 void KFileItemModel::sort(QList<KFileItemModel::ItemData*>::iterator begin,
1445                           QList<KFileItemModel::ItemData*>::iterator end) const
1446 {
1447     KFileItemModelLessThan lessThan(this);
1448
1449     if (m_sortRole == NameRole) {
1450         // Sorting by name can be expensive, in particular if natural sorting is
1451         // enabled. Use all CPU cores to speed up the sorting process.
1452         static const int numberOfThreads = QThread::idealThreadCount();
1453         parallelMergeSort(begin, end, lessThan, numberOfThreads);
1454     } else {
1455         // Sorting by other roles is quite fast. Use only one thread to prevent
1456         // problems caused by non-reentrant comparison functions, see
1457         // https://bugs.kde.org/show_bug.cgi?id=312679
1458         mergeSort(begin, end, lessThan);
1459     }
1460 }
1461
1462 int KFileItemModel::sortRoleCompare(const ItemData* a, const ItemData* b) const
1463 {
1464     const KFileItem& itemA = a->item;
1465     const KFileItem& itemB = b->item;
1466
1467     int result = 0;
1468
1469     switch (m_sortRole) {
1470     case NameRole:
1471         // The name role is handled as default fallback after the switch
1472         break;
1473
1474     case SizeRole: {
1475         if (itemA.isDir()) {
1476             // See "if (m_sortFoldersFirst || m_sortRole == SizeRole)" in KFileItemModel::lessThan():
1477             Q_ASSERT(itemB.isDir());
1478
1479             const QVariant valueA = a->values.value("size");
1480             const QVariant valueB = b->values.value("size");
1481             if (valueA.isNull() && valueB.isNull()) {
1482                 result = 0;
1483             } else if (valueA.isNull()) {
1484                 result = -1;
1485             } else if (valueB.isNull()) {
1486                 result = +1;
1487             } else {
1488                 result = valueA.toInt() - valueB.toInt();
1489             }
1490         } else {
1491             // See "if (m_sortFoldersFirst || m_sortRole == SizeRole)" in KFileItemModel::lessThan():
1492             Q_ASSERT(!itemB.isDir());
1493             const KIO::filesize_t sizeA = itemA.size();
1494             const KIO::filesize_t sizeB = itemB.size();
1495             if (sizeA > sizeB) {
1496                 result = +1;
1497             } else if (sizeA < sizeB) {
1498                 result = -1;
1499             } else {
1500                 result = 0;
1501             }
1502         }
1503         break;
1504     }
1505
1506     case DateRole: {
1507         const KDateTime dateTimeA = itemA.time(KFileItem::ModificationTime);
1508         const KDateTime dateTimeB = itemB.time(KFileItem::ModificationTime);
1509         if (dateTimeA < dateTimeB) {
1510             result = -1;
1511         } else if (dateTimeA > dateTimeB) {
1512             result = +1;
1513         }
1514         break;
1515     }
1516
1517     case RatingRole: {
1518         result = a->values.value("rating").toInt() - b->values.value("rating").toInt();
1519         break;
1520     }
1521
1522     case ImageSizeRole: {
1523         // Alway use a natural comparing to interpret the numbers of a string like
1524         // "1600 x 1200" for having a correct sorting.
1525         result = KStringHandler::naturalCompare(a->values.value("imageSize").toString(),
1526                                                 b->values.value("imageSize").toString(),
1527                                                 Qt::CaseSensitive);
1528         break;
1529     }
1530
1531     default: {
1532         const QByteArray role = roleForType(m_sortRole);
1533         result = QString::compare(a->values.value(role).toString(),
1534                                   b->values.value(role).toString());
1535         break;
1536     }
1537
1538     }
1539
1540     if (result != 0) {
1541         // The current sort role was sufficient to define an order
1542         return result;
1543     }
1544
1545     // Fallback #1: Compare the text of the items
1546     result = stringCompare(itemA.text(), itemB.text());
1547     if (result != 0) {
1548         return result;
1549     }
1550
1551     // Fallback #2: KFileItem::text() may not be unique in case UDS_DISPLAY_NAME is used
1552     result = stringCompare(itemA.name(m_caseSensitivity == Qt::CaseInsensitive),
1553                            itemB.name(m_caseSensitivity == Qt::CaseInsensitive));
1554     if (result != 0) {
1555         return result;
1556     }
1557
1558     // Fallback #3: It must be assured that the sort order is always unique even if two values have been
1559     // equal. In this case a comparison of the URL is done which is unique in all cases
1560     // within KDirLister.
1561     return QString::compare(itemA.url().url(), itemB.url().url(), Qt::CaseSensitive);
1562 }
1563
1564 int KFileItemModel::stringCompare(const QString& a, const QString& b) const
1565 {
1566     // Taken from KDirSortFilterProxyModel (kdelibs/kfile/kdirsortfilterproxymodel.*)
1567     // Copyright (C) 2006 by Peter Penz <peter.penz@gmx.at>
1568     // Copyright (C) 2006 by Dominic Battre <dominic@battre.de>
1569     // Copyright (C) 2006 by Martin Pool <mbp@canonical.com>
1570
1571     if (m_caseSensitivity == Qt::CaseInsensitive) {
1572         const int result = m_naturalSorting ? KStringHandler::naturalCompare(a, b, Qt::CaseInsensitive)
1573                                             : QString::compare(a, b, Qt::CaseInsensitive);
1574         if (result != 0) {
1575             // Only return the result, if the strings are not equal. If they are equal by a case insensitive
1576             // comparison, still a deterministic sort order is required. A case sensitive
1577             // comparison is done as fallback.
1578             return result;
1579         }
1580     }
1581
1582     return m_naturalSorting ? KStringHandler::naturalCompare(a, b, Qt::CaseSensitive)
1583                             : QString::compare(a, b, Qt::CaseSensitive);
1584 }
1585
1586 bool KFileItemModel::useMaximumUpdateInterval() const
1587 {
1588     return !m_dirLister->url().isLocalFile();
1589 }
1590
1591 static bool localeAwareLessThan(const QChar& c1, const QChar& c2)
1592 {
1593     return QString::localeAwareCompare(c1, c2) < 0;
1594 }
1595
1596 QList<QPair<int, QVariant> > KFileItemModel::nameRoleGroups() const
1597 {
1598     Q_ASSERT(!m_itemData.isEmpty());
1599
1600     const int maxIndex = count() - 1;
1601     QList<QPair<int, QVariant> > groups;
1602
1603     QString groupValue;
1604     QChar firstChar;
1605     for (int i = 0; i <= maxIndex; ++i) {
1606         if (isChildItem(i)) {
1607             continue;
1608         }
1609
1610         const QString name = m_itemData.at(i)->values.value("text").toString();
1611
1612         // Use the first character of the name as group indication
1613         QChar newFirstChar = name.at(0).toUpper();
1614         if (newFirstChar == QLatin1Char('~') && name.length() > 1) {
1615             newFirstChar = name.at(1).toUpper();
1616         }
1617
1618         if (firstChar != newFirstChar) {
1619             QString newGroupValue;
1620             if (newFirstChar.isLetter()) {
1621                 // Try to find a matching group in the range 'A' to 'Z'.
1622                 static std::vector<QChar> lettersAtoZ;
1623                 if (lettersAtoZ.empty()) {
1624                     for (char c = 'A'; c <= 'Z'; ++c) {
1625                         lettersAtoZ.push_back(QLatin1Char(c));
1626                     }
1627                 }
1628
1629                 std::vector<QChar>::iterator it = std::lower_bound(lettersAtoZ.begin(), lettersAtoZ.end(), newFirstChar, localeAwareLessThan);
1630                 if (it != lettersAtoZ.end()) {
1631                     if (localeAwareLessThan(newFirstChar, *it) && it != lettersAtoZ.begin()) {
1632                         // newFirstChar belongs to the group preceding *it.
1633                         // Example: for an umlaut 'A' in the German locale, *it would be 'B' now.
1634                         --it;
1635                     }
1636                     newGroupValue = *it;
1637                 } else {
1638                     newGroupValue = newFirstChar;
1639                 }
1640             } else if (newFirstChar >= QLatin1Char('0') && newFirstChar <= QLatin1Char('9')) {
1641                 // Apply group '0 - 9' for any name that starts with a digit
1642                 newGroupValue = i18nc("@title:group Groups that start with a digit", "0 - 9");
1643             } else {
1644                 newGroupValue = i18nc("@title:group", "Others");
1645             }
1646
1647             if (newGroupValue != groupValue) {
1648                 groupValue = newGroupValue;
1649                 groups.append(QPair<int, QVariant>(i, newGroupValue));
1650             }
1651
1652             firstChar = newFirstChar;
1653         }
1654     }
1655     return groups;
1656 }
1657
1658 QList<QPair<int, QVariant> > KFileItemModel::sizeRoleGroups() const
1659 {
1660     Q_ASSERT(!m_itemData.isEmpty());
1661
1662     const int maxIndex = count() - 1;
1663     QList<QPair<int, QVariant> > groups;
1664
1665     QString groupValue;
1666     for (int i = 0; i <= maxIndex; ++i) {
1667         if (isChildItem(i)) {
1668             continue;
1669         }
1670
1671         const KFileItem& item = m_itemData.at(i)->item;
1672         const KIO::filesize_t fileSize = !item.isNull() ? item.size() : ~0U;
1673         QString newGroupValue;
1674         if (!item.isNull() && item.isDir()) {
1675             newGroupValue = i18nc("@title:group Size", "Folders");
1676         } else if (fileSize < 5 * 1024 * 1024) {
1677             newGroupValue = i18nc("@title:group Size", "Small");
1678         } else if (fileSize < 10 * 1024 * 1024) {
1679             newGroupValue = i18nc("@title:group Size", "Medium");
1680         } else {
1681             newGroupValue = i18nc("@title:group Size", "Big");
1682         }
1683
1684         if (newGroupValue != groupValue) {
1685             groupValue = newGroupValue;
1686             groups.append(QPair<int, QVariant>(i, newGroupValue));
1687         }
1688     }
1689
1690     return groups;
1691 }
1692
1693 QList<QPair<int, QVariant> > KFileItemModel::dateRoleGroups() const
1694 {
1695     Q_ASSERT(!m_itemData.isEmpty());
1696
1697     const int maxIndex = count() - 1;
1698     QList<QPair<int, QVariant> > groups;
1699
1700     const QDate currentDate = KDateTime::currentLocalDateTime().date();
1701
1702     QDate previousModifiedDate;
1703     QString groupValue;
1704     for (int i = 0; i <= maxIndex; ++i) {
1705         if (isChildItem(i)) {
1706             continue;
1707         }
1708
1709         const KDateTime modifiedTime = m_itemData.at(i)->item.time(KFileItem::ModificationTime);
1710         const QDate modifiedDate = modifiedTime.date();
1711         if (modifiedDate == previousModifiedDate) {
1712             // The current item is in the same group as the previous item
1713             continue;
1714         }
1715         previousModifiedDate = modifiedDate;
1716
1717         const int daysDistance = modifiedDate.daysTo(currentDate);
1718
1719         QString newGroupValue;
1720         if (currentDate.year() == modifiedDate.year() && currentDate.month() == modifiedDate.month()) {
1721             switch (daysDistance / 7) {
1722             case 0:
1723                 switch (daysDistance) {
1724                 case 0:  newGroupValue = i18nc("@title:group Date", "Today"); break;
1725                 case 1:  newGroupValue = i18nc("@title:group Date", "Yesterday"); break;
1726                 default: newGroupValue = modifiedTime.toString(i18nc("@title:group The week day name: %A", "%A"));
1727                 }
1728                 break;
1729             case 1:
1730                 newGroupValue = i18nc("@title:group Date", "One Week Ago");
1731                 break;
1732             case 2:
1733                 newGroupValue = i18nc("@title:group Date", "Two Weeks Ago");
1734                 break;
1735             case 3:
1736                 newGroupValue = i18nc("@title:group Date", "Three Weeks Ago");
1737                 break;
1738             case 4:
1739             case 5:
1740                 newGroupValue = i18nc("@title:group Date", "Earlier this Month");
1741                 break;
1742             default:
1743                 Q_ASSERT(false);
1744             }
1745         } else {
1746             const QDate lastMonthDate = currentDate.addMonths(-1);
1747             if  (lastMonthDate.year() == modifiedDate.year() && lastMonthDate.month() == modifiedDate.month()) {
1748                 if (daysDistance == 1) {
1749                     newGroupValue = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Yesterday (%B, %Y)"));
1750                 } else if (daysDistance <= 7) {
1751                     newGroupValue = modifiedTime.toString(i18nc("@title:group The week day name: %A, %B is full month name in current locale, and %Y is full year number", "%A (%B, %Y)"));
1752                 } else if (daysDistance <= 7 * 2) {
1753                     newGroupValue = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "One Week Ago (%B, %Y)"));
1754                 } else if (daysDistance <= 7 * 3) {
1755                     newGroupValue = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Two Weeks Ago (%B, %Y)"));
1756                 } else if (daysDistance <= 7 * 4) {
1757                     newGroupValue = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Three Weeks Ago (%B, %Y)"));
1758                 } else {
1759                     newGroupValue = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Earlier on %B, %Y"));
1760                 }
1761             } else {
1762                 newGroupValue = modifiedTime.toString(i18nc("@title:group The month and year: %B is full month name in current locale, and %Y is full year number", "%B, %Y"));
1763             }
1764         }
1765
1766         if (newGroupValue != groupValue) {
1767             groupValue = newGroupValue;
1768             groups.append(QPair<int, QVariant>(i, newGroupValue));
1769         }
1770     }
1771
1772     return groups;
1773 }
1774
1775 QList<QPair<int, QVariant> > KFileItemModel::permissionRoleGroups() const
1776 {
1777     Q_ASSERT(!m_itemData.isEmpty());
1778
1779     const int maxIndex = count() - 1;
1780     QList<QPair<int, QVariant> > groups;
1781
1782     QString permissionsString;
1783     QString groupValue;
1784     for (int i = 0; i <= maxIndex; ++i) {
1785         if (isChildItem(i)) {
1786             continue;
1787         }
1788
1789         const ItemData* itemData = m_itemData.at(i);
1790         const QString newPermissionsString = itemData->values.value("permissions").toString();
1791         if (newPermissionsString == permissionsString) {
1792             continue;
1793         }
1794         permissionsString = newPermissionsString;
1795
1796         const QFileInfo info(itemData->item.url().pathOrUrl());
1797
1798         // Set user string
1799         QString user;
1800         if (info.permission(QFile::ReadUser)) {
1801             user = i18nc("@item:intext Access permission, concatenated", "Read, ");
1802         }
1803         if (info.permission(QFile::WriteUser)) {
1804             user += i18nc("@item:intext Access permission, concatenated", "Write, ");
1805         }
1806         if (info.permission(QFile::ExeUser)) {
1807             user += i18nc("@item:intext Access permission, concatenated", "Execute, ");
1808         }
1809         user = user.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : user.mid(0, user.count() - 2);
1810
1811         // Set group string
1812         QString group;
1813         if (info.permission(QFile::ReadGroup)) {
1814             group = i18nc("@item:intext Access permission, concatenated", "Read, ");
1815         }
1816         if (info.permission(QFile::WriteGroup)) {
1817             group += i18nc("@item:intext Access permission, concatenated", "Write, ");
1818         }
1819         if (info.permission(QFile::ExeGroup)) {
1820             group += i18nc("@item:intext Access permission, concatenated", "Execute, ");
1821         }
1822         group = group.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : group.mid(0, group.count() - 2);
1823
1824         // Set others string
1825         QString others;
1826         if (info.permission(QFile::ReadOther)) {
1827             others = i18nc("@item:intext Access permission, concatenated", "Read, ");
1828         }
1829         if (info.permission(QFile::WriteOther)) {
1830             others += i18nc("@item:intext Access permission, concatenated", "Write, ");
1831         }
1832         if (info.permission(QFile::ExeOther)) {
1833             others += i18nc("@item:intext Access permission, concatenated", "Execute, ");
1834         }
1835         others = others.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : others.mid(0, others.count() - 2);
1836
1837         const QString newGroupValue = i18nc("@title:group Files and folders by permissions", "User: %1 | Group: %2 | Others: %3", user, group, others);
1838         if (newGroupValue != groupValue) {
1839             groupValue = newGroupValue;
1840             groups.append(QPair<int, QVariant>(i, newGroupValue));
1841         }
1842     }
1843
1844     return groups;
1845 }
1846
1847 QList<QPair<int, QVariant> > KFileItemModel::ratingRoleGroups() const
1848 {
1849     Q_ASSERT(!m_itemData.isEmpty());
1850
1851     const int maxIndex = count() - 1;
1852     QList<QPair<int, QVariant> > groups;
1853
1854     int groupValue = -1;
1855     for (int i = 0; i <= maxIndex; ++i) {
1856         if (isChildItem(i)) {
1857             continue;
1858         }
1859         const int newGroupValue = m_itemData.at(i)->values.value("rating", 0).toInt();
1860         if (newGroupValue != groupValue) {
1861             groupValue = newGroupValue;
1862             groups.append(QPair<int, QVariant>(i, newGroupValue));
1863         }
1864     }
1865
1866     return groups;
1867 }
1868
1869 QList<QPair<int, QVariant> > KFileItemModel::genericStringRoleGroups(const QByteArray& role) const
1870 {
1871     Q_ASSERT(!m_itemData.isEmpty());
1872
1873     const int maxIndex = count() - 1;
1874     QList<QPair<int, QVariant> > groups;
1875
1876     bool isFirstGroupValue = true;
1877     QString groupValue;
1878     for (int i = 0; i <= maxIndex; ++i) {
1879         if (isChildItem(i)) {
1880             continue;
1881         }
1882         const QString newGroupValue = m_itemData.at(i)->values.value(role).toString();
1883         if (newGroupValue != groupValue || isFirstGroupValue) {
1884             groupValue = newGroupValue;
1885             groups.append(QPair<int, QVariant>(i, newGroupValue));
1886             isFirstGroupValue = false;
1887         }
1888     }
1889
1890     return groups;
1891 }
1892
1893 KFileItemList KFileItemModel::childItems(const KFileItem& item) const
1894 {
1895     KFileItemList items;
1896
1897     int index = m_items.value(item.url(), -1);
1898     if (index >= 0) {
1899         const int parentLevel = m_itemData.at(index)->values.value("expandedParentsCount").toInt();
1900         ++index;
1901         while (index < m_itemData.count() && m_itemData.at(index)->values.value("expandedParentsCount").toInt() > parentLevel) {
1902             items.append(m_itemData.at(index)->item);
1903             ++index;
1904         }
1905     }
1906
1907     return items;
1908 }
1909
1910 void KFileItemModel::emitSortProgress(int resolvedCount)
1911 {
1912     // Be tolerant against a resolvedCount with a wrong range.
1913     // Although there should not be a case where KFileItemModelRolesUpdater
1914     // (= caller) provides a wrong range, it is important to emit
1915     // a useful progress information even if there is an unexpected
1916     // implementation issue.
1917
1918     const int itemCount = count();
1919     if (resolvedCount >= itemCount) {
1920         m_sortingProgressPercent = -1;
1921         if (m_resortAllItemsTimer->isActive()) {
1922             m_resortAllItemsTimer->stop();
1923             resortAllItems();
1924         }
1925
1926         emit directorySortingProgress(100);
1927     } else if (itemCount > 0) {
1928         resolvedCount = qBound(0, resolvedCount, itemCount);
1929
1930         const int progress = resolvedCount * 100 / itemCount;
1931         if (m_sortingProgressPercent != progress) {
1932             m_sortingProgressPercent = progress;
1933             emit directorySortingProgress(progress);
1934         }
1935     }
1936 }
1937
1938 const KFileItemModel::RoleInfoMap* KFileItemModel::rolesInfoMap(int& count)
1939 {
1940     static const RoleInfoMap rolesInfoMap[] = {
1941     //  | role         | roleType       | role translation                                | group translation           | requires Nepomuk | requires indexer
1942         { 0,             NoRole,          0, 0,                                             0, 0,                                     false, false },
1943         { "text",        NameRole,        I18N_NOOP2_NOSTRIP("@label", "Name"),             0, 0,                                     false, false },
1944         { "size",        SizeRole,        I18N_NOOP2_NOSTRIP("@label", "Size"),             0, 0,                                     false, false },
1945         { "date",        DateRole,        I18N_NOOP2_NOSTRIP("@label", "Date"),             0, 0,                                     false, false },
1946         { "type",        TypeRole,        I18N_NOOP2_NOSTRIP("@label", "Type"),             0, 0,                                     false, false },
1947         { "rating",      RatingRole,      I18N_NOOP2_NOSTRIP("@label", "Rating"),           0, 0,                                     true,  false },
1948         { "tags",        TagsRole,        I18N_NOOP2_NOSTRIP("@label", "Tags"),             0, 0,                                     true,  false },
1949         { "comment",     CommentRole,     I18N_NOOP2_NOSTRIP("@label", "Comment"),          0, 0,                                     true,  false },
1950         { "wordCount",   WordCountRole,   I18N_NOOP2_NOSTRIP("@label", "Word Count"),       I18N_NOOP2_NOSTRIP("@label", "Document"), true,  true  },
1951         { "lineCount",   LineCountRole,   I18N_NOOP2_NOSTRIP("@label", "Line Count"),       I18N_NOOP2_NOSTRIP("@label", "Document"), true,  true  },
1952         { "imageSize",   ImageSizeRole,   I18N_NOOP2_NOSTRIP("@label", "Image Size"),       I18N_NOOP2_NOSTRIP("@label", "Image"),    true,  true  },
1953         { "orientation", OrientationRole, I18N_NOOP2_NOSTRIP("@label", "Orientation"),      I18N_NOOP2_NOSTRIP("@label", "Image"),    true,  true  },
1954         { "artist",      ArtistRole,      I18N_NOOP2_NOSTRIP("@label", "Artist"),           I18N_NOOP2_NOSTRIP("@label", "Audio"),    true,  true  },
1955         { "album",       AlbumRole,       I18N_NOOP2_NOSTRIP("@label", "Album"),            I18N_NOOP2_NOSTRIP("@label", "Audio"),    true,  true  },
1956         { "duration",    DurationRole,    I18N_NOOP2_NOSTRIP("@label", "Duration"),         I18N_NOOP2_NOSTRIP("@label", "Audio"),    true,  true  },
1957         { "track",       TrackRole,       I18N_NOOP2_NOSTRIP("@label", "Track"),            I18N_NOOP2_NOSTRIP("@label", "Audio"),    true,  true  },
1958         { "path",        PathRole,        I18N_NOOP2_NOSTRIP("@label", "Path"),             I18N_NOOP2_NOSTRIP("@label", "Other"),    false, false },
1959         { "destination", DestinationRole, I18N_NOOP2_NOSTRIP("@label", "Link Destination"), I18N_NOOP2_NOSTRIP("@label", "Other"),    false, false },
1960         { "copiedFrom",  CopiedFromRole,  I18N_NOOP2_NOSTRIP("@label", "Copied From"),      I18N_NOOP2_NOSTRIP("@label", "Other"),    true,  false },
1961         { "permissions", PermissionsRole, I18N_NOOP2_NOSTRIP("@label", "Permissions"),      I18N_NOOP2_NOSTRIP("@label", "Other"),    false, false },
1962         { "owner",       OwnerRole,       I18N_NOOP2_NOSTRIP("@label", "Owner"),            I18N_NOOP2_NOSTRIP("@label", "Other"),    false, false },
1963         { "group",       GroupRole,       I18N_NOOP2_NOSTRIP("@label", "User Group"),       I18N_NOOP2_NOSTRIP("@label", "Other"),    false, false },
1964     };
1965
1966     count = sizeof(rolesInfoMap) / sizeof(RoleInfoMap);
1967     return rolesInfoMap;
1968 }
1969
1970 void KFileItemModel::determineMimeTypes(const KFileItemList& items, int timeout)
1971 {
1972     QElapsedTimer timer;
1973     timer.start();
1974     foreach (const KFileItem& item, items) { // krazy:exclude=foreach
1975         item.determineMimeType();
1976         if (timer.elapsed() > timeout) {
1977             // Don't block the user interface, let the remaining items
1978             // be resolved asynchronously.
1979             return;
1980         }
1981     }
1982 }
1983
1984 QByteArray KFileItemModel::sharedValue(const QByteArray& value)
1985 {
1986     static QSet<QByteArray> pool;
1987     const QSet<QByteArray>::const_iterator it = pool.constFind(value);
1988
1989     if (it != pool.constEnd()) {
1990         return *it;
1991     } else {
1992         pool.insert(value);
1993         return value;
1994     }
1995 }
1996
1997 bool KFileItemModel::isConsistent() const
1998 {
1999     if (m_items.count() != m_itemData.count()) {
2000         return false;
2001     }
2002
2003     for (int i = 0; i < count(); ++i) {
2004         // Check if m_items and m_itemData are consistent.
2005         const KFileItem item = fileItem(i);
2006         if (item.isNull()) {
2007             qWarning() << "Item" << i << "is null";
2008             return false;
2009         }
2010
2011         const int itemIndex = index(item);
2012         if (itemIndex != i) {
2013             qWarning() << "Item" << i << "has a wrong index:" << itemIndex;
2014             return false;
2015         }
2016
2017         // Check if the items are sorted correctly.
2018         if (i > 0 && !lessThan(m_itemData.at(i - 1), m_itemData.at(i))) {
2019             qWarning() << "The order of items" << i - 1 << "and" << i << "is wrong:"
2020                 << fileItem(i - 1) << fileItem(i);
2021             return false;
2022         }
2023
2024         // Check if all parent-child relationships are consistent.
2025         const ItemData* data = m_itemData.at(i);
2026         const ItemData* parent = data->parent;
2027         if (parent) {
2028             if (data->values.value("expandedParentsCount").toInt() != parent->values.value("expandedParentsCount").toInt() + 1) {
2029                 qWarning() << "expandedParentsCount is inconsistent for parent" << parent->item << "and child" << data->item;
2030                 return false;
2031             }
2032
2033             const int parentIndex = index(parent->item);
2034             if (parentIndex >= i) {
2035                 qWarning() << "Index" << parentIndex << "of parent" << parent->item << "is not smaller than index" << i << "of child" << data->item;
2036                 return false;
2037             }
2038         }
2039     }
2040
2041     return true;
2042 }
2043
2044 #include "kfileitemmodel.moc"