Add clang-format and format code as in Frameworks

31 files changed, 518 insertions, 644 deletions

diff --git a/src/kitemviews/private/kbaloorolesprovider.cpp b/src/kitemviews/private/kbaloorolesprovider.cpp
index f6d4dddb7..4cf36eb2d 100644
--- a/src/kitemviews/private/kbaloorolesprovider.cpp
+++ b/src/kitemviews/private/kbaloorolesprovider.cpp
@@ -14,20 +14,23 @@
 #include <QCollator>
 #include <QSize>
 
-namespace {
-    QString tagsFromValues(const QStringList& values)
-    {
-        if (values.size() == 1) {
-            return values.at(0);
-        }
-
-        QStringList alphabeticalOrderTags = values;
-        QCollator coll;
-        coll.setNumericMode(true);
-        std::sort(alphabeticalOrderTags.begin(), alphabeticalOrderTags.end(), [&](const QString& s1, const QString& s2){ return coll.compare(s1, s2) < 0; });
-        return alphabeticalOrderTags.join(QLatin1String(", "));
+namespace
+{
+QString tagsFromValues(const QStringList &values)
+{
+    if (values.size() == 1) {
+        return values.at(0);
     }
 
+    QStringList alphabeticalOrderTags = values;
+    QCollator coll;
+    coll.setNumericMode(true);
+    std::sort(alphabeticalOrderTags.begin(), alphabeticalOrderTags.end(), [&](const QString &s1, const QString &s2) {
+        return coll.compare(s1, s2) < 0;
+    });
+    return alphabeticalOrderTags.join(QLatin1String(", "));
+}
+
     using Property = KFileMetaData::Property::Property;
     // Mapping from the KFM::Property to the KFileItemModel roles.
     const QHash<Property, QByteArray> propertyRoleMap() {
@@ -58,14 +61,12 @@ namespace {
     }
 }
 
-struct KBalooRolesProviderSingleton
-{
+struct KBalooRolesProviderSingleton {
     KBalooRolesProvider instance;
 };
 Q_GLOBAL_STATIC(KBalooRolesProviderSingleton, s_balooRolesProvider)
 
-
-KBalooRolesProvider& KBalooRolesProvider::instance()
+KBalooRolesProvider &KBalooRolesProvider::instance()
 {
     return s_balooRolesProvider->instance;
 }
@@ -79,21 +80,21 @@ QSet<QByteArray> KBalooRolesProvider::roles() const
     return m_roles;
 }
 
-QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File& file,
-                                                            const QSet<QByteArray>& roles) const
+QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File &file, const QSet<QByteArray> &roles) const
 {
     QHash<QByteArray, QVariant> values;
 
-    using entry = std::pair<const KFileMetaData::Property::Property&, const QVariant&>;
+    using entry = std::pair<const KFileMetaData::Property::Property &, const QVariant &>;
 
-    const auto& propMap = file.properties();
+    const auto &propMap = file.properties();
     auto rangeBegin = propMap.constKeyValueBegin();
 
     while (rangeBegin != propMap.constKeyValueEnd()) {
         auto key = (*rangeBegin).first;
 
-        auto rangeEnd = std::find_if(rangeBegin, propMap.constKeyValueEnd(),
-            [key](const entry& e) { return e.first != key; });
+        auto rangeEnd = std::find_if(rangeBegin, propMap.constKeyValueEnd(), [key](const entry &e) {
+            return e.first != key;
+        });
 
         const QByteArray role = propertyRoleMap().value(key);
         if (role.isEmpty() || !roles.contains(role)) {
@@ -106,7 +107,9 @@ QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File& f
         if (distance > 1) {
             QVariantList list;
             list.reserve(static_cast<int>(distance));
-            std::for_each(rangeBegin, rangeEnd, [&list](const entry& s) { list.append(s.second); });
+            std::for_each(rangeBegin, rangeEnd, [&list](const entry &s) {
+                list.append(s.second);
+            });
             values.insert(role, propertyInfo.formatAsDisplayString(list));
         } else {
             if (propertyInfo.valueType() == QVariant::DateTime) {
@@ -171,7 +174,7 @@ QHash<QByteArray, QVariant> KBalooRolesProvider::roleValues(const Baloo::File& f
 KBalooRolesProvider::KBalooRolesProvider()
 {
     // Display roles filled from Baloo property cache
-    for (const auto& role : propertyRoleMap()) {
+    for (const auto &role : propertyRoleMap()) {
         m_roles.insert(role);
     }
     m_roles.insert("dimensions");
@@ -182,4 +185,3 @@ KBalooRolesProvider::KBalooRolesProvider()
     m_roles.insert(QByteArrayLiteral("comment"));
     m_roles.insert(QByteArrayLiteral("originUrl"));
 }
-
diff --git a/src/kitemviews/private/kbaloorolesprovider.h b/src/kitemviews/private/kbaloorolesprovider.h
index 97ed58f2b..5ff33e1c6 100644
--- a/src/kitemviews/private/kbaloorolesprovider.h
+++ b/src/kitemviews/private/kbaloorolesprovider.h
@@ -14,8 +14,9 @@
 #include <QSet>
 #include <QVariant>
 
-namespace Baloo {
-    class File;
+namespace Baloo
+{
+class File;
 }
 
 /**
@@ -27,7 +28,7 @@ namespace Baloo {
 class DOLPHIN_EXPORT KBalooRolesProvider
 {
 public:
-    static KBalooRolesProvider& instance();
+    static KBalooRolesProvider &instance();
     virtual ~KBalooRolesProvider();
 
     /**
@@ -39,8 +40,7 @@ public:
      * @return Values for the roles \a roles that can be determined from the file
      *         with the URL \a url.
      */
-    QHash<QByteArray, QVariant> roleValues(const Baloo::File& file,
-                                           const QSet<QByteArray>& roles) const;
+    QHash<QByteArray, QVariant> roleValues(const Baloo::File &file, const QSet<QByteArray> &roles) const;
 
 protected:
     KBalooRolesProvider();
@@ -52,4 +52,3 @@ private:
 };
 
 #endif
-
diff --git a/src/kitemviews/private/kdirectorycontentscounter.cpp b/src/kitemviews/private/kdirectorycontentscounter.cpp
index a2a27ad28..039b79b6e 100644
--- a/src/kitemviews/private/kdirectorycontentscounter.cpp
+++ b/src/kitemviews/private/kdirectorycontentscounter.cpp
@@ -10,26 +10,26 @@
 
 #include <KDirWatch>
 
-#include <QFileInfo>
 #include <QDir>
+#include <QFileInfo>
 #include <QThread>
 
-namespace  {
-    /// cache of directory counting result
-    static QHash<QString, QPair<int, long>> *s_cache;
+namespace
+{
+/// cache of directory counting result
+static QHash<QString, QPair<int, long>> *s_cache;
 }
 
-KDirectoryContentsCounter::KDirectoryContentsCounter(KFileItemModel* model, QObject* parent) :
-    QObject(parent),
-    m_model(model),
-    m_queue(),
-    m_worker(nullptr),
-    m_workerIsBusy(false),
-    m_dirWatcher(nullptr),
-    m_watchedDirs()
+KDirectoryContentsCounter::KDirectoryContentsCounter(KFileItemModel *model, QObject *parent)
+    : QObject(parent)
+    , m_model(model)
+    , m_queue()
+    , m_worker(nullptr)
+    , m_workerIsBusy(false)
+    , m_dirWatcher(nullptr)
+    , m_watchedDirs()
 {
-    connect(m_model, &KFileItemModel::itemsRemoved,
-            this,    &KDirectoryContentsCounter::slotItemsRemoved);
+    connect(m_model, &KFileItemModel::itemsRemoved, this, &KDirectoryContentsCounter::slotItemsRemoved);
 
     if (!m_workerThread) {
         m_workerThread = new QThread();
@@ -43,10 +43,8 @@ KDirectoryContentsCounter::KDirectoryContentsCounter(KFileItemModel* model, QObj
     m_worker = new KDirectoryContentsCounterWorker();
     m_worker->moveToThread(m_workerThread);
 
-    connect(this,     &KDirectoryContentsCounter::requestDirectoryContentsCount,
-            m_worker, &KDirectoryContentsCounterWorker::countDirectoryContents);
-    connect(m_worker, &KDirectoryContentsCounterWorker::result,
-            this,     &KDirectoryContentsCounter::slotResult);
+    connect(this, &KDirectoryContentsCounter::requestDirectoryContentsCount, m_worker, &KDirectoryContentsCounterWorker::countDirectoryContents);
+    connect(m_worker, &KDirectoryContentsCounterWorker::result, this, &KDirectoryContentsCounter::slotResult);
 
     m_dirWatcher = new KDirWatch(this);
     connect(m_dirWatcher, &KDirWatch::dirty, this, &KDirectoryContentsCounter::slotDirWatchDirty);
@@ -73,12 +71,12 @@ KDirectoryContentsCounter::~KDirectoryContentsCounter()
     }
 }
 
-void KDirectoryContentsCounter::scanDirectory(const QString& path)
+void KDirectoryContentsCounter::scanDirectory(const QString &path)
 {
     startWorker(path);
 }
 
-void KDirectoryContentsCounter::slotResult(const QString& path, int count, long size)
+void KDirectoryContentsCounter::slotResult(const QString &path, int count, long size)
 {
     m_workerIsBusy = false;
 
@@ -118,7 +116,7 @@ void KDirectoryContentsCounter::slotResult(const QString& path, int count, long
     Q_EMIT result(path, count, size);
 }
 
-void KDirectoryContentsCounter::slotDirWatchDirty(const QString& path)
+void KDirectoryContentsCounter::slotDirWatchDirty(const QString &path)
 {
     const int index = m_model->index(QUrl::fromLocalFile(path));
     if (index >= 0) {
@@ -140,7 +138,7 @@ void KDirectoryContentsCounter::slotItemsRemoved()
     if (!m_watchedDirs.isEmpty()) {
         // Don't let KDirWatch watch for removed items
         if (allItemsRemoved) {
-            for (const QString& path : qAsConst(m_watchedDirs)) {
+            for (const QString &path : qAsConst(m_watchedDirs)) {
                 m_dirWatcher->removeDir(path);
             }
             m_watchedDirs.clear();
@@ -148,7 +146,7 @@ void KDirectoryContentsCounter::slotItemsRemoved()
         } else {
             QMutableSetIterator<QString> it(m_watchedDirs);
             while (it.hasNext()) {
-                const QString& path = it.next();
+                const QString &path = it.next();
                 if (m_model->index(QUrl::fromLocalFile(path)) < 0) {
                     m_dirWatcher->removeDir(path);
                     it.remove();
@@ -158,7 +156,7 @@ void KDirectoryContentsCounter::slotItemsRemoved()
     }
 }
 
-void KDirectoryContentsCounter::startWorker(const QString& path)
+void KDirectoryContentsCounter::startWorker(const QString &path)
 {
     const QString resolvedPath = QFileInfo(path).canonicalFilePath();
     const bool alreadyInCache = s_cache->contains(resolvedPath);
@@ -170,8 +168,8 @@ void KDirectoryContentsCounter::startWorker(const QString& path)
     }
 
     if (m_workerIsBusy) {
-        if (std::find(m_queue.begin(), m_queue.end(), path) == m_queue.end() &&
-            std::find(m_priorityQueue.begin(), m_priorityQueue.end(), path) == m_priorityQueue.end()) {
+        if (std::find(m_queue.begin(), m_queue.end(), path) == m_queue.end()
+            && std::find(m_priorityQueue.begin(), m_priorityQueue.end(), path) == m_priorityQueue.end()) {
             if (alreadyInCache) {
                 m_queue.push_back(path);
             } else {
@@ -195,4 +193,4 @@ void KDirectoryContentsCounter::startWorker(const QString& path)
     }
 }
 
-QThread* KDirectoryContentsCounter::m_workerThread = nullptr;
+QThread *KDirectoryContentsCounter::m_workerThread = nullptr;
diff --git a/src/kitemviews/private/kdirectorycontentscounter.h b/src/kitemviews/private/kdirectorycontentscounter.h
index 6d3d1f3c1..f74565b73 100644
--- a/src/kitemviews/private/kdirectorycontentscounter.h
+++ b/src/kitemviews/private/kdirectorycontentscounter.h
@@ -21,7 +21,7 @@ class KDirectoryContentsCounter : public QObject
     Q_OBJECT
 
 public:
-    explicit KDirectoryContentsCounter(KFileItemModel* model, QObject* parent = nullptr);
+    explicit KDirectoryContentsCounter(KFileItemModel *model, QObject *parent = nullptr);
     ~KDirectoryContentsCounter() override;
 
     /**
@@ -35,40 +35,40 @@ public:
      * Uses a cache internally to speed up first result,
      * but emit again result when the cache was updated
      */
-    void scanDirectory(const QString& path);
+    void scanDirectory(const QString &path);
 
 Q_SIGNALS:
     /**
      * Signals that the directory \a path contains \a count items of size \a
      * Size calculation depends on parameter DetailsModeSettings::recursiveDirectorySizeLimit
      */
-    void result(const QString& path, int count, long size);
+    void result(const QString &path, int count, long size);
 
-    void requestDirectoryContentsCount(const QString& path, KDirectoryContentsCounterWorker::Options options);
+    void requestDirectoryContentsCount(const QString &path, KDirectoryContentsCounterWorker::Options options);
 
 private Q_SLOTS:
-    void slotResult(const QString& path, int count, long size);
-    void slotDirWatchDirty(const QString& path);
+    void slotResult(const QString &path, int count, long size);
+    void slotDirWatchDirty(const QString &path);
     void slotItemsRemoved();
 
 private:
-    void startWorker(const QString& path);
+    void startWorker(const QString &path);
 
 private:
-    KFileItemModel* m_model;
+    KFileItemModel *m_model;
 
     // Used as FIFO queues.
     std::list<QString> m_priorityQueue;
     std::list<QString> m_queue;
 
-    static QThread* m_workerThread;
+    static QThread *m_workerThread;
 
-    KDirectoryContentsCounterWorker* m_worker;
+    KDirectoryContentsCounterWorker *m_worker;
     bool m_workerIsBusy;
 
-    KDirWatch* m_dirWatcher;
-    QSet<QString> m_watchedDirs;    // Required as sadly KDirWatch does not offer a getter method
-                                    // to get all watched directories.
+    KDirWatch *m_dirWatcher;
+    QSet<QString> m_watchedDirs; // Required as sadly KDirWatch does not offer a getter method
+                                 // to get all watched directories.
 };
 
 #endif
diff --git a/src/kitemviews/private/kdirectorycontentscounterworker.cpp b/src/kitemviews/private/kdirectorycontentscounterworker.cpp
index 2a683cdbc..e227c1bc6 100644
--- a/src/kitemviews/private/kdirectorycontentscounterworker.cpp
+++ b/src/kitemviews/private/kdirectorycontentscounterworker.cpp
@@ -17,17 +17,15 @@
 
 #include "dolphin_detailsmodesettings.h"
 
-KDirectoryContentsCounterWorker::KDirectoryContentsCounterWorker(QObject* parent) :
-    QObject(parent)
+KDirectoryContentsCounterWorker::KDirectoryContentsCounterWorker(QObject *parent)
+    : QObject(parent)
 {
     qRegisterMetaType<KDirectoryContentsCounterWorker::Options>();
 }
 
 #ifndef Q_OS_WIN
-KDirectoryContentsCounterWorker::CountResult walkDir(const QString &dirPath,
-                                                     const bool countHiddenFiles,
-                                                     const bool countDirectoriesOnly,
-                                                     const uint allowedRecursiveLevel)
+KDirectoryContentsCounterWorker::CountResult
+walkDir(const QString &dirPath, const bool countHiddenFiles, const bool countDirectoriesOnly, const uint allowedRecursiveLevel)
 {
     int count = -1;
     long size = -1;
@@ -53,10 +51,7 @@ KDirectoryContentsCounterWorker::CountResult walkDir(const QString &dirPath,
             // If only directories are counted, consider an unknown file type and links also
             // as directory instead of trying to do an expensive stat()
             // (see bugs 292642 and 299997).
-            const bool countEntry = !countDirectoriesOnly ||
-                    dirEntry->d_type == DT_DIR ||
-                    dirEntry->d_type == DT_LNK ||
-                    dirEntry->d_type == DT_UNKNOWN;
+            const bool countEntry = !countDirectoriesOnly || dirEntry->d_type == DT_DIR || dirEntry->d_type == DT_LNK || dirEntry->d_type == DT_UNKNOWN;
             if (countEntry) {
                 ++count;
             }
@@ -84,7 +79,7 @@ KDirectoryContentsCounterWorker::CountResult walkDir(const QString &dirPath,
 }
 #endif
 
-KDirectoryContentsCounterWorker::CountResult KDirectoryContentsCounterWorker::subItemsCount(const QString& path, Options options)
+KDirectoryContentsCounterWorker::CountResult KDirectoryContentsCounterWorker::subItemsCount(const QString &path, Options options)
 {
     const bool countHiddenFiles = options & CountHiddenFiles;
     const bool countDirectoriesOnly = options & CountDirectoriesOnly;
@@ -111,7 +106,7 @@ KDirectoryContentsCounterWorker::CountResult KDirectoryContentsCounterWorker::su
 #endif
 }
 
-void KDirectoryContentsCounterWorker::countDirectoryContents(const QString& path, Options options)
+void KDirectoryContentsCounterWorker::countDirectoryContents(const QString &path, Options options)
 {
     auto res = subItemsCount(path, options);
     Q_EMIT result(path, res.count, res.size);
diff --git a/src/kitemviews/private/kdirectorycontentscounterworker.h b/src/kitemviews/private/kdirectorycontentscounterworker.h
index 48a2d1ff9..6bbe099a5 100644
--- a/src/kitemviews/private/kdirectorycontentscounterworker.h
+++ b/src/kitemviews/private/kdirectorycontentscounterworker.h
@@ -17,11 +17,7 @@ class KDirectoryContentsCounterWorker : public QObject
     Q_OBJECT
 
 public:
-    enum Option {
-        NoOptions = 0x0,
-        CountHiddenFiles = 0x1,
-        CountDirectoriesOnly = 0x2
-    };
+    enum Option { NoOptions = 0x0, CountHiddenFiles = 0x1, CountDirectoriesOnly = 0x2 };
     Q_DECLARE_FLAGS(Options, Option)
 
     struct CountResult {
@@ -32,7 +28,7 @@ public:
         long size;
     };
 
-    explicit KDirectoryContentsCounterWorker(QObject* parent = nullptr);
+    explicit KDirectoryContentsCounterWorker(QObject *parent = nullptr);
 
     /**
      * Counts the items inside the directory \a path using the options
@@ -40,13 +36,13 @@ public:
      *
      * @return The number of items.
      */
-    static CountResult subItemsCount(const QString& path, Options options);
+    static CountResult subItemsCount(const QString &path, Options options);
 
 Q_SIGNALS:
     /**
      * Signals that the directory \a path contains \a count items and optionally the size of its content.
      */
-    void result(const QString& path, int count, long size);
+    void result(const QString &path, int count, long size);
 
 public Q_SLOTS:
     /**
@@ -56,7 +52,7 @@ public Q_SLOTS:
     // Note that the full type name KDirectoryContentsCounterWorker::Options
     // is needed here. Just using 'Options' is OK for the compiler, but
     // confuses moc.
-    void countDirectoryContents(const QString& path, KDirectoryContentsCounterWorker::Options options);
+    void countDirectoryContents(const QString &path, KDirectoryContentsCounterWorker::Options options);
 };
 
 Q_DECLARE_METATYPE(KDirectoryContentsCounterWorker::Options)
diff --git a/src/kitemviews/private/kfileitemclipboard.cpp b/src/kitemviews/private/kfileitemclipboard.cpp
index ec31068e7..33bf298ed 100644
--- a/src/kitemviews/private/kfileitemclipboard.cpp
+++ b/src/kitemviews/private/kfileitemclipboard.cpp
@@ -19,14 +19,12 @@ public:
 };
 Q_GLOBAL_STATIC(KFileItemClipboardSingleton, s_KFileItemClipboard)
 
-
-
-KFileItemClipboard* KFileItemClipboard::instance()
+KFileItemClipboard *KFileItemClipboard::instance()
 {
     return &s_KFileItemClipboard->instance;
 }
 
-bool KFileItemClipboard::isCut(const QUrl& url) const
+bool KFileItemClipboard::isCut(const QUrl &url) const
 {
     return m_cutItems.contains(url);
 }
@@ -42,7 +40,7 @@ KFileItemClipboard::~KFileItemClipboard()
 
 void KFileItemClipboard::updateCutItems()
 {
-    const QMimeData* mimeData = QApplication::clipboard()->mimeData();
+    const QMimeData *mimeData = QApplication::clipboard()->mimeData();
 
     // mimeData can be 0 according to https://bugs.kde.org/show_bug.cgi?id=335053
     if (!mimeData) {
@@ -62,12 +60,11 @@ void KFileItemClipboard::updateCutItems()
     Q_EMIT cutItemsChanged();
 }
 
-KFileItemClipboard::KFileItemClipboard() :
-    QObject(nullptr),
-    m_cutItems()
+KFileItemClipboard::KFileItemClipboard()
+    : QObject(nullptr)
+    , m_cutItems()
 {
     updateCutItems();
 
-    connect(QApplication::clipboard(), &QClipboard::dataChanged,
-            this, &KFileItemClipboard::updateCutItems);
+    connect(QApplication::clipboard(), &QClipboard::dataChanged, this, &KFileItemClipboard::updateCutItems);
 }
diff --git a/src/kitemviews/private/kfileitemclipboard.h b/src/kitemviews/private/kfileitemclipboard.h
index 818201308..1d3e2dedf 100644
--- a/src/kitemviews/private/kfileitemclipboard.h
+++ b/src/kitemviews/private/kfileitemclipboard.h
@@ -23,9 +23,9 @@ class DOLPHIN_EXPORT KFileItemClipboard : public QObject
     Q_OBJECT
 
 public:
-    static KFileItemClipboard* instance();
+    static KFileItemClipboard *instance();
 
-    bool isCut(const QUrl& url) const;
+    bool isCut(const QUrl &url) const;
 
     QList<QUrl> cutItems() const;
 
diff --git a/src/kitemviews/private/kfileitemmodelfilter.cpp b/src/kitemviews/private/kfileitemmodelfilter.cpp
index 6a2a4177f..f199c314f 100644
--- a/src/kitemviews/private/kfileitemmodelfilter.cpp
+++ b/src/kitemviews/private/kfileitemmodelfilter.cpp
@@ -10,11 +10,11 @@
 
 #include <KFileItem>
 
-KFileItemModelFilter::KFileItemModelFilter() :
-    m_useRegExp(false),
-    m_regExp(nullptr),
-    m_lowerCasePattern(),
-    m_pattern()
+KFileItemModelFilter::KFileItemModelFilter()
+    : m_useRegExp(false)
+    , m_regExp(nullptr)
+    , m_lowerCasePattern()
+    , m_pattern()
 {
 }
 
@@ -24,7 +24,7 @@ KFileItemModelFilter::~KFileItemModelFilter()
     m_regExp = nullptr;
 }
 
-void KFileItemModelFilter::setPattern(const QString& filter)
+void KFileItemModelFilter::setPattern(const QString &filter)
 {
     m_pattern = filter;
     m_lowerCasePattern = filter.toLower();
@@ -46,7 +46,7 @@ QString KFileItemModelFilter::pattern() const
     return m_pattern;
 }
 
-void KFileItemModelFilter::setMimeTypes(const QStringList& types)
+void KFileItemModelFilter::setMimeTypes(const QStringList &types)
 {
     m_mimeTypes = types;
 }
@@ -61,8 +61,7 @@ bool KFileItemModelFilter::hasSetFilters() const
     return (!m_pattern.isEmpty() || !m_mimeTypes.isEmpty());
 }
 
-
-bool KFileItemModelFilter::matches(const KFileItem& item) const
+bool KFileItemModelFilter::matches(const KFileItem &item) const
 {
     const bool hasPatternFilter = !m_pattern.isEmpty();
     const bool hasMimeTypesFilter = !m_mimeTypes.isEmpty();
@@ -85,7 +84,7 @@ bool KFileItemModelFilter::matches(const KFileItem& item) const
     return matchesType(item);
 }
 
-bool KFileItemModelFilter::matchesPattern(const KFileItem& item) const
+bool KFileItemModelFilter::matchesPattern(const KFileItem &item) const
 {
     if (m_useRegExp) {
         return m_regExp->match(item.text()).hasMatch();
@@ -94,9 +93,9 @@ bool KFileItemModelFilter::matchesPattern(const KFileItem& item) const
     }
 }
 
-bool KFileItemModelFilter::matchesType(const KFileItem& item) const
+bool KFileItemModelFilter::matchesType(const KFileItem &item) const
 {
-    for (const QString& mimeType : qAsConst(m_mimeTypes)) {
+    for (const QString &mimeType : qAsConst(m_mimeTypes)) {
         if (item.mimetype() == mimeType) {
             return true;
         }
diff --git a/src/kitemviews/private/kfileitemmodelfilter.h b/src/kitemviews/private/kfileitemmodelfilter.h
index f55a8097d..959590da8 100644
--- a/src/kitemviews/private/kfileitemmodelfilter.h
+++ b/src/kitemviews/private/kfileitemmodelfilter.h
@@ -24,7 +24,6 @@ class QRegularExpression;
  */
 class DOLPHIN_EXPORT KFileItemModelFilter
 {
-
 public:
     KFileItemModelFilter();
     virtual ~KFileItemModelFilter();
@@ -35,14 +34,14 @@ public:
      * defines a sub-string. As soon as the pattern contains at least
      * a '*', '?' or '[' the pattern represents a regular expression.
      */
-    void setPattern(const QString& pattern);
+    void setPattern(const QString &pattern);
     QString pattern() const;
 
     /**
      * Set the list of mimetypes that are used for comparison with the
      * item in KFileItemModelFilter::matchesMimeType.
      */
-    void setMimeTypes(const QStringList& types);
+    void setMimeTypes(const QStringList &types);
     QStringList mimeTypes() const;
 
     /**
@@ -54,27 +53,25 @@ public:
      * @return True if the item matches with the pattern defined by
      *         @ref setPattern() or @ref setMimeTypes
      */
-    bool matches(const KFileItem& item) const;
+    bool matches(const KFileItem &item) const;
 
 private:
     /**
      * @return True if item matches pattern set by @ref setPattern.
      */
-    bool matchesPattern(const KFileItem& item) const;
+    bool matchesPattern(const KFileItem &item) const;
 
     /**
      * @return True if item matches mimetypes set by @ref setMimeTypes.
      */
-    bool matchesType(const KFileItem& item) const;
+    bool matchesType(const KFileItem &item) const;
 
-    bool m_useRegExp;           // If true, m_regExp is used for filtering,
-                                // otherwise m_lowerCaseFilter is used.
+    bool m_useRegExp; // If true, m_regExp is used for filtering,
+                      // otherwise m_lowerCaseFilter is used.
     QRegularExpression *m_regExp;
     QString m_lowerCasePattern; // Lowercase version of m_filter for
                                 // faster comparison in matches().
-    QString m_pattern;          // Property set by setPattern().
-    QStringList m_mimeTypes;    // Property set by setMimeTypes()
+    QString m_pattern; // Property set by setPattern().
+    QStringList m_mimeTypes; // Property set by setMimeTypes()
 };
 #endif
-
-
diff --git a/src/kitemviews/private/kfileitemmodelsortalgorithm.h b/src/kitemviews/private/kfileitemmodelsortalgorithm.h
index 4fe6aa66a..29c1fe5ac 100644
--- a/src/kitemviews/private/kfileitemmodelsortalgorithm.h
+++ b/src/kitemviews/private/kfileitemmodelsortalgorithm.h
@@ -21,10 +21,8 @@
  * SPDX-FileCopyrightText: 2011 Nokia Corporation and/or its subsidiary(-ies).
  */
 
-template <typename RandomAccessIterator, typename LessThan>
-static void mergeSort(RandomAccessIterator begin,
-                      RandomAccessIterator end,
-                      const LessThan& lessThan)
+template<typename RandomAccessIterator, typename LessThan>
+static void mergeSort(RandomAccessIterator begin, RandomAccessIterator end, const LessThan &lessThan)
 {
     // The implementation is based on qStableSortHelper() from qalgorithms.h
     // SPDX-FileCopyrightText: 2011 Nokia Corporation and/or its subsidiary(-ies).
@@ -49,12 +47,9 @@ static void mergeSort(RandomAccessIterator begin,
  * The comparison function \a lessThan must be reentrant.
  */
 
-template <typename RandomAccessIterator, typename LessThan>
-static void parallelMergeSort(RandomAccessIterator begin,
-                              RandomAccessIterator end,
-                              LessThan lessThan,
-                              int numberOfThreads,
-                              int parallelMergeSortingThreshold = 100)
+template<typename RandomAccessIterator, typename LessThan>
+static void
+parallelMergeSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan, int numberOfThreads, int parallelMergeSortingThreshold = 100)
 {
     const int span = end - begin;
 
@@ -62,7 +57,8 @@ static void parallelMergeSort(RandomAccessIterator begin,
         const int newNumberOfThreads = numberOfThreads / 2;
         const RandomAccessIterator middle = begin + span / 2;
 
-        QFuture<void> future = QtConcurrent::run(parallelMergeSort<RandomAccessIterator, LessThan>, begin, middle, lessThan, newNumberOfThreads, parallelMergeSortingThreshold);
+        QFuture<void> future =
+            QtConcurrent::run(parallelMergeSort<RandomAccessIterator, LessThan>, begin, middle, lessThan, newNumberOfThreads, parallelMergeSortingThreshold);
         parallelMergeSort(middle, end, lessThan, newNumberOfThreads, parallelMergeSortingThreshold);
 
         future.waitForFinished();
@@ -82,11 +78,8 @@ static void parallelMergeSort(RandomAccessIterator begin,
  * SPDX-FileCopyrightText: 2011 Nokia Corporation and/or its subsidiary(-ies).
  */
 
-template <typename RandomAccessIterator, typename LessThan>
-static void merge(RandomAccessIterator begin,
-                  RandomAccessIterator pivot,
-                  RandomAccessIterator end,
-                  const LessThan& lessThan)
+template<typename RandomAccessIterator, typename LessThan>
+static void merge(RandomAccessIterator begin, RandomAccessIterator pivot, RandomAccessIterator end, const LessThan &lessThan)
 {
     // The implementation is based on qMerge() from qalgorithms.h
     // SPDX-FileCopyrightText: 2011 Nokia Corporation and/or its subsidiary(-ies).
@@ -111,14 +104,12 @@ static void merge(RandomAccessIterator begin,
     if (len1 > len2) {
         const int len1Half = len1 / 2;
         firstCut = begin + len1Half;
-        secondCut = std::lower_bound<RandomAccessIterator,
-            decltype(*firstCut), const LessThan&>(pivot, end, *firstCut, lessThan);
+        secondCut = std::lower_bound<RandomAccessIterator, decltype(*firstCut), const LessThan &>(pivot, end, *firstCut, lessThan);
         len2Half = secondCut - pivot;
     } else {
         len2Half = len2 / 2;
         secondCut = pivot + len2Half;
-        firstCut = std::upper_bound<RandomAccessIterator,
-            decltype(*secondCut), const LessThan&>(begin, pivot, *secondCut, lessThan);
+        firstCut = std::upper_bound<RandomAccessIterator, decltype(*secondCut), const LessThan &>(begin, pivot, *secondCut, lessThan);
     }
 
     std::rotate(firstCut, pivot, secondCut);
@@ -129,4 +120,3 @@ static void merge(RandomAccessIterator begin,
 }
 
 #endif
-
diff --git a/src/kitemviews/private/kitemlistheaderwidget.cpp b/src/kitemviews/private/kitemlistheaderwidget.cpp
index 9f4f868d0..ac25d189c 100644
--- a/src/kitemviews/private/kitemlistheaderwidget.cpp
+++ b/src/kitemviews/private/kitemlistheaderwidget.cpp
@@ -12,21 +12,20 @@
 #include <QPainter>
 #include <QStyleOptionHeader>
 
-
-KItemListHeaderWidget::KItemListHeaderWidget(QGraphicsWidget* parent) :
-    QGraphicsWidget(parent),
-    m_automaticColumnResizing(true),
-    m_model(nullptr),
-    m_offset(0),
-    m_sidePadding(0),
-    m_columns(),
-    m_columnWidths(),
-    m_preferredColumnWidths(),
-    m_hoveredRoleIndex(-1),
-    m_pressedRoleIndex(-1),
-    m_roleOperation(NoRoleOperation),
-    m_pressedMousePos(),
-    m_movingRole()
+KItemListHeaderWidget::KItemListHeaderWidget(QGraphicsWidget *parent)
+    : QGraphicsWidget(parent)
+    , m_automaticColumnResizing(true)
+    , m_model(nullptr)
+    , m_offset(0)
+    , m_sidePadding(0)
+    , m_columns()
+    , m_columnWidths()
+    , m_preferredColumnWidths()
+    , m_hoveredRoleIndex(-1)
+    , m_pressedRoleIndex(-1)
+    , m_roleOperation(NoRoleOperation)
+    , m_pressedMousePos()
+    , m_movingRole()
 {
     m_movingRole.x = 0;
     m_movingRole.xDec = 0;
@@ -41,30 +40,26 @@ KItemListHeaderWidget::~KItemListHeaderWidget()
 {
 }
 
-void KItemListHeaderWidget::setModel(KItemModelBase* model)
+void KItemListHeaderWidget::setModel(KItemModelBase *model)
 {
     if (m_model == model) {
         return;
     }
 
     if (m_model) {
-        disconnect(m_model, &KItemModelBase::sortRoleChanged,
-                   this, &KItemListHeaderWidget::slotSortRoleChanged);
-        disconnect(m_model, &KItemModelBase::sortOrderChanged,
-                   this, &KItemListHeaderWidget::slotSortOrderChanged);
+        disconnect(m_model, &KItemModelBase::sortRoleChanged, this, &KItemListHeaderWidget::slotSortRoleChanged);
+        disconnect(m_model, &KItemModelBase::sortOrderChanged, this, &KItemListHeaderWidget::slotSortOrderChanged);
     }
 
     m_model = model;
 
     if (m_model) {
-        connect(m_model, &KItemModelBase::sortRoleChanged,
-                this, &KItemListHeaderWidget::slotSortRoleChanged);
-        connect(m_model, &KItemModelBase::sortOrderChanged,
-                this, &KItemListHeaderWidget::slotSortOrderChanged);
+        connect(m_model, &KItemModelBase::sortRoleChanged, this, &KItemListHeaderWidget::slotSortRoleChanged);
+        connect(m_model, &KItemModelBase::sortOrderChanged, this, &KItemListHeaderWidget::slotSortOrderChanged);
     }
 }
 
-KItemModelBase* KItemListHeaderWidget::model() const
+KItemModelBase *KItemListHeaderWidget::model() const
 {
     return m_model;
 }
@@ -79,9 +74,9 @@ bool KItemListHeaderWidget::automaticColumnResizing() const
     return m_automaticColumnResizing;
 }
 
-void KItemListHeaderWidget::setColumns(const QList<QByteArray>& roles)
+void KItemListHeaderWidget::setColumns(const QList<QByteArray> &roles)
 {
-    for (const QByteArray& role : roles) {
+    for (const QByteArray &role : roles) {
         if (!m_columnWidths.contains(role)) {
             m_preferredColumnWidths.remove(role);
         }
@@ -96,7 +91,7 @@ QList<QByteArray> KItemListHeaderWidget::columns() const
     return m_columns;
 }
 
-void KItemListHeaderWidget::setColumnWidth(const QByteArray& role, qreal width)
+void KItemListHeaderWidget::setColumnWidth(const QByteArray &role, qreal width)
 {
     const qreal minWidth = minimumColumnWidth();
     if (width < minWidth) {
@@ -109,17 +104,17 @@ void KItemListHeaderWidget::setColumnWidth(const QByteArray& role, qreal width)
     }
 }
 
-qreal KItemListHeaderWidget::columnWidth(const QByteArray& role) const
+qreal KItemListHeaderWidget::columnWidth(const QByteArray &role) const
 {
     return m_columnWidths.value(role);
 }
 
-void KItemListHeaderWidget::setPreferredColumnWidth(const QByteArray& role, qreal width)
+void KItemListHeaderWidget::setPreferredColumnWidth(const QByteArray &role, qreal width)
 {
     m_preferredColumnWidths.insert(role, width);
 }
 
-qreal KItemListHeaderWidget::preferredColumnWidth(const QByteArray& role) const
+qreal KItemListHeaderWidget::preferredColumnWidth(const QByteArray &role) const
 {
     return m_preferredColumnWidths.value(role);
 }
@@ -157,7 +152,7 @@ qreal KItemListHeaderWidget::minimumColumnWidth() const
     return fontMetrics.height() * 4;
 }
 
-void KItemListHeaderWidget::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
+void KItemListHeaderWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
     Q_UNUSED(option)
     Q_UNUSED(widget)
@@ -172,7 +167,7 @@ void KItemListHeaderWidget::paint(QPainter* painter, const QStyleOptionGraphicsI
 
     qreal x = -m_offset + m_sidePadding;
     int orderIndex = 0;
-    for (const QByteArray& role : qAsConst(m_columns)) {
+    for (const QByteArray &role : qAsConst(m_columns)) {
         const qreal roleWidth = m_columnWidths.value(role);
         const QRectF rect(x, 0, roleWidth, size().height());
         paintRole(painter, role, rect, orderIndex, widget);
@@ -186,7 +181,7 @@ void KItemListHeaderWidget::paint(QPainter* painter, const QStyleOptionGraphicsI
     }
 }
 
-void KItemListHeaderWidget::mousePressEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     if (event->button() & Qt::LeftButton) {
         m_pressedMousePos = event->pos();
@@ -194,8 +189,7 @@ void KItemListHeaderWidget::mousePressEvent(QGraphicsSceneMouseEvent* event)
             m_roleOperation = ResizePaddingColumnOperation;
         } else {
             updatePressedRoleIndex(event->pos());
-            m_roleOperation = isAboveRoleGrip(m_pressedMousePos, m_pressedRoleIndex) ?
-                              ResizeRoleOperation : NoRoleOperation;
+            m_roleOperation = isAboveRoleGrip(m_pressedMousePos, m_pressedRoleIndex) ? ResizeRoleOperation : NoRoleOperation;
         }
         event->accept();
     } else {
@@ -203,7 +197,7 @@ void KItemListHeaderWidget::mousePressEvent(QGraphicsSceneMouseEvent* event)
     }
 }
 
-void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     QGraphicsWidget::mouseReleaseEvent(event);
 
@@ -219,8 +213,7 @@ void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
         if (m_pressedRoleIndex == sortRoleIndex) {
             // Toggle the sort order
             const Qt::SortOrder previous = m_model->sortOrder();
-            const Qt::SortOrder current = (m_model->sortOrder() == Qt::AscendingOrder) ?
-                                          Qt::DescendingOrder : Qt::AscendingOrder;
+            const Qt::SortOrder current = (m_model->sortOrder() == Qt::AscendingOrder) ? Qt::DescendingOrder : Qt::AscendingOrder;
             m_model->setSortOrder(current);
             Q_EMIT sortOrderChanged(current, previous);
         } else {
@@ -264,7 +257,7 @@ void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
     QApplication::restoreOverrideCursor();
 }
 
-void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
     QGraphicsWidget::mouseMoveEvent(event);
 
@@ -352,7 +345,7 @@ void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
     }
 }
 
-void KItemListHeaderWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 {
     QGraphicsItem::mouseDoubleClickEvent(event);
 
@@ -369,13 +362,13 @@ void KItemListHeaderWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* even
     }
 }
 
-void KItemListHeaderWidget::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
+void KItemListHeaderWidget::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
     QGraphicsWidget::hoverEnterEvent(event);
     updateHoveredRoleIndex(event->pos());
 }
 
-void KItemListHeaderWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent* event)
+void KItemListHeaderWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
 {
     QGraphicsWidget::hoverLeaveEvent(event);
     if (m_hoveredRoleIndex != -1) {
@@ -384,22 +377,21 @@ void KItemListHeaderWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent* event)
     }
 }
 
-void KItemListHeaderWidget::hoverMoveEvent(QGraphicsSceneHoverEvent* event)
+void KItemListHeaderWidget::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 {
     QGraphicsWidget::hoverMoveEvent(event);
 
-    const QPointF& pos = event->pos();
+    const QPointF &pos = event->pos();
     updateHoveredRoleIndex(pos);
-    if ((m_hoveredRoleIndex >= 0 && isAboveRoleGrip(pos, m_hoveredRoleIndex)) ||
-            isAbovePaddingGrip(pos, PaddingGrip::Leading) ||
-        isAbovePaddingGrip(pos, PaddingGrip::Trailing)) {
+    if ((m_hoveredRoleIndex >= 0 && isAboveRoleGrip(pos, m_hoveredRoleIndex)) || isAbovePaddingGrip(pos, PaddingGrip::Leading)
+        || isAbovePaddingGrip(pos, PaddingGrip::Trailing)) {
         setCursor(Qt::SplitHCursor);
     } else {
         unsetCursor();
     }
 }
 
-void KItemListHeaderWidget::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
+void KItemListHeaderWidget::slotSortRoleChanged(const QByteArray &current, const QByteArray &previous)
 {
     Q_UNUSED(current)
     Q_UNUSED(previous)
@@ -413,11 +405,7 @@ void KItemListHeaderWidget::slotSortOrderChanged(Qt::SortOrder current, Qt::Sort
     update();
 }
 
-void KItemListHeaderWidget::paintRole(QPainter* painter,
-                                      const QByteArray& role,
-                                      const QRectF& rect,
-                                      int orderIndex,
-                                      QWidget* widget) const
+void KItemListHeaderWidget::paintRole(QPainter *painter, const QByteArray &role, const QRectF &rect, int orderIndex, QWidget *widget) const
 {
     const auto direction = widget ? widget->layoutDirection() : qApp->layoutDirection();
 
@@ -425,10 +413,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
     // SPDX-FileCopyrightText: 2011 Nokia Corporation and/or its subsidiary(-ies).
     QStyleOptionHeader option;
     option.direction = direction;
-    option.textAlignment =
-        direction == Qt::LeftToRight
-            ? Qt::AlignLeft
-            : Qt::AlignRight;
+    option.textAlignment = direction == Qt::LeftToRight ? Qt::AlignLeft : Qt::AlignRight;
 
     option.section = orderIndex;
     option.state = QStyle::State_None | QStyle::State_Raised | QStyle::State_Horizontal;
@@ -445,8 +430,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
         option.state |= QStyle::State_Sunken;
     }
     if (m_model->sortRole() == role) {
-        option.sortIndicator = (m_model->sortOrder() == Qt::AscendingOrder) ?
-                                QStyleOptionHeader::SortDown : QStyleOptionHeader::SortUp;
+        option.sortIndicator = (m_model->sortOrder() == Qt::AscendingOrder) ? QStyleOptionHeader::SortDown : QStyleOptionHeader::SortUp;
     }
     option.rect = rect.toRect();
     option.orientation = Qt::Horizontal;
@@ -454,7 +438,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
     option.text = m_model->roleDescription(role);
 
     // First we paint any potential empty (padding) space on left and/or right of this role's column.
-    const auto paintPadding = [&](int section, const QRectF &rect, const QStyleOptionHeader::SectionPosition &pos){
+    const auto paintPadding = [&](int section, const QRectF &rect, const QStyleOptionHeader::SectionPosition &pos) {
         QStyleOptionHeader padding;
         padding.state = QStyle::State_None | QStyle::State_Raised | QStyle::State_Horizontal;
         padding.section = section;
@@ -473,7 +457,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
         // Paint the header for the first column; check if there is some empty space to the left which needs to be filled.
         if (rect.left() > 0) {
             option.position = QStyleOptionHeader::Middle;
-            paintPadding(0,QRectF(0.0, 0.0, rect.left(), rect.height()), QStyleOptionHeader::Beginning);
+            paintPadding(0, QRectF(0.0, 0.0, rect.left(), rect.height()), QStyleOptionHeader::Beginning);
         } else {
             option.position = QStyleOptionHeader::Beginning;
         }
@@ -492,7 +476,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
     style()->drawControl(QStyle::CE_Header, &option, painter, widget);
 }
 
-void KItemListHeaderWidget::updatePressedRoleIndex(const QPointF& pos)
+void KItemListHeaderWidget::updatePressedRoleIndex(const QPointF &pos)
 {
     const int pressedIndex = roleIndexAt(pos);
     if (m_pressedRoleIndex != pressedIndex) {
@@ -501,7 +485,7 @@ void KItemListHeaderWidget::updatePressedRoleIndex(const QPointF& pos)
     }
 }
 
-void KItemListHeaderWidget::updateHoveredRoleIndex(const QPointF& pos)
+void KItemListHeaderWidget::updateHoveredRoleIndex(const QPointF &pos)
 {
     const int hoverIndex = roleIndexAt(pos);
     if (m_hoveredRoleIndex != hoverIndex) {
@@ -510,12 +494,12 @@ void KItemListHeaderWidget::updateHoveredRoleIndex(const QPointF& pos)
     }
 }
 
-int KItemListHeaderWidget::roleIndexAt(const QPointF& pos) const
+int KItemListHeaderWidget::roleIndexAt(const QPointF &pos) const
 {
     int index = -1;
 
     qreal x = -m_offset + m_sidePadding;
-    for (const QByteArray& role : qAsConst(m_columns)) {
+    for (const QByteArray &role : qAsConst(m_columns)) {
         ++index;
         x += m_columnWidths.value(role);
         if (pos.x() <= x) {
@@ -526,7 +510,7 @@ int KItemListHeaderWidget::roleIndexAt(const QPointF& pos) const
     return index;
 }
 
-bool KItemListHeaderWidget::isAboveRoleGrip(const QPointF& pos, int roleIndex) const
+bool KItemListHeaderWidget::isAboveRoleGrip(const QPointF &pos, int roleIndex) const
 {
     qreal x = -m_offset + m_sidePadding;
     for (int i = 0; i <= roleIndex; ++i) {
@@ -538,7 +522,7 @@ bool KItemListHeaderWidget::isAboveRoleGrip(const QPointF& pos, int roleIndex) c
     return pos.x() >= (x - grip) && pos.x() <= x;
 }
 
-bool KItemListHeaderWidget::isAbovePaddingGrip(const QPointF& pos, PaddingGrip paddingGrip) const
+bool KItemListHeaderWidget::isAbovePaddingGrip(const QPointF &pos, PaddingGrip paddingGrip) const
 {
     const qreal lx = -m_offset + m_sidePadding;
     const int grip = style()->pixelMetric(QStyle::PM_HeaderGripMargin);
@@ -546,10 +530,9 @@ bool KItemListHeaderWidget::isAbovePaddingGrip(const QPointF& pos, PaddingGrip p
     switch (paddingGrip) {
     case Leading:
         return pos.x() >= (lx - grip) && pos.x() <= lx;
-    case Trailing:
-    {
+    case Trailing: {
         qreal rx = lx;
-        for (const QByteArray& role : qAsConst(m_columns)) {
+        for (const QByteArray &role : qAsConst(m_columns)) {
             rx += m_columnWidths.value(role);
         }
         return pos.x() >= (rx - grip) && pos.x() <= rx;
@@ -596,12 +579,8 @@ int KItemListHeaderWidget::targetOfMovingRole() const
         const qreal targetWidth = m_columnWidths.value(role);
         const qreal targetRight = targetLeft + targetWidth - 1;
 
-        const bool isInTarget = (targetWidth >= movingWidth &&
-                                 movingLeft  >= targetLeft  &&
-                                 movingRight <= targetRight) ||
-                                (targetWidth <  movingWidth &&
-                                 movingLeft  <= targetLeft  &&
-                                 movingRight >= targetRight);
+        const bool isInTarget = (targetWidth >= movingWidth && movingLeft >= targetLeft && movingRight <= targetRight)
+            || (targetWidth < movingWidth && movingLeft <= targetLeft && movingRight >= targetRight);
 
         if (isInTarget) {
             return targetIndex;
@@ -614,10 +593,10 @@ int KItemListHeaderWidget::targetOfMovingRole() const
     return m_movingRole.index;
 }
 
-qreal KItemListHeaderWidget::roleXPosition(const QByteArray& role) const
+qreal KItemListHeaderWidget::roleXPosition(const QByteArray &role) const
 {
     qreal x = -m_offset + m_sidePadding;
-    for (const QByteArray& visibleRole : qAsConst(m_columns)) {
+    for (const QByteArray &visibleRole : qAsConst(m_columns)) {
         if (visibleRole == role) {
             return x;
         }
@@ -627,4 +606,3 @@ qreal KItemListHeaderWidget::roleXPosition(const QByteArray& role) const
 
     return -1;
 }
-
diff --git a/src/kitemviews/private/kitemlistheaderwidget.h b/src/kitemviews/private/kitemlistheaderwidget.h
index f99d64c81..58c27b43a 100644
--- a/src/kitemviews/private/kitemlistheaderwidget.h
+++ b/src/kitemviews/private/kitemlistheaderwidget.h
@@ -26,26 +26,26 @@ class DOLPHIN_EXPORT KItemListHeaderWidget : public QGraphicsWidget
     Q_OBJECT
 
 public:
-    explicit KItemListHeaderWidget(QGraphicsWidget* parent = nullptr);
+    explicit KItemListHeaderWidget(QGraphicsWidget *parent = nullptr);
     ~KItemListHeaderWidget() override;
 
-    void setModel(KItemModelBase* model);
-    KItemModelBase* model() const;
+    void setModel(KItemModelBase *model);
+    KItemModelBase *model() const;
 
     void setAutomaticColumnResizing(bool automatic);
     bool automaticColumnResizing() const;
 
-    void setColumns(const QList<QByteArray>& roles);
+    void setColumns(const QList<QByteArray> &roles);
     QList<QByteArray> columns() const;
 
-    void setColumnWidth(const QByteArray& role, qreal width);
-    qreal columnWidth(const QByteArray& role) const;
+    void setColumnWidth(const QByteArray &role, qreal width);
+    qreal columnWidth(const QByteArray &role) const;
 
     /**
      * Sets the column-width that is required to show the role unclipped.
      */
-    void setPreferredColumnWidth(const QByteArray& role, qreal width);
-    qreal preferredColumnWidth(const QByteArray& role) const;
+    void setPreferredColumnWidth(const QByteArray &role, qreal width);
+    qreal preferredColumnWidth(const QByteArray &role) const;
 
     void setOffset(qreal offset);
     qreal offset() const;
@@ -55,16 +55,14 @@ public:
 
     qreal minimumColumnWidth() const;
 
-    void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;
 
 Q_SIGNALS:
     /**
      * Is emitted if the width of a visible role has been adjusted by the user with the mouse
      * (no signal is emitted if KItemListHeader::setVisibleRoleWidth() is invoked).
      */
-    void columnWidthChanged(const QByteArray& role,
-                            qreal currentWidth,
-                            qreal previousWidth);
+    void columnWidthChanged(const QByteArray &role, qreal currentWidth, qreal previousWidth);
 
     void sidePaddingChanged(qreal width);
 
@@ -72,13 +70,12 @@ Q_SIGNALS:
      * Is emitted if the user has released the mouse button after adjusting the
      * width of a visible role.
      */
-    void columnWidthChangeFinished(const QByteArray& role,
-                                   qreal currentWidth);
+    void columnWidthChangeFinished(const QByteArray &role, qreal currentWidth);
 
     /**
      * Is emitted if the position of the column has been changed.
      */
-    void columnMoved(const QByteArray& role, int currentIndex, int previousIndex);
+    void columnMoved(const QByteArray &role, int currentIndex, int previousIndex);
 
     /**
      * Is emitted if the user has changed the sort order by clicking on a
@@ -94,40 +91,34 @@ Q_SIGNALS:
      * the current sort role. Note that no signal will be emitted if the
      * sort role of the model has been changed without user interaction.
      */
-    void sortRoleChanged(const QByteArray& current, const QByteArray& previous);
+    void sortRoleChanged(const QByteArray &current, const QByteArray &previous);
 
 protected:
-    void mousePressEvent(QGraphicsSceneMouseEvent* event) override;
-    void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) override;
-    void mouseMoveEvent(QGraphicsSceneMouseEvent* event) override;
-    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) override;
-    void hoverEnterEvent(QGraphicsSceneHoverEvent* event) override;
-    void hoverLeaveEvent(QGraphicsSceneHoverEvent* event) override;
-    void hoverMoveEvent(QGraphicsSceneHoverEvent* event) override;
+    void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override;
+    void hoverEnterEvent(QGraphicsSceneHoverEvent *event) override;
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override;
+    void hoverMoveEvent(QGraphicsSceneHoverEvent *event) override;
 
 private Q_SLOTS:
-    void slotSortRoleChanged(const QByteArray& current, const QByteArray& previous);
+    void slotSortRoleChanged(const QByteArray &current, const QByteArray &previous);
     void slotSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous);
 
 private:
-
-    enum PaddingGrip
-    {
+    enum PaddingGrip {
         Leading,
         Trailing,
     };
 
-    void paintRole(QPainter* painter,
-                   const QByteArray& role,
-                   const QRectF& rect,
-                   int orderIndex,
-                   QWidget* widget = nullptr) const;
+    void paintRole(QPainter *painter, const QByteArray &role, const QRectF &rect, int orderIndex, QWidget *widget = nullptr) const;
 
-    void updatePressedRoleIndex(const QPointF& pos);
-    void updateHoveredRoleIndex(const QPointF& pos);
-    int roleIndexAt(const QPointF& pos) const;
-    bool isAboveRoleGrip(const QPointF& pos, int roleIndex) const;
-    bool isAbovePaddingGrip(const QPointF& pos, PaddingGrip paddingGrip) const;
+    void updatePressedRoleIndex(const QPointF &pos);
+    void updateHoveredRoleIndex(const QPointF &pos);
+    int roleIndexAt(const QPointF &pos) const;
+    bool isAboveRoleGrip(const QPointF &pos, int roleIndex) const;
+    bool isAbovePaddingGrip(const QPointF &pos, PaddingGrip paddingGrip) const;
 
     /**
      * Creates a pixmap of the role with the index \a roleIndex that is shown
@@ -144,19 +135,13 @@ private:
     /**
      * @return x-position of the left border of the role \a role.
      */
-    qreal roleXPosition(const QByteArray& role) const;
+    qreal roleXPosition(const QByteArray &role) const;
 
 private:
-    enum RoleOperation
-    {
-        NoRoleOperation,
-        ResizeRoleOperation,
-        ResizePaddingColumnOperation,
-        MoveRoleOperation
-    };
+    enum RoleOperation { NoRoleOperation, ResizeRoleOperation, ResizePaddingColumnOperation, MoveRoleOperation };
 
     bool m_automaticColumnResizing;
-    KItemModelBase* m_model;
+    KItemModelBase *m_model;
     qreal m_offset;
     qreal m_sidePadding;
     QList<QByteArray> m_columns;
@@ -168,8 +153,7 @@ private:
     RoleOperation m_roleOperation;
     QPointF m_pressedMousePos;
 
-    struct MovingRole
-    {
+    struct MovingRole {
         QPixmap pixmap;
         int x;
         int xDec;
@@ -178,5 +162,3 @@ private:
 };
 
 #endif
-
-
diff --git a/src/kitemviews/private/kitemlistkeyboardsearchmanager.cpp b/src/kitemviews/private/kitemlistkeyboardsearchmanager.cpp
index e646a6249..b7318b344 100644
--- a/src/kitemviews/private/kitemlistkeyboardsearchmanager.cpp
+++ b/src/kitemviews/private/kitemlistkeyboardsearchmanager.cpp
@@ -8,10 +8,10 @@
 
 #include "kitemlistkeyboardsearchmanager.h"
 
-KItemListKeyboardSearchManager::KItemListKeyboardSearchManager(QObject* parent) :
-    QObject(parent),
-    m_isSearchRestarted(false),
-    m_timeout(1000)
+KItemListKeyboardSearchManager::KItemListKeyboardSearchManager(QObject *parent)
+    : QObject(parent)
+    , m_isSearchRestarted(false)
+    , m_timeout(1000)
 {
     m_keyboardInputTime.invalidate();
 }
@@ -27,7 +27,7 @@ bool KItemListKeyboardSearchManager::shouldClearSearchIfInputTimeReached()
     return (keyboardInputTimeElapsed > m_timeout) || !keyboardTimeWasValid;
 }
 
-void KItemListKeyboardSearchManager::addKeys(const QString& keys)
+void KItemListKeyboardSearchManager::addKeys(const QString &keys)
 {
     if (shouldClearSearchIfInputTimeReached()) {
         m_searchedString.clear();
@@ -94,7 +94,7 @@ void KItemListKeyboardSearchManager::slotCurrentChanged(int current, int previou
     }
 }
 
-void KItemListKeyboardSearchManager::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
+void KItemListKeyboardSearchManager::slotSelectionChanged(const KItemSet &current, const KItemSet &previous)
 {
     if (!previous.isEmpty() && current.isEmpty() && previous.count() > 0 && current.count() == 0) {
         // The selection has been emptied. We should cancel the search.
diff --git a/src/kitemviews/private/kitemlistkeyboardsearchmanager.h b/src/kitemviews/private/kitemlistkeyboardsearchmanager.h
index 80caea2ed..d370bc9ba 100644
--- a/src/kitemviews/private/kitemlistkeyboardsearchmanager.h
+++ b/src/kitemviews/private/kitemlistkeyboardsearchmanager.h
@@ -27,14 +27,13 @@ class DOLPHIN_EXPORT KItemListKeyboardSearchManager : public QObject
     Q_OBJECT
 
 public:
-
-    explicit KItemListKeyboardSearchManager(QObject* parent = nullptr);
+    explicit KItemListKeyboardSearchManager(QObject *parent = nullptr);
     ~KItemListKeyboardSearchManager() override;
 
     /**
      * Add \a keys to the text buffer used for searching.
      */
-    void addKeys(const QString& keys);
+    void addKeys(const QString &keys);
     /**
      * @returns true if the next call to addKeys() will trigger a new search.
      *          Returns false if the next added key char will be added to the search string that was used previously.
@@ -55,7 +54,7 @@ public:
 public Q_SLOTS:
 
     void slotCurrentChanged(int current, int previous);
-    void slotSelectionChanged(const KItemSet& current, const KItemSet& previous);
+    void slotSelectionChanged(const KItemSet &current, const KItemSet &previous);
 
 Q_SIGNALS:
     /**
@@ -67,7 +66,7 @@ Q_SIGNALS:
      */
     // TODO: Think about getting rid of the bool parameter
     // (see https://doc.qt.io/archives/qq/qq13-apis.html#thebooleanparametertrap)
-    void changeCurrentItem(const QString& string, bool searchFromNextItem);
+    void changeCurrentItem(const QString &string, bool searchFromNextItem);
 
 private:
     bool shouldClearSearchIfInputTimeReached();
@@ -82,5 +81,3 @@ private:
 };
 
 #endif
-
-
diff --git a/src/kitemviews/private/kitemlistroleeditor.cpp b/src/kitemviews/private/kitemlistroleeditor.cpp
index 993c6893a..d3389832b 100644
--- a/src/kitemviews/private/kitemlistroleeditor.cpp
+++ b/src/kitemviews/private/kitemlistroleeditor.cpp
@@ -8,10 +8,10 @@
 
 #include <KIO/Global>
 
-KItemListRoleEditor::KItemListRoleEditor(QWidget *parent) :
-    KTextEdit(parent),
-    m_role(),
-    m_blockFinishedSignal(false)
+KItemListRoleEditor::KItemListRoleEditor(QWidget *parent)
+    : KTextEdit(parent)
+    , m_role()
+    , m_blockFinishedSignal(false)
 {
     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
@@ -30,7 +30,7 @@ KItemListRoleEditor::~KItemListRoleEditor()
 {
 }
 
-void KItemListRoleEditor::setRole(const QByteArray& role)
+void KItemListRoleEditor::setRole(const QByteArray &role)
 {
     m_role = role;
 }
@@ -45,7 +45,7 @@ void KItemListRoleEditor::setAllowUpDownKeyChainEdit(bool allowChainEdit)
     m_allowUpDownKeyChainEdit = allowChainEdit;
 }
 
-bool KItemListRoleEditor::eventFilter(QObject* watched, QEvent* event)
+bool KItemListRoleEditor::eventFilter(QObject *watched, QEvent *event)
 {
     if (watched == parentWidget() && event->type() == QEvent::Resize) {
         emitRoleEditingFinished();
@@ -54,10 +54,10 @@ bool KItemListRoleEditor::eventFilter(QObject* watched, QEvent* event)
     return KTextEdit::eventFilter(watched, event);
 }
 
-bool KItemListRoleEditor::event(QEvent* event)
+bool KItemListRoleEditor::event(QEvent *event)
 {
     if (event->type() == QEvent::FocusOut) {
-        QFocusEvent* focusEvent = static_cast<QFocusEvent*>(event);
+        QFocusEvent *focusEvent = static_cast<QFocusEvent *>(event);
         if (focusEvent->reason() != Qt::PopupFocusReason) {
             emitRoleEditingFinished();
         }
@@ -65,7 +65,7 @@ bool KItemListRoleEditor::event(QEvent* event)
     return KTextEdit::event(event);
 }
 
-void KItemListRoleEditor::keyPressEvent(QKeyEvent* event)
+void KItemListRoleEditor::keyPressEvent(QKeyEvent *event)
 {
     switch (event->key()) {
     case Qt::Key_Escape:
@@ -118,12 +118,8 @@ void KItemListRoleEditor::keyPressEvent(QKeyEvent* event)
     case Qt::Key_Home:
     case Qt::Key_End: {
         if (event->modifiers() == Qt::NoModifier || event->modifiers() == Qt::ShiftModifier) {
-            const QTextCursor::MoveOperation op = event->key() == Qt::Key_Home
-                                                ? QTextCursor::Start
-                                                : QTextCursor::End;
-            const QTextCursor::MoveMode mode = event->modifiers() == Qt::NoModifier
-                                             ? QTextCursor::MoveAnchor
-                                             : QTextCursor::KeepAnchor;
+            const QTextCursor::MoveOperation op = event->key() == Qt::Key_Home ? QTextCursor::Start : QTextCursor::End;
+            const QTextCursor::MoveMode mode = event->modifiers() == Qt::NoModifier ? QTextCursor::MoveAnchor : QTextCursor::KeepAnchor;
             QTextCursor cursor = textCursor();
             cursor.movePosition(op, mode);
             setTextCursor(cursor);
@@ -167,10 +163,9 @@ void KItemListRoleEditor::autoAdjustSize()
 void KItemListRoleEditor::emitRoleEditingFinished(EditResultDirection direction)
 {
     QVariant ret;
-    ret.setValue(EditResult {KIO::encodeFileName(toPlainText()), direction});
+    ret.setValue(EditResult{KIO::encodeFileName(toPlainText()), direction});
 
     if (!m_blockFinishedSignal) {
         Q_EMIT roleEditingFinished(m_role, ret);
     }
 }
-
diff --git a/src/kitemviews/private/kitemlistroleeditor.h b/src/kitemviews/private/kitemlistroleeditor.h
index a0f55df51..18304374d 100644
--- a/src/kitemviews/private/kitemlistroleeditor.h
+++ b/src/kitemviews/private/kitemlistroleeditor.h
@@ -11,15 +11,14 @@
 
 #include <KTextEdit>
 
-enum EditResultDirection{
+enum EditResultDirection {
     EditDone,
     EditNext,
     EditPrevious,
 };
 Q_DECLARE_METATYPE(EditResultDirection)
 
-struct EditResult
-{
+struct EditResult {
     QString newName;
     EditResultDirection direction;
 };
@@ -39,22 +38,22 @@ class DOLPHIN_EXPORT KItemListRoleEditor : public KTextEdit
     Q_OBJECT
 
 public:
-    explicit KItemListRoleEditor(QWidget* parent);
+    explicit KItemListRoleEditor(QWidget *parent);
     ~KItemListRoleEditor() override;
 
-    void setRole(const QByteArray& role);
+    void setRole(const QByteArray &role);
     QByteArray role() const;
 
     void setAllowUpDownKeyChainEdit(bool allowChainEdit);
-    bool eventFilter(QObject* watched, QEvent* event) override;
+    bool eventFilter(QObject *watched, QEvent *event) override;
 
 Q_SIGNALS:
-    void roleEditingFinished(const QByteArray& role, const QVariant& value);
-    void roleEditingCanceled(const QByteArray& role, const QVariant& value);
+    void roleEditingFinished(const QByteArray &role, const QVariant &value);
+    void roleEditingCanceled(const QByteArray &role, const QVariant &value);
 
 protected:
-    bool event(QEvent* event) override;
-    void keyPressEvent(QKeyEvent* event) override;
+    bool event(QEvent *event) override;
+    void keyPressEvent(QKeyEvent *event) override;
 
 private Q_SLOTS:
     /**
diff --git a/src/kitemviews/private/kitemlistrubberband.cpp b/src/kitemviews/private/kitemlistrubberband.cpp
index 646139a33..e572780e7 100644
--- a/src/kitemviews/private/kitemlistrubberband.cpp
+++ b/src/kitemviews/private/kitemlistrubberband.cpp
@@ -6,11 +6,11 @@
 
 #include "kitemlistrubberband.h"
 
-KItemListRubberBand::KItemListRubberBand(QObject* parent) :
-    QObject(parent),
-    m_active(false),
-    m_startPos(),
-    m_endPos()
+KItemListRubberBand::KItemListRubberBand(QObject *parent)
+    : QObject(parent)
+    , m_active(false)
+    , m_startPos()
+    , m_endPos()
 {
 }
 
@@ -18,7 +18,7 @@ KItemListRubberBand::~KItemListRubberBand()
 {
 }
 
-void KItemListRubberBand::setStartPosition(const QPointF& pos)
+void KItemListRubberBand::setStartPosition(const QPointF &pos)
 {
     if (m_startPos != pos) {
         const QPointF previous = m_startPos;
@@ -32,7 +32,7 @@ QPointF KItemListRubberBand::startPosition() const
     return m_startPos;
 }
 
-void KItemListRubberBand::setEndPosition(const QPointF& pos)
+void KItemListRubberBand::setEndPosition(const QPointF &pos)
 {
     if (m_endPos != pos) {
         const QPointF previous = m_endPos;
@@ -74,4 +74,3 @@ bool KItemListRubberBand::isActive() const
 {
     return m_active;
 }
-
diff --git a/src/kitemviews/private/kitemlistrubberband.h b/src/kitemviews/private/kitemlistrubberband.h
index 11febcf7e..fd1416b56 100644
--- a/src/kitemviews/private/kitemlistrubberband.h
+++ b/src/kitemviews/private/kitemlistrubberband.h
@@ -21,13 +21,13 @@ class DOLPHIN_EXPORT KItemListRubberBand : public QObject
     Q_PROPERTY(QPointF endPosition MEMBER m_endPos READ endPosition WRITE setEndPosition)
 
 public:
-    explicit KItemListRubberBand(QObject* parent = nullptr);
+    explicit KItemListRubberBand(QObject *parent = nullptr);
     ~KItemListRubberBand() override;
 
-    void setStartPosition(const QPointF& pos);
+    void setStartPosition(const QPointF &pos);
     QPointF startPosition() const;
 
-    void setEndPosition(const QPointF& pos);
+    void setEndPosition(const QPointF &pos);
     QPointF endPosition() const;
 
     void setActive(bool active);
@@ -35,8 +35,8 @@ public:
 
 Q_SIGNALS:
     void activationChanged(bool active);
-    void startPositionChanged(const QPointF& current, const QPointF& previous);
-    void endPositionChanged(const QPointF& current, const QPointF& previous);
+    void startPositionChanged(const QPointF &current, const QPointF &previous);
+    void endPositionChanged(const QPointF &current, const QPointF &previous);
 
 private:
     bool m_active;
@@ -45,5 +45,3 @@ private:
 };
 
 #endif
-
-
diff --git a/src/kitemviews/private/kitemlistselectiontoggle.cpp b/src/kitemviews/private/kitemlistselectiontoggle.cpp
index 2905e2925..bec32b3d3 100644
--- a/src/kitemviews/private/kitemlistselectiontoggle.cpp
+++ b/src/kitemviews/private/kitemlistselectiontoggle.cpp
@@ -11,10 +11,10 @@
 #include <QIcon>
 #include <QPainter>
 
-KItemListSelectionToggle::KItemListSelectionToggle(QGraphicsItem* parent) :
-    QGraphicsWidget(parent),
-    m_checked(false),
-    m_hovered(false)
+KItemListSelectionToggle::KItemListSelectionToggle(QGraphicsItem *parent)
+    : QGraphicsWidget(parent)
+    , m_checked(false)
+    , m_hovered(false)
 {
 }
 
@@ -45,7 +45,7 @@ void KItemListSelectionToggle::setHovered(bool hovered)
     }
 }
 
-void KItemListSelectionToggle::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
+void KItemListSelectionToggle::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
     Q_UNUSED(option)
     Q_UNUSED(widget)
@@ -54,12 +54,12 @@ void KItemListSelectionToggle::paint(QPainter* painter, const QStyleOptionGraphi
         updatePixmap();
     }
 
-    const qreal x = (size().width()  - qreal(m_pixmap.width() / m_pixmap.devicePixelRatioF()))  / 2;
+    const qreal x = (size().width() - qreal(m_pixmap.width() / m_pixmap.devicePixelRatioF())) / 2;
     const qreal y = (size().height() - qreal(m_pixmap.height() / m_pixmap.devicePixelRatioF())) / 2;
     painter->drawPixmap(x, y, m_pixmap);
 }
 
-void KItemListSelectionToggle::resizeEvent(QGraphicsSceneResizeEvent* event)
+void KItemListSelectionToggle::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
     QGraphicsWidget::resizeEvent(event);
 
@@ -99,4 +99,3 @@ int KItemListSelectionToggle::iconSize() const
 
     return iconSize;
 }
-
diff --git a/src/kitemviews/private/kitemlistselectiontoggle.h b/src/kitemviews/private/kitemlistselectiontoggle.h
index 0a592653e..2f3969c29 100644
--- a/src/kitemviews/private/kitemlistselectiontoggle.h
+++ b/src/kitemviews/private/kitemlistselectiontoggle.h
@@ -11,7 +11,6 @@
 #include <QGraphicsWidget>
 #include <QPixmap>
 
-
 /**
  * @brief Allows to toggle between the selected and unselected state of an item.
  */
@@ -20,7 +19,7 @@ class DOLPHIN_EXPORT KItemListSelectionToggle : public QGraphicsWidget
     Q_OBJECT
 
 public:
-    explicit KItemListSelectionToggle(QGraphicsItem* parent);
+    explicit KItemListSelectionToggle(QGraphicsItem *parent);
     ~KItemListSelectionToggle() override;
 
     void setChecked(bool checked);
@@ -28,10 +27,10 @@ public:
 
     void setHovered(bool hovered);
 
-    void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override;
 
 protected:
-    void resizeEvent(QGraphicsSceneResizeEvent* event) override;
+    void resizeEvent(QGraphicsSceneResizeEvent *event) override;
 
 private:
     void updatePixmap();
@@ -44,5 +43,3 @@ private:
 };
 
 #endif
-
-
diff --git a/src/kitemviews/private/kitemlistsizehintresolver.cpp b/src/kitemviews/private/kitemlistsizehintresolver.cpp
index 0c2dd0b80..b7165e8c3 100644
--- a/src/kitemviews/private/kitemlistsizehintresolver.cpp
+++ b/src/kitemviews/private/kitemlistsizehintresolver.cpp
@@ -7,12 +7,12 @@
 #include "kitemlistsizehintresolver.h"
 #include "kitemviews/kitemlistview.h"
 
-KItemListSizeHintResolver::KItemListSizeHintResolver(const KItemListView* itemListView) :
-    m_itemListView(itemListView),
-    m_logicalHeightHintCache(),
-    m_logicalWidthHint(0.0),
-    m_minHeightHint(0.0),
-    m_needsResolving(false)
+KItemListSizeHintResolver::KItemListSizeHintResolver(const KItemListView *itemListView)
+    : m_itemListView(itemListView)
+    , m_logicalHeightHintCache()
+    , m_logicalWidthHint(0.0)
+    , m_minHeightHint(0.0)
+    , m_needsResolving(false)
 {
 }
 
@@ -37,10 +37,10 @@ bool KItemListSizeHintResolver::isElided(int index)
     return m_logicalHeightHintCache.at(index).second;
 }
 
-void KItemListSizeHintResolver::itemsInserted(const KItemRangeList& itemRanges)
+void KItemListSizeHintResolver::itemsInserted(const KItemRangeList &itemRanges)
 {
     int insertedCount = 0;
-    for (const KItemRange& range : itemRanges) {
+    for (const KItemRange &range : itemRanges) {
         insertedCount += range.count;
     }
 
@@ -56,7 +56,7 @@ void KItemListSizeHintResolver::itemsInserted(const KItemRangeList& itemRanges)
     int itemsToInsertBeforeCurrentRange = insertedCount;
 
     for (int rangeIndex = itemRanges.count() - 1; rangeIndex >= 0; --rangeIndex) {
-        const KItemRange& range = itemRanges.at(rangeIndex);
+        const KItemRange &range = itemRanges.at(rangeIndex);
         itemsToInsertBeforeCurrentRange -= range.count;
 
         // First: move all existing items that must be put behind 'range'.
@@ -78,7 +78,7 @@ void KItemListSizeHintResolver::itemsInserted(const KItemRangeList& itemRanges)
     Q_ASSERT(m_logicalHeightHintCache.count() == m_itemListView->model()->count());
 }
 
-void KItemListSizeHintResolver::itemsRemoved(const KItemRangeList& itemRanges)
+void KItemListSizeHintResolver::itemsRemoved(const KItemRangeList &itemRanges)
 {
     const QVector<std::pair<qreal, bool>>::iterator begin = m_logicalHeightHintCache.begin();
     const QVector<std::pair<qreal, bool>>::iterator end = m_logicalHeightHintCache.end();
@@ -112,7 +112,7 @@ void KItemListSizeHintResolver::itemsRemoved(const KItemRangeList& itemRanges)
     }
 }
 
-void KItemListSizeHintResolver::itemsMoved(const KItemRange& range, const QList<int>& movedToIndexes)
+void KItemListSizeHintResolver::itemsMoved(const KItemRange &range, const QList<int> &movedToIndexes)
 {
     QVector<std::pair<qreal, bool>> newLogicalHeightHintCache(m_logicalHeightHintCache);
 
@@ -125,7 +125,7 @@ void KItemListSizeHintResolver::itemsMoved(const KItemRange& range, const QList<
     m_logicalHeightHintCache = newLogicalHeightHintCache;
 }
 
-void KItemListSizeHintResolver::itemsChanged(int index, int count, const QSet<QByteArray>& roles)
+void KItemListSizeHintResolver::itemsChanged(int index, int count, const QSet<QByteArray> &roles)
 {
     Q_UNUSED(roles)
     while (count) {
diff --git a/src/kitemviews/private/kitemlistsizehintresolver.h b/src/kitemviews/private/kitemlistsizehintresolver.h
index a6cc56614..c5a47f130 100644
--- a/src/kitemviews/private/kitemlistsizehintresolver.h
+++ b/src/kitemviews/private/kitemlistsizehintresolver.h
@@ -21,22 +21,22 @@ class KItemListView;
 class DOLPHIN_EXPORT KItemListSizeHintResolver
 {
 public:
-    explicit KItemListSizeHintResolver(const KItemListView* itemListView);
+    explicit KItemListSizeHintResolver(const KItemListView *itemListView);
     virtual ~KItemListSizeHintResolver();
     QSizeF minSizeHint();
     QSizeF sizeHint(int index);
     bool isElided(int index);
 
-    void itemsInserted(const KItemRangeList& itemRanges);
-    void itemsRemoved(const KItemRangeList& itemRanges);
-    void itemsMoved(const KItemRange& range, const QList<int>& movedToIndexes);
-    void itemsChanged(int index, int count, const QSet<QByteArray>& roles);
+    void itemsInserted(const KItemRangeList &itemRanges);
+    void itemsRemoved(const KItemRangeList &itemRanges);
+    void itemsMoved(const KItemRange &range, const QList<int> &movedToIndexes);
+    void itemsChanged(int index, int count, const QSet<QByteArray> &roles);
 
     void clearCache();
     void updateCache();
 
 private:
-    const KItemListView* m_itemListView;
+    const KItemListView *m_itemListView;
     mutable QVector<std::pair<qreal /* height */, bool /* isElided */>> m_logicalHeightHintCache;
     mutable qreal m_logicalWidthHint;
     mutable qreal m_minHeightHint;
diff --git a/src/kitemviews/private/kitemlistsmoothscroller.cpp b/src/kitemviews/private/kitemlistsmoothscroller.cpp
index 343399179..19d47aac8 100644
--- a/src/kitemviews/private/kitemlistsmoothscroller.cpp
+++ b/src/kitemviews/private/kitemlistsmoothscroller.cpp
@@ -12,20 +12,18 @@
 #include <QStyle>
 #include <QWheelEvent>
 
-KItemListSmoothScroller::KItemListSmoothScroller(QScrollBar* scrollBar,
-                                                 QObject* parent) :
-    QObject(parent),
-    m_scrollBarPressed(false),
-    m_smoothScrolling(true),
-    m_scrollBar(scrollBar),
-    m_animation(nullptr)
+KItemListSmoothScroller::KItemListSmoothScroller(QScrollBar *scrollBar, QObject *parent)
+    : QObject(parent)
+    , m_scrollBarPressed(false)
+    , m_smoothScrolling(true)
+    , m_scrollBar(scrollBar)
+    , m_animation(nullptr)
 {
     m_animation = new QPropertyAnimation(this);
     const int animationDuration = m_scrollBar->style()->styleHint(QStyle::SH_Widget_Animation_Duration, nullptr, m_scrollBar);
     const bool animationEnabled = (animationDuration > 0);
     m_animation->setDuration(animationEnabled ? animationDuration : 1);
-    connect(m_animation, &QPropertyAnimation::stateChanged,
-            this, &KItemListSmoothScroller::slotAnimationStateChanged);
+    connect(m_animation, &QPropertyAnimation::stateChanged, this, &KItemListSmoothScroller::slotAnimationStateChanged);
 
     m_scrollBar->installEventFilter(this);
 }
@@ -39,22 +37,22 @@ void KItemListSmoothScroller::setScrollBar(QScrollBar *scrollBar)
     m_scrollBar = scrollBar;
 }
 
-QScrollBar* KItemListSmoothScroller::scrollBar() const
+QScrollBar *KItemListSmoothScroller::scrollBar() const
 {
     return m_scrollBar;
 }
 
-void KItemListSmoothScroller::setTargetObject(QObject* target)
+void KItemListSmoothScroller::setTargetObject(QObject *target)
 {
     m_animation->setTargetObject(target);
 }
 
-QObject* KItemListSmoothScroller::targetObject() const
+QObject *KItemListSmoothScroller::targetObject() const
 {
     return m_animation->targetObject();
 }
 
-void KItemListSmoothScroller::setPropertyName(const QByteArray& propertyName)
+void KItemListSmoothScroller::setPropertyName(const QByteArray &propertyName)
 {
     m_animation->setPropertyName(propertyName);
 }
@@ -66,7 +64,7 @@ QByteArray KItemListSmoothScroller::propertyName() const
 
 void KItemListSmoothScroller::scrollContentsBy(qreal distance)
 {
-    QObject* target = targetObject();
+    QObject *target = targetObject();
     if (!target) {
         return;
     }
@@ -143,7 +141,7 @@ bool KItemListSmoothScroller::requestScrollBarUpdate(int newMaximum)
     return true;
 }
 
-bool KItemListSmoothScroller::eventFilter(QObject* obj, QEvent* event)
+bool KItemListSmoothScroller::eventFilter(QObject *obj, QEvent *event)
 {
     Q_ASSERT(obj == m_scrollBar);
 
@@ -168,8 +166,7 @@ bool KItemListSmoothScroller::eventFilter(QObject* obj, QEvent* event)
     return QObject::eventFilter(obj, event);
 }
 
-void KItemListSmoothScroller::slotAnimationStateChanged(QAbstractAnimation::State newState,
-                                                        QAbstractAnimation::State oldState)
+void KItemListSmoothScroller::slotAnimationStateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
 {
     Q_UNUSED(oldState)
     if (newState == QAbstractAnimation::Stopped && m_smoothScrolling && !m_scrollBarPressed) {
@@ -180,7 +177,7 @@ void KItemListSmoothScroller::slotAnimationStateChanged(QAbstractAnimation::Stat
     }
 }
 
-void KItemListSmoothScroller::handleWheelEvent(QWheelEvent* event)
+void KItemListSmoothScroller::handleWheelEvent(QWheelEvent *event)
 {
     const bool previous = m_smoothScrolling;
 
@@ -198,4 +195,3 @@ void KItemListSmoothScroller::handleWheelEvent(QWheelEvent* event)
 
     m_smoothScrolling = previous;
 }
-
diff --git a/src/kitemviews/private/kitemlistsmoothscroller.h b/src/kitemviews/private/kitemlistsmoothscroller.h
index 7b2839884..d1cfcf9d9 100644
--- a/src/kitemviews/private/kitemlistsmoothscroller.h
+++ b/src/kitemviews/private/kitemlistsmoothscroller.h
@@ -25,17 +25,16 @@ class DOLPHIN_EXPORT KItemListSmoothScroller : public QObject
     Q_OBJECT
 
 public:
-    explicit KItemListSmoothScroller(QScrollBar* scrollBar,
-                                     QObject* parent = nullptr);
+    explicit KItemListSmoothScroller(QScrollBar *scrollBar, QObject *parent = nullptr);
     ~KItemListSmoothScroller() override;
 
-    void setScrollBar(QScrollBar* scrollBar);
-    QScrollBar* scrollBar() const;
+    void setScrollBar(QScrollBar *scrollBar);
+    QScrollBar *scrollBar() const;
 
-    void setTargetObject(QObject* target);
-    QObject* targetObject() const;
+    void setTargetObject(QObject *target);
+    QObject *targetObject() const;
 
-    void setPropertyName(const QByteArray& propertyName);
+    void setPropertyName(const QByteArray &propertyName);
     QByteArray propertyName() const;
 
     /**
@@ -67,27 +66,25 @@ public:
     /**
      * Forwards wheel events to the scrollbar, ensuring smooth and proper scrolling
      */
-    void handleWheelEvent(QWheelEvent* event);
+    void handleWheelEvent(QWheelEvent *event);
 
 Q_SIGNALS:
     /**
      * Emitted when the scrolling animation has finished
      */
     void scrollingStopped();
+
 protected:
-    bool eventFilter(QObject* obj, QEvent* event) override;
+    bool eventFilter(QObject *obj, QEvent *event) override;
 
 private Q_SLOTS:
-    void slotAnimationStateChanged(QAbstractAnimation::State newState,
-                                   QAbstractAnimation::State oldState);
+    void slotAnimationStateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
 
 private:
     bool m_scrollBarPressed;
     bool m_smoothScrolling;
-    QScrollBar* m_scrollBar;
-    QPropertyAnimation* m_animation;
+    QScrollBar *m_scrollBar;
+    QPropertyAnimation *m_animation;
 };
 
 #endif
-
-
diff --git a/src/kitemviews/private/kitemlistviewanimation.cpp b/src/kitemviews/private/kitemlistviewanimation.cpp
index 0c16c8b0a..83a7a2ec6 100644
--- a/src/kitemviews/private/kitemlistviewanimation.cpp
+++ b/src/kitemviews/private/kitemlistviewanimation.cpp
@@ -9,11 +9,11 @@
 
 #include <QPropertyAnimation>
 
-KItemListViewAnimation::KItemListViewAnimation(QObject* parent) :
-    QObject(parent),
-    m_scrollOrientation(Qt::Vertical),
-    m_scrollOffset(0),
-    m_animation()
+KItemListViewAnimation::KItemListViewAnimation(QObject *parent)
+    : QObject(parent)
+    , m_scrollOrientation(Qt::Vertical)
+    , m_scrollOffset(0)
+    , m_animation()
 {
 }
 
@@ -48,12 +48,12 @@ void KItemListViewAnimation::setScrollOffset(qreal offset)
             continue;
         }
 
-        QHashIterator<QGraphicsWidget*, QPropertyAnimation*>  it(m_animation[type]);
+        QHashIterator<QGraphicsWidget *, QPropertyAnimation *> it(m_animation[type]);
         while (it.hasNext()) {
             it.next();
 
-            QGraphicsWidget* widget = it.key();
-            QPropertyAnimation* propertyAnim = it.value();
+            QGraphicsWidget *widget = it.key();
+            QPropertyAnimation *propertyAnim = it.value();
 
             QPointF currentPos = widget->pos();
             if (m_scrollOrientation == Qt::Vertical) {
@@ -65,8 +65,7 @@ void KItemListViewAnimation::setScrollOffset(qreal offset)
             if (type == MovingAnimation) {
                 // Stop the animation, calculate the moved start- and end-value
                 // and restart the animation for the remaining duration.
-                const int remainingDuration = propertyAnim->duration()
-                                              - propertyAnim->currentTime();
+                const int remainingDuration = propertyAnim->duration() - propertyAnim->currentTime();
 
                 const bool block = propertyAnim->signalsBlocked();
                 propertyAnim->blockSignals(true);
@@ -96,11 +95,11 @@ qreal KItemListViewAnimation::scrollOffset() const
     return m_scrollOffset;
 }
 
-void KItemListViewAnimation::start(QGraphicsWidget* widget, AnimationType type, const QVariant& endValue)
+void KItemListViewAnimation::start(QGraphicsWidget *widget, AnimationType type, const QVariant &endValue)
 {
     stop(widget, type);
 
-    QPropertyAnimation* propertyAnim = nullptr;
+    QPropertyAnimation *propertyAnim = nullptr;
     const int animationDuration = widget->style()->styleHint(QStyle::SH_Widget_Animate) ? 200 : 1;
 
     switch (type) {
@@ -165,18 +164,25 @@ void KItemListViewAnimation::start(QGraphicsWidget* widget, AnimationType type,
     propertyAnim->start();
 }
 
-void KItemListViewAnimation::stop(QGraphicsWidget* widget, AnimationType type)
+void KItemListViewAnimation::stop(QGraphicsWidget *widget, AnimationType type)
 {
-    QPropertyAnimation* propertyAnim = m_animation[type].value(widget);
+    QPropertyAnimation *propertyAnim = m_animation[type].value(widget);
     if (propertyAnim) {
         propertyAnim->stop();
 
         switch (type) {
-        case MovingAnimation: break;
-        case CreateAnimation: widget->setOpacity(1.0); break;
-        case DeleteAnimation: widget->setOpacity(0.0); break;
-        case ResizeAnimation: break;
-        default: break;
+        case MovingAnimation:
+            break;
+        case CreateAnimation:
+            widget->setOpacity(1.0);
+            break;
+        case DeleteAnimation:
+            widget->setOpacity(0.0);
+            break;
+        case ResizeAnimation:
+            break;
+        default:
+            break;
         }
 
         m_animation[type].remove(widget);
@@ -186,7 +192,7 @@ void KItemListViewAnimation::stop(QGraphicsWidget* widget, AnimationType type)
     }
 }
 
-void KItemListViewAnimation::stop(QGraphicsWidget* widget)
+void KItemListViewAnimation::stop(QGraphicsWidget *widget)
 {
     for (int type = 0; type < AnimationTypeCount; ++type) {
         stop(widget, static_cast<AnimationType>(type));
@@ -198,7 +204,7 @@ bool KItemListViewAnimation::isStarted(QGraphicsWidget *widget, AnimationType ty
     return m_animation[type].value(widget);
 }
 
-bool KItemListViewAnimation::isStarted(QGraphicsWidget* widget) const
+bool KItemListViewAnimation::isStarted(QGraphicsWidget *widget) const
 {
     for (int type = 0; type < AnimationTypeCount; ++type) {
         if (isStarted(widget, static_cast<AnimationType>(type))) {
@@ -210,14 +216,14 @@ bool KItemListViewAnimation::isStarted(QGraphicsWidget* widget) const
 
 void KItemListViewAnimation::slotFinished()
 {
-    QPropertyAnimation* finishedAnim = qobject_cast<QPropertyAnimation*>(sender());
+    QPropertyAnimation *finishedAnim = qobject_cast<QPropertyAnimation *>(sender());
     for (int type = 0; type < AnimationTypeCount; ++type) {
-        QMutableHashIterator<QGraphicsWidget*, QPropertyAnimation*> it(m_animation[type]);
+        QMutableHashIterator<QGraphicsWidget *, QPropertyAnimation *> it(m_animation[type]);
         while (it.hasNext()) {
             it.next();
-            QPropertyAnimation* propertyAnim = it.value();
+            QPropertyAnimation *propertyAnim = it.value();
             if (propertyAnim == finishedAnim) {
-                QGraphicsWidget* widget = it.key();
+                QGraphicsWidget *widget = it.key();
                 it.remove();
                 finishedAnim->deleteLater();
 
@@ -228,4 +234,3 @@ void KItemListViewAnimation::slotFinished()
     }
     Q_ASSERT(false);
 }
-
diff --git a/src/kitemviews/private/kitemlistviewanimation.h b/src/kitemviews/private/kitemlistviewanimation.h
index 5e0ebf982..c052d5dff 100644
--- a/src/kitemviews/private/kitemlistviewanimation.h
+++ b/src/kitemviews/private/kitemlistviewanimation.h
@@ -28,16 +28,9 @@ class DOLPHIN_EXPORT KItemListViewAnimation : public QObject
     Q_OBJECT
 
 public:
-    enum AnimationType {
-        MovingAnimation,
-        CreateAnimation,
-        DeleteAnimation,
-        ResizeAnimation,
-        IconResizeAnimation,
-        AnimationTypeCount
-    };
+    enum AnimationType { MovingAnimation, CreateAnimation, DeleteAnimation, ResizeAnimation, IconResizeAnimation, AnimationTypeCount };
 
-    explicit KItemListViewAnimation(QObject* parent = nullptr);
+    explicit KItemListViewAnimation(QObject *parent = nullptr);
     ~KItemListViewAnimation() override;
 
     void setScrollOrientation(Qt::Orientation orientation);
@@ -51,17 +44,17 @@ public:
      * of the type is already running, this animation will be stopped before starting
      * the new animation.
      */
-    void start(QGraphicsWidget* widget, AnimationType type, const QVariant& endValue = QVariant());
+    void start(QGraphicsWidget *widget, AnimationType type, const QVariant &endValue = QVariant());
 
     /**
      * Stops the animation of the type \a type for the widget \a widget.
      */
-    void stop(QGraphicsWidget* widget, AnimationType type);
+    void stop(QGraphicsWidget *widget, AnimationType type);
 
     /**
      * Stops all animations that have been applied to the widget \a widget.
      */
-    void stop(QGraphicsWidget* widget);
+    void stop(QGraphicsWidget *widget);
 
     /**
      * @return True if the animation of the type \a type has been started
@@ -72,10 +65,10 @@ public:
     /**
      * @return True if any animation has been started for the widget.
      */
-    bool isStarted(QGraphicsWidget* widget) const;
+    bool isStarted(QGraphicsWidget *widget) const;
 
 Q_SIGNALS:
-    void finished(QGraphicsWidget* widget, KItemListViewAnimation::AnimationType type);
+    void finished(QGraphicsWidget *widget, KItemListViewAnimation::AnimationType type);
 
 private Q_SLOTS:
     void slotFinished();
@@ -83,9 +76,7 @@ private Q_SLOTS:
 private:
     Qt::Orientation m_scrollOrientation;
     qreal m_scrollOffset;
-    QHash<QGraphicsWidget*, QPropertyAnimation*> m_animation[AnimationTypeCount];
+    QHash<QGraphicsWidget *, QPropertyAnimation *> m_animation[AnimationTypeCount];
 };
 
 #endif
-
-
diff --git a/src/kitemviews/private/kitemlistviewlayouter.cpp b/src/kitemviews/private/kitemlistviewlayouter.cpp
index 4c22b4dbc..027943683 100644
--- a/src/kitemviews/private/kitemlistviewlayouter.cpp
+++ b/src/kitemviews/private/kitemlistviewlayouter.cpp
@@ -14,32 +14,32 @@
 
 // #define KITEMLISTVIEWLAYOUTER_DEBUG
 
-KItemListViewLayouter::KItemListViewLayouter(KItemListSizeHintResolver* sizeHintResolver, QObject* parent) :
-    QObject(parent),
-    m_dirty(true),
-    m_visibleIndexesDirty(true),
-    m_scrollOrientation(Qt::Vertical),
-    m_size(),
-    m_itemSize(128, 128),
-    m_itemMargin(),
-    m_headerHeight(0),
-    m_model(nullptr),
-    m_sizeHintResolver(sizeHintResolver),
-    m_scrollOffset(0),
-    m_maximumScrollOffset(0),
-    m_itemOffset(0),
-    m_maximumItemOffset(0),
-    m_firstVisibleIndex(-1),
-    m_lastVisibleIndex(-1),
-    m_columnWidth(0),
-    m_xPosInc(0),
-    m_columnCount(0),
-    m_rowOffsets(),
-    m_columnOffsets(),
-    m_groupItemIndexes(),
-    m_groupHeaderHeight(0),
-    m_groupHeaderMargin(0),
-    m_itemInfos()
+KItemListViewLayouter::KItemListViewLayouter(KItemListSizeHintResolver *sizeHintResolver, QObject *parent)
+    : QObject(parent)
+    , m_dirty(true)
+    , m_visibleIndexesDirty(true)
+    , m_scrollOrientation(Qt::Vertical)
+    , m_size()
+    , m_itemSize(128, 128)
+    , m_itemMargin()
+    , m_headerHeight(0)
+    , m_model(nullptr)
+    , m_sizeHintResolver(sizeHintResolver)
+    , m_scrollOffset(0)
+    , m_maximumScrollOffset(0)
+    , m_itemOffset(0)
+    , m_maximumItemOffset(0)
+    , m_firstVisibleIndex(-1)
+    , m_lastVisibleIndex(-1)
+    , m_columnWidth(0)
+    , m_xPosInc(0)
+    , m_columnCount(0)
+    , m_rowOffsets()
+    , m_columnOffsets()
+    , m_groupItemIndexes()
+    , m_groupHeaderHeight(0)
+    , m_groupHeaderMargin(0)
+    , m_itemInfos()
 {
     Q_ASSERT(m_sizeHintResolver);
 }
@@ -61,7 +61,7 @@ Qt::Orientation KItemListViewLayouter::scrollOrientation() const
     return m_scrollOrientation;
 }
 
-void KItemListViewLayouter::setSize(const QSizeF& size)
+void KItemListViewLayouter::setSize(const QSizeF &size)
 {
     if (m_size != size) {
         if (m_scrollOrientation == Qt::Vertical) {
@@ -82,7 +82,7 @@ QSizeF KItemListViewLayouter::size() const
     return m_size;
 }
 
-void KItemListViewLayouter::setItemSize(const QSizeF& size)
+void KItemListViewLayouter::setItemSize(const QSizeF &size)
 {
     if (m_itemSize != size) {
         m_itemSize = size;
@@ -95,7 +95,7 @@ QSizeF KItemListViewLayouter::itemSize() const
     return m_itemSize;
 }
 
-void KItemListViewLayouter::setItemMargin(const QSizeF& margin)
+void KItemListViewLayouter::setItemMargin(const QSizeF &margin)
 {
     if (m_itemMargin != margin) {
         m_itemMargin = margin;
@@ -162,7 +162,7 @@ qreal KItemListViewLayouter::scrollOffset() const
 
 qreal KItemListViewLayouter::maximumScrollOffset() const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     return m_maximumScrollOffset;
 }
 
@@ -181,11 +181,11 @@ qreal KItemListViewLayouter::itemOffset() const
 
 qreal KItemListViewLayouter::maximumItemOffset() const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     return m_maximumItemOffset;
 }
 
-void KItemListViewLayouter::setModel(const KItemModelBase* model)
+void KItemListViewLayouter::setModel(const KItemModelBase *model)
 {
     if (m_model != model) {
         m_model = model;
@@ -193,26 +193,26 @@ void KItemListViewLayouter::setModel(const KItemModelBase* model)
     }
 }
 
-const KItemModelBase* KItemListViewLayouter::model() const
+const KItemModelBase *KItemListViewLayouter::model() const
 {
     return m_model;
 }
 
 int KItemListViewLayouter::firstVisibleIndex() const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     return m_firstVisibleIndex;
 }
 
 int KItemListViewLayouter::lastVisibleIndex() const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     return m_lastVisibleIndex;
 }
 
 QRectF KItemListViewLayouter::itemRect(int index) const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     if (index < 0 || index >= m_itemInfos.count()) {
         return QRectF();
     }
@@ -242,7 +242,7 @@ QRectF KItemListViewLayouter::itemRect(int index) const
 
 QRectF KItemListViewLayouter::groupHeaderRect(int index) const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
 
     const QRectF firstItemRect = itemRect(index);
     QPointF pos = firstItemRect.topLeft();
@@ -271,9 +271,8 @@ QRectF KItemListViewLayouter::groupHeaderRect(int index) const
                 break;
             }
 
-            const qreal itemWidth = (m_scrollOrientation == Qt::Vertical)
-                                     ? m_sizeHintResolver->sizeHint(index).width()
-                                     : m_sizeHintResolver->sizeHint(index).height();
+            const qreal itemWidth =
+                (m_scrollOrientation == Qt::Vertical) ? m_sizeHintResolver->sizeHint(index).width() : m_sizeHintResolver->sizeHint(index).height();
 
             if (itemWidth > headerWidth) {
                 headerWidth = itemWidth;
@@ -289,31 +288,27 @@ QRectF KItemListViewLayouter::groupHeaderRect(int index) const
 
 int KItemListViewLayouter::itemColumn(int index) const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     if (index < 0 || index >= m_itemInfos.count()) {
         return -1;
     }
 
-    return (m_scrollOrientation == Qt::Vertical)
-            ? m_itemInfos[index].column
-            : m_itemInfos[index].row;
+    return (m_scrollOrientation == Qt::Vertical) ? m_itemInfos[index].column : m_itemInfos[index].row;
 }
 
 int KItemListViewLayouter::itemRow(int index) const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     if (index < 0 || index >= m_itemInfos.count()) {
         return -1;
     }
 
-    return (m_scrollOrientation == Qt::Vertical)
-            ? m_itemInfos[index].row
-            : m_itemInfos[index].column;
+    return (m_scrollOrientation == Qt::Vertical) ? m_itemInfos[index].row : m_itemInfos[index].column;
 }
 
 int KItemListViewLayouter::maximumVisibleItems() const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
 
     const int height = static_cast<int>(m_size.height());
     const int rowHeight = static_cast<int>(m_itemSize.height());
@@ -327,7 +322,7 @@ int KItemListViewLayouter::maximumVisibleItems() const
 
 bool KItemListViewLayouter::isFirstGroupItem(int itemIndex) const
 {
-    const_cast<KItemListViewLayouter*>(this)->doLayout();
+    const_cast<KItemListViewLayouter *>(this)->doLayout();
     return m_groupItemIndexes.contains(itemIndex);
 }
 
@@ -336,18 +331,19 @@ void KItemListViewLayouter::markAsDirty()
     m_dirty = true;
 }
 
-
 #ifndef QT_NO_DEBUG
-    bool KItemListViewLayouter::isDirty()
-    {
-        return m_dirty;
-    }
+bool KItemListViewLayouter::isDirty()
+{
+    return m_dirty;
+}
 #endif
 
 void KItemListViewLayouter::doLayout()
 {
     // we always want to update visible indexes after performing a layout
-    auto qsg = qScopeGuard([this] { updateVisibleIndexes(); });
+    auto qsg = qScopeGuard([this] {
+        updateVisibleIndexes();
+    });
 
     if (!m_dirty) {
         return;
@@ -409,14 +405,16 @@ void KItemListViewLayouter::doLayout()
         currentOffset += m_groupHeaderHeight;
     }
 
-    if (QGuiApplication::isLeftToRight()) for (int column = 0; column < m_columnCount; ++column) {
-        m_columnOffsets[column] = currentOffset;
-        currentOffset += m_columnWidth;
-    }
-    else for (int column = 0; column < m_columnCount; ++column) {
-        m_columnOffsets[column] = currentOffset - m_columnWidth;
-        currentOffset -= m_columnWidth;
-    }
+    if (QGuiApplication::isLeftToRight())
+        for (int column = 0; column < m_columnCount; ++column) {
+            m_columnOffsets[column] = currentOffset;
+            currentOffset += m_columnWidth;
+        }
+    else
+        for (int column = 0; column < m_columnCount; ++column) {
+            m_columnOffsets[column] = currentOffset - m_columnWidth;
+            currentOffset -= m_columnWidth;
+        }
 
     // Prepare the QVector which stores the y-coordinate for each new row.
     int numberOfRows = (itemCount + m_columnCount - 1) / m_columnCount;
@@ -467,7 +465,7 @@ void KItemListViewLayouter::doLayout()
                 requiredItemHeight = sizeHintHeight;
             }
 
-            ItemInfo& itemInfo = m_itemInfos[index];
+            ItemInfo &itemInfo = m_itemInfos[index];
             itemInfo.column = column;
             itemInfo.row = row;
 
@@ -598,7 +596,7 @@ bool KItemListViewLayouter::createGroupHeaders()
 
     m_groupItemIndexes.clear();
 
-    const QList<QPair<int, QVariant> > groups = m_model->groups();
+    const QList<QPair<int, QVariant>> groups = m_model->groups();
     if (groups.isEmpty()) {
         return false;
     }
@@ -615,4 +613,3 @@ qreal KItemListViewLayouter::minimumGroupHeaderWidth() const
 {
     return 100;
 }
-
diff --git a/src/kitemviews/private/kitemlistviewlayouter.h b/src/kitemviews/private/kitemlistviewlayouter.h
index d5dc6dae1..77d59c947 100644
--- a/src/kitemviews/private/kitemlistviewlayouter.h
+++ b/src/kitemviews/private/kitemlistviewlayouter.h
@@ -37,22 +37,22 @@ class DOLPHIN_EXPORT KItemListViewLayouter : public QObject
     Q_OBJECT
 
 public:
-    explicit KItemListViewLayouter(KItemListSizeHintResolver* sizeHintResolver, QObject* parent = nullptr);
+    explicit KItemListViewLayouter(KItemListSizeHintResolver *sizeHintResolver, QObject *parent = nullptr);
     ~KItemListViewLayouter() override;
 
     void setScrollOrientation(Qt::Orientation orientation);
     Qt::Orientation scrollOrientation() const;
 
-    void setSize(const QSizeF& size);
+    void setSize(const QSizeF &size);
     QSizeF size() const;
 
-    void setItemSize(const QSizeF& size);
+    void setItemSize(const QSizeF &size);
     QSizeF itemSize() const;
 
     /**
      * Margin between the rows and columns of items.
      */
-    void setItemMargin(const QSizeF& margin);
+    void setItemMargin(const QSizeF &margin);
     QSizeF itemMargin() const;
 
     /**
@@ -87,8 +87,8 @@ public:
 
     qreal maximumItemOffset() const;
 
-    void setModel(const KItemModelBase* model);
-    const KItemModelBase* model() const;
+    void setModel(const KItemModelBase *model);
+    const KItemModelBase *model() const;
 
     /**
      * @return The first (at least partly) visible index. -1 is returned
@@ -188,8 +188,8 @@ private:
     QSizeF m_itemSize;
     QSizeF m_itemMargin;
     qreal m_headerHeight;
-    const KItemModelBase* m_model;
-    KItemListSizeHintResolver* m_sizeHintResolver;
+    const KItemModelBase *m_model;
+    KItemListSizeHintResolver *m_sizeHintResolver;
 
     qreal m_scrollOffset;
     qreal m_maximumScrollOffset;
@@ -223,5 +223,3 @@ private:
 };
 
 #endif
-
-
diff --git a/src/kitemviews/private/kpixmapmodifier.cpp b/src/kitemviews/private/kpixmapmodifier.cpp
index 9f7f2edc8..bf316b880 100644
--- a/src/kitemviews/private/kpixmapmodifier.cpp
+++ b/src/kitemviews/private/kpixmapmodifier.cpp
@@ -19,52 +19,32 @@
 #include <QImage>
 #include <QPainter>
 
-static const quint32 stackBlur8Mul[255] =
-{
-    512,512,456,512,328,456,335,512,405,328,271,456,388,335,292,512,
-    454,405,364,328,298,271,496,456,420,388,360,335,312,292,273,512,
-    482,454,428,405,383,364,345,328,312,298,284,271,259,496,475,456,
-    437,420,404,388,374,360,347,335,323,312,302,292,282,273,265,512,
-    497,482,468,454,441,428,417,405,394,383,373,364,354,345,337,328,
-    320,312,305,298,291,284,278,271,265,259,507,496,485,475,465,456,
-    446,437,428,420,412,404,396,388,381,374,367,360,354,347,341,335,
-    329,323,318,312,307,302,297,292,287,282,278,273,269,265,261,512,
-    505,497,489,482,475,468,461,454,447,441,435,428,422,417,411,405,
-    399,394,389,383,378,373,368,364,359,354,350,345,341,337,332,328,
-    324,320,316,312,309,305,301,298,294,291,287,284,281,278,274,271,
-    268,265,262,259,257,507,501,496,491,485,480,475,470,465,460,456,
-    451,446,442,437,433,428,424,420,416,412,408,404,400,396,392,388,
-    385,381,377,374,370,367,363,360,357,354,350,347,344,341,338,335,
-    332,329,326,323,320,318,315,312,310,307,304,302,299,297,294,292,
-    289,287,285,282,280,278,275,273,271,269,267,265,263,261,259
-};
+static const quint32 stackBlur8Mul[255] = {
+    512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312,
+    292, 273, 512, 482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312,
+    302, 292, 282, 273, 265, 512, 497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278,
+    271, 265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335, 329, 323, 318, 312,
+    307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482, 475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405, 399,
+    394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278,
+    274, 271, 268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408,
+    404, 400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335, 332, 329, 326, 323, 320, 318, 315, 312,
+    310, 307, 304, 302, 299, 297, 294, 292, 289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259};
 
-static const quint32 stackBlur8Shr[255] =
-{
-    9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17,
-    17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19,
-    19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20,
-    20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,
-    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22,
-    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23,
-    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-    23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24
-};
+static const quint32 stackBlur8Shr[255] = {
+    9,  11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19,
+    19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24};
 
-static void blurHorizontal(QImage& image, unsigned int* stack, int div, int radius)
+static void blurHorizontal(QImage &image, unsigned int *stack, int div, int radius)
 {
     int stackindex;
     int stackstart;
 
-    quint32 * const pixels = reinterpret_cast<quint32 *>(image.bits());
+    quint32 *const pixels = reinterpret_cast<quint32 *>(image.bits());
     quint32 pixel;
 
     int w = image.width();
@@ -77,8 +57,8 @@ static void blurHorizontal(QImage& image, unsigned int* stack, int div, int radi
     unsigned int sum, sumIn, sumOut;
 
     for (int y = 0; y < h; y++) {
-        sum    = 0;
-        sumIn  = 0;
+        sum = 0;
+        sumIn = 0;
         sumOut = 0;
 
         const int yw = y * w;
@@ -93,10 +73,10 @@ static void blurHorizontal(QImage& image, unsigned int* stack, int div, int radi
         for (int i = 1; i <= radius; i++) {
             pixel = pixels[yw + qMin(i, wm)];
 
-            unsigned int* stackpix = &stack[i + radius];
+            unsigned int *stackpix = &stack[i + radius];
             *stackpix = qAlpha(pixel);
 
-            sum    += *stackpix * (radius + 1 - i);
+            sum += *stackpix * (radius + 1 - i);
             sumIn += *stackpix;
         }
 
@@ -111,7 +91,7 @@ static void blurHorizontal(QImage& image, unsigned int* stack, int div, int radi
                 stackstart -= div;
             }
 
-            unsigned int* stackpix = &stack[stackstart];
+            unsigned int *stackpix = &stack[stackstart];
 
             sumOut -= *stackpix;
 
@@ -120,7 +100,7 @@ static void blurHorizontal(QImage& image, unsigned int* stack, int div, int radi
             *stackpix = qAlpha(pixel);
 
             sumIn += *stackpix;
-            sum    += sumIn;
+            sum += sumIn;
 
             if (++stackindex >= div) {
                 stackindex = 0;
@@ -129,17 +109,17 @@ static void blurHorizontal(QImage& image, unsigned int* stack, int div, int radi
             stackpix = &stack[stackindex];
 
             sumOut += *stackpix;
-            sumIn  -= *stackpix;
+            sumIn -= *stackpix;
         }
     }
 }
 
-static void blurVertical(QImage& image, unsigned int* stack, int div, int radius)
+static void blurVertical(QImage &image, unsigned int *stack, int div, int radius)
 {
     int stackindex;
     int stackstart;
 
-    quint32 * const pixels = reinterpret_cast<quint32 *>(image.bits());
+    quint32 *const pixels = reinterpret_cast<quint32 *>(image.bits());
     quint32 pixel;
 
     int w = image.width();
@@ -152,8 +132,8 @@ static void blurVertical(QImage& image, unsigned int* stack, int div, int radius
     unsigned int sum, sumIn, sumOut;
 
     for (int x = 0; x < w; x++) {
-        sum    = 0;
-        sumIn  = 0;
+        sum = 0;
+        sumIn = 0;
         sumOut = 0;
 
         pixel = pixels[x];
@@ -167,10 +147,10 @@ static void blurVertical(QImage& image, unsigned int* stack, int div, int radius
         for (int i = 1; i <= radius; i++) {
             pixel = pixels[qMin(i, hm) * w + x];
 
-            unsigned int* stackpix = &stack[i + radius];
+            unsigned int *stackpix = &stack[i + radius];
             *stackpix = qAlpha(pixel);
 
-            sum    += *stackpix * (radius + 1 - i);
+            sum += *stackpix * (radius + 1 - i);
             sumIn += *stackpix;
         }
 
@@ -184,7 +164,7 @@ static void blurVertical(QImage& image, unsigned int* stack, int div, int radius
             if (stackstart >= div)
                 stackstart -= div;
 
-            unsigned int* stackpix = &stack[stackstart];
+            unsigned int *stackpix = &stack[stackstart];
 
             sumOut -= *stackpix;
 
@@ -193,7 +173,7 @@ static void blurVertical(QImage& image, unsigned int* stack, int div, int radius
             *stackpix = qAlpha(pixel);
 
             sumIn += *stackpix;
-            sum    += sumIn;
+            sum += sumIn;
 
             if (++stackindex >= div) {
                 stackindex = 0;
@@ -202,25 +182,25 @@ static void blurVertical(QImage& image, unsigned int* stack, int div, int radius
             stackpix = &stack[stackindex];
 
             sumOut += *stackpix;
-            sumIn  -= *stackpix;
+            sumIn -= *stackpix;
         }
     }
 }
 
-static void stackBlur(QImage& image, float radius)
+static void stackBlur(QImage &image, float radius)
 {
     radius = qRound(radius);
 
     int div = int(radius * 2) + 1;
-    unsigned int* stack  = new unsigned int[div];
+    unsigned int *stack = new unsigned int[div];
 
     blurHorizontal(image, stack, div, radius);
     blurVertical(image, stack, div, radius);
 
-    delete [] stack;
+    delete[] stack;
 }
 
-static void shadowBlur(QImage& image, float radius, const QColor& color)
+static void shadowBlur(QImage &image, float radius, const QColor &color)
 {
     if (radius < 0) {
         return;
@@ -236,67 +216,65 @@ static void shadowBlur(QImage& image, float radius, const QColor& color)
     p.fillRect(image.rect(), color);
 }
 
-namespace {
-    /** Helper class for drawing frames for KPixmapModifier::applyFrame(). */
-    class TileSet
-    {
-    public:
-        enum { LeftMargin = 3, TopMargin = 2, RightMargin = 3, BottomMargin = 4 };
-
-        enum Tile { TopLeftCorner = 0, TopSide, TopRightCorner, LeftSide,
-                    RightSide, BottomLeftCorner, BottomSide, BottomRightCorner,
-                    NumTiles };
+namespace
+{
+/** Helper class for drawing frames for KPixmapModifier::applyFrame(). */
+class TileSet
+{
+public:
+    enum { LeftMargin = 3, TopMargin = 2, RightMargin = 3, BottomMargin = 4 };
 
-        TileSet()
-        {
-            QImage image(8 * 3, 8 * 3, QImage::Format_ARGB32_Premultiplied);
+    enum Tile { TopLeftCorner = 0, TopSide, TopRightCorner, LeftSide, RightSide, BottomLeftCorner, BottomSide, BottomRightCorner, NumTiles };
 
-            QPainter p(&image);
-            p.setCompositionMode(QPainter::CompositionMode_Source);
-            p.fillRect(image.rect(), Qt::transparent);
-            p.fillRect(image.rect().adjusted(3, 3, -3, -3), Qt::black);
-            p.end();
+    TileSet()
+    {
+        QImage image(8 * 3, 8 * 3, QImage::Format_ARGB32_Premultiplied);
 
-            shadowBlur(image, 3, Qt::black);
+        QPainter p(&image);
+        p.setCompositionMode(QPainter::CompositionMode_Source);
+        p.fillRect(image.rect(), Qt::transparent);
+        p.fillRect(image.rect().adjusted(3, 3, -3, -3), Qt::black);
+        p.end();
 
-            QPixmap pixmap = QPixmap::fromImage(image);
-            m_tiles[TopLeftCorner]     = pixmap.copy(0, 0, 8, 8);
-            m_tiles[TopSide]           = pixmap.copy(8, 0, 8, 8);
-            m_tiles[TopRightCorner]    = pixmap.copy(16, 0, 8, 8);
-            m_tiles[LeftSide]          = pixmap.copy(0, 8, 8, 8);
-            m_tiles[RightSide]         = pixmap.copy(16, 8, 8, 8);
-            m_tiles[BottomLeftCorner]  = pixmap.copy(0, 16, 8, 8);
-            m_tiles[BottomSide]        = pixmap.copy(8, 16, 8, 8);
-            m_tiles[BottomRightCorner] = pixmap.copy(16, 16, 8, 8);
-        }
+        shadowBlur(image, 3, Qt::black);
 
-        void paint(QPainter* p, const QRect& r)
-        {
-            p->drawPixmap(r.topLeft(), m_tiles[TopLeftCorner]);
-            if (r.width() - 16 > 0) {
-                p->drawTiledPixmap(r.x() + 8, r.y(), r.width() - 16, 8, m_tiles[TopSide]);
-            }
-            p->drawPixmap(r.right() - 8 + 1, r.y(), m_tiles[TopRightCorner]);
-            if (r.height() - 16 > 0) {
-                p->drawTiledPixmap(r.x(), r.y() + 8, 8, r.height() - 16,  m_tiles[LeftSide]);
-                p->drawTiledPixmap(r.right() - 8 + 1, r.y() + 8, 8, r.height() - 16, m_tiles[RightSide]);
-            }
-            p->drawPixmap(r.x(), r.bottom() - 8 + 1, m_tiles[BottomLeftCorner]);
-            if (r.width() - 16 > 0) {
-                p->drawTiledPixmap(r.x() + 8, r.bottom() - 8 + 1, r.width() - 16, 8, m_tiles[BottomSide]);
-            }
-            p->drawPixmap(r.right() - 8 + 1, r.bottom() - 8 + 1, m_tiles[BottomRightCorner]);
+        QPixmap pixmap = QPixmap::fromImage(image);
+        m_tiles[TopLeftCorner] = pixmap.copy(0, 0, 8, 8);
+        m_tiles[TopSide] = pixmap.copy(8, 0, 8, 8);
+        m_tiles[TopRightCorner] = pixmap.copy(16, 0, 8, 8);
+        m_tiles[LeftSide] = pixmap.copy(0, 8, 8, 8);
+        m_tiles[RightSide] = pixmap.copy(16, 8, 8, 8);
+        m_tiles[BottomLeftCorner] = pixmap.copy(0, 16, 8, 8);
+        m_tiles[BottomSide] = pixmap.copy(8, 16, 8, 8);
+        m_tiles[BottomRightCorner] = pixmap.copy(16, 16, 8, 8);
+    }
 
-            const QRect contentRect = r.adjusted(LeftMargin + 1, TopMargin + 1,
-                                                 -(RightMargin + 1), -(BottomMargin + 1));
-            p->fillRect(contentRect, Qt::transparent);
+    void paint(QPainter *p, const QRect &r)
+    {
+        p->drawPixmap(r.topLeft(), m_tiles[TopLeftCorner]);
+        if (r.width() - 16 > 0) {
+            p->drawTiledPixmap(r.x() + 8, r.y(), r.width() - 16, 8, m_tiles[TopSide]);
+        }
+        p->drawPixmap(r.right() - 8 + 1, r.y(), m_tiles[TopRightCorner]);
+        if (r.height() - 16 > 0) {
+            p->drawTiledPixmap(r.x(), r.y() + 8, 8, r.height() - 16, m_tiles[LeftSide]);
+            p->drawTiledPixmap(r.right() - 8 + 1, r.y() + 8, 8, r.height() - 16, m_tiles[RightSide]);
         }
+        p->drawPixmap(r.x(), r.bottom() - 8 + 1, m_tiles[BottomLeftCorner]);
+        if (r.width() - 16 > 0) {
+            p->drawTiledPixmap(r.x() + 8, r.bottom() - 8 + 1, r.width() - 16, 8, m_tiles[BottomSide]);
+        }
+        p->drawPixmap(r.right() - 8 + 1, r.bottom() - 8 + 1, m_tiles[BottomRightCorner]);
+
+        const QRect contentRect = r.adjusted(LeftMargin + 1, TopMargin + 1, -(RightMargin + 1), -(BottomMargin + 1));
+        p->fillRect(contentRect, Qt::transparent);
+    }
 
-        QPixmap m_tiles[NumTiles];
-    };
+    QPixmap m_tiles[NumTiles];
+};
 }
 
-void KPixmapModifier::scale(QPixmap& pixmap, const QSize& scaledSize)
+void KPixmapModifier::scale(QPixmap &pixmap, const QSize &scaledSize)
 {
     if (scaledSize.isEmpty() || pixmap.isNull()) {
         pixmap = QPixmap();
@@ -307,7 +285,7 @@ void KPixmapModifier::scale(QPixmap& pixmap, const QSize& scaledSize)
     pixmap.setDevicePixelRatio(dpr);
 }
 
-void KPixmapModifier::applyFrame(QPixmap& icon, const QSize& scaledSize)
+void KPixmapModifier::applyFrame(QPixmap &icon, const QSize &scaledSize)
 {
     if (icon.isNull()) {
         icon = QPixmap(scaledSize);
@@ -319,8 +297,7 @@ void KPixmapModifier::applyFrame(QPixmap& icon, const QSize& scaledSize)
     qreal dpr = qApp->devicePixelRatio();
 
     // Resize the icon to the maximum size minus the space required for the frame
-    const QSize size(scaledSize.width() - TileSet::LeftMargin - TileSet::RightMargin,
-                     scaledSize.height() - TileSet::TopMargin - TileSet::BottomMargin);
+    const QSize size(scaledSize.width() - TileSet::LeftMargin - TileSet::RightMargin, scaledSize.height() - TileSet::TopMargin - TileSet::BottomMargin);
     scale(icon, size * dpr);
     icon.setDevicePixelRatio(dpr);
 
@@ -332,16 +309,14 @@ void KPixmapModifier::applyFrame(QPixmap& icon, const QSize& scaledSize)
     QPainter painter;
     painter.begin(&framedIcon);
     painter.setCompositionMode(QPainter::CompositionMode_Source);
-    tileSet.paint(&painter, QRect(QPoint(0,0), framedIcon.size() / dpr));
+    tileSet.paint(&painter, QRect(QPoint(0, 0), framedIcon.size() / dpr));
     painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
     painter.drawPixmap(TileSet::LeftMargin, TileSet::TopMargin, icon);
 
     icon = framedIcon;
 }
 
-QSize KPixmapModifier::sizeInsideFrame(const QSize& frameSize)
+QSize KPixmapModifier::sizeInsideFrame(const QSize &frameSize)
 {
-    return QSize(frameSize.width() - TileSet::LeftMargin - TileSet::RightMargin,
-                 frameSize.height() - TileSet::TopMargin - TileSet::BottomMargin);
+    return QSize(frameSize.width() - TileSet::LeftMargin - TileSet::RightMargin, frameSize.height() - TileSet::TopMargin - TileSet::BottomMargin);
 }
-
diff --git a/src/kitemviews/private/kpixmapmodifier.h b/src/kitemviews/private/kpixmapmodifier.h
index d8d7f2394..0d86b0157 100644
--- a/src/kitemviews/private/kpixmapmodifier.h
+++ b/src/kitemviews/private/kpixmapmodifier.h
@@ -20,14 +20,14 @@ public:
      * @arg scaledSize is assumed to be the scaled to the same device pixel ratio as the source pixmap
      * @arg scaledSize is in device pixels
      */
-    static void scale(QPixmap& pixmap, const QSize& scaledSize);
+    static void scale(QPixmap &pixmap, const QSize &scaledSize);
 
     /**
      * Resize and paint a frame round an icon
      * @arg scaledSize is in device-independent pixels
      * The returned image will be scaled by the application devicePixelRatio
      */
-    static void applyFrame(QPixmap& icon, const QSize& scaledSize);
+    static void applyFrame(QPixmap &icon, const QSize &scaledSize);
 
     /**
      * return and paint a frame round an icon
@@ -35,9 +35,7 @@ public:
      * @return is in device-independent pixels
      */
 
-    static QSize sizeInsideFrame(const QSize& frameSize);
+    static QSize sizeInsideFrame(const QSize &frameSize);
 };
 
 #endif
-
-