internal: format cpp

.clang-format

@@ -0,0 +1,22 @@
+---
+BasedOnStyle: LLVM
+IndentWidth: 4
+ColumnLimit: 120
+---
+Language: Cpp
+DerivePointerAlignment: false
+PointerAlignment: Left
+AccessModifierOffset: -4
+AlignAfterOpenBracket: DontAlign
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortLambdasOnASingleLine: None
+BinPackArguments: true
+BreakBeforeBraces: Attach
+BreakConstructorInitializers: BeforeComma
+Cpp11BracedListStyle: false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: Always
+IndentAccessModifiers: false
+IndentCaseLabels: false
+...

.vscode/settings.json

@@ -1,3 +1,6 @@
 {
-    "editor.defaultFormatter": "theqtcompany.qt-qml"
+    "editor.defaultFormatter": "theqtcompany.qt-qml",
+    "[cpp]": {
+        "editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd"
+    }
 }

assets/cpp/beat-detector.cpp

@@ -1,20 +1,18 @@
 #include <algorithm>
+#include <atomic>
+#include <aubio/aubio.h>
+#include <chrono>
+#include <csignal>
+#include <cstring>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <memory>
 #include <pipewire/pipewire.h>
 #include <spa/param/audio/format-utils.h>
 #include <spa/param/props.h>
-#include <aubio/aubio.h>
-#include <memory>
-#include <iostream>
-#include <fstream>
-#include <csignal>
-#include <atomic>
-#include <vector>
-#include <cstring>
-#include <chrono>
-#include <iomanip>
 #include <sstream>
-#include <thread>
+#include <vector>
-#include <cmath>
 
 class EnhancedBeatDetector {
 private:
@@ -65,15 +63,18 @@ private:
 
     // Useless Visual feedback
     std::string generate_beat_visual(float bpm, bool is_beat) {
-        if (!enable_visual_feedback_) return "";
+        if (!enable_visual_feedback_)
+            return "";
 
         std::stringstream ss;
         if (is_beat) {
             // Useless Animated beat indicator based on BPM intensity
             int intensity = static_cast<int>(std::min(bpm / 20.0f, 10.0f));
             ss << "\r ";
-            for (int i = 0; i < intensity; ++i) ss << "█";
+            for (int i = 0; i < intensity; ++i)
-            for (int i = intensity; i < 10; ++i) ss << "░";
+                ss << "█";
+            for (int i = intensity; i < 10; ++i)
+                ss << "░";
             ss << " BPM: " << std::fixed << std::setprecision(1) << bpm;
             ss << " | Avg: " << get_average_bpm();
         }
@@ -81,11 +82,8 @@ private:
     }
 
 public:
-    explicit EnhancedBeatDetector(uint32_t buf_size = 512, 
+    explicit EnhancedBeatDetector(uint32_t buf_size = 512, bool enable_logging = true,
-                                 bool enable_logging = true,
+        bool enable_performance_stats = true, bool enable_pitch_detection = false, bool enable_visual_feedback = true)
-                                 bool enable_performance_stats = true,
-                                 bool enable_pitch_detection = false,
-                                 bool enable_visual_feedback = true) 
         : main_loop_(nullptr)
         , context_(nullptr)
         , core_(nullptr)
@@ -104,8 +102,7 @@ public:
         , enable_visual_feedback_(enable_visual_feedback)
         , total_beats_(0)
         , total_onsets_(0)
-        , last_bpm_(0.0f)
+        , last_bpm_(0.0f) {
-    {
         instance_ = this;
         recent_bpms_.reserve(BPM_HISTORY_SIZE);
         if (enable_performance_stats_) {
@@ -135,7 +132,8 @@ public:
             filename << "beat_log_" << std::put_time(std::localtime(&time_t), "%Y%m%d_%H%M%S") << ".txt";
             log_file_.open(filename.str());
             if (log_file_.is_open()) {
-                log_file_ << "# Beat Detection Log - " << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S") << "\n";
+                log_file_ << "# Beat Detection Log - " << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S")
+                          << "\n";
                 log_file_ << "# Timestamp,BPM,Onset,Pitch(Hz),ProcessTime(ms)\n";
                 std::cout << " Logging to: " << filename.str() << std::endl;
             }
@@ -199,7 +197,8 @@ public:
     }
 
     void run() {
-        if (!main_loop_) return;
+        if (!main_loop_)
+            return;
 
         print_startup_info();
         pw_main_loop_run(main_loop_);
@@ -232,7 +231,8 @@ private:
     }
 
     void print_final_stats() {
-        if (!enable_performance_stats_) return;
+        if (!enable_performance_stats_)
+            return;
 
         auto end_time = std::chrono::steady_clock::now();
         auto duration = std::chrono::duration_cast<std::chrono::seconds>(end_time - start_time_);
@@ -244,14 +244,15 @@ private:
 
         if (!process_times_.empty()) {
             double avg_time = 0;
-            for (double t : process_times_) avg_time += t;
+            for (double t : process_times_)
+                avg_time += t;
             avg_time /= process_times_.size();
 
             auto max_time = *std::max_element(process_times_.begin(), process_times_.end());
             auto min_time = *std::min_element(process_times_.begin(), process_times_.end());
 
-            std::cout << "   ⚡ Average processing time: " << std::fixed << std::setprecision(3) 
+            std::cout << "   ⚡ Average processing time: " << std::fixed << std::setprecision(3) << avg_time << " ms"
-                      << avg_time << " ms" << std::endl;
+                      << std::endl;
             std::cout << "   📈 Max processing time: " << max_time << " ms" << std::endl;
             std::cout << "   📉 Min processing time: " << min_time << " ms" << std::endl;
         }
@@ -262,9 +263,11 @@ private:
     }
 
     float get_average_bpm() const {
-        if (recent_bpms_.empty()) return 0.0f;
+        if (recent_bpms_.empty())
+            return 0.0f;
         float sum = 0;
-        for (float bpm : recent_bpms_) sum += bpm;
+        for (float bpm : recent_bpms_)
+            sum += bpm;
         return sum / recent_bpms_.size();
     }
 
@@ -285,18 +288,10 @@ private:
             .trigger_done = nullptr,
         };
 
-        stream_ = pw_stream_new_simple(
+        stream_ = pw_stream_new_simple(pw_main_loop_get_loop(main_loop_), "enhanced-beat-detector",
-            pw_main_loop_get_loop(main_loop_),
-            "enhanced-beat-detector",
             pw_properties_new(
-                PW_KEY_MEDIA_TYPE, "Audio",
+                PW_KEY_MEDIA_TYPE, "Audio", PW_KEY_MEDIA_CATEGORY, "Capture", PW_KEY_MEDIA_ROLE, "Music", nullptr),
-                PW_KEY_MEDIA_CATEGORY, "Capture",
+            &stream_events, this);
-                PW_KEY_MEDIA_ROLE, "Music",
-                nullptr
-            ),
-            &stream_events,
-            this
-        );
 
         if (!stream_) {
             std::cerr << " Failed to create stream" << std::endl;
@@ -316,13 +311,9 @@ private:
         const spa_pod* params[1];
         params[0] = spa_format_audio_raw_build(&pod_builder, SPA_PARAM_EnumFormat, &audio_info);
 
-        if (pw_stream_connect(stream_,
+        if (pw_stream_connect(stream_, PW_DIRECTION_INPUT, PW_ID_ANY,
-                             PW_DIRECTION_INPUT,
-                             PW_ID_ANY,
                 static_cast<pw_stream_flags>(
-                                 PW_STREAM_FLAG_AUTOCONNECT |
+                    PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS | PW_STREAM_FLAG_RT_PROCESS),
-                                 PW_STREAM_FLAG_MAP_BUFFERS |
-                                 PW_STREAM_FLAG_RT_PROCESS),
                 params, 1) < 0) {
             std::cerr << " Failed to connect stream" << std::endl;
             return false;
@@ -331,17 +322,27 @@ private:
         return true;
     }
 
-    static void on_state_changed(void* userdata, enum pw_stream_state /* old_state */, 
+    static void on_state_changed(
-                                enum pw_stream_state state, const char* error) {
+        void* userdata, enum pw_stream_state /* old_state */, enum pw_stream_state state, const char* error) {
         auto* detector = static_cast<EnhancedBeatDetector*>(userdata);
 
         const char* state_emoji = "󰑓 ";
         switch (state) {
-            case PW_STREAM_STATE_CONNECTING: state_emoji = "󰄙 "; break;
+        case PW_STREAM_STATE_CONNECTING:
-            case PW_STREAM_STATE_PAUSED: state_emoji = ""; break;
+            state_emoji = "󰄙 ";
-            case PW_STREAM_STATE_STREAMING: state_emoji = "󰝚 "; break;
+            break;
-            case PW_STREAM_STATE_ERROR: state_emoji = ""; break;
+        case PW_STREAM_STATE_PAUSED:
-            case PW_STREAM_STATE_UNCONNECTED: state_emoji = " "; break;
+            state_emoji = "";
+            break;
+        case PW_STREAM_STATE_STREAMING:
+            state_emoji = "󰝚 ";
+            break;
+        case PW_STREAM_STATE_ERROR:
+            state_emoji = "";
+            break;
+        case PW_STREAM_STATE_UNCONNECTED:
+            state_emoji = " ";
+            break;
         }
 
         std::cout << state_emoji << " Stream state: " << pw_stream_state_as_string(state) << std::endl;
@@ -358,12 +359,14 @@ private:
     }
 
     void process_audio() {
-        if (should_quit_) return;
+        if (should_quit_)
+            return;
 
         auto process_start = std::chrono::high_resolution_clock::now();
 
         pw_buffer* buffer = pw_stream_dequeue_buffer(stream_);
-        if (!buffer) return;
+        if (!buffer)
+            return;
 
         spa_buffer* spa_buf = buffer->buffer;
         if (!spa_buf->datas[0].data) {
@@ -419,14 +422,11 @@ private:
             if (enable_logging_ && log_file_.is_open() && (is_beat || is_onset)) {
                 auto now = std::chrono::system_clock::now();
                 auto time_t = std::chrono::system_clock::to_time_t(now);
-                auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
-                    now.time_since_epoch()) % 1000;
 
-                log_file_ << std::put_time(std::localtime(&time_t), "%H:%M:%S") 
+                log_file_ << std::put_time(std::localtime(&time_t), "%H:%M:%S") << "." << std::setfill('0')
-                         << "." << std::setfill('0') << std::setw(3) << ms.count() << ","
+                          << std::setw(3) << ms.count() << "," << (is_beat ? last_bpm_ : 0) << "," << (is_onset ? 1 : 0)
-                         << (is_beat ? last_bpm_ : 0) << ","
+                          << "," << pitch_hz << ",";
-                         << (is_onset ? 1 : 0) << ","
-                         << pitch_hz << ",";
             }
         }
 
@@ -486,8 +486,8 @@ private:
 };
 
 // Static member definitions
-std::atomic<bool> EnhancedBeatDetector::should_quit_{false};
+std::atomic<bool> EnhancedBeatDetector::should_quit_{ false };
-EnhancedBeatDetector* EnhancedBeatDetector::instance_{nullptr};
+EnhancedBeatDetector* EnhancedBeatDetector::instance_{ nullptr };
 
 void print_usage() {
     std::cout << " Beat Detector Usage:" << std::endl;
@@ -550,8 +550,8 @@ int main(int argc, char* argv[]) {
     std::signal(SIGTERM, EnhancedBeatDetector::signal_handler);
 
     try {
-        EnhancedBeatDetector detector(buffer_size, enable_logging, enable_performance_stats,
+        EnhancedBeatDetector detector(
-                                     enable_pitch_detection, enable_visual_feedback);
+            buffer_size, enable_logging, enable_performance_stats, enable_pitch_detection, enable_visual_feedback);
         detector.run();
     } catch (const std::exception& e) {
         std::cerr << " Error: " << e.what() << std::endl;

plugin/src/Caelestia/cachingimagemanager.cpp

@@ -1,14 +1,14 @@
 #include "cachingimagemanager.hpp"
 
+#include <QCryptographicHash>
+#include <QDir>
+#include <QFile>
+#include <QImageReader>
 #include <QObject>
+#include <QPainter>
+#include <QThreadPool>
 #include <QtQuick/QQuickItem>
 #include <QtQuick/QQuickWindow>
-#include <QCryptographicHash>
-#include <QThreadPool>
-#include <QFile>
-#include <QDir>
-#include <QPainter>
-#include <QImageReader>
 
 qreal CachingImageManager::effectiveScale() const {
     if (m_item && m_item->window()) {
@@ -49,8 +49,12 @@ void CachingImageManager::setItem(QQuickItem* item) {
     emit itemChanged();
 
     if (item) {
-        m_widthConn = connect(item, &QQuickItem::widthChanged, this, [this]() { updateSource(); });
+        m_widthConn = connect(item, &QQuickItem::widthChanged, this, [this]() {
-        m_heightConn = connect(item, &QQuickItem::heightChanged, this, [this]() { updateSource(); });
+            updateSource();
+        });
+        m_heightConn = connect(item, &QQuickItem::heightChanged, this, [this]() {
+            updateSource();
+        });
         updateSource();
     }
 }
@@ -104,7 +108,9 @@ void CachingImageManager::updateSource(const QString& path) {
     QThreadPool::globalInstance()->start([path, self] {
         const QString sha = self->sha256sum(path);
 
-        QMetaObject::invokeMethod(self, [path, sha, self]() {
+        QMetaObject::invokeMethod(
+            self,
+            [path, sha, self]() {
                 if (!self || self->m_path != path) {
                     // Object is destroyed or path has changed, ignore
                     return;
@@ -117,9 +123,11 @@ void CachingImageManager::updateSource(const QString& path) {
                 }
 
                 const QString fillMode = self->m_item->property("fillMode").toString();
+                // clang-format off
                 const QString filename = QString("%1@%2x%3-%4.png")
                     .arg(sha).arg(size.width()).arg(size.height())
                     .arg(fillMode == "PreserveAspectCrop" ? "crop" : fillMode == "PreserveAspectFit" ? "fit" : "stretch");
+                // clang-format on
 
                 const QUrl cache = self->m_cacheDir.resolved(QUrl(filename));
                 if (self->m_cachePath == cache) {
@@ -146,7 +154,8 @@ void CachingImageManager::updateSource(const QString& path) {
                 if (self->m_shaPath == path) {
                     self->m_shaPath = QString();
                 }
-        }, Qt::QueuedConnection);
+            },
+            Qt::QueuedConnection);
     });
 }
 
@@ -154,7 +163,8 @@ QUrl CachingImageManager::cachePath() const {
     return m_cachePath;
 }
 
-void CachingImageManager::createCache(const QString& path, const QString& cache, const QString& fillMode, const QSize& size) const {
+void CachingImageManager::createCache(
+    const QString& path, const QString& cache, const QString& fillMode, const QSize& size) const {
     QThreadPool::globalInstance()->start([path, cache, fillMode, size] {
         QImage image(path);
 

plugin/src/Caelestia/cachingimagemanager.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <QtQuick/QQuickItem>
 #include <qobject.h>
 #include <qqmlintegration.h>
-#include <QtQuick/QQuickItem>
 
 class CachingImageManager : public QObject {
     Q_OBJECT
@@ -15,7 +15,8 @@ class CachingImageManager : public QObject {
     Q_PROPERTY(QUrl cachePath READ cachePath NOTIFY cachePathChanged)
 
 public:
-    explicit CachingImageManager(QObject* parent = nullptr): QObject(parent) {}
+    explicit CachingImageManager(QObject* parent = nullptr)
+        : QObject(parent) {}
 
     [[nodiscard]] QQuickItem* item() const;
     void setItem(QQuickItem* item);

plugin/src/Caelestia/cutils.cpp

@@ -1,12 +1,12 @@
 #include "cutils.hpp"
 
+#include <QDir>
 #include <QObject>
-#include <QtQuick/QQuickWindow>
+#include <QQmlEngine>
+#include <QThreadPool>
 #include <QtQuick/QQuickItem>
 #include <QtQuick/QQuickItemGrabResult>
-#include <QThreadPool>
+#include <QtQuick/QQuickWindow>
-#include <QQmlEngine>
-#include <QDir>
 
 void CUtils::saveItem(QQuickItem* target, const QUrl& path) {
     this->saveItem(target, path, QRect(), QJSValue(), QJSValue());
@@ -47,7 +47,8 @@ void CUtils::saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, Q
     auto scaledRect = rect;
     const qreal scale = target->window()->devicePixelRatio();
     if (rect.isValid() && scale != 1.0) {
-        scaledRect = QRectF(rect.left() * scale, rect.top() * scale, rect.width() * scale, rect.height() * scale).toRect();
+        scaledRect =
+            QRectF(rect.left() * scale, rect.top() * scale, rect.width() * scale, rect.height() * scale).toRect();
     }
 
     const QSharedPointer<const QQuickItemGrabResult> grabResult = target->grabToImage();
@@ -65,10 +66,13 @@ void CUtils::saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, Q
                 const QString parent = QFileInfo(file).absolutePath();
                 const bool success = QDir().mkpath(parent) && image.save(file);
 
-                QMetaObject::invokeMethod(this, [file, success, path, onSaved, onFailed, this]() {
+                QMetaObject::invokeMethod(
+                    this,
+                    [file, success, path, onSaved, onFailed, this]() {
                         if (success) {
                             if (onSaved.isCallable()) {
-                            onSaved.call({ QJSValue(file), qmlEngine(this)->toScriptValue(QVariant::fromValue(path)) });
+                                onSaved.call(
+                                    { QJSValue(file), qmlEngine(this)->toScriptValue(QVariant::fromValue(path)) });
                             }
                         } else {
                             qWarning() << "CUtils::saveItem: failed to save" << path;
@@ -76,10 +80,10 @@ void CUtils::saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, Q
                                 onFailed.call({ qmlEngine(this)->toScriptValue(QVariant::fromValue(path)) });
                             }
                         }
-                }, Qt::QueuedConnection);
+                    },
+                    Qt::QueuedConnection);
+            });
         });
-        }
-    );
 }
 
 bool CUtils::copyFile(const QUrl& source, const QUrl& target) const {
@@ -120,21 +124,23 @@ void CUtils::getDominantColour(QQuickItem* item, int rescaleSize, QJSValue callb
 
     const QSharedPointer<const QQuickItemGrabResult> grabResult = item->grabToImage();
 
-    QObject::connect(grabResult.data(), &QQuickItemGrabResult::ready, this,
+    QObject::connect(
-        [grabResult, rescaleSize, callback, this]() {
+        grabResult.data(), &QQuickItemGrabResult::ready, this, [grabResult, rescaleSize, callback, this]() {
             const QImage image = grabResult->image();
 
             QThreadPool::globalInstance()->start([grabResult, image, rescaleSize, callback, this]() {
                 const QColor color = this->findDominantColour(image, rescaleSize);
 
                 if (callback.isCallable()) {
-                    QMetaObject::invokeMethod(this, [color, callback, this]() {
+                    QMetaObject::invokeMethod(
+                        this,
+                        [color, callback, this]() {
                             callback.call({ qmlEngine(this)->toScriptValue(QVariant::fromValue(color)) });
-                    }, Qt::QueuedConnection);
+                        },
+                        Qt::QueuedConnection);
                 }
             });
-        }
+        });
-    );
 }
 
 void CUtils::getDominantColour(const QString& path, QJSValue callback) {
@@ -158,9 +164,12 @@ void CUtils::getDominantColour(const QString& path, int rescaleSize, QJSValue ca
         const QColor color = this->findDominantColour(image, rescaleSize);
 
         if (callback.isCallable()) {
-            QMetaObject::invokeMethod(this, [color, callback, this]() {
+            QMetaObject::invokeMethod(
+                this,
+                [color, callback, this]() {
                     callback.call({ qmlEngine(this)->toScriptValue(QVariant::fromValue(color)) });
-            }, Qt::QueuedConnection);
+                },
+                Qt::QueuedConnection);
         }
     });
 }
@@ -234,21 +243,23 @@ void CUtils::getAverageLuminance(QQuickItem* item, int rescaleSize, QJSValue cal
 
     const QSharedPointer<const QQuickItemGrabResult> grabResult = item->grabToImage();
 
-    QObject::connect(grabResult.data(), &QQuickItemGrabResult::ready, this,
+    QObject::connect(
-        [grabResult, rescaleSize, callback, this]() {
+        grabResult.data(), &QQuickItemGrabResult::ready, this, [grabResult, rescaleSize, callback, this]() {
             const QImage image = grabResult->image();
 
             QThreadPool::globalInstance()->start([grabResult, image, rescaleSize, callback, this]() {
                 const qreal luminance = this->findAverageLuminance(image, rescaleSize);
 
                 if (callback.isCallable()) {
-                    QMetaObject::invokeMethod(this, [luminance, callback]() {
+                    QMetaObject::invokeMethod(
+                        this,
+                        [luminance, callback]() {
                             callback.call({ QJSValue(luminance) });
-                    }, Qt::QueuedConnection);
+                        },
+                        Qt::QueuedConnection);
                 }
             });
-        }
+        });
-    );
 }
 
 void CUtils::getAverageLuminance(const QString& path, QJSValue callback) {
@@ -272,9 +283,12 @@ void CUtils::getAverageLuminance(const QString& path, int rescaleSize, QJSValue
         const qreal luminance = this->findAverageLuminance(image, rescaleSize);
 
         if (callback.isCallable()) {
-            QMetaObject::invokeMethod(this, [luminance, callback]() {
+            QMetaObject::invokeMethod(
+                this,
+                [luminance, callback]() {
                     callback.call({ QJSValue(luminance) });
-            }, Qt::QueuedConnection);
+                },
+                Qt::QueuedConnection);
         }
     });
 }

plugin/src/Caelestia/cutils.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
+#include <QtQuick/QQuickItem>
 #include <qobject.h>
 #include <qqmlintegration.h>
-#include <QtQuick/QQuickItem>
 
 class CUtils : public QObject {
     Q_OBJECT
@@ -15,7 +15,8 @@ public:
     Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, QJSValue onSaved);
     Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, QJSValue onSaved, QJSValue onFailed);
     Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, QJSValue onSaved);
-    Q_INVOKABLE void saveItem(QQuickItem* target, const QUrl& path, const QRect& rect, QJSValue onSaved, QJSValue onFailed);
+    Q_INVOKABLE void saveItem(
+        QQuickItem* target, const QUrl& path, const QRect& rect, QJSValue onSaved, QJSValue onFailed);
 
     Q_INVOKABLE bool copyFile(const QUrl& source, const QUrl& target) const;
     Q_INVOKABLE bool copyFile(const QUrl& source, const QUrl& target, bool overwrite) const;

plugin/src/Caelestia/filesystemmodel.cpp

@@ -1,12 +1,12 @@
 #include "filesystemmodel.hpp"
 
-#include <QObject>
-#include <qqmlintegration.h>
 #include <QAbstractListModel>
-#include <QFileInfo>
 #include <QDir>
 #include <QDirIterator>
+#include <QFileInfo>
 #include <QImageReader>
+#include <QObject>
+#include <qqmlintegration.h>
 
 int FileSystemModel::rowCount(const QModelIndex& parent) const {
     if (parent != QModelIndex()) {
@@ -23,7 +23,7 @@ QVariant FileSystemModel::data(const QModelIndex& index, int role) const {
 }
 
 QHash<int, QByteArray> FileSystemModel::roleNames() const {
-    return {{ Qt::UserRole, "modelData"}};
+    return { { Qt::UserRole, "modelData" } };
 }
 
 QString FileSystemModel::path() const {

plugin/src/Caelestia/filesystemmodel.hpp

@@ -1,12 +1,12 @@
 #pragma once
 
+#include <QAbstractListModel>
+#include <QDir>
+#include <QFileInfo>
+#include <QFileSystemWatcher>
+#include <QImageReader>
 #include <QObject>
 #include <qqmlintegration.h>
-#include <QAbstractListModel>
-#include <QFileSystemWatcher>
-#include <QFileInfo>
-#include <QDir>
-#include <QImageReader>
 
 class FileSystemEntry : public QObject {
     Q_OBJECT
@@ -23,7 +23,10 @@ class FileSystemEntry : public QObject {
 
 public:
     explicit FileSystemEntry(const QString& path, const QString& relativePath, QObject* parent = nullptr)
-        : QObject(parent), m_fileInfo(QFileInfo(path)), m_path(path), m_relativePath(relativePath) {}
+        : QObject(parent)
+        , m_fileInfo(QFileInfo(path))
+        , m_path(path)
+        , m_relativePath(relativePath) {}
 
     QString path() const { return m_path; };
     QString relativePath() const { return m_relativePath; };
@@ -71,7 +74,9 @@ public:
     Q_ENUM(Filter)
 
     explicit FileSystemModel(QObject* parent = nullptr)
-        : QAbstractListModel(parent), m_recursive(true), m_filter(NoFilter) {
+        : QAbstractListModel(parent)
+        , m_recursive(true)
+        , m_filter(NoFilter) {
         connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::watchDirIfRecursive);
         connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this, &FileSystemModel::updateEntries);
     }