src/kitemviews/kfileitemmodel.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  18  ***************************************************************************/
  19
  20 #include "kfileitemmodel.h"
  21
  22 #include <KDirLister>
  23 #include <KDirModel>
  24 #include <KLocale>
  25 #include <KStringHandler>
  26 #include <KDebug>
  27
  28 #include <QMimeData>
  29 #include <QTimer>
  30
  31 #define KFILEITEMMODEL_DEBUG
  32
  33 KFileItemModel::KFileItemModel(KDirLister* dirLister, QObject* parent) :
  34     KItemModelBase("name", parent),
  35     m_dirLister(dirLister),
  36     m_naturalSorting(true),
  37     m_sortFoldersFirst(true),
  38     m_sortRole(NameRole),
  39     m_roles(),
  40     m_caseSensitivity(Qt::CaseInsensitive),
  41     m_itemData(),
  42     m_items(),
  43     m_requestRole(),
  44     m_minimumUpdateIntervalTimer(0),
  45     m_maximumUpdateIntervalTimer(0),
  46     m_resortAllItemsTimer(0),
  47     m_pendingItemsToInsert(),
  48     m_pendingEmitLoadingCompleted(false),
  49     m_groups(),
  50     m_rootExpansionLevel(-1),
  51     m_expandedUrls(),
  52     m_restoredExpandedUrls()
  53 {
  54     // Apply default roles that should be determined
  55     resetRoles();
  56     m_requestRole[NameRole] = true;
  57     m_requestRole[IsDirRole] = true;
  58     m_roles.insert("name");
  59     m_roles.insert("isDir");
  60
  61     Q_ASSERT(dirLister);
  62
  63     connect(dirLister, SIGNAL(canceled()), this, SLOT(slotCanceled()));
  64     connect(dirLister, SIGNAL(completed()), this, SLOT(slotCompleted()));
  65     connect(dirLister, SIGNAL(newItems(KFileItemList)), this, SLOT(slotNewItems(KFileItemList)));
  66     connect(dirLister, SIGNAL(itemsDeleted(KFileItemList)), this, SLOT(slotItemsDeleted(KFileItemList)));
  67     connect(dirLister, SIGNAL(refreshItems(QList<QPair<KFileItem,KFileItem> >)), this, SLOT(slotRefreshItems(QList<QPair<KFileItem,KFileItem> >)));
  68     connect(dirLister, SIGNAL(clear()), this, SLOT(slotClear()));
  69     connect(dirLister, SIGNAL(clear(KUrl)), this, SLOT(slotClear(KUrl)));
  70
  71     // Although the layout engine of KItemListView is fast it is very inefficient to e.g.
  72     // emit 50 itemsInserted()-signals each 100 ms. m_minimumUpdateIntervalTimer assures that updates
  73     // are done in 1 second intervals for equal operations.
  74     m_minimumUpdateIntervalTimer = new QTimer(this);
  75     m_minimumUpdateIntervalTimer->setInterval(1000);
  76     m_minimumUpdateIntervalTimer->setSingleShot(true);
  77     connect(m_minimumUpdateIntervalTimer, SIGNAL(timeout()), this, SLOT(dispatchPendingItemsToInsert()));
  78
  79     // For slow KIO-slaves like used for searching it makes sense to show results periodically even
  80     // before the completed() or canceled() signal has been emitted.
  81     m_maximumUpdateIntervalTimer = new QTimer(this);
  82     m_maximumUpdateIntervalTimer->setInterval(2000);
  83     m_maximumUpdateIntervalTimer->setSingleShot(true);
  84     connect(m_maximumUpdateIntervalTimer, SIGNAL(timeout()), this, SLOT(dispatchPendingItemsToInsert()));
  85
  86     // When changing the value of an item which represents the sort-role a resorting must be
  87     // triggered. Especially in combination with KFileItemModelRolesUpdater this might be done
  88     // for a lot of items within a quite small timeslot. To prevent expensive resortings the
  89     // resorting is postponed until the timer has been exceeded.
  90     m_resortAllItemsTimer = new QTimer(this);
  91     m_resortAllItemsTimer->setInterval(500);
  92     m_resortAllItemsTimer->setSingleShot(true);
  93     connect(m_resortAllItemsTimer, SIGNAL(timeout()), this, SLOT(resortAllItems()));
  94
  95     Q_ASSERT(m_minimumUpdateIntervalTimer->interval() <= m_maximumUpdateIntervalTimer->interval());
  96 }
  97
  98 KFileItemModel::~KFileItemModel()
  99 {
 100     qDeleteAll(m_itemData);
 101     m_itemData.clear();
 102 }
 103
 104 int KFileItemModel::count() const
 105 {
 106     return m_itemData.count();
 107 }
 108
 109 QHash<QByteArray, QVariant> KFileItemModel::data(int index) const
 110 {
 111     if (index >= 0 && index < count()) {
 112         return m_itemData.at(index)->values;
 113     }
 114     return QHash<QByteArray, QVariant>();
 115 }
 116
 117 bool KFileItemModel::setData(int index, const QHash<QByteArray, QVariant>& values)
 118 {
 119     if (index < 0 || index >= count()) {
 120         return false;
 121     }
 122
 123     QHash<QByteArray, QVariant> currentValues = m_itemData.at(index)->values;
 124
 125     // Determine which roles have been changed
 126     QSet<QByteArray> changedRoles;
 127     QHashIterator<QByteArray, QVariant> it(values);
 128     while (it.hasNext()) {
 129         it.next();
 130         const QByteArray role = it.key();
 131         const QVariant value = it.value();
 132
 133         if (currentValues[role] != value) {
 134             currentValues[role] = value;
 135             changedRoles.insert(role);
 136         }
 137     }
 138
 139     if (changedRoles.isEmpty()) {
 140         return false;
 141     }
 142
 143     m_itemData[index]->values = currentValues;
 144     emit itemsChanged(KItemRangeList() << KItemRange(index, 1), changedRoles);
 145
 146     if (changedRoles.contains(sortRole())) {
 147         m_resortAllItemsTimer->start();
 148     }
 149
 150     return true;
 151 }
 152
 153 void KFileItemModel::setSortFoldersFirst(bool foldersFirst)
 154 {
 155     if (foldersFirst != m_sortFoldersFirst) {
 156         m_sortFoldersFirst = foldersFirst;
 157         resortAllItems();
 158     }
 159 }
 160
 161 bool KFileItemModel::sortFoldersFirst() const
 162 {
 163     return m_sortFoldersFirst;
 164 }
 165
 166 QMimeData* KFileItemModel::createMimeData(const QSet<int>& indexes) const
 167 {
 168     QMimeData* data = new QMimeData();
 169
 170     // The following code has been taken from KDirModel::mimeData()
 171     // (kdelibs/kio/kio/kdirmodel.cpp)
 172     // Copyright (C) 2006 David Faure <faure@kde.org>
 173     KUrl::List urls;
 174     KUrl::List mostLocalUrls;
 175     bool canUseMostLocalUrls = true;
 176
 177     QSetIterator<int> it(indexes);
 178     while (it.hasNext()) {
 179         const int index = it.next();
 180         const KFileItem item = fileItem(index);
 181         if (!item.isNull()) {
 182             urls << item.url();
 183
 184             bool isLocal;
 185             mostLocalUrls << item.mostLocalUrl(isLocal);
 186             if (!isLocal) {
 187                 canUseMostLocalUrls = false;
 188             }
 189         }
 190     }
 191
 192     const bool different = canUseMostLocalUrls && mostLocalUrls != urls;
 193     urls = KDirModel::simplifiedUrlList(urls); // TODO: Check if we still need KDirModel for this in KDE 5.0
 194     if (different) {
 195         mostLocalUrls = KDirModel::simplifiedUrlList(mostLocalUrls);
 196         urls.populateMimeData(mostLocalUrls, data);
 197     } else {
 198         urls.populateMimeData(data);
 199     }
 200
 201     return data;
 202 }
 203
 204 int KFileItemModel::indexForKeyboardSearch(const QString& text, int startFromIndex) const
 205 {
 206     startFromIndex = qMax(0, startFromIndex);
 207     for (int i = startFromIndex; i < count(); ++i) {
 208         if (data(i)["name"].toString().startsWith(text, Qt::CaseInsensitive)) {
 209             return i;
 210         }
 211     }
 212     for (int i = 0; i < startFromIndex; ++i) {
 213         if (data(i)["name"].toString().startsWith(text, Qt::CaseInsensitive)) {
 214             return i;
 215         }
 216     }
 217     return -1;
 218 }
 219
 220 bool KFileItemModel::supportsDropping(int index) const
 221 {
 222     const KFileItem item = fileItem(index);
 223     return item.isNull() ? false : item.isDir();
 224 }
 225
 226 QString KFileItemModel::roleDescription(const QByteArray& role) const
 227 {
 228     QString descr;
 229
 230     switch (roleIndex(role)) {
 231     case NameRole:           descr = i18nc("@item:intable", "Name"); break;
 232     case SizeRole:           descr = i18nc("@item:intable", "Size"); break;
 233     case DateRole:           descr = i18nc("@item:intable", "Date"); break;
 234     case PermissionsRole:    descr = i18nc("@item:intable", "Permissions"); break;
 235     case OwnerRole:          descr = i18nc("@item:intable", "Owner"); break;
 236     case GroupRole:          descr = i18nc("@item:intable", "Group"); break;
 237     case TypeRole:           descr = i18nc("@item:intable", "Type"); break;
 238     case DestinationRole:    descr = i18nc("@item:intable", "Destination"); break;
 239     case PathRole:           descr = i18nc("@item:intable", "Path"); break;
 240     case CommentRole:        descr = i18nc("@item:intable", "Comment"); break;
 241     case TagsRole:           descr = i18nc("@item:intable", "Tags"); break;
 242     case RatingRole:         descr = i18nc("@item:intable", "Rating"); break;
 243     case NoRole:             break;
 244     case IsDirRole:          break;
 245     case IsExpandedRole:     break;
 246     case ExpansionLevelRole: break;
 247     default:                 Q_ASSERT(false); break;
 248     }
 249
 250     return descr;
 251 }
 252
 253 QList<QPair<int, QVariant> > KFileItemModel::groups() const
 254 {
 255     if (!m_itemData.isEmpty() && m_groups.isEmpty()) {
 256 #ifdef KFILEITEMMODEL_DEBUG
 257         QElapsedTimer timer;
 258         timer.start();
 259 #endif
 260         switch (roleIndex(sortRole())) {
 261         case NameRole:           m_groups = nameRoleGroups(); break;
 262         case SizeRole:           m_groups = sizeRoleGroups(); break;
 263         case DateRole:           m_groups = dateRoleGroups(); break;
 264         case PermissionsRole:    m_groups = permissionRoleGroups(); break;
 265         case OwnerRole:          m_groups = genericStringRoleGroups("owner"); break;
 266         case GroupRole:          m_groups = genericStringRoleGroups("group"); break;
 267         case TypeRole:           m_groups = genericStringRoleGroups("type"); break;
 268         case DestinationRole:    m_groups = genericStringRoleGroups("destination"); break;
 269         case PathRole:           m_groups = genericStringRoleGroups("path"); break;
 270         case CommentRole:        m_groups = genericStringRoleGroups("comment"); break;
 271         case TagsRole:           m_groups = genericStringRoleGroups("tags"); break;
 272         case RatingRole:         m_groups = ratingRoleGroups(); break;
 273         case NoRole:             break;
 274         case IsDirRole:          break;
 275         case IsExpandedRole:     break;
 276         case ExpansionLevelRole: break;
 277         default:                 Q_ASSERT(false); break;
 278         }
 279
 280 #ifdef KFILEITEMMODEL_DEBUG
 281         kDebug() << "[TIME] Calculating groups for" << count() << "items:" << timer.elapsed();
 282 #endif
 283     }
 284
 285     return m_groups;
 286 }
 287
 288 KFileItem KFileItemModel::fileItem(int index) const
 289 {
 290     if (index >= 0 && index < count()) {
 291         return m_itemData.at(index)->item;
 292     }
 293
 294     return KFileItem();
 295 }
 296
 297 KFileItem KFileItemModel::fileItem(const KUrl& url) const
 298 {
 299     const int index = m_items.value(url, -1);
 300     if (index >= 0) {
 301         return m_itemData.at(index)->item;
 302     }
 303     return KFileItem();
 304 }
 305
 306 int KFileItemModel::index(const KFileItem& item) const
 307 {
 308     if (item.isNull()) {
 309         return -1;
 310     }
 311
 312     return m_items.value(item.url(), -1);
 313 }
 314
 315 int KFileItemModel::index(const KUrl& url) const
 316 {
 317     KUrl urlToFind = url;
 318     urlToFind.adjustPath(KUrl::RemoveTrailingSlash);
 319     return m_items.value(urlToFind, -1);
 320 }
 321
 322 KFileItem KFileItemModel::rootItem() const
 323 {
 324     const KDirLister* dirLister = m_dirLister.data();
 325     if (dirLister) {
 326         return dirLister->rootItem();
 327     }
 328     return KFileItem();
 329 }
 330
 331 void KFileItemModel::clear()
 332 {
 333     slotClear();
 334 }
 335
 336 void KFileItemModel::setRoles(const QSet<QByteArray>& roles)
 337 {
 338     m_roles = roles;
 339
 340     if (count() > 0) {
 341         const bool supportedExpanding = m_requestRole[IsExpandedRole] && m_requestRole[ExpansionLevelRole];
 342         const bool willSupportExpanding = roles.contains("isExpanded") && roles.contains("expansionLevel");
 343         if (supportedExpanding && !willSupportExpanding) {
 344             // No expanding is supported anymore. Take care to delete all items that have an expansion level
 345             // that is not 0 (and hence are part of an expanded item).
 346             removeExpandedItems();
 347         }
 348     }
 349
 350     resetRoles();
 351
 352     QSetIterator<QByteArray> it(roles);
 353     while (it.hasNext()) {
 354         const QByteArray& role = it.next();
 355         m_requestRole[roleIndex(role)] = true;
 356     }
 357
 358     if (count() > 0) {
 359         // Update m_data with the changed requested roles
 360         const int maxIndex = count() - 1;
 361         for (int i = 0; i <= maxIndex; ++i) {
 362             m_itemData[i]->values = retrieveData(m_itemData.at(i)->item);
 363         }
 364
 365         kWarning() << "TODO: Emitting itemsChanged() with no information what has changed!";
 366         emit itemsChanged(KItemRangeList() << KItemRange(0, count()), QSet<QByteArray>());
 367     }
 368 }
 369
 370 QSet<QByteArray> KFileItemModel::roles() const
 371 {
 372     return m_roles;
 373 }
 374
 375 bool KFileItemModel::setExpanded(int index, bool expanded)
 376 {
 377     if (isExpanded(index) == expanded || index < 0 || index >= count()) {
 378         return false;
 379     }
 380
 381     QHash<QByteArray, QVariant> values;
 382     values.insert("isExpanded", expanded);
 383     if (!setData(index, values)) {
 384         return false;
 385     }
 386
 387     const KUrl url = m_itemData.at(index)->item.url();
 388     if (expanded) {
 389         m_expandedUrls.insert(url);
 390
 391         KDirLister* dirLister = m_dirLister.data();
 392         if (dirLister) {
 393             dirLister->openUrl(url, KDirLister::Keep);
 394             return true;
 395         }
 396     } else {
 397         m_expandedUrls.remove(url);
 398
 399         KFileItemList itemsToRemove;
 400         const int expansionLevel = data(index)["expansionLevel"].toInt();
 401         ++index;
 402         while (index < count() && data(index)["expansionLevel"].toInt() > expansionLevel) {
 403             itemsToRemove.append(m_itemData.at(index)->item);
 404             ++index;
 405         }
 406         removeItems(itemsToRemove);
 407         return true;
 408     }
 409
 410     return false;
 411 }
 412
 413 bool KFileItemModel::isExpanded(int index) const
 414 {
 415     if (index >= 0 && index < count()) {
 416         return m_itemData.at(index)->values.value("isExpanded").toBool();
 417     }
 418     return false;
 419 }
 420
 421 bool KFileItemModel::isExpandable(int index) const
 422 {
 423     if (index >= 0 && index < count()) {
 424         return m_itemData.at(index)->item.isDir();
 425     }
 426     return false;
 427 }
 428
 429 QSet<KUrl> KFileItemModel::expandedUrls() const
 430 {
 431     return m_expandedUrls;
 432 }
 433
 434 void KFileItemModel::restoreExpandedUrls(const QSet<KUrl>& urls)
 435 {
 436     m_restoredExpandedUrls = urls;
 437 }
 438
 439 void KFileItemModel::onGroupedSortingChanged(bool current)
 440 {
 441     Q_UNUSED(current);
 442     m_groups.clear();
 443 }
 444
 445 void KFileItemModel::onSortRoleChanged(const QByteArray& current, const QByteArray& previous)
 446 {
 447     Q_UNUSED(previous);
 448     m_sortRole = roleIndex(current);
 449
 450 #ifdef KFILEITEMMODEL_DEBUG
 451     if (!m_requestRole[m_sortRole]) {
 452         kWarning() << "The sort-role has been changed to a role that has not been received yet";
 453     }
 454 #endif
 455
 456     resortAllItems();
 457 }
 458
 459 void KFileItemModel::onSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous)
 460 {
 461     Q_UNUSED(current);
 462     Q_UNUSED(previous);
 463     resortAllItems();
 464 }
 465
 466 void KFileItemModel::resortAllItems()
 467 {
 468     m_resortAllItemsTimer->stop();
 469
 470     const int itemCount = count();
 471     if (itemCount <= 0) {
 472         return;
 473     }
 474
 475 #ifdef KFILEITEMMODEL_DEBUG
 476     QElapsedTimer timer;
 477     timer.start();
 478     kDebug() << "===========================================================";
 479     kDebug() << "Resorting" << itemCount << "items";
 480 #endif
 481
 482     // Remember the order of the current URLs so
 483     // that it can be determined which indexes have
 484     // been moved because of the resorting.
 485     QList<KUrl> oldUrls;
 486     oldUrls.reserve(itemCount);
 487     foreach (const ItemData* itemData, m_itemData) {
 488         oldUrls.append(itemData->item.url());
 489     }
 490
 491     m_groups.clear();
 492     m_items.clear();
 493
 494     // Resort the items
 495     sort(m_itemData.begin(), m_itemData.end());
 496     for (int i = 0; i < itemCount; ++i) {
 497         m_items.insert(m_itemData.at(i)->item.url(), i);
 498     }
 499
 500     // Determine the indexes that have been moved
 501     bool emitItemsMoved = false;
 502     QList<int> movedToIndexes;
 503     movedToIndexes.reserve(itemCount);
 504     for (int i = 0; i < itemCount; i++) {
 505         const int newIndex = m_items.value(oldUrls.at(i).url());
 506         movedToIndexes.append(newIndex);
 507         if (!emitItemsMoved && newIndex != i) {
 508             emitItemsMoved = true;
 509         }
 510     }
 511
 512     if (emitItemsMoved) {
 513         emit itemsMoved(KItemRange(0, itemCount), movedToIndexes);
 514     }
 515
 516 #ifdef KFILEITEMMODEL_DEBUG
 517     kDebug() << "[TIME] Resorting of" << itemCount << "items:" << timer.elapsed();
 518 #endif
 519 }
 520
 521 void KFileItemModel::slotCompleted()
 522 {
 523     if (m_restoredExpandedUrls.isEmpty() && m_minimumUpdateIntervalTimer->isActive()) {
 524         // dispatchPendingItems() will be called when the timer
 525         // has been expired.
 526         m_pendingEmitLoadingCompleted = true;
 527         return;
 528     }
 529
 530     m_pendingEmitLoadingCompleted = false;
 531     dispatchPendingItemsToInsert();
 532
 533     if (!m_restoredExpandedUrls.isEmpty()) {
 534         // Try to find a URL that can be expanded.
 535         // Note that the parent folder must be expanded before any of its subfolders become visible.
 536         // Therefore, some URLs in m_restoredExpandedUrls might not be visible yet
 537         // -> we expand the first visible URL we find in m_restoredExpandedUrls.
 538         foreach(const KUrl& url, m_restoredExpandedUrls) {
 539             const int index = m_items.value(url, -1);
 540             if (index >= 0) {
 541                 // We have found an expandable URL. Expand it and return - when
 542                 // the dir lister has finished, this slot will be called again.
 543                 m_restoredExpandedUrls.remove(url);
 544                 setExpanded(index, true);
 545                 return;
 546             }
 547         }
 548
 549         // None of the URLs in m_restoredExpandedUrls could be found in the model. This can happen
 550         // if these URLs have been deleted in the meantime.
 551         m_restoredExpandedUrls.clear();
 552     }
 553
 554     emit loadingCompleted();
 555     m_minimumUpdateIntervalTimer->start();
 556 }
 557
 558 void KFileItemModel::slotCanceled()
 559 {
 560     m_minimumUpdateIntervalTimer->stop();
 561     m_maximumUpdateIntervalTimer->stop();
 562     dispatchPendingItemsToInsert();
 563 }
 564
 565 void KFileItemModel::slotNewItems(const KFileItemList& items)
 566 {
 567     m_pendingItemsToInsert.append(items);
 568
 569     if (useMaximumUpdateInterval() && !m_maximumUpdateIntervalTimer->isActive()) {
 570         // Assure that items get dispatched if no completed() or canceled() signal is
 571         // emitted during the maximum update interval.
 572         m_maximumUpdateIntervalTimer->start();
 573     }
 574 }
 575
 576 void KFileItemModel::slotItemsDeleted(const KFileItemList& items)
 577 {
 578     if (!m_pendingItemsToInsert.isEmpty()) {
 579         insertItems(m_pendingItemsToInsert);
 580         m_pendingItemsToInsert.clear();
 581     }
 582     removeItems(items);
 583 }
 584
 585 void KFileItemModel::slotRefreshItems(const QList<QPair<KFileItem, KFileItem> >& items)
 586 {
 587     Q_ASSERT(!items.isEmpty());
 588 #ifdef KFILEITEMMODEL_DEBUG
 589     kDebug() << "Refreshing" << items.count() << "items";
 590 #endif
 591
 592     m_groups.clear();
 593
 594     // Get the indexes of all items that have been refreshed
 595     QList<int> indexes;
 596     indexes.reserve(items.count());
 597
 598     QListIterator<QPair<KFileItem, KFileItem> > it(items);
 599     while (it.hasNext()) {
 600         const QPair<KFileItem, KFileItem>& itemPair = it.next();
 601         const int index = m_items.value(itemPair.second.url(), -1);
 602         if (index >= 0) {
 603             indexes.append(index);
 604         }
 605     }
 606
 607     // If the changed items have been created recently, they might not be in m_items yet.
 608     // In that case, the list 'indexes' might be empty.
 609     if (indexes.isEmpty()) {
 610         return;
 611     }
 612
 613     // Extract the item-ranges out of the changed indexes
 614     qSort(indexes);
 615
 616     KItemRangeList itemRangeList;
 617     int rangeIndex = 0;
 618     int rangeCount = 1;
 619     int previousIndex = indexes.at(0);
 620
 621     const int maxIndex = indexes.count() - 1;
 622     for (int i = 1; i <= maxIndex; ++i) {
 623         const int currentIndex = indexes.at(i);
 624         if (currentIndex == previousIndex + 1) {
 625             ++rangeCount;
 626         } else {
 627             itemRangeList.append(KItemRange(rangeIndex, rangeCount));
 628
 629             rangeIndex = currentIndex;
 630             rangeCount = 1;
 631         }
 632         previousIndex = currentIndex;
 633     }
 634
 635     if (rangeCount > 0) {
 636         itemRangeList.append(KItemRange(rangeIndex, rangeCount));
 637     }
 638
 639     emit itemsChanged(itemRangeList, QSet<QByteArray>());
 640 }
 641
 642 void KFileItemModel::slotClear()
 643 {
 644 #ifdef KFILEITEMMODEL_DEBUG
 645     kDebug() << "Clearing all items";
 646 #endif
 647
 648     m_groups.clear();
 649
 650     m_minimumUpdateIntervalTimer->stop();
 651     m_maximumUpdateIntervalTimer->stop();
 652     m_resortAllItemsTimer->stop();
 653     m_pendingItemsToInsert.clear();
 654
 655     m_rootExpansionLevel = -1;
 656
 657     const int removedCount = m_itemData.count();
 658     if (removedCount > 0) {
 659         qDeleteAll(m_itemData);
 660         m_itemData.clear();
 661         m_items.clear();
 662         emit itemsRemoved(KItemRangeList() << KItemRange(0, removedCount));
 663     }
 664
 665     m_expandedUrls.clear();
 666 }
 667
 668 void KFileItemModel::slotClear(const KUrl& url)
 669 {
 670     Q_UNUSED(url);
 671 }
 672
 673 void KFileItemModel::dispatchPendingItemsToInsert()
 674 {
 675     if (!m_pendingItemsToInsert.isEmpty()) {
 676         insertItems(m_pendingItemsToInsert);
 677         m_pendingItemsToInsert.clear();
 678     }
 679
 680     if (m_pendingEmitLoadingCompleted) {
 681         emit loadingCompleted();
 682     }
 683 }
 684
 685 void KFileItemModel::insertItems(const KFileItemList& items)
 686 {
 687     if (items.isEmpty()) {
 688         return;
 689     }
 690
 691 #ifdef KFILEITEMMODEL_DEBUG
 692     QElapsedTimer timer;
 693     timer.start();
 694     kDebug() << "===========================================================";
 695     kDebug() << "Inserting" << items.count() << "items";
 696 #endif
 697
 698     m_groups.clear();
 699
 700     QList<ItemData*> sortedItems = createItemDataList(items);
 701     sort(sortedItems.begin(), sortedItems.end());
 702
 703 #ifdef KFILEITEMMODEL_DEBUG
 704     kDebug() << "[TIME] Sorting:" << timer.elapsed();
 705 #endif
 706
 707     KItemRangeList itemRanges;
 708     int targetIndex = 0;
 709     int sourceIndex = 0;
 710     int insertedAtIndex = -1;        // Index for the current item-range
 711     int insertedCount = 0;           // Count for the current item-range
 712     int previouslyInsertedCount = 0; // Sum of previously inserted items for all ranges
 713     while (sourceIndex < sortedItems.count()) {
 714         // Find target index from m_items to insert the current item
 715         // in a sorted order
 716         const int previousTargetIndex = targetIndex;
 717         while (targetIndex < m_itemData.count()) {
 718             if (!lessThan(m_itemData.at(targetIndex), sortedItems.at(sourceIndex))) {
 719                 break;
 720             }
 721             ++targetIndex;
 722         }
 723
 724         if (targetIndex - previousTargetIndex > 0 && insertedAtIndex >= 0) {
 725             itemRanges << KItemRange(insertedAtIndex, insertedCount);
 726             previouslyInsertedCount += insertedCount;
 727             insertedAtIndex = targetIndex - previouslyInsertedCount;
 728             insertedCount = 0;
 729         }
 730
 731         // Insert item at the position targetIndex by transfering
 732         // the ownership of the item-data from sortedItems to m_itemData.
 733         // m_items will be inserted after the loop (see comment below)
 734         m_itemData.insert(targetIndex, sortedItems.at(sourceIndex));
 735         ++insertedCount;
 736
 737         if (insertedAtIndex < 0) {
 738             insertedAtIndex = targetIndex;
 739             Q_ASSERT(previouslyInsertedCount == 0);
 740         }
 741         ++targetIndex;
 742         ++sourceIndex;
 743     }
 744
 745     // The indexes of all m_items must be adjusted, not only the index
 746     // of the new items
 747     const int itemDataCount = m_itemData.count();
 748     for (int i = 0; i < itemDataCount; ++i) {
 749         m_items.insert(m_itemData.at(i)->item.url(), i);
 750     }
 751
 752     itemRanges << KItemRange(insertedAtIndex, insertedCount);
 753     emit itemsInserted(itemRanges);
 754
 755 #ifdef KFILEITEMMODEL_DEBUG
 756     kDebug() << "[TIME] Inserting of" << items.count() << "items:" << timer.elapsed();
 757 #endif
 758 }
 759
 760 void KFileItemModel::removeItems(const KFileItemList& items)
 761 {
 762     if (items.isEmpty()) {
 763         return;
 764     }
 765
 766 #ifdef KFILEITEMMODEL_DEBUG
 767     kDebug() << "Removing " << items.count() << "items";
 768 #endif
 769
 770     m_groups.clear();
 771
 772     QList<ItemData*> sortedItems = createItemDataList(items);
 773     sort(sortedItems.begin(), sortedItems.end());
 774
 775     QList<int> indexesToRemove;
 776     indexesToRemove.reserve(items.count());
 777
 778     // Calculate the item ranges that will get deleted
 779     KItemRangeList itemRanges;
 780     int removedAtIndex = -1;
 781     int removedCount = 0;
 782     int targetIndex = 0;
 783     foreach (const ItemData* itemData, sortedItems) {
 784         const KFileItem& itemToRemove = itemData->item;
 785
 786         const int previousTargetIndex = targetIndex;
 787         while (targetIndex < m_itemData.count()) {
 788             if (m_itemData.at(targetIndex)->item.url() == itemToRemove.url()) {
 789                 break;
 790             }
 791             ++targetIndex;
 792         }
 793         if (targetIndex >= m_itemData.count()) {
 794             kWarning() << "Item that should be deleted has not been found!";
 795             return;
 796         }
 797
 798         if (targetIndex - previousTargetIndex > 0 && removedAtIndex >= 0) {
 799             itemRanges << KItemRange(removedAtIndex, removedCount);
 800             removedAtIndex = targetIndex;
 801             removedCount = 0;
 802         }
 803
 804         indexesToRemove.append(targetIndex);
 805         if (removedAtIndex < 0) {
 806             removedAtIndex = targetIndex;
 807         }
 808         ++removedCount;
 809         ++targetIndex;
 810     }
 811     qDeleteAll(sortedItems);
 812     sortedItems.clear();
 813
 814     // Delete the items
 815     for (int i = indexesToRemove.count() - 1; i >= 0; --i) {
 816         const int indexToRemove = indexesToRemove.at(i);
 817         delete m_itemData.at(indexToRemove);
 818         m_itemData.removeAt(indexToRemove);
 819     }
 820
 821     // The indexes of all m_items must be adjusted, not only the index
 822     // of the removed items
 823     const int itemDataCount = m_itemData.count();
 824     for (int i = 0; i < itemDataCount; ++i) {
 825         m_items.insert(m_itemData.at(i)->item.url(), i);
 826     }
 827
 828     if (count() <= 0) {
 829         m_rootExpansionLevel = -1;
 830     }
 831
 832     itemRanges << KItemRange(removedAtIndex, removedCount);
 833     emit itemsRemoved(itemRanges);
 834 }
 835
 836 QList<KFileItemModel::ItemData*> KFileItemModel::createItemDataList(const KFileItemList& items) const
 837 {
 838     QList<ItemData*> itemDataList;
 839     itemDataList.reserve(items.count());
 840
 841     foreach (const KFileItem& item, items) {
 842         ItemData* itemData = new ItemData();
 843         itemData->item = item;
 844         itemData->values = retrieveData(item);
 845         itemDataList.append(itemData);
 846     }
 847
 848     return itemDataList;
 849 }
 850
 851 void KFileItemModel::removeExpandedItems()
 852 {
 853     KFileItemList expandedItems;
 854
 855     const int maxIndex = m_itemData.count() - 1;
 856     for (int i = 0; i <= maxIndex; ++i) {
 857         const ItemData* itemData = m_itemData.at(i);
 858         if (itemData->values.value("expansionLevel").toInt() > 0) {
 859             expandedItems.append(itemData->item);
 860         }
 861     }
 862
 863     // The m_rootExpansionLevel may not get reset before all items with
 864     // a bigger expansionLevel have been removed.
 865     Q_ASSERT(m_rootExpansionLevel >= 0);
 866     removeItems(expandedItems);
 867
 868     m_rootExpansionLevel = -1;
 869     m_expandedUrls.clear();
 870 }
 871
 872 void KFileItemModel::resetRoles()
 873 {
 874     for (int i = 0; i < RolesCount; ++i) {
 875         m_requestRole[i] = false;
 876     }
 877 }
 878
 879 KFileItemModel::Role KFileItemModel::roleIndex(const QByteArray& role) const
 880 {
 881     static QHash<QByteArray, Role> rolesHash;
 882     if (rolesHash.isEmpty()) {
 883         rolesHash.insert("name", NameRole);
 884         rolesHash.insert("size", SizeRole);
 885         rolesHash.insert("date", DateRole);
 886         rolesHash.insert("permissions", PermissionsRole);
 887         rolesHash.insert("owner", OwnerRole);
 888         rolesHash.insert("group", GroupRole);
 889         rolesHash.insert("type", TypeRole);
 890         rolesHash.insert("destination", DestinationRole);
 891         rolesHash.insert("path", PathRole);
 892         rolesHash.insert("comment", CommentRole);
 893         rolesHash.insert("tags", TagsRole);
 894         rolesHash.insert("rating", RatingRole);
 895         rolesHash.insert("isDir", IsDirRole);
 896         rolesHash.insert("isExpanded", IsExpandedRole);
 897         rolesHash.insert("expansionLevel", ExpansionLevelRole);
 898     }
 899     return rolesHash.value(role, NoRole);
 900 }
 901
 902 QHash<QByteArray, QVariant> KFileItemModel::retrieveData(const KFileItem& item) const
 903 {
 904     // It is important to insert only roles that are fast to retrieve. E.g.
 905     // KFileItem::iconName() can be very expensive if the MIME-type is unknown
 906     // and hence will be retrieved asynchronously by KFileItemModelRolesUpdater.
 907     QHash<QByteArray, QVariant> data;
 908     data.insert("iconPixmap", QPixmap());
 909
 910     const bool isDir = item.isDir();
 911     if (m_requestRole[IsDirRole]) {
 912         data.insert("isDir", isDir);
 913     }
 914
 915     if (m_requestRole[NameRole]) {
 916         data.insert("name", item.name());
 917     }
 918
 919     if (m_requestRole[SizeRole]) {
 920         if (isDir) {
 921             data.insert("size", QVariant());
 922         } else {
 923             data.insert("size", item.size());
 924         }
 925     }
 926
 927     if (m_requestRole[DateRole]) {
 928         // Don't use KFileItem::timeString() as this is too expensive when
 929         // having several thousands of items. Instead the formatting of the
 930         // date-time will be done on-demand by the view when the date will be shown.
 931         const KDateTime dateTime = item.time(KFileItem::ModificationTime);
 932         data.insert("date", dateTime.dateTime());
 933     }
 934
 935     if (m_requestRole[PermissionsRole]) {
 936         data.insert("permissions", item.permissionsString());
 937     }
 938
 939     if (m_requestRole[OwnerRole]) {
 940         data.insert("owner", item.user());
 941     }
 942
 943     if (m_requestRole[GroupRole]) {
 944         data.insert("group", item.group());
 945     }
 946
 947     if (m_requestRole[DestinationRole]) {
 948         QString destination = item.linkDest();
 949         if (destination.isEmpty()) {
 950             destination = i18nc("@item:intable", "No destination");
 951         }
 952         data.insert("destination", destination);
 953     }
 954
 955     if (m_requestRole[PathRole]) {
 956         data.insert("path", item.localPath());
 957     }
 958
 959     if (m_requestRole[IsExpandedRole]) {
 960         data.insert("isExpanded", false);
 961     }
 962
 963     if (m_requestRole[ExpansionLevelRole]) {
 964         if (m_rootExpansionLevel < 0 && m_dirLister.data()) {
 965             const QString rootDir = m_dirLister.data()->url().directory(KUrl::AppendTrailingSlash);
 966             m_rootExpansionLevel = rootDir.count('/');
 967             if (m_rootExpansionLevel == 1) {
 968                 // Special case: The root is already reached and no parent is available
 969                 --m_rootExpansionLevel;
 970             }
 971         }
 972         const QString dir = item.url().directory(KUrl::AppendTrailingSlash);
 973         const int level = dir.count('/') - m_rootExpansionLevel - 1;
 974         data.insert("expansionLevel", level);
 975     }
 976
 977     if (item.isMimeTypeKnown()) {
 978         data.insert("iconName", item.iconName());
 979
 980         if (m_requestRole[TypeRole]) {
 981             data.insert("type", item.mimeComment());
 982         }
 983     }
 984
 985     return data;
 986 }
 987
 988 bool KFileItemModel::lessThan(const ItemData* a, const ItemData* b) const
 989 {
 990     const KFileItem& itemA = a->item;
 991     const KFileItem& itemB = b->item;
 992
 993     int result = 0;
 994
 995     if (m_rootExpansionLevel >= 0) {
 996         result = expansionLevelsCompare(itemA, itemB);
 997         if (result != 0) {
 998             // The items have parents with different expansion levels
 999             return (sortOrder() == Qt::AscendingOrder) ? result < 0 : result > 0;
1000         }
1001     }
1002
1003     if (m_sortFoldersFirst || m_sortRole == SizeRole) {
1004         const bool isDirA = itemA.isDir();
1005         const bool isDirB = itemB.isDir();
1006         if (isDirA && !isDirB) {
1007             return true;
1008         } else if (!isDirA && isDirB) {
1009             return false;
1010         }
1011     }
1012
1013     switch (m_sortRole) {
1014     case NameRole: {
1015         result = stringCompare(itemA.text(), itemB.text());
1016         if (result == 0) {
1017             // KFileItem::text() may not be unique in case UDS_DISPLAY_NAME is used
1018             result = stringCompare(itemA.name(m_caseSensitivity == Qt::CaseInsensitive),
1019                                    itemB.name(m_caseSensitivity == Qt::CaseInsensitive));
1020         }
1021         break;
1022     }
1023
1024     case DateRole: {
1025         const KDateTime dateTimeA = itemA.time(KFileItem::ModificationTime);
1026         const KDateTime dateTimeB = itemB.time(KFileItem::ModificationTime);
1027         if (dateTimeA < dateTimeB) {
1028             result = -1;
1029         } else if (dateTimeA > dateTimeB) {
1030             result = +1;
1031         }
1032         break;
1033     }
1034
1035     case SizeRole: {
1036         if (itemA.isDir()) {
1037             Q_ASSERT(itemB.isDir()); // see "if (m_sortFoldersFirst || m_sortRole == SizeRole)" above
1038
1039             const QVariant valueA = a->values.value("size");
1040             const QVariant valueB = b->values.value("size");
1041
1042             if (valueA.isNull()) {
1043                 result = -1;
1044             } else if (valueB.isNull()) {
1045                 result = +1;
1046             } else {
1047                 result = valueA.value<KIO::filesize_t>() - valueB.value<KIO::filesize_t>();
1048             }
1049         } else {
1050             Q_ASSERT(!itemB.isDir()); // see "if (m_sortFoldersFirst || m_sortRole == SizeRole)" above
1051             result = itemA.size() - itemB.size();
1052         }
1053         break;
1054     }
1055
1056     case TypeRole: {
1057         result = QString::compare(a->values.value("type").toString(),
1058                                   b->values.value("type").toString());
1059         break;
1060     }
1061
1062     case CommentRole: {
1063         result = QString::compare(a->values.value("comment").toString(),
1064                                   b->values.value("comment").toString());
1065         break;
1066     }
1067
1068     case TagsRole: {
1069         result = QString::compare(a->values.value("tags").toString(),
1070                                   b->values.value("tags").toString());
1071         break;
1072     }
1073
1074     case RatingRole: {
1075         result = a->values.value("rating").toInt() - b->values.value("rating").toInt();
1076         break;
1077     }
1078
1079     default:
1080         break;
1081     }
1082
1083     if (result == 0) {
1084         // It must be assured that the sort order is always unique even if two values have been
1085         // equal. In this case a comparison of the URL is done which is unique in all cases
1086         // within KDirLister.
1087         result = QString::compare(itemA.url().url(), itemB.url().url(), Qt::CaseSensitive);
1088     }
1089
1090     return (sortOrder() == Qt::AscendingOrder) ? result < 0 : result > 0;
1091 }
1092
1093 void KFileItemModel::sort(QList<ItemData*>::iterator begin,
1094                           QList<ItemData*>::iterator end)
1095 {
1096     // The implementation is based on qStableSortHelper() from qalgorithms.h
1097     // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
1098     // In opposite to qStableSort() it allows to use a member-function for the comparison of elements.
1099
1100     const int span = end - begin;
1101     if (span < 2) {
1102         return;
1103     }
1104
1105     const QList<ItemData*>::iterator middle = begin + span / 2;
1106     sort(begin, middle);
1107     sort(middle, end);
1108     merge(begin, middle, end);
1109 }
1110
1111 void KFileItemModel::merge(QList<ItemData*>::iterator begin,
1112                            QList<ItemData*>::iterator pivot,
1113                            QList<ItemData*>::iterator end)
1114 {
1115     // The implementation is based on qMerge() from qalgorithms.h
1116     // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
1117
1118     const int len1 = pivot - begin;
1119     const int len2 = end - pivot;
1120
1121     if (len1 == 0 || len2 == 0) {
1122         return;
1123     }
1124
1125     if (len1 + len2 == 2) {
1126         if (lessThan(*(begin + 1), *(begin))) {
1127             qSwap(*begin, *(begin + 1));
1128         }
1129         return;
1130     }
1131
1132     QList<ItemData*>::iterator firstCut;
1133     QList<ItemData*>::iterator secondCut;
1134     int len2Half;
1135     if (len1 > len2) {
1136         const int len1Half = len1 / 2;
1137         firstCut = begin + len1Half;
1138         secondCut = lowerBound(pivot, end, *firstCut);
1139         len2Half = secondCut - pivot;
1140     } else {
1141         len2Half = len2 / 2;
1142         secondCut = pivot + len2Half;
1143         firstCut = upperBound(begin, pivot, *secondCut);
1144     }
1145
1146     reverse(firstCut, pivot);
1147     reverse(pivot, secondCut);
1148     reverse(firstCut, secondCut);
1149
1150     const QList<ItemData*>::iterator newPivot = firstCut + len2Half;
1151     merge(begin, firstCut, newPivot);
1152     merge(newPivot, secondCut, end);
1153 }
1154
1155 QList<KFileItemModel::ItemData*>::iterator KFileItemModel::lowerBound(QList<ItemData*>::iterator begin,
1156                                                                       QList<ItemData*>::iterator end,
1157                                                                       const ItemData* value)
1158 {
1159     // The implementation is based on qLowerBound() from qalgorithms.h
1160     // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
1161
1162     QList<ItemData*>::iterator middle;
1163     int n = int(end - begin);
1164     int half;
1165
1166     while (n > 0) {
1167         half = n >> 1;
1168         middle = begin + half;
1169         if (lessThan(*middle, value)) {
1170             begin = middle + 1;
1171             n -= half + 1;
1172         } else {
1173             n = half;
1174         }
1175     }
1176     return begin;
1177 }
1178
1179 QList<KFileItemModel::ItemData*>::iterator KFileItemModel::upperBound(QList<ItemData*>::iterator begin,
1180                                                                       QList<ItemData*>::iterator end,
1181                                                                       const ItemData* value)
1182 {
1183     // The implementation is based on qUpperBound() from qalgorithms.h
1184     // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
1185
1186     QList<ItemData*>::iterator middle;
1187     int n = end - begin;
1188     int half;
1189
1190     while (n > 0) {
1191         half = n >> 1;
1192         middle = begin + half;
1193         if (lessThan(value, *middle)) {
1194             n = half;
1195         } else {
1196             begin = middle + 1;
1197             n -= half + 1;
1198         }
1199     }
1200     return begin;
1201 }
1202
1203 void KFileItemModel::reverse(QList<ItemData*>::iterator begin,
1204                              QList<ItemData*>::iterator end)
1205 {
1206     // The implementation is based on qReverse() from qalgorithms.h
1207     // Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
1208
1209     --end;
1210     while (begin < end) {
1211         qSwap(*begin++, *end--);
1212     }
1213 }
1214
1215 int KFileItemModel::stringCompare(const QString& a, const QString& b) const
1216 {
1217     // Taken from KDirSortFilterProxyModel (kdelibs/kfile/kdirsortfilterproxymodel.*)
1218     // Copyright (C) 2006 by Peter Penz <peter.penz@gmx.at>
1219     // Copyright (C) 2006 by Dominic Battre <dominic@battre.de>
1220     // Copyright (C) 2006 by Martin Pool <mbp@canonical.com>
1221
1222     if (m_caseSensitivity == Qt::CaseInsensitive) {
1223         const int result = m_naturalSorting ? KStringHandler::naturalCompare(a, b, Qt::CaseInsensitive)
1224                                             : QString::compare(a, b, Qt::CaseInsensitive);
1225         if (result != 0) {
1226             // Only return the result, if the strings are not equal. If they are equal by a case insensitive
1227             // comparison, still a deterministic sort order is required. A case sensitive
1228             // comparison is done as fallback.
1229             return result;
1230         }
1231     }
1232
1233     return m_naturalSorting ? KStringHandler::naturalCompare(a, b, Qt::CaseSensitive)
1234                             : QString::compare(a, b, Qt::CaseSensitive);
1235 }
1236
1237 int KFileItemModel::expansionLevelsCompare(const KFileItem& a, const KFileItem& b) const
1238 {
1239     const KUrl urlA = a.url();
1240     const KUrl urlB = b.url();
1241     if (urlA.directory() == urlB.directory()) {
1242         // Both items have the same directory as parent
1243         return 0;
1244     }
1245
1246     // Check whether one item is the parent of the other item
1247     if (urlA.isParentOf(urlB)) {
1248         return -1;
1249     } else if (urlB.isParentOf(urlA)) {
1250         return +1;
1251     }
1252
1253     // Determine the maximum common path of both items and
1254     // remember the index in 'index'
1255     const QString pathA = urlA.path();
1256     const QString pathB = urlB.path();
1257
1258     const int maxIndex = qMin(pathA.length(), pathB.length()) - 1;
1259     int index = 0;
1260     while (index <= maxIndex && pathA.at(index) == pathB.at(index)) {
1261         ++index;
1262     }
1263     if (index > maxIndex) {
1264         index = maxIndex;
1265     }
1266     while ((pathA.at(index) != QLatin1Char('/') || pathB.at(index) != QLatin1Char('/')) && index > 0) {
1267         --index;
1268     }
1269
1270     // Determine the first sub-path after the common path and
1271     // check whether it represents a directory or already a file
1272     bool isDirA = true;
1273     const QString subPathA = subPath(a, pathA, index, &isDirA);
1274     bool isDirB = true;
1275     const QString subPathB = subPath(b, pathB, index, &isDirB);
1276
1277     if (isDirA && !isDirB) {
1278         return -1;
1279     } else if (!isDirA && isDirB) {
1280         return +1;
1281     }
1282
1283     return stringCompare(subPathA, subPathB);
1284 }
1285
1286 QString KFileItemModel::subPath(const KFileItem& item,
1287                                 const QString& itemPath,
1288                                 int start,
1289                                 bool* isDir) const
1290 {
1291     Q_ASSERT(isDir);
1292     const int pathIndex = itemPath.indexOf('/', start + 1);
1293     *isDir = (pathIndex > 0) || item.isDir();
1294     return itemPath.mid(start, pathIndex - start);
1295 }
1296
1297 bool KFileItemModel::useMaximumUpdateInterval() const
1298 {
1299     const KDirLister* dirLister = m_dirLister.data();
1300     return dirLister && !dirLister->url().isLocalFile();
1301 }
1302
1303 QList<QPair<int, QVariant> > KFileItemModel::nameRoleGroups() const
1304 {
1305     Q_ASSERT(!m_itemData.isEmpty());
1306
1307     const int maxIndex = count() - 1;
1308     QList<QPair<int, QVariant> > groups;
1309
1310     QString groupValue;
1311     QChar firstChar;
1312     bool isLetter = false;
1313     for (int i = 0; i <= maxIndex; ++i) {
1314         if (isChildItem(i)) {
1315             continue;
1316         }
1317
1318         const QString name = m_itemData.at(i)->values.value("name").toString();
1319
1320         // Use the first character of the name as group indication
1321         QChar newFirstChar = name.at(0).toUpper();
1322         if (newFirstChar == QLatin1Char('~') && name.length() > 1) {
1323             newFirstChar = name.at(1);
1324         }
1325
1326         if (firstChar != newFirstChar) {
1327             QString newGroupValue;
1328             if (newFirstChar >= QLatin1Char('A') && newFirstChar <= QLatin1Char('Z')) {
1329                 // Apply group 'A' - 'Z'
1330                 newGroupValue = newFirstChar;
1331                 isLetter = true;
1332             } else if (newFirstChar >= QLatin1Char('0') && newFirstChar <= QLatin1Char('9')) {
1333                 // Apply group '0 - 9' for any name that starts with a digit
1334                 newGroupValue = i18nc("@title:group Groups that start with a digit", "0 - 9");
1335                 isLetter = false;
1336             } else {
1337                 if (isLetter) {
1338                     // If the current group is 'A' - 'Z' check whether a locale character
1339                     // fits into the existing group.
1340                     // TODO: This does not work in the case if e.g. the group 'O' starts with
1341                     // an umlaut 'O' -> provide unit-test to document this known issue
1342                     const QChar prevChar(firstChar.unicode() - ushort(1));
1343                     const QChar nextChar(firstChar.unicode() + ushort(1));
1344                     const QString currChar(newFirstChar);
1345                     const bool partOfCurrentGroup = currChar.localeAwareCompare(prevChar) > 0 &&
1346                                                     currChar.localeAwareCompare(nextChar) < 0;
1347                     if (partOfCurrentGroup) {
1348                         continue;
1349                     }
1350                 }
1351                 newGroupValue = i18nc("@title:group", "Others");
1352                 isLetter = false;
1353             }
1354
1355             if (newGroupValue != groupValue) {
1356                 groupValue = newGroupValue;
1357                 groups.append(QPair<int, QVariant>(i, newGroupValue));
1358             }
1359
1360             firstChar = newFirstChar;
1361         }
1362     }
1363     return groups;
1364 }
1365
1366 QList<QPair<int, QVariant> > KFileItemModel::sizeRoleGroups() const
1367 {
1368     Q_ASSERT(!m_itemData.isEmpty());
1369
1370     const int maxIndex = count() - 1;
1371     QList<QPair<int, QVariant> > groups;
1372
1373     QString groupValue;
1374     for (int i = 0; i <= maxIndex; ++i) {
1375         if (isChildItem(i)) {
1376             continue;
1377         }
1378
1379         const KFileItem& item = m_itemData.at(i)->item;
1380         const KIO::filesize_t fileSize = !item.isNull() ? item.size() : ~0U;
1381         QString newGroupValue;
1382         if (!item.isNull() && item.isDir()) {
1383             newGroupValue = i18nc("@title:group Size", "Folders");
1384         } else if (fileSize < 5 * 1024 * 1024) {
1385             newGroupValue = i18nc("@title:group Size", "Small");
1386         } else if (fileSize < 10 * 1024 * 1024) {
1387             newGroupValue = i18nc("@title:group Size", "Medium");
1388         } else {
1389             newGroupValue = i18nc("@title:group Size", "Big");
1390         }
1391
1392         if (newGroupValue != groupValue) {
1393             groupValue = newGroupValue;
1394             groups.append(QPair<int, QVariant>(i, newGroupValue));
1395         }
1396     }
1397
1398     return groups;
1399 }
1400
1401 QList<QPair<int, QVariant> > KFileItemModel::dateRoleGroups() const
1402 {
1403     Q_ASSERT(!m_itemData.isEmpty());
1404
1405     const int maxIndex = count() - 1;
1406     QList<QPair<int, QVariant> > groups;
1407
1408     const QDate currentDate = KDateTime::currentLocalDateTime().date();
1409
1410     int yearForCurrentWeek = 0;
1411     int currentWeek = currentDate.weekNumber(&yearForCurrentWeek);
1412     if (yearForCurrentWeek == currentDate.year() + 1) {
1413         currentWeek = 53;
1414     }
1415
1416     QDate previousModifiedDate;
1417     QString groupValue;
1418     for (int i = 0; i <= maxIndex; ++i) {
1419         if (isChildItem(i)) {
1420             continue;
1421         }
1422
1423         const KDateTime modifiedTime = m_itemData.at(i)->item.time(KFileItem::ModificationTime);
1424         const QDate modifiedDate = modifiedTime.date();
1425         if (modifiedDate == previousModifiedDate) {
1426             // The current item is in the same group as the previous item
1427             continue;
1428         }
1429         previousModifiedDate = modifiedDate;
1430
1431         const int daysDistance = modifiedDate.daysTo(currentDate);
1432
1433         int yearForModifiedWeek = 0;
1434         int modifiedWeek = modifiedDate.weekNumber(&yearForModifiedWeek);
1435         if (yearForModifiedWeek == modifiedDate.year() + 1) {
1436             modifiedWeek = 53;
1437         }
1438
1439         QString newGroupValue;
1440         if (currentDate.year() == modifiedDate.year() && currentDate.month() == modifiedDate.month()) {
1441             if (modifiedWeek > currentWeek) {
1442                 // Usecase: modified date = 2010-01-01, current date = 2010-01-22
1443                 //          modified week = 53,         current week = 3
1444                 modifiedWeek = 0;
1445             }
1446             switch (currentWeek - modifiedWeek) {
1447             case 0:
1448                 switch (daysDistance) {
1449                 case 0:  newGroupValue = i18nc("@title:group Date", "Today"); break;
1450                 case 1:  newGroupValue = i18nc("@title:group Date", "Yesterday"); break;
1451                 default: newGroupValue = modifiedTime.toString(i18nc("@title:group The week day name: %A", "%A"));
1452                 }
1453                 break;
1454             case 1:
1455                 newGroupValue = i18nc("@title:group Date", "Last Week");
1456                 break;
1457             case 2:
1458                 newGroupValue = i18nc("@title:group Date", "Two Weeks Ago");
1459                 break;
1460             case 3:
1461                 newGroupValue = i18nc("@title:group Date", "Three Weeks Ago");
1462                 break;
1463             case 4:
1464             case 5:
1465                 newGroupValue = i18nc("@title:group Date", "Earlier this Month");
1466                 break;
1467             default:
1468                 Q_ASSERT(false);
1469             }
1470         } else {
1471             const QDate lastMonthDate = currentDate.addMonths(-1);
1472             if  (lastMonthDate.year() == modifiedDate.year() && lastMonthDate.month() == modifiedDate.month()) {
1473                 if (daysDistance == 1) {
1474                     newGroupValue = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Yesterday (%B, %Y)"));
1475                 } else if (daysDistance <= 7) {
1476                     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)"));
1477                 } else if (daysDistance <= 7 * 2) {
1478                     newGroupValue = modifiedTime.toString(i18nc("@title:group Date: %B is full month name in current locale, and %Y is full year number", "Last Week (%B, %Y)"));
1479                 } else if (daysDistance <= 7 * 3) {
1480                     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)"));
1481                 } else if (daysDistance <= 7 * 4) {
1482                     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)"));
1483                 } else {
1484                     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"));
1485                 }
1486             } else {
1487                 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"));
1488             }
1489         }
1490
1491         if (newGroupValue != groupValue) {
1492             groupValue = newGroupValue;
1493             groups.append(QPair<int, QVariant>(i, newGroupValue));
1494         }
1495     }
1496
1497     return groups;
1498 }
1499
1500 QList<QPair<int, QVariant> > KFileItemModel::permissionRoleGroups() const
1501 {
1502     Q_ASSERT(!m_itemData.isEmpty());
1503
1504     const int maxIndex = count() - 1;
1505     QList<QPair<int, QVariant> > groups;
1506
1507     QString permissionsString;
1508     QString groupValue;
1509     for (int i = 0; i <= maxIndex; ++i) {
1510         if (isChildItem(i)) {
1511             continue;
1512         }
1513
1514         const ItemData* itemData = m_itemData.at(i);
1515         const QString newPermissionsString = itemData->values.value("permissions").toString();
1516         if (newPermissionsString == permissionsString) {
1517             continue;
1518         }
1519         permissionsString = newPermissionsString;
1520
1521         const QFileInfo info(itemData->item.url().pathOrUrl());
1522
1523         // Set user string
1524         QString user;
1525         if (info.permission(QFile::ReadUser)) {
1526             user = i18nc("@item:intext Access permission, concatenated", "Read, ");
1527         }
1528         if (info.permission(QFile::WriteUser)) {
1529             user += i18nc("@item:intext Access permission, concatenated", "Write, ");
1530         }
1531         if (info.permission(QFile::ExeUser)) {
1532             user += i18nc("@item:intext Access permission, concatenated", "Execute, ");
1533         }
1534         user = user.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : user.mid(0, user.count() - 2);
1535
1536         // Set group string
1537         QString group;
1538         if (info.permission(QFile::ReadGroup)) {
1539             group = i18nc("@item:intext Access permission, concatenated", "Read, ");
1540         }
1541         if (info.permission(QFile::WriteGroup)) {
1542             group += i18nc("@item:intext Access permission, concatenated", "Write, ");
1543         }
1544         if (info.permission(QFile::ExeGroup)) {
1545             group += i18nc("@item:intext Access permission, concatenated", "Execute, ");
1546         }
1547         group = group.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : group.mid(0, group.count() - 2);
1548
1549         // Set others string
1550         QString others;
1551         if (info.permission(QFile::ReadOther)) {
1552             others = i18nc("@item:intext Access permission, concatenated", "Read, ");
1553         }
1554         if (info.permission(QFile::WriteOther)) {
1555             others += i18nc("@item:intext Access permission, concatenated", "Write, ");
1556         }
1557         if (info.permission(QFile::ExeOther)) {
1558             others += i18nc("@item:intext Access permission, concatenated", "Execute, ");
1559         }
1560         others = others.isEmpty() ? i18nc("@item:intext Access permission, concatenated", "Forbidden") : others.mid(0, others.count() - 2);
1561
1562         const QString newGroupValue = i18nc("@title:group Files and folders by permissions", "User: %1 | Group: %2 | Others: %3", user, group, others);
1563         if (newGroupValue != groupValue) {
1564             groupValue = newGroupValue;
1565             groups.append(QPair<int, QVariant>(i, newGroupValue));
1566         }
1567     }
1568
1569     return groups;
1570 }
1571
1572 QList<QPair<int, QVariant> > KFileItemModel::ratingRoleGroups() const
1573 {
1574     Q_ASSERT(!m_itemData.isEmpty());
1575
1576     const int maxIndex = count() - 1;
1577     QList<QPair<int, QVariant> > groups;
1578
1579     int groupValue;
1580     for (int i = 0; i <= maxIndex; ++i) {
1581         if (isChildItem(i)) {
1582             continue;
1583         }
1584         const int newGroupValue = m_itemData.at(i)->values.value("rating").toInt();
1585         if (newGroupValue != groupValue) {
1586             groupValue = newGroupValue;
1587             groups.append(QPair<int, QVariant>(i, newGroupValue));
1588         }
1589     }
1590
1591     return groups;
1592 }
1593
1594 QList<QPair<int, QVariant> > KFileItemModel::genericStringRoleGroups(const QByteArray& role) const
1595 {
1596     Q_ASSERT(!m_itemData.isEmpty());
1597
1598     const int maxIndex = count() - 1;
1599     QList<QPair<int, QVariant> > groups;
1600
1601     QString groupValue;
1602     for (int i = 0; i <= maxIndex; ++i) {
1603         if (isChildItem(i)) {
1604             continue;
1605         }
1606         const QString newGroupValue = m_itemData.at(i)->values.value(role).toString();
1607         if (newGroupValue != groupValue) {
1608             groupValue = newGroupValue;
1609             groups.append(QPair<int, QVariant>(i, newGroupValue));
1610         }
1611     }
1612
1613     return groups;
1614 }
1615
1616 #include "kfileitemmodel.moc"