]> cloud.milkyroute.net Git - dolphin.git/blobdiff - src/kitemviews/kfileitemmodel.h
projects / dolphin.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge remote-tracking branch 'fork/work/zakharafoniam/useful-groups'
[dolphin.git] / src / kitemviews / kfileitemmodel.h
diff --git a/src/kitemviews/kfileitemmodel.h b/src/kitemviews/kfileitemmodel.h
index b79eec4eeb25e2859f0ff98e6859fa15f065d9f2..13554d8c7fa1999dc62e8fd355c71967096ca9e5 100644 (file)
--- a/src/kitemviews/kfileitemmodel.h
+++ b/src/kitemviews/kfileitemmodel.h
@@ -1,88 +1,119 @@
-/***************************************************************************
- *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
- ***************************************************************************/
+/*
+ * SPDX-FileCopyrightText: 2011 Peter Penz <peter.penz19@gmail.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
 
 #ifndef KFILEITEMMODEL_H
 #define KFILEITEMMODEL_H
 
 
 #ifndef KFILEITEMMODEL_H
 #define KFILEITEMMODEL_H
 
-#include <libdolphin_export.h>
-#include <KFileItemList>
-#include <KUrl>
-#include <kitemviews/kitemmodelbase.h>
+#include "dolphin_export.h"
+#include "kitemviews/kitemmodelbase.h"
+#include "kitemviews/private/kfileitemmodelfilter.h"
+
+#include <KFileItem>
+#include <KLazyLocalizedString>
 
 
+#include <QCollator>
 #include <QHash>
 #include <QHash>
+#include <QSet>
+#include <QUrl>
+
+#include <functional>
 
 class KDirLister;
 
 class KDirLister;
+
 class QTimer;
 
 class QTimer;
 
+namespace KIO
+{
+class Job;
+}
+
 /**
  * @brief KItemModelBase implementation for KFileItems.
  *
 /**
  * @brief KItemModelBase implementation for KFileItems.
  *
- * KFileItemModel is connected with one KDirLister. Each time the KDirLister
- * emits new items, removes items or changes items the model gets synchronized.
- *
- * KFileItemModel supports sorting and grouping of items. Additional roles that
- * are not part of KFileItem can be added with KFileItemModel::setData().
+ * Allows to load items of a directory. Sorting and grouping of
+ * items are supported. Roles that are not part of KFileItem can
+ * be added with KFileItemModel::setData().
  *
  *
- * Also the recursive expansion of sub-directories is supported by
+ * Recursive expansion of sub-directories is supported by
  * KFileItemModel::setExpanded().
  */
  * KFileItemModel::setExpanded().
  */
-class LIBDOLPHINPRIVATE_EXPORT KFileItemModel : public KItemModelBase
+class DOLPHIN_EXPORT KFileItemModel : public KItemModelBase
 {
     Q_OBJECT
 
 public:
 {
     Q_OBJECT
 
 public:
-    explicit KFileItemModel(KDirLister* dirLister, QObject* parent = 0);
-    virtual ~KFileItemModel();
+    explicit KFileItemModel(QObject *parent = nullptr);
+    ~KFileItemModel() override;
 
 
-    virtual int count() const;
-    virtual QHash<QByteArray, QVariant> data(int index) const;
-    virtual bool setData(int index, const QHash<QByteArray, QVariant> &values);
+    /**
+     * Loads the directory specified by \a url. The signals
+     * directoryLoadingStarted(), directoryLoadingProgress() and directoryLoadingCompleted()
+     * indicate the current state of the loading process. The items
+     * of the directory are added after the loading has been completed.
+     */
+    void loadDirectory(const QUrl &url);
 
     /**
 
     /**
-     * @return True
-     * @reimp
+     * Throws away all currently loaded items and refreshes the directory
+     * by reloading all items again.
      */
      */
-    virtual bool supportsGrouping() const;
+    void refreshDirectory(const QUrl &url);
 
     /**
 
     /**
-     * @return True
-     * @reimp
+     * @return Parent directory of the items that are shown. In case
+     *         if a directory tree is shown, KFileItemModel::dir() returns
+     *         the root-parent of all items.
+     * @see rootItem()
      */
      */
-    virtual bool supportsSorting() const;
+    QUrl directory() const override;
 
     /**
 
     /**
-     * Sets a separate sorting with folders first (true) or a mixed sorting of files and folders (false).
+     * Cancels the loading of a directory which has been started by either
+     * loadDirectory() or refreshDirectory().
      */
      */
-    void setSortFoldersFirst(bool foldersFirst);
-    bool sortFoldersFirst() const;
+    void cancelDirectoryLoading();
+
+    int count() const override;
+    QHash<QByteArray, QVariant> data(int index) const override;
+    bool setData(int index, const QHash<QByteArray, QVariant> &values) override;
+
+    /**
+     * Sets a separate sorting with directories first (true) or a mixed
+     * sorting of files and directories (false).
+     */
+    void setSortDirectoriesFirst(bool dirsFirst);
+    bool sortDirectoriesFirst() const;
+
+    /**
+     * Sets a separate sorting with hidden files and folders last (true) or not (false).
+     */
+    void setSortHiddenLast(bool hiddenLast);
+    bool sortHiddenLast() const;
+
+    void setShowHiddenFiles(bool show);
+    bool showHiddenFiles() const;
+
+    /**
+     * If set to true, only directories are shown as items of the model. Files
+     * are ignored.
+     */
+    void setShowDirectoriesOnly(bool enabled);
+    bool showDirectoriesOnly() const;
+
+    QMimeData *createMimeData(const KItemSet &indexes) const override;
+
+    int indexForKeyboardSearch(const QString &text, int startFromIndex = 0) const override;
 
 
-    /** @reimp */
-    virtual QMimeData* createMimeData(const QSet<int>& indexes) const;
+    bool supportsDropping(int index) const override;
 
 
-    /** @reimp */
-    virtual int indexForKeyboardSearch(const QString& text, int startFromIndex = 0) const;
+    bool canEnterOnHover(int index) const override;
 
 
-    /** @reimp */
-    virtual bool supportsDropping(int index) const;
+    QString roleDescription(const QByteArray &role) const override;
 
 
-    /** @reimp */
-    virtual QString roleDescription(const QByteArray& role) const;
+    QList<QPair<int, QVariant>> groups() const override;
 
     /**
      * @return The file-item for the index \a index. If the index is in a valid
 
     /**
      * @return The file-item for the index \a index. If the index is in a valid
@@ -96,17 +127,24 @@ public:
      *         URL is found KFileItem::isNull() will be true for the returned
      *         file-item. The runtime complexity of this call is O(1).
      */
      *         URL is found KFileItem::isNull() will be true for the returned
      *         file-item. The runtime complexity of this call is O(1).
      */
-    KFileItem fileItem(const KUrl& url) const;
+    KFileItem fileItem(const QUrl &url) const;
 
     /**
      * @return The index for the file-item \a item. -1 is returned if no file-item
 
     /**
      * @return The index for the file-item \a item. -1 is returned if no file-item
-     *         is found or if the file-item is null. The runtime
+     *         is found or if the file-item is null. The amortized runtime
      *         complexity of this call is O(1).
      */
      *         complexity of this call is O(1).
      */
-    int index(const KFileItem& item) const;
+    int index(const KFileItem &item) const;
 
     /**
 
     /**
-     * @return Root item of all items.
+     * @return The index for the URL \a url. -1 is returned if no file-item
+     *         is found. The amortized runtime complexity of this call is O(1).
+     */
+    int index(const QUrl &url) const;
+
+    /**
+     * @return Root item of all items representing the item
+     *         for KFileItemModel::dir().
      */
     KFileItem rootItem() const;
 
      */
     KFileItem rootItem() const;
 
@@ -115,123 +153,514 @@ public:
      */
     void clear();
 
      */
     void clear();
 
-    // TODO: "name" + "isDir" is default in ctor
-    void setRoles(const QSet<QByteArray>& roles);
+    /**
+     * Sets the roles that should be shown for each item.
+     */
+    void setRoles(const QSet<QByteArray> &roles);
     QSet<QByteArray> roles() const;
 
     QSet<QByteArray> roles() const;
 
-    bool setExpanded(int index, bool expanded);
-    bool isExpanded(int index) const;
-    bool isExpandable(int index) const;
-    QSet<KUrl> expandedUrls() const;
-    void restoreExpandedUrls(const QSet<KUrl>& urls);
+    bool setExpanded(int index, bool expanded) override;
+    bool isExpanded(int index) const override;
+    bool isExpandable(int index) const override;
+    int expandedParentsCount(int index) const override;
+
+    QSet<QUrl> expandedDirectories() const;
+
+    /**
+     * Marks the URLs in \a urls as sub-directories which were expanded previously.
+     * After calling loadDirectory() or refreshDirectory() the marked sub-directories
+     * will be expanded step-by-step.
+     */
+    void restoreExpandedDirectories(const QSet<QUrl> &urls);
+
+    /**
+     * Expands all parent-directories of the item \a url.
+     */
+    void expandParentDirectories(const QUrl &url);
+
+    void setNameFilter(const QString &nameFilter);
+    QString nameFilter() const;
+
+    void setMimeTypeFilters(const QStringList &filters);
+    QStringList mimeTypeFilters() const;
+
+    void setExcludeMimeTypeFilter(const QStringList &filters);
+    QStringList excludeMimeTypeFilter() const;
+
+    struct RoleInfo {
+        QByteArray role;
+        QString translation;
+        QString group;
+        QString tooltip;
+        bool requiresBaloo;
+        bool requiresIndexer;
+    };
 
 
-signals:
-    void loadingCompleted();
+    /**
+     * @return Provides static information for a role that is supported
+     *         by KFileItemModel. Some roles can only be determined if
+     *         Baloo is enabled and/or the Baloo indexing is enabled.
+     */
+    static RoleInfo roleInformation(const QByteArray &role);
+
+    /**
+     * @return Provides static information for all available roles that
+     *         are supported by KFileItemModel. Some roles can only be
+     *         determined if Baloo is enabled and/or the Baloo
+     *         indexing is enabled.
+     */
+    static QList<RoleInfo> rolesInformation();
+
+    /**
+     * @return Provides static information for all available grouping
+     *         behaviors supported by KFileItemModel but not directly
+     *         mapped to roles of KFileItemModel.
+     */
+    static QList<RoleInfo> extraGroupingInformation();
+
+    /** set to true to hide application/x-trash files */
+    void setShowTrashMime(bool show);
+
+Q_SIGNALS:
+    /**
+     * Is emitted if the loading of a directory has been started. It is
+     * assured that a signal directoryLoadingCompleted() will be send after
+     * the loading has been finished. For tracking the loading progress
+     * the signal directoryLoadingProgress() gets emitted in between.
+     */
+    void directoryLoadingStarted();
+
+    /**
+     * Is emitted after the loading of a directory has been completed or new
+     * items have been inserted to an already loaded directory. Usually
+     * one or more itemsInserted() signals are emitted before loadingCompleted()
+     * (the only exception is loading an empty directory, where only a
+     * loadingCompleted() signal gets emitted).
+     */
+    void directoryLoadingCompleted();
+
+    /**
+     * Is emitted when the model is being refreshed (F5 key press)
+     */
+    void directoryRefreshing();
+
+    /**
+     * Is emitted after the loading of a directory has been canceled.
+     */
+    void directoryLoadingCanceled();
+
+    /**
+     * Informs about the progress in percent when loading a directory. It is assured
+     * that the signal directoryLoadingStarted() has been emitted before.
+     */
+    void directoryLoadingProgress(int percent);
+
+    /**
+     * Is emitted if the sort-role gets resolved asynchronously and provides
+     * the progress-information of the sorting in percent. It is assured
+     * that the last sortProgress-signal contains 100 as value.
+     */
+    void directorySortingProgress(int percent);
+
+    /**
+     * Is emitted if an information message (e.g. "Connecting to host...")
+     * should be shown.
+     */
+    void infoMessage(const QString &message);
+
+    /**
+     * Is emitted if an error message (e.g. "Unknown location")
+     * should be shown.
+     */
+    void errorMessage(const QString &message, const int kioErrorCode);
+
+    /**
+     * Is emitted if a redirection from the current URL \a oldUrl
+     * to the new URL \a newUrl has been done.
+     */
+    void directoryRedirection(const QUrl &oldUrl, const QUrl &newUrl);
+
+    /**
+     * Is emitted when the URL passed by KFileItemModel::setUrl() represents a file.
+     * In this case no signal errorMessage() will be emitted.
+     */
+    void urlIsFileError(const QUrl &url);
+
+    /**
+     * It is emitted for files when they change and
+     * for dirs when files are added or removed.
+     */
+    void fileItemsChanged(const KFileItemList &changedFileItems);
+
+    /**
+     * It is emitted when the parent directory was removed.
+     */
+    void currentDirectoryRemoved();
 
 protected:
 
 protected:
-    virtual void onGroupRoleChanged(const QByteArray& current, const QByteArray& previous);
-    virtual void onSortRoleChanged(const QByteArray& current, const QByteArray& previous);
-    virtual void onSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous);
+    void onGroupedSortingChanged(bool current) override;
+    void onSortRoleChanged(const QByteArray &current, const QByteArray &previous, bool resortItems = true) override;
+    void onSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous) override;
+    void onGroupRoleChanged(const QByteArray &current, const QByteArray &previous, bool resortItems = true) override;
+    void onGroupOrderChanged(Qt::SortOrder current, Qt::SortOrder previous) override;
+
+private Q_SLOTS:
+    /**
+     * Resorts all items dependent on the set sortRole(), sortOrder(),
+     * groupRole(), groupOrder() and foldersFirst() settings.
+     */
+    void resortAllItems();
 
 
-private slots:
     void slotCompleted();
     void slotCanceled();
     void slotCompleted();
     void slotCanceled();
-    void slotNewItems(const KFileItemList& items);
-    void slotItemsDeleted(const KFileItemList& items);
-    void slotRefreshItems(const QList<QPair<KFileItem, KFileItem> >& items);
+    void slotItemsAdded(const QUrl &directoryUrl, const KFileItemList &items);
+    void slotItemsDeleted(const KFileItemList &items);
+    void slotRefreshItems(const QList<QPair<KFileItem, KFileItem>> &items);
     void slotClear();
     void slotClear();
-    void slotClear(const KUrl& url);
+    void slotSortingChoiceChanged();
+    void slotListerError(KIO::Job *job);
 
     void dispatchPendingItemsToInsert();
 
 private:
 
     void dispatchPendingItemsToInsert();
 
 private:
-    void insertItems(const KFileItemList& items);
-    void removeItems(const KFileItemList& items);
-
-    void resortAllItems();
-
-    void removeExpandedItems();
-
-    enum Role {
+    enum RoleType {
+        // User visible roles:
         NoRole,
         NameRole,
         SizeRole,
         NoRole,
         NameRole,
         SizeRole,
-        DateRole,
+        ModificationTimeRole,
+        CreationTimeRole,
+        AccessTimeRole,
         PermissionsRole,
         OwnerRole,
         GroupRole,
         TypeRole,
         PermissionsRole,
         OwnerRole,
         GroupRole,
         TypeRole,
+        ExtensionRole,
         DestinationRole,
         PathRole,
         DestinationRole,
         PathRole,
+        DeletionTimeRole,
+        // User visible roles available with Baloo:
+        CommentRole,
+        TagsRole,
+        RatingRole,
+        DimensionsRole,
+        WidthRole,
+        HeightRole,
+        ImageDateTimeRole,
+        OrientationRole,
+        PublisherRole,
+        PageCountRole,
+        WordCountRole,
+        TitleRole,
+        AuthorRole,
+        LineCountRole,
+        ArtistRole,
+        GenreRole,
+        AlbumRole,
+        DurationRole,
+        TrackRole,
+        ReleaseYearRole,
+        BitrateRole,
+        OriginUrlRole,
+        AspectRatioRole,
+        FrameRateRole,
+        // Non-visible roles:
         IsDirRole,
         IsDirRole,
+        IsLinkRole,
+        IsHiddenRole,
         IsExpandedRole,
         IsExpandedRole,
-        ExpansionLevelRole,
-        RolesCount // Mandatory last entry
+        IsExpandableRole,
+        ExpandedParentsCountRole,
+        // Mandatory last entry:
+        RolesCount
+    };
+
+    struct ItemData {
+        KFileItem item;
+        QHash<QByteArray, QVariant> values;
+        ItemData *parent;
+    };
+    
+    struct ItemGroupInfo {
+        int comparable;
+        QString text;
+
+        bool operator==(const ItemGroupInfo &other) const;
+        bool operator!=(const ItemGroupInfo &other) const;
+        bool operator<(const ItemGroupInfo &other) const;
     };
 
     };
 
+    enum RemoveItemsBehavior { KeepItemData, DeleteItemData, DeleteItemDataIfUnfiltered };
+
+    void insertItems(QList<ItemData *> &items);
+    void removeItems(const KItemRangeList &itemRanges, RemoveItemsBehavior behavior);
+
+    /**
+     * Helper method for insertItems() and removeItems(): Creates
+     * a list of ItemData elements based on the given items.
+     * Note that the ItemData instances are created dynamically and
+     * must be deleted by the caller.
+     */
+    QList<ItemData *> createItemDataList(const QUrl &parentUrl, const KFileItemList &items) const;
+
+    /**
+     * Helper method for prepareItemsForSorting(). 
+     * For a set role, fills 'values' of ItemData non-lazily.
+     */
+    void prepareItemsWithRole(QList<ItemData *> &itemDataList, RoleType roleType);
+
+    /**
+     * Prepares the items for sorting. Normally, the hash 'values' in ItemData is filled
+     * lazily to save time and memory, but for some sort roles, it is expected that the
+     * sort role data is stored in 'values'.
+     */
+    void prepareItemsForSorting(QList<ItemData *> &itemDataList);
+
+    static int expandedParentsCount(const ItemData *data);
+
+    void removeExpandedItems();
+
+    /**
+     * This function is called by setData() and slotRefreshItems(). It emits
+     * the itemsChanged() signal, checks if the sort order is still correct,
+     * and starts m_resortAllItemsTimer if that is not the case.
+     */
+    void emitItemsChangedAndTriggerResorting(const KItemRangeList &itemRanges, const QSet<QByteArray> &changedRoles);
+
+    /**
+     * Resets all values from m_requestRole to false.
+     */
     void resetRoles();
 
     void resetRoles();
 
-    Role roleIndex(const QByteArray& role) const;
+    /**
+     * @return Role-type for the given role.
+     *         Runtime complexity is O(1).
+     */
+    RoleType typeForRole(const QByteArray &role) const;
+
+    /**
+     * @return Role-byte-array for the given role-type.
+     *         Runtime complexity is O(1).
+     */
+    QByteArray roleForType(RoleType roleType) const;
+
+    QHash<QByteArray, QVariant> retrieveData(const KFileItem &item, const ItemData *parent) const;
+
+    /**
+     * @return True if role values benefit from natural or case insensitive sorting.
+     */
+    static bool isRoleValueNatural(const RoleType roleType);
 
 
-    QHash<QByteArray, QVariant> retrieveData(const KFileItem& item) const;
+    /**
+     * @return True if \a a has a KFileItem whose text is 'less than' the one
+     *         of \a b according to QString::operator<(const QString&).
+     */
+    static bool nameLessThan(const ItemData *a, const ItemData *b);
 
 
-    bool lessThan(const KFileItem& a, const KFileItem& b) const;
-    void sort(const KFileItemList::iterator& start, const KFileItemList::iterator& end);
-    int stringCompare(const QString& a, const QString& b) const;
+    /**
+     * @return True if the item-data \a a should be ordered before the item-data
+     *         \b. The item-data may have different parent-items.
+     */
+    bool lessThan(const ItemData *a, const ItemData *b, const QCollator &collator) const;
 
     /**
 
     /**
-     * Compares the expansion level of both items. The "expansion level" is defined
-     * by the number of parent directories. However simply comparing just the numbers
-     * is not sufficient, it is also important to check the hierarchy for having
-     * a correct order like shown in a tree.
+     * Sorts the items between \a begin and \a end using the comparison
+     * function lessThan().
      */
      */
-    int expansionLevelsCompare(const KFileItem& a, const KFileItem& b) const;
+    void sort(const QList<ItemData *>::iterator &begin, const QList<ItemData *>::iterator &end) const;
 
     /**
 
     /**
-     * Helper method for expansionLevelCompare().
+     * Helper method for lessThan() and expandedParentsCountCompare(): Compares
+     * the passed item-data using m_sortRole as criteria. Both items must
+     * have the same parent item, otherwise the comparison will be wrong.
      */
      */
-    QString subPath(const KFileItem& item,
-                    const QString& itemPath,
-                    int start,
-                    bool* isDir) const;
+    int sortRoleCompare(const ItemData *a, const ItemData *b, const QCollator &collator) const;
 
 
-    bool useMaximumUpdateInterval() const;
+    /**
+     * Helper method for lessThan() and expandedParentsCountCompare(): Compares
+     * the passed item-data using m_groupRole as criteria. Both items must
+     * have the same parent item, otherwise the comparison will be wrong.
+     */
+    int groupRoleCompare(const ItemData *a, const ItemData *b, const QCollator &collator) const;
+
+    int stringCompare(const QString &a, const QString &b, const QCollator &collator) const;
+
+    ItemGroupInfo nameRoleGroup(const ItemData *itemData, bool withString = true) const;
+    ItemGroupInfo sizeRoleGroup(const ItemData *itemData, bool withString = true) const;
+    ItemGroupInfo timeRoleGroup(const std::function<QDateTime(const ItemData *)> &fileTimeCb, const ItemData *itemData, bool withString = true) const;
+    ItemGroupInfo permissionRoleGroup(const ItemData *itemData, bool withString = true) const;
+    ItemGroupInfo ratingRoleGroup(const ItemData *itemData, bool withString = true) const;
+    ItemGroupInfo typeRoleGroup(const ItemData *itemData) const;
+    ItemGroupInfo genericStringRoleGroup(const QByteArray &role, const ItemData *itemData) const;
+
+    QList<QPair<int, QVariant>> nameRoleGroups() const;
+    QList<QPair<int, QVariant>> sizeRoleGroups() const;
+    QList<QPair<int, QVariant>> timeRoleGroups(const std::function<QDateTime(const ItemData *)> &fileTimeCb) const;
+    QList<QPair<int, QVariant>> permissionRoleGroups() const;
+    QList<QPair<int, QVariant>> ratingRoleGroups() const;
+    QList<QPair<int, QVariant>> typeRoleGroups() const;
+    QList<QPair<int, QVariant>> genericStringRoleGroups(const QByteArray &typeForRole) const;
+
+    /**
+     * Helper method for all xxxRoleGroups() methods to check whether the
+     * item with the given index is a child-item. A child-item is defined
+     * as item having an expansion-level > 0. All xxxRoleGroups() methods
+     * should skip the grouping if the item is a child-item (although
+     * KItemListView would be capable to show sub-groups in groups this
+     * results in visual clutter for most usecases).
+     */
+    bool isChildItem(int index) const;
+
+    void scheduleResortAllItems();
+
+    /**
+     * Is invoked by KFileItemModelRolesUpdater and results in emitting the
+     * sortProgress signal with a percent-value of the progress.
+     */
+    void emitSortProgress(int resolvedCount);
+
+    /**
+     * Applies the filters set through @ref setNameFilter and @ref setMimeTypeFilters.
+     */
+    void applyFilters();
+
+    /**
+     * Removes filtered items whose expanded parents have been deleted
+     * or collapsed via setExpanded(parentIndex, false).
+     */
+    void removeFilteredChildren(const KItemRangeList &parents);
+
+    /**
+     * Loads the selected choice of sorting method from Dolphin General Settings
+     */
+    void loadSortingSettings();
+
+    /**
+     * Maps the QByteArray-roles to RoleTypes and provides translation- and
+     * group-contexts.
+     */
+    struct RoleInfoMap {
+        const char *const role;
+        const RoleType roleType;
+        const KLazyLocalizedString roleTranslation;
+        const KLazyLocalizedString groupTranslation;
+        const KLazyLocalizedString tooltipTranslation;
+        const bool requiresBaloo;
+        const bool requiresIndexer;
+    };
+
+    /**
+     * @return Map of user visible roles that are accessible by KFileItemModel::rolesInformation().
+     */
+    static const RoleInfoMap *rolesInfoMap(int &count);
+
+    /**
+     * Determines the MIME-types of all items that can be done within
+     * the given timeout.
+     */
+    static void determineMimeTypes(const KFileItemList &items, int timeout);
+
+    /**
+     * @return Returns a copy of \a value that is implicitly shared
+     * with other users to save memory.
+     */
+    static QByteArray sharedValue(const QByteArray &value);
+
+    /**
+     * Checks if the model's internal data structures are consistent.
+     */
+    bool isConsistent() const;
+
+    /**
+     * Filters out the expanded folders that don't pass the filter themselves and don't have any filter-passing children.
+     * Will update the removedItemRanges arguments to include the parents that have been filtered.
+     * @returns the number of parents that have been filtered.
+     * @param removedItemRanges The ranges of items being deleted/filtered, will get updated
+     * @param parentsToEnsureVisible Parents that must be visible no matter what due to being ancestors of newly visible items
+     */
+    int filterChildlessParents(KItemRangeList &removedItemRanges, const QSet<ItemData *> &parentsToEnsureVisible = QSet<ItemData *>());
 
 private:
 
 private:
-    QWeakPointer<KDirLister> m_dirLister;
+    KDirLister *m_dirLister = nullptr;
 
 
+    QCollator m_collator;
     bool m_naturalSorting;
     bool m_naturalSorting;
-    bool m_sortFoldersFirst;
+    bool m_sortDirsFirst;
+    bool m_sortHiddenLast;
+
+    RoleType m_sortRole;
+    RoleType m_groupRole;
+    QByteArray m_sortExtraInfo;
+    QByteArray m_groupExtraInfo;
 
 
-    Role m_groupRole;
-    Role m_sortRole;
-    Qt::CaseSensitivity m_caseSensitivity;
+    int m_sortingProgressPercent; // Value of directorySortingProgress() signal
+    QSet<QByteArray> m_roles;
 
 
-    KFileItemList m_sortedItems;   // Allows O(1) access for KFileItemModel::fileItem(int index)
-    QHash<KUrl, int> m_items;      // Allows O(1) access for KFileItemModel::index(const KFileItem& item)
-    QList<QHash<QByteArray, QVariant> > m_data;
+    QList<ItemData *> m_itemData;
+
+    // m_items is a cache for the method index(const QUrl&). If it contains N
+    // entries, it is guaranteed that these correspond to the first N items in
+    // the model, i.e., that (for every i between 0 and N - 1)
+    // m_items.value(fileItem(i).url()) == i
+    mutable QHash<QUrl, int> m_items;
+
+    KFileItemModelFilter m_filter;
+    QHash<KFileItem, ItemData *> m_filteredItems; // Items that got hidden by KFileItemModel::setNameFilter()
 
     bool m_requestRole[RolesCount];
 
 
     bool m_requestRole[RolesCount];
 
-    QTimer* m_minimumUpdateIntervalTimer;
-    QTimer* m_maximumUpdateIntervalTimer;
-    KFileItemList m_pendingItemsToInsert;
-    bool m_pendingEmitLoadingCompleted;
+    QTimer *m_maximumUpdateIntervalTimer;
+    QTimer *m_resortAllItemsTimer;
+    QList<ItemData *> m_pendingItemsToInsert;
 
 
-    // Stores the smallest expansion level of the root-URL. Is required to calculate
-    // the "expansionLevel" role in an efficient way. A value < 0 indicates that
-    // it has not been initialized yet.
-    mutable int m_rootExpansionLevel;
+    // Cache for KFileItemModel::groups()
+    mutable QList<QPair<int, QVariant>> m_groups;
 
 
-    // Stores the URLs of the expanded folders.
-    QSet<KUrl> m_expandedUrls;
+    // Stores the URLs (key: target url, value: url) of the expanded directories.
+    QHash<QUrl, QUrl> m_expandedDirs;
 
 
-    // Stores the URLs which have to be expanded in order to restore a previous state of the model.
-    QSet<KUrl> m_restoredExpandedUrls;
+    // URLs that must be expanded. The expanding is initially triggered in setExpanded()
+    // and done step after step in slotCompleted().
+    QSet<QUrl> m_urlsToExpand;
 
 
+    friend class KFileItemModelRolesUpdater; // Accesses emitSortProgress() method
     friend class KFileItemModelTest; // For unit testing
     friend class KFileItemModelTest; // For unit testing
+    friend class KFileItemModelBenchmark; // For unit testing
+    friend class KFileItemListViewTest; // For unit testing
+    friend class DolphinPart; // Accesses m_dirLister
 };
 
 };
 
-#endif
+inline bool KFileItemModel::isRoleValueNatural(RoleType roleType)
+{
+    return (roleType == TypeRole || roleType == ExtensionRole || roleType == TagsRole || roleType == CommentRole || roleType == TitleRole
+            || roleType == ArtistRole || roleType == GenreRole || roleType == AlbumRole || roleType == PathRole || roleType == DestinationRole
+            || roleType == OriginUrlRole || roleType == OwnerRole || roleType == GroupRole);
+}
 
 
+inline bool KFileItemModel::nameLessThan(const ItemData *a, const ItemData *b)
+{
+    // Split extension, taking into account it can be empty
+    constexpr QString::SectionFlags flags = QString::SectionSkipEmpty | QString::SectionIncludeLeadingSep;
+    return a->item.text().section('.', 0, 0, flags) < b->item.text().section('.', 0, 0, flags);
+}
 
 
+inline bool KFileItemModel::isChildItem(int index) const
+{
+    if (m_itemData.at(index)->parent) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+inline bool KFileItemModel::ItemGroupInfo::operator==(const ItemGroupInfo &other) const
+{
+    return comparable == other.comparable && text == other.text;
+}
+
+inline bool KFileItemModel::ItemGroupInfo::operator!=(const ItemGroupInfo &other) const
+{
+    return comparable != other.comparable || text != other.text;
+}
+
+#endif