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