MainWindow: Save tab mode immediately when changed

The sidebar mode (tabs on top, large sidebar, etc.) was only being saved
when the application exits normally. This caused the setting to be lost
if the application crashed or was force-closed, reverting to the default
"Large Sidebar" mode on next startup.

This fix connects the FancyTabWidget::ModeChanged signal to immediately
save the tab_mode setting when the user changes it via the context menu.

Fixes issue where sidebar keeps periodically reverting to Large mode.

Co-authored-by: jonaski <10343810+jonaski@users.noreply.github.com>

.github/workflows/build.yml

@@ -739,12 +739,18 @@ jobs:
       with:
         fetch-depth: 0
         submodules: recursive
+    - name: Free disk space
+      run: |
+        df -h
+        sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc
+        sudo apt-get clean
+        df -h
     - name: Build FreeBSD
       id: build-freebsd
-      uses: vmactions/freebsd-vm@v1.3.0
+      uses: vmactions/freebsd-vm@v1.3.5
       with:
         usesh: true
-        mem: 4096
+        mem: 8192
         prepare: pkg install -y git cmake pkgconf boost-libs alsa-lib glib qt6-base qt6-tools sqlite gstreamer1 gstreamer1-plugins chromaprint libebur128 taglib libcdio libmtp gdk-pixbuf2 libgpod fftw3 icu kdsingleapplication googletest pulseaudio sparsehash rapidjson
         run: |
           set -e
@@ -766,7 +772,7 @@ jobs:
         submodules: recursive
     - name: Build OpenBSD
       id: build-openbsd
-      uses: vmactions/openbsd-vm@v1.2.5
+      uses: vmactions/openbsd-vm@v1.3.1
       with:
         usesh: true
         mem: 4096
@@ -839,7 +845,7 @@ jobs:
           p12-password: ${{ secrets.APPLE_DEVELOPER_ID_CERTIFICATE_PASSWORD }}
 
       - name: Download macOS dependencies
-        run: curl -f -O -L https://github.com/strawberrymusicplayer/strawberry-macos-dependencies$(test "${{env.arch}}" = "x86_64" && echo "-intel" || echo "")/releases/latest/download/strawberry-macos-${{env.arch}}-${{env.buildtype}}.tar.xz
+        run: curl -f -O -L https://github.com/strawberrymusicplayer/strawberry-macos-dependencies/releases/latest/download/strawberry-macos-${{env.arch}}-${{env.buildtype}}.tar.xz
 
       - name: Extract macOS dependencies
         run: sudo tar -C / -xf strawberry-macos-${{env.arch}}-${{env.buildtype}}.tar.xz
@@ -892,7 +898,7 @@ jobs:
       - name: Manually Codesign
         if: github.repository == 'strawberrymusicplayer/strawberry' && github.event.pull_request.head.repo.fork == false && matrix.runner == 'macos-15-intel'
         working-directory: build
-        run: codesign -s 383J84DVB6 -f strawberry.app/Contents/Frameworks/{libpcre2-8.0.dylib,libpcre2-16.0.dylib,libpng16.16.dylib,libfreetype.6.dylib,libzstd.1.dylib,libbrotlicommon.1.dylib,libbrotlienc.1.dylib} strawberry.app/Contents/Frameworks/png.framework/png strawberry.app
+        run: codesign -s 383J84DVB6 -f strawberry.app/Contents/Frameworks/{libpcre2-8.0.dylib,libpcre2-16.0.dylib,libpng16.16.dylib,libfreetype.6.dylib,libzstd.1.dylib,libbrotlicommon.1.dylib,libbrotlienc.1.dylib,libbrotlidec.1.dylib,libsoup-3.0.0.dylib,libnghttp2.14.dylib,libpsl.5.dylib} strawberry.app/Contents/Frameworks/png.framework/png strawberry.app
 
       - name: Manually Codesign
         if: github.repository == 'strawberrymusicplayer/strawberry' && github.event.pull_request.head.repo.fork == false && matrix.runner == 'macos-15'

CMakeLists.txt

@@ -823,6 +823,8 @@ set(SOURCES
 
   src/fileview/fileview.cpp
   src/fileview/fileviewlist.cpp
+  src/fileview/fileviewtree.cpp
+  src/fileview/fileviewtreemodel.cpp
 
   src/device/devicemanager.cpp
   src/device/devicelister.cpp
@@ -1112,6 +1114,8 @@ set(HEADERS
 
   src/fileview/fileview.h
   src/fileview/fileviewlist.h
+  src/fileview/fileviewtree.h
+  src/fileview/fileviewtreemodel.h
 
   src/device/devicemanager.h
   src/device/devicelister.h

src/collection/collectionlibrary.cpp

@@ -2,7 +2,7 @@
  * Strawberry Music Player
  * This file was part of Clementine.
  * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, Jonas Kvinge <jonas@jkvinge.net>
  *
  * Strawberry is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -189,6 +189,26 @@ void CollectionLibrary::ReloadSettings() {
 
 }
 
+void CollectionLibrary::CurrentSongChanged(const Song &song) {
+
+  current_song_url_ = song.url();
+
+  if (!pending_song_saves_.isEmpty()) {
+    SavePendingPlaycountsAndRatings();
+  }
+
+}
+
+void CollectionLibrary::Stopped() {
+
+  current_song_url_ = QUrl();
+
+  if (!pending_song_saves_.isEmpty()) {
+    SavePendingPlaycountsAndRatings();
+  }
+
+}
+
 void CollectionLibrary::SyncPlaycountAndRatingToFilesAsync() {
 
   (void)QtConcurrent::run(&CollectionLibrary::SyncPlaycountAndRatingToFiles, this);
@@ -212,18 +232,85 @@ void CollectionLibrary::SyncPlaycountAndRatingToFiles() {
 
 }
 
-void CollectionLibrary::SongsPlaycountChanged(const SongList &songs, const bool save_tags) const {
+void CollectionLibrary::SongsPlaycountChanged(const SongList &songs, const bool save_tags) {
 
   if (save_tags || save_playcounts_to_files_) {
-    tagreader_client_->SaveSongsPlaycountAsync(songs);
+    SongList songs_to_save_now;
+    for (const Song &song : songs) {
+      if (song.url().isLocalFile() && song.url() == current_song_url_ &&
+          (song.filetype() == Song::FileType::OggFlac || song.filetype() == Song::FileType::OggVorbis || song.filetype() == Song::FileType::OggOpus)) {
+        qLog(Debug) << "Deferring playcount save for currently playing file" << song.url().toLocalFile();
+        if (pending_song_saves_.contains(song.url())) {
+          SharedPtr<PendingSongSave> pending_song_save = pending_song_saves_[song.url()];
+          pending_song_save->save_playcount = true;
+          pending_song_save->song.set_playcount(song.playcount());
+        }
+        else {
+          SharedPtr<PendingSongSave> pending_song_save = make_shared<PendingSongSave>();
+          pending_song_save->save_playcount = true;
+          pending_song_save->song = song;
+          pending_song_saves_.insert(song.url(), pending_song_save);
+        }
+      }
+      else {
+        songs_to_save_now << song;
+      }
+    }
+    if (!songs_to_save_now.isEmpty()) {
+      tagreader_client_->SaveSongsPlaycountAsync(songs_to_save_now);
+    }
   }
 
 }
 
-void CollectionLibrary::SongsRatingChanged(const SongList &songs, const bool save_tags) const {
+void CollectionLibrary::SongsRatingChanged(const SongList &songs, const bool save_tags) {
 
   if (save_tags || save_ratings_to_files_) {
-    tagreader_client_->SaveSongsRatingAsync(songs);
+    SongList songs_to_save_now;
+    for (const Song &song : songs) {
+      if (song.url().isLocalFile() && song.url() == current_song_url_ &&
+          (song.filetype() == Song::FileType::OggFlac || song.filetype() == Song::FileType::OggVorbis || song.filetype() == Song::FileType::OggOpus)) {
+        qLog(Debug) << "Deferring rating save for currently playing file" << song.url().toLocalFile();
+        if (pending_song_saves_.contains(song.url())) {
+          SharedPtr<PendingSongSave> pending_song_save = pending_song_saves_[song.url()];
+          pending_song_save->save_rating = true;
+          pending_song_save->song.set_rating(song.rating());
+        }
+        else {
+          SharedPtr<PendingSongSave> pending_song_save = make_shared<PendingSongSave>();
+          pending_song_save->save_rating = true;
+          pending_song_save->song = song;
+          pending_song_saves_.insert(song.url(), pending_song_save);
+        }
+      }
+      else {
+        songs_to_save_now << song;
+      }
+    }
+    if (!songs_to_save_now.isEmpty()) {
+      tagreader_client_->SaveSongsRatingAsync(songs_to_save_now);
+    }
+  }
+
+}
+
+void CollectionLibrary::SavePendingPlaycountsAndRatings() {
+
+  for (auto it = pending_song_saves_.constBegin(); it != pending_song_saves_.constEnd();) {
+    const QUrl url = it.key();
+    SharedPtr<PendingSongSave> pending_song_save = it.value();
+    if (url == current_song_url_) {
+      ++it;
+      continue;
+    }
+    qLog(Debug) << "Saving deferred playcount/rating for" << url.toLocalFile();
+    if (pending_song_save->save_playcount) {
+      tagreader_client_->SaveSongsPlaycountAsync(SongList() << pending_song_save->song);
+    }
+    if (pending_song_save->save_rating) {
+      tagreader_client_->SaveSongsRatingAsync(SongList() << pending_song_save->song);
+    }
+    it = pending_song_saves_.erase(it);
   }
 
 }

src/collection/collectionlibrary.h

@@ -2,7 +2,7 @@
  * Strawberry Music Player
  * This file was part of Clementine.
  * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2025, Jonas Kvinge <jonas@jkvinge.net>
  *
  * Strawberry is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -27,6 +27,7 @@
 #include <QObject>
 #include <QList>
 #include <QHash>
+#include <QMap>
 #include <QString>
 
 #include "includes/shared_ptr.h"
@@ -71,6 +72,7 @@ class CollectionLibrary : public QObject {
 
  private:
   void SyncPlaycountAndRatingToFiles();
+  void SavePendingPlaycountsAndRatings();
 
  public Q_SLOTS:
   void ReloadSettings();
@@ -84,16 +86,26 @@ class CollectionLibrary : public QObject {
 
   void IncrementalScan();
 
+  void CurrentSongChanged(const Song &song);
+  void Stopped();
+
  private Q_SLOTS:
   void ExitReceived();
-  void SongsPlaycountChanged(const SongList &songs, const bool save_tags = false) const;
-  void SongsRatingChanged(const SongList &songs, const bool save_tags = false) const;
+  void SongsPlaycountChanged(const SongList &songs, const bool save_tags = false);
+  void SongsRatingChanged(const SongList &songs, const bool save_tags = false);
 
  Q_SIGNALS:
   void Error(const QString &error);
   void ExitFinished();
 
  private:
+  class PendingSongSave {
+   public:
+    Song song;
+    bool save_playcount = false;
+    bool save_rating = false;
+  };
+
   const SharedPtr<TaskManager> task_manager_;
   const SharedPtr<TagReaderClient> tagreader_client_;
 
@@ -111,6 +123,10 @@ class CollectionLibrary : public QObject {
 
   bool save_playcounts_to_files_;
   bool save_ratings_to_files_;
+
+  QUrl current_song_url_;
+
+  QMap<QUrl, SharedPtr<PendingSongSave>> pending_song_saves_;
 };
 
 #endif

src/collection/collectionmodel.cpp

@@ -1209,49 +1209,41 @@ QString CollectionModel::ContainerKey(const GroupBy group_by, const Song &song,
   switch (group_by) {
     case GroupBy::AlbumArtist:
       key = TextOrUnknown(song.effective_albumartist());
-      if (!song.effective_albumartistsort().isEmpty() && song.effective_albumartistsort() != song.effective_albumartist()) key.append(QLatin1Char('-') + TextOrUnknown(song.effective_albumartistsort()));
       has_unique_album_identifier = true;
       break;
     case GroupBy::Artist:
       key = TextOrUnknown(song.artist());
-      if (!song.artistsort().isEmpty() && song.artistsort() != song.artist()) key.append(QLatin1Char('-') + TextOrUnknown(song.artistsort()));
       has_unique_album_identifier = true;
       break;
     case GroupBy::Album:
       key = TextOrUnknown(song.album());
-      if (!song.albumsort().isEmpty() && song.albumsort() != song.album()) key.append(QLatin1Char('-') + TextOrUnknown(song.albumsort()));
       if (!song.album_id().isEmpty()) key.append(QLatin1Char('-') + song.album_id());
       if (options_active_.separate_albums_by_grouping && !song.grouping().isEmpty()) key.append(QLatin1Char('-') + song.grouping());
       break;
     case GroupBy::AlbumDisc:
       key = TextOrUnknown(song.album());
-      if (!song.albumsort().isEmpty() && song.albumsort() != song.album()) key.append(QLatin1Char('-') + TextOrUnknown(song.albumsort()));
       key.append(QLatin1Char('-') + SortTextForNumber(song.disc()));
       if (!song.album_id().isEmpty()) key.append(QLatin1Char('-') + song.album_id());
       if (options_active_.separate_albums_by_grouping && !song.grouping().isEmpty()) key.append(QLatin1Char('-') + song.grouping());
       break;
     case GroupBy::YearAlbum:
       key = SortTextForYear(song.year()) + QLatin1Char('-') + TextOrUnknown(song.album());
-      if (!song.albumsort().isEmpty() && song.albumsort() != song.album()) key.append(QLatin1Char('-') + TextOrUnknown(song.albumsort()));
       if (!song.album_id().isEmpty()) key.append(QLatin1Char('-') + song.album_id());
       if (options_active_.separate_albums_by_grouping && !song.grouping().isEmpty()) key.append(QLatin1Char('-') + song.grouping());
       break;
     case GroupBy::YearAlbumDisc:
       key = SortTextForYear(song.year()) + QLatin1Char('-') + TextOrUnknown(song.album());
-      if (!song.albumsort().isEmpty() && song.albumsort() != song.album()) key.append(QLatin1Char('-') + TextOrUnknown(song.albumsort()));
       key.append(QLatin1Char('-') + SortTextForNumber(song.disc()));
       if (!song.album_id().isEmpty()) key.append(QLatin1Char('-') + song.album_id());
       if (options_active_.separate_albums_by_grouping && !song.grouping().isEmpty()) key.append(QLatin1Char('-') + song.grouping());
       break;
     case GroupBy::OriginalYearAlbum:
       key = SortTextForYear(song.effective_originalyear()) + QLatin1Char('-') + TextOrUnknown(song.album());
-      if (!song.albumsort().isEmpty() && song.albumsort() != song.album()) key.append(QLatin1Char('-') + TextOrUnknown(song.albumsort()));
       if (!song.album_id().isEmpty()) key.append(QLatin1Char('-') + song.album_id());
       if (options_active_.separate_albums_by_grouping && !song.grouping().isEmpty()) key.append(QLatin1Char('-') + song.grouping());
       break;
     case GroupBy::OriginalYearAlbumDisc:
       key = SortTextForYear(song.effective_originalyear()) + QLatin1Char('-') + TextOrUnknown(song.album());
-      if (!song.albumsort().isEmpty() && song.albumsort() != song.album()) key.append(QLatin1Char('-') + TextOrUnknown(song.albumsort()));
       key.append(QLatin1Char('-') + SortTextForNumber(song.disc()));
       if (!song.album_id().isEmpty()) key.append(QLatin1Char('-') + song.album_id());
       if (options_active_.separate_albums_by_grouping && !song.grouping().isEmpty()) key.append(QLatin1Char('-') + song.grouping());
@@ -1270,12 +1262,10 @@ QString CollectionModel::ContainerKey(const GroupBy group_by, const Song &song,
       break;
     case GroupBy::Composer:
       key = TextOrUnknown(song.composer());
-      if (!song.composersort().isEmpty() && song.composersort() != song.composer()) key.append(QLatin1Char('-') + song.composersort());
       has_unique_album_identifier = true;
       break;
     case GroupBy::Performer:
       key = TextOrUnknown(song.performer());
-      if (!song.performersort().isEmpty() && song.performersort() != song.performer()) key.append(QLatin1Char('-') + song.performersort());
       has_unique_album_identifier = true;
       break;
     case GroupBy::Grouping:

src/collection/collectionview.cpp

@@ -383,7 +383,7 @@ void CollectionView::keyPressEvent(QKeyEvent *e) {
     case Qt::Key_Enter:
     case Qt::Key_Return:
       if (currentIndex().isValid()) {
-        AddToPlaylist();
+        Q_EMIT doubleClicked(currentIndex());
       }
       e->accept();
       break;

src/core/filesystemmusicstorage.cpp

@@ -110,21 +110,32 @@ bool FilesystemMusicStorage::CopyToStorage(const CopyJob &job, QString &error_te
 
 bool FilesystemMusicStorage::DeleteFromStorage(const DeleteJob &job) {
 
-  QString path = job.metadata_.url().toLocalFile();
-  QFileInfo fileInfo(path);
+  const QString path = job.metadata_.url().toLocalFile();
+  const QFileInfo fileInfo(path);
 
 #if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
   if (job.use_trash_ && QFile::supportsMoveToTrash()) {
 #else
   if (job.use_trash_) {
 #endif
-    return QFile::moveToTrash(path);
+    if (QFile::moveToTrash(path)) {
+      return true;
+    }
+    qLog(Warning) << "Moving file to trash failed for" << path << ", falling back to direct deletion";
   }
 
+  bool success = false;
   if (fileInfo.isDir()) {
-    return Utilities::RemoveRecursive(path);
+    success = Utilities::RemoveRecursive(path);
+  }
+  else {
+    success = QFile::remove(path);
   }
 
-  return QFile::remove(path);
+  if (!success) {
+    qLog(Error) << "Failed to delete file" << path;
+  }
+
+  return success;
 
 }

src/core/mainwindow.cpp

@@ -58,7 +58,6 @@
 #include <QShortcut>
 #include <QMessageBox>
 #include <QErrorMessage>
-#include <QSettings>
 #include <QColor>
 #include <QFrame>
 #include <QItemSelectionModel>
@@ -448,6 +447,14 @@ MainWindow::MainWindow(Application *app,
   ui_->tabs->SetBackgroundPixmap(QPixmap(u":/pictures/sidebar-background.png"_s));
   ui_->tabs->LoadSettings(QLatin1String(MainWindowSettings::kSettingsGroup));
 
+  // Save tab mode immediately when changed to avoid losing the setting
+  QObject::connect(ui_->tabs, &FancyTabWidget::ModeChanged, this, [this](FancyTabWidget::Mode mode) {
+    Settings s;
+    s.beginGroup(MainWindowSettings::kSettingsGroup);
+    s.setValue("tab_mode", static_cast<int>(mode));
+    s.endGroup();
+  });
+
   track_position_timer_->setInterval(kTrackPositionUpdateTimeMs);
   QObject::connect(track_position_timer_, &QTimer::timeout, this, &MainWindow::UpdateTrackPosition);
   track_slider_timer_->setInterval(kTrackSliderUpdateTimeMs);
@@ -697,6 +704,9 @@ MainWindow::MainWindow(Application *app,
   QObject::connect(&*app_->task_manager(), &TaskManager::PauseCollectionWatchers, &*app_->collection(), &CollectionLibrary::PauseWatcher);
   QObject::connect(&*app_->task_manager(), &TaskManager::ResumeCollectionWatchers, &*app_->collection(), &CollectionLibrary::ResumeWatcher);
 
+  QObject::connect(&*app_->playlist_manager(), &PlaylistManager::CurrentSongChanged, &*app_->collection(), &CollectionLibrary::CurrentSongChanged);
+  QObject::connect(&*app_->player(), &Player::Stopped, &*app_->collection(), &CollectionLibrary::Stopped);
+
   QObject::connect(&*app_->playlist_manager(), &PlaylistManager::CurrentSongChanged, &*app_->current_albumcover_loader(), &CurrentAlbumCoverLoader::LoadAlbumCover);
   QObject::connect(&*app_->current_albumcover_loader(), &CurrentAlbumCoverLoader::AlbumCoverLoaded, this, &MainWindow::AlbumCoverLoaded);
   QObject::connect(album_cover_choice_controller_, &AlbumCoverChoiceController::Error, this, &MainWindow::ShowErrorDialog);
@@ -977,27 +987,28 @@ MainWindow::MainWindow(Application *app,
 
   // Load settings
   qLog(Debug) << "Loading settings";
-  settings_.beginGroup(MainWindowSettings::kSettingsGroup);
+  Settings settings;
+  settings.beginGroup(MainWindowSettings::kSettingsGroup);
 
   // Set last used geometry to position window on the correct monitor
   // Set window state only if the window was last maximized
-  if (settings_.contains("geometry")) {
-    restoreGeometry(settings_.value("geometry").toByteArray());
+  if (settings.contains("geometry")) {
+    restoreGeometry(settings.value("geometry").toByteArray());
   }
 
-  if (!settings_.contains(MainWindowSettings::kSplitterState) || !ui_->splitter->restoreState(settings_.value(MainWindowSettings::kSplitterState).toByteArray())) {
+  if (!settings.contains(MainWindowSettings::kSplitterState) || !ui_->splitter->restoreState(settings.value(MainWindowSettings::kSplitterState).toByteArray())) {
     ui_->splitter->setSizes(QList<int>() << 20 << (width() - 20));
   }
 
-  ui_->tabs->setCurrentIndex(settings_.value("current_tab", 1).toInt());
+  ui_->tabs->setCurrentIndex(settings.value("current_tab", 1).toInt());
   FancyTabWidget::Mode default_mode = FancyTabWidget::Mode::LargeSidebar;
-  FancyTabWidget::Mode tab_mode = static_cast<FancyTabWidget::Mode>(settings_.value("tab_mode", static_cast<int>(default_mode)).toInt());
+  FancyTabWidget::Mode tab_mode = static_cast<FancyTabWidget::Mode>(settings.value("tab_mode", static_cast<int>(default_mode)).toInt());
   if (tab_mode == FancyTabWidget::Mode::None) tab_mode = default_mode;
   ui_->tabs->SetMode(tab_mode);
 
   TabSwitched();
 
-  file_view_->SetPath(settings_.value("file_path", QDir::homePath()).toString());
+  file_view_->SetPath(settings.value("file_path", QDir::homePath()).toString());
 
   // Users often collapse one side of the splitter by mistake and don't know how to restore it. This must be set after the state is restored above.
   ui_->splitter->setChildrenCollapsible(false);
@@ -1040,13 +1051,13 @@ MainWindow::MainWindow(Application *app,
     case BehaviourSettings::StartupBehaviour::Remember:
     default:{
 
-      was_maximized_ = settings_.value(MainWindowSettings::kMaximized, true).toBool();
+      was_maximized_ = settings.value(MainWindowSettings::kMaximized, true).toBool();
       if (was_maximized_) setWindowState(windowState() | Qt::WindowMaximized);
 
-      was_minimized_ = settings_.value(MainWindowSettings::kMinimized, false).toBool();
+      was_minimized_ = settings.value(MainWindowSettings::kMinimized, false).toBool();
       if (was_minimized_) setWindowState(windowState() | Qt::WindowMinimized);
 
-      if (!systemtrayicon_->IsSystemTrayAvailable() || !systemtrayicon_->isVisible() || !settings_.value(MainWindowSettings::kHidden, false).toBool()) {
+      if (!systemtrayicon_->IsSystemTrayAvailable() || !systemtrayicon_->isVisible() || !settings.value(MainWindowSettings::kHidden, false).toBool()) {
         show();
       }
       break;
@@ -1054,7 +1065,7 @@ MainWindow::MainWindow(Application *app,
   }
 #endif
 
-  bool show_sidebar = settings_.value(MainWindowSettings::kShowSidebar, true).toBool();
+  bool show_sidebar = settings.value(MainWindowSettings::kShowSidebar, true).toBool();
   ui_->sidebar_layout->setVisible(show_sidebar);
   ui_->action_toggle_show_sidebar->setChecked(show_sidebar);
 
@@ -1225,7 +1236,9 @@ void MainWindow::ReloadSettings() {
 
   osd_->ReloadSettings();
 
-  album_cover_choice_controller_->search_cover_auto_action()->setChecked(settings_.value(MainWindowSettings::kSearchForCoverAuto, true).toBool());
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  album_cover_choice_controller_->search_cover_auto_action()->setChecked(s.value(MainWindowSettings::kSearchForCoverAuto, true).toBool());
+  s.endGroup();
 
 #ifdef HAVE_SUBSONIC
   s.beginGroup(SubsonicSettings::kSettingsGroup);
@@ -1342,8 +1355,11 @@ void MainWindow::SaveSettings() {
   ui_->playlist->view()->SaveSettings();
   app_->scrobbler()->WriteCache();
 
-  settings_.setValue(MainWindowSettings::kShowSidebar, ui_->action_toggle_show_sidebar->isChecked());
-  settings_.setValue(MainWindowSettings::kSearchForCoverAuto, album_cover_choice_controller_->search_cover_auto_action()->isChecked());
+  Settings s;
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  s.setValue(MainWindowSettings::kShowSidebar, ui_->action_toggle_show_sidebar->isChecked());
+  s.setValue(MainWindowSettings::kSearchForCoverAuto, album_cover_choice_controller_->search_cover_auto_action()->isChecked());
+  s.endGroup();
 
 }
 
@@ -1584,23 +1600,35 @@ void MainWindow::ToggleSidebar(const bool checked) {
 
   ui_->sidebar_layout->setVisible(checked);
   TabSwitched();
-  settings_.setValue(MainWindowSettings::kShowSidebar, checked);
+
+  Settings s;
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  s.setValue(MainWindowSettings::kShowSidebar, checked);
+  s.endGroup();
 
 }
 
 void MainWindow::ToggleSearchCoverAuto(const bool checked) {
-  settings_.setValue(MainWindowSettings::kSearchForCoverAuto, checked);
+
+  Settings s;
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  s.setValue(MainWindowSettings::kSearchForCoverAuto, checked);
+  s.endGroup();
+
 }
 
 void MainWindow::SaveGeometry() {
 
   if (!initialized_) return;
 
-  settings_.setValue(MainWindowSettings::kMaximized, isMaximized());
-  settings_.setValue(MainWindowSettings::kMinimized, isMinimized());
-  settings_.setValue(MainWindowSettings::kHidden, isHidden());
-  settings_.setValue(MainWindowSettings::kGeometry, saveGeometry());
-  settings_.setValue(MainWindowSettings::kSplitterState, ui_->splitter->saveState());
+  Settings s;
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  s.setValue(MainWindowSettings::kMaximized, isMaximized());
+  s.setValue(MainWindowSettings::kMinimized, isMinimized());
+  s.setValue(MainWindowSettings::kHidden, isHidden());
+  s.setValue(MainWindowSettings::kGeometry, saveGeometry());
+  s.setValue(MainWindowSettings::kSplitterState, ui_->splitter->saveState());
+  s.endGroup();
 
 }
 
@@ -1742,7 +1770,12 @@ void MainWindow::SetHiddenInTray(const bool hidden) {
 }
 
 void MainWindow::FilePathChanged(const QString &path) {
-  settings_.setValue("file_path", path);
+
+  Settings s;
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  s.setValue("file_path", path);
+  s.endGroup();
+
 }
 
 void MainWindow::Seeked(const qint64 microseconds) {
@@ -2324,7 +2357,9 @@ void MainWindow::EditValue() {
 void MainWindow::AddFile() {
 
   // Last used directory
-  QString directory = settings_.value("add_media_path", QDir::currentPath()).toString();
+  Settings s;
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  QString directory = s.value("add_media_path", QDir::currentPath()).toString();
 
   PlaylistParser parser(app_->tagreader_client(), app_->collection_backend());
 
@@ -2334,7 +2369,7 @@ void MainWindow::AddFile() {
   if (filenames.isEmpty()) return;
 
   // Save last used directory
-  settings_.setValue("add_media_path", filenames[0]);
+  s.setValue("add_media_path", filenames[0]);
 
   // Convert to URLs
   QList<QUrl> urls;
@@ -2352,14 +2387,16 @@ void MainWindow::AddFile() {
 void MainWindow::AddFolder() {
 
   // Last used directory
-  QString directory = settings_.value("add_folder_path", QDir::currentPath()).toString();
+  Settings s;
+  s.beginGroup(MainWindowSettings::kSettingsGroup);
+  QString directory = s.value("add_folder_path", QDir::currentPath()).toString();
 
   // Show dialog
   directory = QFileDialog::getExistingDirectory(this, tr("Add folder"), directory);
   if (directory.isEmpty()) return;
 
   // Save last used directory
-  settings_.setValue("add_folder_path", directory);
+  s.setValue("add_folder_path", directory);
 
   // Add media
   MimeData *mimedata = new MimeData;

src/core/mainwindow.h

@@ -43,9 +43,7 @@
 #include <QString>
 #include <QUrl>
 #include <QImage>
-#include <QPixmap>
 #include <QTimer>
-#include <QSettings>
 #include <QtEvents>
 
 #include "includes/scoped_ptr.h"
@@ -53,7 +51,6 @@
 #include "includes/lazy.h"
 #include "core/platforminterface.h"
 #include "core/song.h"
-#include "core/settings.h"
 #include "core/commandlineoptions.h"
 #include "tagreader/tagreaderclient.h"
 #include "osd/osdbase.h"
@@ -292,9 +289,6 @@ class MainWindow : public QMainWindow, public PlatformInterface {
 
   void CheckFullRescanRevisions();
 
-  // creates the icon by painting the full one depending on the current position
-  QPixmap CreateOverlayedIcon(const int position, const int scrobble_point);
-
   void GetCoverAutomatically();
 
   void SetToggleScrobblingIcon(const bool value);
@@ -390,7 +384,6 @@ class MainWindow : public QMainWindow, public PlatformInterface {
 
   QTimer *track_position_timer_;
   QTimer *track_slider_timer_;
-  Settings settings_;
 
   bool keep_running_;
   bool playing_widget_;

src/core/song.cpp

@@ -805,19 +805,19 @@ bool Song::lyrics_supported() const {
 }
 
 bool Song::albumartistsort_supported() const {
-  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::MPEG;
+  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::OggOpus || d->filetype_ == FileType::MPEG;
 }
 
 bool Song::albumsort_supported() const {
-  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::MPEG;
+  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::OggOpus || d->filetype_ == FileType::MPEG;
 }
 
 bool Song::artistsort_supported() const {
-  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::MPEG;
+  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::OggOpus || d->filetype_ == FileType::MPEG;
 }
 
 bool Song::composersort_supported() const {
-  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::MPEG;
+  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::OggOpus || d->filetype_ == FileType::MPEG;
 }
 
 bool Song::performersort_supported() const {
@@ -826,7 +826,7 @@ bool Song::performersort_supported() const {
 }
 
 bool Song::titlesort_supported() const {
-  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::MPEG;
+  return d->filetype_ == FileType::FLAC || d->filetype_ == FileType::OggFlac || d->filetype_ == FileType::OggVorbis || d->filetype_ == FileType::OggOpus || d->filetype_ == FileType::MPEG;
 }
 
 bool Song::save_embedded_cover_supported(const FileType filetype) {
@@ -1668,12 +1668,24 @@ void Song::InitArtManual() {
 void Song::InitArtAutomatic() {
 
   if (d->art_automatic_.isEmpty() && d->source_ == Source::LocalFile && d->url_.isLocalFile()) {
-    // Pick the first image file in the album directory.
-    QFileInfo file(d->url_.toLocalFile());
-    QDir dir(file.path());
-    QStringList files = dir.entryList(QStringList() << u"*.jpg"_s << u"*.png"_s << u"*.gif"_s << u"*.jpeg"_s, QDir::Files|QDir::Readable, QDir::Name);
-    if (files.count() > 0) {
-      d->art_automatic_ = QUrl::fromLocalFile(file.path() + QDir::separator() + files.first());
+    const QFileInfo fileinfo(d->url_.toLocalFile());
+    const QDir dir(fileinfo.path());
+    const QStringList cover_files = dir.entryList(QStringList() << u"*.jpg"_s << u"*.png"_s << u"*.gif"_s << u"*.jpeg"_s, QDir::Files|QDir::Readable, QDir::Name);
+    QString best_cover_file;
+    for (const QString &cover_file : cover_files) {
+      if (cover_file.contains("back"_L1, Qt::CaseInsensitive)) {
+        continue;
+      }
+      if (cover_file.contains("front"_L1, Qt::CaseInsensitive) || cover_file.startsWith("cover"_L1, Qt::CaseInsensitive)) {
+        best_cover_file = cover_file;
+        break;
+      }
+      if (best_cover_file.isEmpty()) {
+        best_cover_file = cover_file;
+      }
+    }
+    if (!best_cover_file.isEmpty()) {
+      d->art_automatic_ = QUrl::fromLocalFile(fileinfo.path() + QDir::separator() + best_cover_file);
     }
   }
 

src/core/songloader.cpp

@@ -98,6 +98,9 @@ SongLoader::SongLoader(const SharedPtr<UrlHandlers> url_handlers,
 
   QObject::connect(timeout_timer_, &QTimer::timeout, this, &SongLoader::Timeout);
 
+  QObject::connect(playlist_parser_, &PlaylistParser::Error, this, &SongLoader::ParserError);
+  QObject::connect(cue_parser_, &CueParser::Error, this, &SongLoader::ParserError);
+
 }
 
 SongLoader::~SongLoader() {
@@ -106,6 +109,10 @@ SongLoader::~SongLoader() {
 
 }
 
+void SongLoader::ParserError(const QString &error) {
+  errors_ << error;
+}
+
 SongLoader::Result SongLoader::Load(const QUrl &url) {
 
   if (url.isEmpty()) return Result::Error;
@@ -287,6 +294,7 @@ SongLoader::Result SongLoader::LoadLocalAsync(const QString &filename) {
   }
 
   if (parser) {  // It's a playlist!
+    QObject::connect(parser, &ParserBase::Error, this, &SongLoader::ParserError, static_cast<Qt::ConnectionType>(Qt::QueuedConnection | Qt::UniqueConnection));
     qLog(Debug) << "Parsing using" << parser->name();
     LoadPlaylist(parser, filename);
     return Result::Success;
@@ -706,6 +714,10 @@ void SongLoader::MagicReady() {
     StopTypefindAsync(true);
   }
 
+  if (parser_) {
+    QObject::connect(parser_, &ParserBase::Error, this, &SongLoader::ParserError, static_cast<Qt::ConnectionType>(Qt::QueuedConnection | Qt::UniqueConnection));
+  }
+
   state_ = State::WaitingForData;
 
   if (!IsPipelinePlaying()) {

src/core/songloader.h

@@ -99,6 +99,7 @@ class SongLoader : public QObject {
   void ScheduleTimeout();
   void Timeout();
   void StopTypefind();
+  void ParserError(const QString &error);
 
 #ifdef HAVE_AUDIOCD
   void AudioCDTracksLoadErrorSlot(const QString &error);

src/engine/gstenginepipeline.cpp

@@ -178,7 +178,6 @@ GstEnginePipeline::GstEnginePipeline(QObject *parent)
       audiobin_(nullptr),
       audiosink_(nullptr),
       audioqueue_(nullptr),
-      audioqueueconverter_(nullptr),
       volume_(nullptr),
       volume_sw_(nullptr),
       volume_fading_(nullptr),
@@ -187,6 +186,7 @@ GstEnginePipeline::GstEnginePipeline(QObject *parent)
       equalizer_(nullptr),
       equalizer_preamp_(nullptr),
       eventprobe_(nullptr),
+      bufferprobe_(nullptr),
       logged_unsupported_analyzer_format_(false),
       about_to_finish_(false),
       finish_requested_(false),
@@ -436,7 +436,7 @@ void GstEnginePipeline::Disconnect() {
     }
 
     if (buffer_probe_cb_id_.has_value()) {
-      GstPad *pad = gst_element_get_static_pad(audioqueueconverter_, "src");
+      GstPad *pad = gst_element_get_static_pad(bufferprobe_, "src");
       if (pad) {
         gst_pad_remove_probe(pad, buffer_probe_cb_id_.value());
         gst_object_unref(pad);
@@ -674,8 +674,13 @@ bool GstEnginePipeline::InitAudioBin(QString &error) {
     return false;
   }
 
-  audioqueueconverter_ = CreateElement(u"audioconvert"_s, u"audioqueueconverter"_s, audiobin_, error);
-  if (!audioqueueconverter_) {
+  GstElement *audioqueueconverter = CreateElement(u"audioconvert"_s, u"audioqueueconverter"_s, audiobin_, error);
+  if (!audioqueueconverter) {
+    return false;
+  }
+
+  GstElement *audioqueueresampler = CreateElement(u"audioresample"_s, u"audioqueueresampler"_s, audiobin_, error);
+  if (!audioqueueresampler) {
     return false;
   }
 
@@ -684,6 +689,11 @@ bool GstEnginePipeline::InitAudioBin(QString &error) {
     return false;
   }
 
+  GstElement *audiosinkresampler = CreateElement(u"audioresample"_s, u"audiosinkresampler"_s, audiobin_, error);
+  if (!audiosinkresampler) {
+    return false;
+  }
+
   // Create the volume element if it's enabled.
   if (volume_enabled_ && !volume_) {
     volume_sw_ = CreateElement(u"volume"_s, u"volume_sw"_s, audiobin_, error);
@@ -761,7 +771,8 @@ bool GstEnginePipeline::InitAudioBin(QString &error) {
 
   }
 
-  eventprobe_ = audioqueueconverter_;
+  eventprobe_ = audioqueueconverter;
+  bufferprobe_ = audioqueueconverter;
 
   // Create the replaygain elements if it's enabled.
   GstElement *rgvolume = nullptr;
@@ -847,12 +858,17 @@ bool GstEnginePipeline::InitAudioBin(QString &error) {
 
   // Link all elements
 
-  if (!gst_element_link(audioqueue_, audioqueueconverter_)) {
+  if (!gst_element_link(audioqueue_, audioqueueconverter)) {
     error = u"Failed to link audio queue to audio queue converter."_s;
     return false;
   }
 
-  GstElement *element_link = audioqueueconverter_;  // The next element to link from.
+  if (!gst_element_link(audioqueueconverter, audioqueueresampler)) {
+    error = u"Failed to link audio queue converter to audio queue resampler."_s;
+    return false;
+  }
+
+  GstElement *element_link = audioqueueresampler;  // The next element to link from.
 
   // Link replaygain elements if enabled.
   if (rg_enabled_ && rgvolume && rglimiter && rgconverter) {
@@ -928,6 +944,11 @@ bool GstEnginePipeline::InitAudioBin(QString &error) {
     return false;
   }
 
+  if (!gst_element_link(audiosinkconverter, audiosinkresampler)) {
+    error = "Failed to link audio sink converter to audio sink resampler."_L1;
+    return false;
+  }
+
   {
     GstCaps *caps = gst_caps_new_empty_simple("audio/x-raw");
     if (!caps) {
@@ -938,16 +959,16 @@ bool GstEnginePipeline::InitAudioBin(QString &error) {
       qLog(Debug) << "Setting channels to" << channels_;
       gst_caps_set_simple(caps, "channels", G_TYPE_INT, channels_, nullptr);
     }
-    const bool link_filtered_result = gst_element_link_filtered(audiosinkconverter, audiosink_, caps);
+    const bool link_filtered_result = gst_element_link_filtered(audiosinkresampler, audiosink_, caps);
     gst_caps_unref(caps);
     if (!link_filtered_result) {
-      error = "Failed to link audio sink converter to audio sink with filter for "_L1 + output_;
+      error = "Failed to link audio sink resampler to audio sink with filter for "_L1 + output_;
       return false;
     }
   }
 
   {  // Add probes and handlers.
-    GstPad *pad = gst_element_get_static_pad(audioqueueconverter_, "src");
+    GstPad *pad = gst_element_get_static_pad(bufferprobe_, "src");
     if (pad) {
       buffer_probe_cb_id_ = gst_pad_add_probe(pad, GST_PAD_PROBE_TYPE_BUFFER, BufferProbeCallback, this, nullptr);
       gst_object_unref(pad);

src/engine/gstenginepipeline.h

@@ -355,7 +355,6 @@ class GstEnginePipeline : public QObject {
   GstElement *audiobin_;
   GstElement *audiosink_;
   GstElement *audioqueue_;
-  GstElement *audioqueueconverter_;
   GstElement *volume_;
   GstElement *volume_sw_;
   GstElement *volume_fading_;
@@ -364,6 +363,7 @@ class GstEnginePipeline : public QObject {
   GstElement *equalizer_;
   GstElement *equalizer_preamp_;
   GstElement *eventprobe_;
+  GstElement *bufferprobe_;
 
   std::optional<gulong> upstream_events_probe_cb_id_;
   std::optional<gulong> buffer_probe_cb_id_;

src/fileview/fileview.cpp

@@ -29,13 +29,17 @@
 #include <QString>
 #include <QStringList>
 #include <QUrl>
-#include <QSettings>
+#include <QStandardPaths>
 #include <QMessageBox>
 #include <QScrollBar>
 #include <QLineEdit>
 #include <QToolButton>
+#include <QFileDialog>
+#include <QSpacerItem>
 #include <QtEvents>
 
+#include "constants/appearancesettings.h"
+#include "constants/filefilterconstants.h"
 #include "includes/shared_ptr.h"
 #include "core/deletefiles.h"
 #include "core/filesystemmusicstorage.h"
@@ -45,10 +49,11 @@
 #include "dialogs/deleteconfirmationdialog.h"
 #include "fileview.h"
 #include "fileviewlist.h"
+#include "fileviewtree.h"
+#include "fileviewtreemodel.h"
+#include "fileviewtreeitem.h"
 #include "ui_fileview.h"
 #include "organize/organizeerrordialog.h"
-#include "constants/appearancesettings.h"
-#include "constants/filefilterconstants.h"
 
 using std::make_unique;
 using namespace Qt::Literals::StringLiterals;
@@ -57,9 +62,12 @@ FileView::FileView(QWidget *parent)
     : QWidget(parent),
       ui_(new Ui_FileView),
       model_(nullptr),
+      tree_model_(nullptr),
       undo_stack_(new QUndoStack(this)),
       task_manager_(nullptr),
-      storage_(new FilesystemMusicStorage(Song::Source::LocalFile, u"/"_s)) {
+      storage_(new FilesystemMusicStorage(Song::Source::LocalFile, u"/"_s)),
+      tree_view_active_(false),
+      view_mode_spacer_(nullptr) {
 
   ui_->setupUi(this);
 
@@ -68,12 +76,14 @@ FileView::FileView(QWidget *parent)
   ui_->forward->setIcon(IconLoader::Load(u"go-next"_s));
   ui_->home->setIcon(IconLoader::Load(u"go-home"_s));
   ui_->up->setIcon(IconLoader::Load(u"go-up"_s));
+  ui_->toggle_view->setIcon(IconLoader::Load(u"view-choose"_s));
 
   QObject::connect(ui_->back, &QToolButton::clicked, undo_stack_, &QUndoStack::undo);
   QObject::connect(ui_->forward, &QToolButton::clicked, undo_stack_, &QUndoStack::redo);
   QObject::connect(ui_->home, &QToolButton::clicked, this, &FileView::FileHome);
   QObject::connect(ui_->up, &QToolButton::clicked, this, &FileView::FileUp);
   QObject::connect(ui_->path, &QLineEdit::textChanged, this, &FileView::ChangeFilePath);
+  QObject::connect(ui_->toggle_view, &QToolButton::clicked, this, &FileView::ToggleViewMode);
 
   QObject::connect(undo_stack_, &QUndoStack::canUndoChanged, ui_->back, &FileView::setEnabled);
   QObject::connect(undo_stack_, &QUndoStack::canRedoChanged, ui_->forward, &FileView::setEnabled);
@@ -87,6 +97,22 @@ FileView::FileView(QWidget *parent)
   QObject::connect(ui_->list, &FileViewList::Delete, this, &FileView::Delete);
   QObject::connect(ui_->list, &FileViewList::EditTags, this, &FileView::EditTags);
 
+  // Connect tree view signals
+  QObject::connect(ui_->tree, &FileViewTree::AddToPlaylist, this, &FileView::AddToPlaylist);
+  QObject::connect(ui_->tree, &FileViewTree::CopyToCollection, this, &FileView::CopyToCollection);
+  QObject::connect(ui_->tree, &FileViewTree::MoveToCollection, this, &FileView::MoveToCollection);
+  QObject::connect(ui_->tree, &FileViewTree::CopyToDevice, this, &FileView::CopyToDevice);
+  QObject::connect(ui_->tree, &FileViewTree::Delete, this, &FileView::Delete);
+  QObject::connect(ui_->tree, &FileViewTree::EditTags, this, &FileView::EditTags);
+  QObject::connect(ui_->tree, &FileViewTree::activated, this, &FileView::ItemActivated);
+  QObject::connect(ui_->tree, &FileViewTree::doubleClicked, this, &FileView::ItemDoubleClick);
+
+  // Setup tree root management buttons
+  ui_->add_tree_root->setIcon(IconLoader::Load(u"folder-new"_s));
+  ui_->remove_tree_root->setIcon(IconLoader::Load(u"list-remove"_s));
+  QObject::connect(ui_->add_tree_root, &QToolButton::clicked, this, &FileView::AddRootButtonClicked);
+  QObject::connect(ui_->remove_tree_root, &QToolButton::clicked, this, &FileView::RemoveRootButtonClicked);
+
   QString filter = QLatin1String(kFileFilter);
   filter_list_ << filter.split(u' ');
 
@@ -109,6 +135,19 @@ void FileView::ReloadSettings() {
   ui_->forward->setIconSize(QSize(iconsize, iconsize));
   ui_->home->setIconSize(QSize(iconsize, iconsize));
   ui_->up->setIconSize(QSize(iconsize, iconsize));
+  ui_->toggle_view->setIconSize(QSize(iconsize, iconsize));
+  ui_->add_tree_root->setIconSize(QSize(iconsize, iconsize));
+  ui_->remove_tree_root->setIconSize(QSize(iconsize, iconsize));
+
+  // Load tree root paths setting
+  Settings file_settings;
+  file_settings.beginGroup(u"FileView"_s);
+  tree_root_paths_ = file_settings.value(u"tree_root_paths"_s, QStandardPaths::standardLocations(QStandardPaths::StandardLocation::MusicLocation)).toStringList();
+  tree_view_active_ = file_settings.value(u"tree_view_active"_s, false).toBool();
+  file_settings.endGroup();
+
+  // Set initial view mode
+  UpdateViewModeUI();
 
 }
 
@@ -180,24 +219,46 @@ void FileView::ChangeFilePathWithoutUndo(const QString &new_path) {
 }
 
 void FileView::ItemActivated(const QModelIndex &idx) {
-  if (model_->isDir(idx))
+  // Only handle activation for list view (not tree view)
+  if (!tree_view_active_ && model_->isDir(idx)) {
     ChangeFilePath(model_->filePath(idx));
+  }
 }
 
 void FileView::ItemDoubleClick(const QModelIndex &idx) {
 
-  if (model_->isDir(idx)) {
-    return;
+  QString file_path;
+  bool is_file = false;
+
+  // Handle tree view with virtual roots
+  if (tree_view_active_ && tree_model_) {
+    QVariant type_var = tree_model_->data(idx, FileViewTreeModel::Role_Type);
+    if (type_var.isValid()) {
+      FileViewTreeItem::Type item_type = type_var.value<FileViewTreeItem::Type>();
+      // Only handle files, ignore directories and virtual roots
+      if (item_type == FileViewTreeItem::Type::File) {
+        file_path = tree_model_->data(idx, FileViewTreeModel::Role_FilePath).toString();
+        is_file = true;
+      }
+    }
+  }
+  // Handle list view with filesystem model
+  else if (!tree_view_active_ && model_) {
+    if (!model_->isDir(idx)) {
+      file_path = model_->filePath(idx);
+      is_file = true;
+    }
   }
 
-  QString file_path = model_->filePath(idx);
+  // Add file to playlist if it's a valid file
+  if (is_file && !file_path.isEmpty()) {
+    MimeData *mimedata = new MimeData;
+    mimedata->from_doubleclick_ = true;
+    mimedata->setUrls(QList<QUrl>() << QUrl::fromLocalFile(file_path));
+    mimedata->name_for_new_playlist_ = file_path;
 
-  MimeData *mimedata = new MimeData;
-  mimedata->from_doubleclick_ = true;
-  mimedata->setUrls(QList<QUrl>() << QUrl::fromLocalFile(file_path));
-  mimedata->name_for_new_playlist_ = file_path;
-
-  Q_EMIT AddToPlaylist(mimedata);
+    Q_EMIT AddToPlaylist(mimedata);
+  }
 
 }
 
@@ -272,12 +333,156 @@ void FileView::showEvent(QShowEvent *e) {
   model_->setNameFilterDisables(false);
 
   ui_->list->setModel(model_);
+
+  // Create tree model
+  tree_model_ = new FileViewTreeModel(this);
+  tree_model_->SetNameFilters(filter_list_);
+
+  SetupTreeView();
+
   ChangeFilePathWithoutUndo(QDir::homePath());
 
   if (!lazy_set_path_.isEmpty()) ChangeFilePathWithoutUndo(lazy_set_path_);
 
 }
 
+void FileView::SetupTreeView() {
+
+  // Use the new tree model with virtual roots
+  ui_->tree->setModel(tree_model_);
+
+  // Set the root paths in the model
+  tree_model_->SetRootPaths(tree_root_paths_);
+
+  // No need to set root index - the model handles virtual roots
+
+}
+
+void FileView::ToggleViewMode() {
+
+  tree_view_active_ = !tree_view_active_;
+  UpdateViewModeUI();
+
+  // Save the preference
+  Settings s;
+  s.beginGroup(u"FileView"_s);
+  s.setValue(u"tree_view_active"_s, tree_view_active_);
+  s.endGroup();
+
+}
+
+void FileView::UpdateViewModeUI() {
+
+  if (tree_view_active_) {
+    ui_->view_stack->setCurrentWidget(ui_->tree_page);
+    // Hide navigation controls in tree view mode
+    ui_->back->setVisible(false);
+    ui_->forward->setVisible(false);
+    ui_->up->setVisible(false);
+    ui_->home->setVisible(false);
+    ui_->path->setVisible(false);
+    // Show tree root management buttons
+    ui_->add_tree_root->setVisible(true);
+    ui_->remove_tree_root->setVisible(true);
+    // Insert spacer in tree view if not already present
+    if (!view_mode_spacer_) {
+      view_mode_spacer_ = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum);
+      ui_->horizontalLayout->insertSpacerItem(ui_->horizontalLayout->indexOf(ui_->toggle_view), view_mode_spacer_);
+    }
+  }
+  else {
+    ui_->view_stack->setCurrentWidget(ui_->list_page);
+    // Show navigation controls in list view mode
+    ui_->back->setVisible(true);
+    ui_->forward->setVisible(true);
+    ui_->up->setVisible(true);
+    ui_->home->setVisible(true);
+    ui_->path->setVisible(true);
+    // Hide tree root management buttons in list view
+    ui_->add_tree_root->setVisible(false);
+    ui_->remove_tree_root->setVisible(false);
+    // Remove spacer in list view
+    if (view_mode_spacer_) {
+      ui_->horizontalLayout->removeItem(view_mode_spacer_);
+      delete view_mode_spacer_;
+      view_mode_spacer_ = nullptr;
+    }
+  }
+
+}
+
+void FileView::AddTreeRootPath(const QString &path) {
+
+  if (!tree_root_paths_.contains(path)) {
+    tree_root_paths_.append(path);
+    SaveTreeRootPaths();
+
+    // Refresh the tree view to show the new root
+    if (tree_model_) {
+      SetupTreeView();
+    }
+  }
+
+}
+
+void FileView::RemoveTreeRootPath(const QString &path) {
+
+  tree_root_paths_.removeAll(path);
+  SaveTreeRootPaths();
+
+  // Refresh the tree view
+  if (tree_model_) {
+    SetupTreeView();
+  }
+
+}
+
+void FileView::SaveTreeRootPaths() {
+
+  Settings s;
+  s.beginGroup(u"FileView"_s);
+  s.setValue(u"tree_root_paths"_s, tree_root_paths_);
+  s.endGroup();
+
+}
+
+void FileView::AddRootButtonClicked() {
+
+  const QString dir = QFileDialog::getExistingDirectory(this, tr("Select folder to add as tree root"), tree_root_paths_.isEmpty() ? QDir::homePath() : tree_root_paths_.first(), QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
+  if (!dir.isEmpty()) {
+    AddTreeRootPath(dir);
+  }
+
+}
+
+void FileView::RemoveRootButtonClicked() {
+
+  // Get currently selected item in tree
+  QModelIndex current = ui_->tree->currentIndex();
+  if (!current.isValid()) return;
+
+  QString path;
+
+  // Get the file path from the appropriate model
+  if (tree_model_) {
+    path = tree_model_->data(current, FileViewTreeModel::Role_FilePath).toString();
+  }
+
+  if (path.isEmpty()) return;
+
+  const QString clean_path = QDir::cleanPath(path);
+
+  // Check if this path or any parent is a configured root
+  for (const QString &root : std::as_const(tree_root_paths_)) {
+    const QString clean_root = QDir::cleanPath(root);
+    if (clean_path == clean_root || clean_path.startsWith(clean_root + QDir::separator())) {
+      RemoveTreeRootPath(root);
+      return;
+    }
+  }
+
+}
+
 void FileView::keyPressEvent(QKeyEvent *e) {
 
   switch (e->key()) {

src/fileview/fileview.h

@@ -40,10 +40,12 @@ class QFileIconProvider;
 class QUndoStack;
 class QKeyEvent;
 class QShowEvent;
+class QSpacerItem;
 
 class MusicStorage;
 class TaskManager;
 class Ui_FileView;
+class FileViewTreeModel;
 
 class FileView : public QWidget {
   Q_OBJECT
@@ -76,12 +78,22 @@ class FileView : public QWidget {
   void ChangeFilePath(const QString &new_path);
   void ItemActivated(const QModelIndex &idx);
   void ItemDoubleClick(const QModelIndex &idx);
+  void ToggleViewMode();
 
   void Delete(const QStringList &filenames);
   void DeleteFinished(const SongList &songs_with_errors);
 
+ public Q_SLOTS:
+  void AddTreeRootPath(const QString &path);
+  void RemoveTreeRootPath(const QString &path);
+
  private:
   void ChangeFilePathWithoutUndo(const QString &new_path);
+  void SetupTreeView();
+  void SaveTreeRootPaths();
+  void AddRootButtonClicked();
+  void RemoveRootButtonClicked();
+  void UpdateViewModeUI();
 
  private:
   class UndoCommand : public QUndoCommand {
@@ -110,16 +122,21 @@ class FileView : public QWidget {
   Ui_FileView *ui_;
 
   QFileSystemModel *model_;
+  FileViewTreeModel *tree_model_;
   QUndoStack *undo_stack_;
 
   SharedPtr<TaskManager> task_manager_;
   SharedPtr<MusicStorage> storage_;
 
   QString lazy_set_path_;
+  QStringList tree_root_paths_;
 
   QStringList filter_list_;
 
   ScopedPtr<QFileIconProvider> file_icon_provider_;
+
+  bool tree_view_active_;
+  QSpacerItem *view_mode_spacer_;
 };
 
 #endif  // FILEVIEW_H

src/fileview/fileview.ui

@@ -95,28 +95,143 @@
      <item>
       <widget class="QLineEdit" name="path"/>
      </item>
+     <item>
+      <widget class="QToolButton" name="add_tree_root">
+       <property name="toolTip">
+        <string>Add root directory</string>
+       </property>
+       <property name="iconSize">
+        <size>
+         <width>22</width>
+         <height>22</height>
+        </size>
+       </property>
+       <property name="autoRaise">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="remove_tree_root">
+       <property name="toolTip">
+        <string>Remove selected root directory</string>
+       </property>
+       <property name="iconSize">
+        <size>
+         <width>22</width>
+         <height>22</height>
+        </size>
+       </property>
+       <property name="autoRaise">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="toggle_view">
+       <property name="iconSize">
+        <size>
+         <width>22</width>
+         <height>22</height>
+        </size>
+       </property>
+       <property name="autoRaise">
+        <bool>true</bool>
+       </property>
+       <property name="toolTip">
+        <string>Toggle between list and tree view</string>
+       </property>
+      </widget>
+     </item>
     </layout>
    </item>
    <item>
-    <widget class="FileViewList" name="list">
-     <property name="dragEnabled">
-      <bool>true</bool>
-     </property>
-     <property name="dragDropMode">
-      <enum>QAbstractItemView::DragOnly</enum>
-     </property>
-     <property name="selectionMode">
-      <enum>QAbstractItemView::ExtendedSelection</enum>
-     </property>
-     <property name="selectionBehavior">
-      <enum>QAbstractItemView::SelectRows</enum>
-     </property>
-     <property name="iconSize">
-      <size>
-       <width>16</width>
-       <height>16</height>
-      </size>
+    <widget class="QStackedWidget" name="view_stack">
+     <property name="currentIndex">
+      <number>0</number>
      </property>
+     <widget class="QWidget" name="list_page">
+      <layout class="QVBoxLayout" name="list_layout">
+       <property name="spacing">
+        <number>0</number>
+       </property>
+       <property name="leftMargin">
+        <number>0</number>
+       </property>
+       <property name="topMargin">
+        <number>0</number>
+       </property>
+       <property name="rightMargin">
+        <number>0</number>
+       </property>
+       <property name="bottomMargin">
+        <number>0</number>
+       </property>
+       <item>
+        <widget class="FileViewList" name="list">
+         <property name="dragEnabled">
+          <bool>true</bool>
+         </property>
+         <property name="dragDropMode">
+          <enum>QAbstractItemView::DragOnly</enum>
+         </property>
+         <property name="selectionMode">
+          <enum>QAbstractItemView::ExtendedSelection</enum>
+         </property>
+         <property name="selectionBehavior">
+          <enum>QAbstractItemView::SelectRows</enum>
+         </property>
+         <property name="iconSize">
+          <size>
+           <width>16</width>
+           <height>16</height>
+          </size>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tree_page">
+      <layout class="QVBoxLayout" name="tree_layout">
+       <property name="spacing">
+        <number>0</number>
+       </property>
+       <property name="leftMargin">
+        <number>0</number>
+       </property>
+       <property name="topMargin">
+        <number>0</number>
+       </property>
+       <property name="rightMargin">
+        <number>0</number>
+       </property>
+       <property name="bottomMargin">
+        <number>0</number>
+       </property>
+       <item>
+        <widget class="FileViewTree" name="tree">
+         <property name="dragEnabled">
+          <bool>true</bool>
+         </property>
+         <property name="dragDropMode">
+          <enum>QAbstractItemView::DragOnly</enum>
+         </property>
+         <property name="selectionMode">
+          <enum>QAbstractItemView::ExtendedSelection</enum>
+         </property>
+         <property name="selectionBehavior">
+          <enum>QAbstractItemView::SelectRows</enum>
+         </property>
+         <property name="iconSize">
+          <size>
+           <width>16</width>
+           <height>16</height>
+          </size>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
     </widget>
    </item>
   </layout>
@@ -127,6 +242,11 @@
    <extends>QListView</extends>
    <header>fileview/fileviewlist.h</header>
   </customwidget>
+  <customwidget>
+   <class>FileViewTree</class>
+   <extends>QTreeView</extends>
+   <header>fileview/fileviewtree.h</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>

src/fileview/fileviewlist.cpp

@@ -99,7 +99,7 @@ MimeData *FileViewList::MimeDataFromSelection() const {
 
   const QStringList filenames = FilenamesFromSelection();
 
-  // if just one folder selected - use its path as the new playlist's name
+  // If just one folder selected - use its path as the new playlist's name
   if (filenames.size() == 1 && QFileInfo(filenames.first()).isDir()) {
     if (filenames.first().length() > 20) {
       mimedata->name_for_new_playlist_ = QDir(filenames.first()).dirName();
@@ -108,7 +108,7 @@ MimeData *FileViewList::MimeDataFromSelection() const {
       mimedata->name_for_new_playlist_ = filenames.first();
     }
   }
-  // otherwise, use the current root path
+  // Otherwise, use the current root path
   else {
     QString path = qobject_cast<QFileSystemModel*>(model())->rootPath();
     if (path.length() > 20) {
@@ -196,11 +196,11 @@ void FileViewList::mousePressEvent(QMouseEvent *e) {
     case Qt::XButton2:
       Q_EMIT Forward();
       break;
-    // enqueue to playlist with middleClick
+    // Enqueue to playlist with middleClick
     case Qt::MiddleButton:{
       QListView::mousePressEvent(e);
 
-      // we need to update the menu selection
+      // We need to update the menu selection
       menu_selection_ = selectionModel()->selection();
 
       MimeData *mimedata = new MimeData;

src/fileview/fileviewtree.cpp

@@ -0,0 +1,205 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <algorithm>
+#include <utility>
+
+#include <QWidget>
+#include <QAbstractItemModel>
+#include <QFileInfo>
+#include <QDir>
+#include <QMenu>
+#include <QUrl>
+#include <QCollator>
+#include <QtEvents>
+
+#include "core/iconloader.h"
+#include "core/mimedata.h"
+#include "utilities/filemanagerutils.h"
+#include "fileviewtree.h"
+#include "fileviewtreemodel.h"
+
+using namespace Qt::Literals::StringLiterals;
+
+FileViewTree::FileViewTree(QWidget *parent)
+    : QTreeView(parent),
+      menu_(new QMenu(this)) {
+
+  menu_->addAction(IconLoader::Load(u"media-playback-start"_s), tr("Append to current playlist"), this, &FileViewTree::AddToPlaylistSlot);
+  menu_->addAction(IconLoader::Load(u"media-playback-start"_s), tr("Replace current playlist"), this, &FileViewTree::LoadSlot);
+  menu_->addAction(IconLoader::Load(u"document-new"_s), tr("Open in new playlist"), this, &FileViewTree::OpenInNewPlaylistSlot);
+  menu_->addSeparator();
+  menu_->addAction(IconLoader::Load(u"edit-copy"_s), tr("Copy to collection..."), this, &FileViewTree::CopyToCollectionSlot);
+  menu_->addAction(IconLoader::Load(u"go-jump"_s), tr("Move to collection..."), this, &FileViewTree::MoveToCollectionSlot);
+  menu_->addAction(IconLoader::Load(u"device"_s), tr("Copy to device..."), this, &FileViewTree::CopyToDeviceSlot);
+  menu_->addAction(IconLoader::Load(u"edit-delete"_s), tr("Delete from disk..."), this, &FileViewTree::DeleteSlot);
+
+  menu_->addSeparator();
+  menu_->addAction(IconLoader::Load(u"edit-rename"_s), tr("Edit track information..."), this, &FileViewTree::EditTagsSlot);
+  menu_->addAction(IconLoader::Load(u"document-open-folder"_s), tr("Show in file browser..."), this, &FileViewTree::ShowInBrowser);
+
+  setAttribute(Qt::WA_MacShowFocusRect, false);
+  setHeaderHidden(true);
+  setUniformRowHeights(true);
+
+}
+
+void FileViewTree::contextMenuEvent(QContextMenuEvent *e) {
+
+  menu_selection_ = selectionModel()->selection();
+
+  menu_->popup(e->globalPos());
+  e->accept();
+
+}
+
+QStringList FileViewTree::FilenamesFromSelection() const {
+
+  QStringList filenames;
+  const QModelIndexList indexes = menu_selection_.indexes();
+
+  FileViewTreeModel *tree_model = qobject_cast<FileViewTreeModel*>(model());
+  if (tree_model) {
+    for (const QModelIndex &index : indexes) {
+      if (index.column() == 0) {
+        QString path = tree_model->data(index, FileViewTreeModel::Role_FilePath).toString();
+        if (!path.isEmpty()) {
+          filenames << path;
+        }
+      }
+    }
+  }
+
+  QCollator collator;
+  collator.setNumericMode(true);
+  std::sort(filenames.begin(), filenames.end(), collator);
+
+  return filenames;
+
+}
+
+QList<QUrl> FileViewTree::UrlListFromSelection() const {
+
+  QList<QUrl> urls;
+  const QStringList filenames = FilenamesFromSelection();
+  urls.reserve(filenames.count());
+  for (const QString &filename : std::as_const(filenames)) {
+    urls << QUrl::fromLocalFile(filename);
+  }
+
+  return urls;
+
+}
+
+MimeData *FileViewTree::MimeDataFromSelection() const {
+
+  MimeData *mimedata = new MimeData;
+  mimedata->setUrls(UrlListFromSelection());
+
+  const QStringList filenames = FilenamesFromSelection();
+
+  // if just one folder selected - use its path as the new playlist's name
+  if (filenames.size() == 1 && QFileInfo(filenames.first()).isDir()) {
+    if (filenames.first().length() > 20) {
+      mimedata->name_for_new_playlist_ = QDir(filenames.first()).dirName();
+    }
+    else {
+      mimedata->name_for_new_playlist_ = filenames.first();
+    }
+  }
+  // otherwise, use "Files" as default
+  else {
+    mimedata->name_for_new_playlist_ = tr("Files");
+  }
+
+  return mimedata;
+
+}
+
+void FileViewTree::LoadSlot() {
+
+  MimeData *mimedata = MimeDataFromSelection();
+  mimedata->clear_first_ = true;
+  Q_EMIT AddToPlaylist(mimedata);
+
+}
+
+void FileViewTree::AddToPlaylistSlot() {
+  Q_EMIT AddToPlaylist(MimeDataFromSelection());
+}
+
+void FileViewTree::OpenInNewPlaylistSlot() {
+
+  MimeData *mimedata = MimeDataFromSelection();
+  mimedata->open_in_new_playlist_ = true;
+  Q_EMIT AddToPlaylist(mimedata);
+
+}
+
+void FileViewTree::CopyToCollectionSlot() {
+  Q_EMIT CopyToCollection(UrlListFromSelection());
+}
+
+void FileViewTree::MoveToCollectionSlot() {
+  Q_EMIT MoveToCollection(UrlListFromSelection());
+}
+
+void FileViewTree::CopyToDeviceSlot() {
+  Q_EMIT CopyToDevice(UrlListFromSelection());
+}
+
+void FileViewTree::DeleteSlot() {
+  Q_EMIT Delete(FilenamesFromSelection());
+}
+
+void FileViewTree::EditTagsSlot() {
+  Q_EMIT EditTags(UrlListFromSelection());
+}
+
+void FileViewTree::mousePressEvent(QMouseEvent *e) {
+
+  switch (e->button()) {
+    // Enqueue to playlist with middleClick
+    case Qt::MiddleButton:{
+      QTreeView::mousePressEvent(e);
+
+      // We need to update the menu selection
+      QItemSelectionModel *selection_model = selectionModel();
+      if (!selection_model) {
+        e->ignore();
+        return;
+      }
+      menu_selection_ = selection_model->selection();
+
+      MimeData *mimedata = new MimeData;
+      mimedata->setUrls(UrlListFromSelection());
+      mimedata->enqueue_now_ = true;
+      Q_EMIT AddToPlaylist(mimedata);
+      break;
+    }
+    default:
+      QTreeView::mousePressEvent(e);
+      break;
+  }
+
+}
+
+void FileViewTree::ShowInBrowser() {
+  Utilities::OpenInFileBrowser(UrlListFromSelection());
+}

src/fileview/fileviewtree.h

@@ -0,0 +1,78 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef FILEVIEWTREE_H
+#define FILEVIEWTREE_H
+
+#include <QObject>
+#include <QTreeView>
+#include <QList>
+#include <QUrl>
+#include <QString>
+#include <QStringList>
+
+class QWidget;
+class QMimeData;
+class QMenu;
+class QMouseEvent;
+class QContextMenuEvent;
+
+class MimeData;
+
+class FileViewTree : public QTreeView {
+  Q_OBJECT
+
+ public:
+  explicit FileViewTree(QWidget *parent = nullptr);
+
+  void mousePressEvent(QMouseEvent *e) override;
+
+ Q_SIGNALS:
+  void AddToPlaylist(QMimeData *data);
+  void CopyToCollection(const QList<QUrl> &urls);
+  void MoveToCollection(const QList<QUrl> &urls);
+  void CopyToDevice(const QList<QUrl> &urls);
+  void Delete(const QStringList &filenames);
+  void EditTags(const QList<QUrl> &urls);
+
+ protected:
+  void contextMenuEvent(QContextMenuEvent *e) override;
+
+ private:
+  QStringList FilenamesFromSelection() const;
+  QList<QUrl> UrlListFromSelection() const;
+  MimeData *MimeDataFromSelection() const;
+
+ private Q_SLOTS:
+  void LoadSlot();
+  void AddToPlaylistSlot();
+  void OpenInNewPlaylistSlot();
+  void CopyToCollectionSlot();
+  void MoveToCollectionSlot();
+  void CopyToDeviceSlot();
+  void DeleteSlot();
+  void EditTagsSlot();
+  void ShowInBrowser();
+
+ private:
+  QMenu *menu_;
+  QItemSelection menu_selection_;
+};
+
+#endif  // FILEVIEWTREE_H

src/fileview/fileviewtreeitem.h

@@ -0,0 +1,52 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef FILEVIEWTREEITEM_H
+#define FILEVIEWTREEITEM_H
+
+#include "config.h"
+
+#include <QFileInfo>
+
+#include "core/simpletreeitem.h"
+
+class FileViewTreeItem : public SimpleTreeItem<FileViewTreeItem> {
+ public:
+  enum class Type {
+    Root,          // Hidden root
+    VirtualRoot,   // User-configured root paths
+    Directory,     // File system directory
+    File           // File system file
+  };
+
+  explicit FileViewTreeItem(SimpleTreeModel<FileViewTreeItem> *_model) : SimpleTreeItem<FileViewTreeItem>(_model), type(Type::Root), lazy_loaded(false) {}
+  explicit FileViewTreeItem(const Type _type, FileViewTreeItem *_parent = nullptr) : SimpleTreeItem<FileViewTreeItem>(_parent), type(_type), lazy_loaded(false) {}
+
+  Type type;
+  QString file_path;        // Absolute file system path
+  QFileInfo file_info;      // Cached file info
+  bool lazy_loaded;         // Whether children have been loaded
+
+ private:
+  Q_DISABLE_COPY(FileViewTreeItem)
+};
+
+Q_DECLARE_METATYPE(FileViewTreeItem::Type)
+
+#endif  // FILEVIEWTREEITEM_H

src/fileview/fileviewtreemodel.cpp

@@ -0,0 +1,246 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QVariant>
+#include <QString>
+#include <QStringList>
+#include <QList>
+#include <QMap>
+#include <QDir>
+#include <QFileInfo>
+#include <QFileIconProvider>
+#include <QMimeData>
+#include <QUrl>
+#include <QIcon>
+
+#include "core/simpletreemodel.h"
+#include "core/logging.h"
+#include "fileviewtreemodel.h"
+#include "fileviewtreeitem.h"
+
+using namespace Qt::Literals::StringLiterals;
+
+FileViewTreeModel::FileViewTreeModel(QObject *parent)
+    : SimpleTreeModel<FileViewTreeItem>(new FileViewTreeItem(this), parent),
+      icon_provider_(new QFileIconProvider()) {
+}
+
+FileViewTreeModel::~FileViewTreeModel() {
+  delete root_;
+  delete icon_provider_;
+}
+
+Qt::ItemFlags FileViewTreeModel::flags(const QModelIndex &idx) const {
+
+  const FileViewTreeItem *item = IndexToItem(idx);
+  if (!item) return Qt::NoItemFlags;
+
+  switch (item->type) {
+    case FileViewTreeItem::Type::VirtualRoot:
+    case FileViewTreeItem::Type::Directory:
+    case FileViewTreeItem::Type::File:
+      return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
+    case FileViewTreeItem::Type::Root:
+    default:
+      return Qt::ItemIsEnabled;
+  }
+
+}
+
+QVariant FileViewTreeModel::data(const QModelIndex &idx, const int role) const {
+
+  if (!idx.isValid()) return QVariant();
+
+  const FileViewTreeItem *item = IndexToItem(idx);
+  if (!item) return QVariant();
+
+  switch (role) {
+    case Qt::DisplayRole:
+      if (item->type == FileViewTreeItem::Type::VirtualRoot) {
+        return item->display_text.isEmpty() ? item->file_path : item->display_text;
+      }
+      return item->file_info.fileName();
+
+    case Qt::DecorationRole:
+      return GetIcon(item);
+
+    case Role_Type:
+      return QVariant::fromValue(item->type);
+
+    case Role_FilePath:
+      return item->file_path;
+
+    case Role_FileName:
+      return item->file_info.fileName();
+
+    default:
+      return QVariant();
+  }
+
+}
+
+bool FileViewTreeModel::hasChildren(const QModelIndex &parent) const {
+
+  const FileViewTreeItem *item = IndexToItem(parent);
+  if (!item) return false;
+
+  // Root and VirtualRoot always have children (or can have them)
+  if (item->type == FileViewTreeItem::Type::Root) return true;
+  if (item->type == FileViewTreeItem::Type::VirtualRoot) return true;
+
+  // Directories can have children
+  if (item->type == FileViewTreeItem::Type::Directory) {
+    return true;
+  }
+
+  // Files don't have children
+  return false;
+
+}
+
+bool FileViewTreeModel::canFetchMore(const QModelIndex &parent) const {
+
+  const FileViewTreeItem *item = IndexToItem(parent);
+  if (!item) return false;
+
+  // Can fetch more if not yet lazy loaded
+  return !item->lazy_loaded && (item->type == FileViewTreeItem::Type::VirtualRoot || item->type == FileViewTreeItem::Type::Directory);
+
+}
+
+void FileViewTreeModel::fetchMore(const QModelIndex &parent) {
+
+  FileViewTreeItem *item = IndexToItem(parent);
+  if (!item || item->lazy_loaded) return;
+
+  LazyLoad(item);
+
+}
+
+void FileViewTreeModel::LazyLoad(FileViewTreeItem *item) {
+
+  if (item->lazy_loaded) return;
+
+  QDir dir(item->file_path);
+  if (!dir.exists()) {
+    item->lazy_loaded = true;
+    return;
+  }
+
+  // Apply name filters
+  const QDir::Filters filters = QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot;
+  if (!name_filters_.isEmpty()) {
+    dir.setNameFilters(name_filters_);
+  }
+
+  const QFileInfoList entries = dir.entryInfoList(filters, QDir::Name | QDir::DirsFirst);
+  if (!entries.isEmpty()) {
+    BeginInsert(item, 0, static_cast<int>(entries.count()) - 1);
+
+    for (const QFileInfo &entry : entries) {
+      FileViewTreeItem *child = new FileViewTreeItem(
+        entry.isDir() ? FileViewTreeItem::Type::Directory : FileViewTreeItem::Type::File,
+        item
+      );
+      child->file_path = entry.absoluteFilePath();
+      child->file_info = entry;
+      child->lazy_loaded = false;
+      child->display_text = entry.fileName();
+    }
+
+    EndInsert();
+  }
+
+  item->lazy_loaded = true;
+
+}
+
+QIcon FileViewTreeModel::GetIcon(const FileViewTreeItem *item) const {
+
+  if (!item) return QIcon();
+
+  switch (item->type) {
+    case FileViewTreeItem::Type::VirtualRoot:
+    case FileViewTreeItem::Type::Directory:
+      return icon_provider_->icon(QFileIconProvider::Folder);
+    case FileViewTreeItem::Type::File:
+      return icon_provider_->icon(item->file_info);
+    default:
+      return QIcon();
+  }
+
+}
+
+QStringList FileViewTreeModel::mimeTypes() const {
+  return QStringList() << u"text/uri-list"_s;
+}
+
+QMimeData *FileViewTreeModel::mimeData(const QModelIndexList &indexes) const {
+
+  if (indexes.isEmpty()) return nullptr;
+
+  QList<QUrl> urls;
+  for (const QModelIndex &idx : indexes) {
+    const FileViewTreeItem *item = IndexToItem(idx);
+    if (item && (item->type == FileViewTreeItem::Type::File || item->type == FileViewTreeItem::Type::Directory || item->type == FileViewTreeItem::Type::VirtualRoot)) {
+      urls << QUrl::fromLocalFile(item->file_path);
+    }
+  }
+
+  if (urls.isEmpty()) return nullptr;
+
+  QMimeData *data = new QMimeData();
+  data->setUrls(urls);
+  return data;
+
+}
+
+void FileViewTreeModel::SetRootPaths(const QStringList &paths) {
+
+  Reset();
+
+  for (const QString &path : paths) {
+    QFileInfo info(path);
+    if (!info.exists() || !info.isDir()) continue;
+
+    FileViewTreeItem *virtual_root = new FileViewTreeItem(FileViewTreeItem::Type::VirtualRoot, root_);
+    virtual_root->file_path = info.absoluteFilePath();
+    virtual_root->file_info = info;
+    virtual_root->display_text = info.absoluteFilePath();
+    virtual_root->lazy_loaded = false;
+  }
+
+}
+
+void FileViewTreeModel::SetNameFilters(const QStringList &filters) {
+  name_filters_ = filters;
+}
+
+void FileViewTreeModel::Reset() {
+
+  beginResetModel();
+
+  // Clear children without notifications since we're in a reset
+  qDeleteAll(root_->children);
+  root_->children.clear();
+
+  endResetModel();
+
+}

src/fileview/fileviewtreemodel.h

@@ -0,0 +1,72 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef FILEVIEWTREEMODEL_H
+#define FILEVIEWTREEMODEL_H
+
+#include "config.h"
+
+#include <QObject>
+#include <QVariant>
+#include <QStringList>
+#include <QIcon>
+
+#include "core/simpletreemodel.h"
+#include "fileviewtreeitem.h"
+
+class QFileIconProvider;
+class QMimeData;
+
+class FileViewTreeModel : public SimpleTreeModel<FileViewTreeItem> {
+  Q_OBJECT
+
+ public:
+  explicit FileViewTreeModel(QObject *parent = nullptr);
+  ~FileViewTreeModel() override;
+
+  enum Role {
+    Role_Type = Qt::UserRole + 1,
+    Role_FilePath,
+    Role_FileName,
+    RoleCount
+  };
+
+  // QAbstractItemModel
+  Qt::ItemFlags flags(const QModelIndex &idx) const override;
+  QVariant data(const QModelIndex &idx, const int role) const override;
+  bool hasChildren(const QModelIndex &parent) const override;
+  bool canFetchMore(const QModelIndex &parent) const override;
+  void fetchMore(const QModelIndex &parent) override;
+  QStringList mimeTypes() const override;
+  QMimeData *mimeData(const QModelIndexList &indexes) const override;
+
+  void SetRootPaths(const QStringList &paths);
+  void SetNameFilters(const QStringList &filters);
+
+ private:
+  void Reset();
+  void LazyLoad(FileViewTreeItem *item);
+  QIcon GetIcon(const FileViewTreeItem *item) const;
+
+ private:
+  QFileIconProvider *icon_provider_;
+  QStringList name_filters_;
+};
+
+#endif  // FILEVIEWTREEMODEL_H

src/globalshortcuts/globalshortcutsmanager.cpp

@@ -32,6 +32,7 @@
 #include <QKeySequence>
 
 #include "core/logging.h"
+#include "core/settings.h"
 
 #include "globalshortcutsmanager.h"
 #include "globalshortcutsbackend.h"
@@ -58,29 +59,32 @@ using namespace Qt::Literals::StringLiterals;
 
 GlobalShortcutsManager::GlobalShortcutsManager(QWidget *parent) : QWidget(parent) {
 
-  settings_.beginGroup(GlobalShortcutsSettings::kSettingsGroup);
+  Settings s;
+  s.beginGroup(GlobalShortcutsSettings::kSettingsGroup);
 
   // Create actions
-  AddShortcut(u"play"_s, tr("Play"), std::bind(&GlobalShortcutsManager::Play, this));
-  AddShortcut(u"pause"_s, tr("Pause"), std::bind(&GlobalShortcutsManager::Pause, this));
-  AddShortcut(u"play_pause"_s, tr("Play/Pause"), std::bind(&GlobalShortcutsManager::PlayPause, this), QKeySequence(Qt::Key_MediaPlay));
-  AddShortcut(u"stop"_s, tr("Stop"), std::bind(&GlobalShortcutsManager::Stop, this), QKeySequence(Qt::Key_MediaStop));
-  AddShortcut(u"stop_after"_s, tr("Stop playing after current track"), std::bind(&GlobalShortcutsManager::StopAfter, this));
-  AddShortcut(u"next_track"_s, tr("Next track"), std::bind(&GlobalShortcutsManager::Next, this), QKeySequence(Qt::Key_MediaNext));
-  AddShortcut(u"prev_track"_s, tr("Previous track"), std::bind(&GlobalShortcutsManager::Previous, this), QKeySequence(Qt::Key_MediaPrevious));
-  AddShortcut(u"restart_or_prev_track"_s, tr("Restart or previous track"), std::bind(&GlobalShortcutsManager::RestartOrPrevious, this));
-  AddShortcut(u"inc_volume"_s, tr("Increase volume"), std::bind(&GlobalShortcutsManager::IncVolume, this));
-  AddShortcut(u"dec_volume"_s, tr("Decrease volume"), std::bind(&GlobalShortcutsManager::DecVolume, this));
-  AddShortcut(u"mute"_s, tr("Mute"), std::bind(&GlobalShortcutsManager::Mute, this));
-  AddShortcut(u"seek_forward"_s, tr("Seek forward"), std::bind(&GlobalShortcutsManager::SeekForward, this));
-  AddShortcut(u"seek_backward"_s, tr("Seek backward"), std::bind(&GlobalShortcutsManager::SeekBackward, this));
-  AddShortcut(u"show_hide"_s, tr("Show/Hide"), std::bind(&GlobalShortcutsManager::ShowHide, this));
-  AddShortcut(u"show_osd"_s, tr("Show OSD"), std::bind(&GlobalShortcutsManager::ShowOSD, this));
-  AddShortcut(u"toggle_pretty_osd"_s, tr("Toggle Pretty OSD"), std::bind(&GlobalShortcutsManager::TogglePrettyOSD, this));  // Toggling possible only for pretty OSD
-  AddShortcut(u"shuffle_mode"_s, tr("Change shuffle mode"), std::bind(&GlobalShortcutsManager::CycleShuffleMode, this));
-  AddShortcut(u"repeat_mode"_s, tr("Change repeat mode"), std::bind(&GlobalShortcutsManager::CycleRepeatMode, this));
-  AddShortcut(u"toggle_scrobbling"_s, tr("Enable/disable scrobbling"), std::bind(&GlobalShortcutsManager::ToggleScrobbling, this));
-  AddShortcut(u"love"_s, tr("Love"), std::bind(&GlobalShortcutsManager::Love, this));
+  AddShortcut(s, u"play"_s, tr("Play"), std::bind(&GlobalShortcutsManager::Play, this));
+  AddShortcut(s, u"pause"_s, tr("Pause"), std::bind(&GlobalShortcutsManager::Pause, this));
+  AddShortcut(s, u"play_pause"_s, tr("Play/Pause"), std::bind(&GlobalShortcutsManager::PlayPause, this), QKeySequence(Qt::Key_MediaPlay));
+  AddShortcut(s, u"stop"_s, tr("Stop"), std::bind(&GlobalShortcutsManager::Stop, this), QKeySequence(Qt::Key_MediaStop));
+  AddShortcut(s, u"stop_after"_s, tr("Stop playing after current track"), std::bind(&GlobalShortcutsManager::StopAfter, this));
+  AddShortcut(s, u"next_track"_s, tr("Next track"), std::bind(&GlobalShortcutsManager::Next, this), QKeySequence(Qt::Key_MediaNext));
+  AddShortcut(s, u"prev_track"_s, tr("Previous track"), std::bind(&GlobalShortcutsManager::Previous, this), QKeySequence(Qt::Key_MediaPrevious));
+  AddShortcut(s, u"restart_or_prev_track"_s, tr("Restart or previous track"), std::bind(&GlobalShortcutsManager::RestartOrPrevious, this));
+  AddShortcut(s, u"inc_volume"_s, tr("Increase volume"), std::bind(&GlobalShortcutsManager::IncVolume, this));
+  AddShortcut(s, u"dec_volume"_s, tr("Decrease volume"), std::bind(&GlobalShortcutsManager::DecVolume, this));
+  AddShortcut(s, u"mute"_s, tr("Mute"), std::bind(&GlobalShortcutsManager::Mute, this));
+  AddShortcut(s, u"seek_forward"_s, tr("Seek forward"), std::bind(&GlobalShortcutsManager::SeekForward, this));
+  AddShortcut(s, u"seek_backward"_s, tr("Seek backward"), std::bind(&GlobalShortcutsManager::SeekBackward, this));
+  AddShortcut(s, u"show_hide"_s, tr("Show/Hide"), std::bind(&GlobalShortcutsManager::ShowHide, this));
+  AddShortcut(s, u"show_osd"_s, tr("Show OSD"), std::bind(&GlobalShortcutsManager::ShowOSD, this));
+  AddShortcut(s, u"toggle_pretty_osd"_s, tr("Toggle Pretty OSD"), std::bind(&GlobalShortcutsManager::TogglePrettyOSD, this));  // Toggling possible only for pretty OSD
+  AddShortcut(s, u"shuffle_mode"_s, tr("Change shuffle mode"), std::bind(&GlobalShortcutsManager::CycleShuffleMode, this));
+  AddShortcut(s, u"repeat_mode"_s, tr("Change repeat mode"), std::bind(&GlobalShortcutsManager::CycleRepeatMode, this));
+  AddShortcut(s, u"toggle_scrobbling"_s, tr("Enable/disable scrobbling"), std::bind(&GlobalShortcutsManager::ToggleScrobbling, this));
+  AddShortcut(s, u"love"_s, tr("Love"), std::bind(&GlobalShortcutsManager::Love, this));
+
+  s.endGroup();
 
   // Create backends - these do the actual shortcut registration
 
@@ -116,35 +120,39 @@ void GlobalShortcutsManager::ReloadSettings() {
   backends_enabled_ << GlobalShortcutsBackend::Type::Win;
 #endif
 
+  {
+    Settings s;
+    s.beginGroup(GlobalShortcutsSettings::kSettingsGroup);
 #ifdef HAVE_KGLOBALACCEL_GLOBALSHORTCUTS
-  if (settings_.value(GlobalShortcutsSettings::kUseKGlobalAccel, true).toBool()) {
-    backends_enabled_ << GlobalShortcutsBackend::Type::KGlobalAccel;
-  }
+    if (s.value(GlobalShortcutsSettings::kUseKGlobalAccel, true).toBool()) {
+      backends_enabled_ << GlobalShortcutsBackend::Type::KGlobalAccel;
+    }
 #endif
-
 #ifdef HAVE_X11_GLOBALSHORTCUTS
-  if (settings_.value(GlobalShortcutsSettings::kUseX11, false).toBool()) {
-    backends_enabled_ << GlobalShortcutsBackend::Type::X11;
-  }
+    if (s.value(GlobalShortcutsSettings::kUseX11, false).toBool()) {
+      backends_enabled_ << GlobalShortcutsBackend::Type::X11;
+    }
 #endif
+    s.endGroup();
+  }
 
   Unregister();
   Register();
 
 }
 
-void GlobalShortcutsManager::AddShortcut(const QString &id, const QString &name, std::function<void()> signal, const QKeySequence &default_key) {  // clazy:exclude=function-args-by-ref
+void GlobalShortcutsManager::AddShortcut(Settings &s, const QString &id, const QString &name, std::function<void()> signal, const QKeySequence &default_key) {  // clazy:exclude=function-args-by-ref
 
-  Shortcut shortcut = AddShortcut(id, name, default_key);
+  Shortcut shortcut = AddShortcut(s, id, name, default_key);
   QObject::connect(shortcut.action, &QAction::triggered, this, signal);
 
 }
 
-GlobalShortcutsManager::Shortcut GlobalShortcutsManager::AddShortcut(const QString &id, const QString &name, const QKeySequence &default_key) {
+GlobalShortcutsManager::Shortcut GlobalShortcutsManager::AddShortcut(Settings &s, const QString &id, const QString &name, const QKeySequence &default_key) {
 
   Shortcut shortcut;
   shortcut.action = new QAction(name, this);
-  QKeySequence key_sequence = QKeySequence::fromString(settings_.value(id, default_key.toString()).toString());
+  QKeySequence key_sequence = QKeySequence::fromString(s.value(id, default_key.toString()).toString());
   shortcut.action->setShortcut(key_sequence);
   shortcut.id = id;
   shortcut.default_key = default_key;

src/globalshortcuts/globalshortcutsmanager.h

@@ -32,15 +32,14 @@
 #include <QMap>
 #include <QString>
 #include <QKeySequence>
-#include <QSettings>
 
 #include "globalshortcutsbackend.h"
 
-#include "core/settings.h"
-
 class QShortcut;
 class QAction;
 
+class Settings;
+
 class GlobalShortcutsManager : public QWidget {
   Q_OBJECT
 
@@ -99,12 +98,11 @@ class GlobalShortcutsManager : public QWidget {
   void Love();
 
  private:
-  void AddShortcut(const QString &id, const QString &name, std::function<void()> signal, const QKeySequence &default_key = QKeySequence(0));
-  Shortcut AddShortcut(const QString &id, const QString &name, const QKeySequence &default_key);
+  void AddShortcut(Settings &s, const QString &id, const QString &name, std::function<void()> signal, const QKeySequence &default_key = QKeySequence(0));
+  Shortcut AddShortcut(Settings &s, const QString &id, const QString &name, const QKeySequence &default_key);
 
  private:
   QList<GlobalShortcutsBackend*> backends_;
-  Settings settings_;
   QList<GlobalShortcutsBackend::Type> backends_enabled_;
   QMap<QString, Shortcut> shortcuts_;
 };

src/playlist/playlistcontainer.cpp

@@ -106,8 +106,6 @@ PlaylistContainer::PlaylistContainer(QWidget *parent)
   no_matches_font.setBold(true);
   no_matches_label_->setFont(no_matches_font);
 
-  settings_.beginGroup(kSettingsGroup);
-
   // Tab bar
   ui_->tab_bar->setExpanding(false);
   ui_->tab_bar->setMovable(true);
@@ -257,7 +255,11 @@ void PlaylistContainer::ReloadSettings() {
   ui_->redo->setIconSize(QSize(iconsize, iconsize));
   ui_->search_field->setIconSize(iconsize);
 
-  bool playlist_clear = settings_.value("playlist_clear", true).toBool();
+  s.beginGroup(kSettingsGroup);
+  const bool playlist_clear = s.value("playlist_clear", true).toBool();
+  const bool show_toolbar = s.value("show_toolbar", true).toBool();
+  s.endGroup();
+
   if (playlist_clear) {
     ui_->clear->show();
   }
@@ -265,7 +267,6 @@ void PlaylistContainer::ReloadSettings() {
     ui_->clear->hide();
   }
 
-  bool show_toolbar = settings_.value("show_toolbar", true).toBool();
   ui_->toolbar->setVisible(show_toolbar);
 
   if (!show_toolbar) ui_->search_field->clear();
@@ -308,7 +309,12 @@ void PlaylistContainer::PlaylistAdded(const int id, const QString &name, const b
   ui_->tab_bar->InsertTab(id, index, name, favorite);
 
   // Are we start up, should we select this tab?
-  if (starting_up_ && settings_.value("current_playlist", 1).toInt() == id) {
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  const int current_playlist = s.value("current_playlist", 1).toInt();
+  s.endGroup();
+
+  if (starting_up_ && current_playlist == id) {
     starting_up_ = false;
     ui_->tab_bar->set_current_id(id);
   }
@@ -347,12 +353,14 @@ void PlaylistContainer::NewPlaylist() { manager_->New(tr("Playlist")); }
 
 void PlaylistContainer::LoadPlaylist() {
 
-  QString filename = settings_.value("last_load_playlist").toString();
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  QString filename = s.value("last_load_playlist").toString();
   filename = QFileDialog::getOpenFileName(this, tr("Load playlist"), filename, manager_->parser()->filters(PlaylistParser::Type::Load));
 
   if (filename.isNull()) return;
 
-  settings_.setValue("last_load_playlist", filename);
+  s.setValue("last_load_playlist", filename);
 
   manager_->Load(filename);
 
@@ -391,7 +399,10 @@ void PlaylistContainer::Save() {
 
   if (starting_up_) return;
 
-  settings_.setValue("current_playlist", ui_->tab_bar->current_id());
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  s.setValue("current_playlist", ui_->tab_bar->current_id());
+  s.endGroup();
 
 }
 

src/playlist/playlistcontainer.h

@@ -28,7 +28,6 @@
 #include <QWidget>
 #include <QString>
 #include <QIcon>
-#include <QSettings>
 
 class QTimer;
 class QTimeLine;
@@ -45,7 +44,6 @@ class PlaylistView;
 class Ui_PlaylistContainer;
 
 #include "includes/shared_ptr.h"
-#include "core/settings.h"
 
 class PlaylistContainer : public QWidget {
   Q_OBJECT
@@ -118,7 +116,6 @@ class PlaylistContainer : public QWidget {
   QAction *redo_;
   Playlist *playlist_;
 
-  Settings settings_;
   bool starting_up_;
 
   bool tab_bar_visible_;

src/playlist/playlistview.cpp

@@ -57,7 +57,6 @@
 #include <QLinearGradient>
 #include <QScrollBar>
 #include <QtEvents>
-#include <QSettings>
 #include <QDrag>
 
 #include "includes/qt_blurimage.h"

src/playlist/songloaderinserter.cpp

@@ -80,12 +80,13 @@ void SongLoaderInserter::Load(Playlist *destination, const int row, const bool p
       songs_ << loader->songs();
       playlist_name_ = loader->playlist_name();
     }
-    else {
-      const QStringList errors = loader->errors();
-      for (const QString &error : errors) {
-        Q_EMIT Error(error);
-      }
+    
+    // Always check for errors, even on success (e.g., playlist parsed but some songs failed to load)
+    const QStringList errors = loader->errors();
+    for (const QString &error : errors) {
+      Q_EMIT Error(error);
     }
+    
     delete loader;
   }
 
@@ -192,11 +193,13 @@ void SongLoaderInserter::AsyncLoad() {
     const SongLoader::Result result = loader->LoadFilenamesBlocking();
     task_manager_->SetTaskProgress(async_load_id, static_cast<quint64>(++async_progress));
 
+    // Always check for errors, even on success (e.g., playlist parsed but some songs failed to load)
+    const QStringList errors = loader->errors();
+    for (const QString &error : errors) {
+      Q_EMIT Error(error);
+    }
+
     if (result == SongLoader::Result::Error) {
-      const QStringList errors = loader->errors();
-      for (const QString &error : errors) {
-        Q_EMIT Error(error);
-      }
       continue;
     }
 

src/playlistparsers/parserbase.cpp

@@ -112,10 +112,18 @@ void ParserBase::LoadSong(const QString &filename_or_url, const qint64 beginning
     }
   }
 
+  // Check if the file exists before trying to read it
+  if (!QFile::exists(filename)) {
+    qLog(Error) << "File does not exist:" << filename;
+    Q_EMIT Error(tr("File %1 does not exist").arg(filename));
+    return;
+  }
+
   if (tagreader_client_) {
     const TagReaderResult result = tagreader_client_->ReadFileBlocking(filename, song);
     if (!result.success()) {
       qLog(Error) << "Could not read file" << filename << result.error_string();
+      Q_EMIT Error(tr("Could not read file %1: %2").arg(filename, result.error_string()));
     }
   }
 

src/translations/strawberry_ru_RU.ts

@@ -5526,7 +5526,7 @@ Are you sure you want to continue?</source>
     <name>RadioParadiseService</name>
     <message>
       <source>Getting %1 channels</source>
-      <translation>Получение %1 каналов</translation>
+      <translation>Получение каналов %1</translation>
     </message>
   </context>
   <context>
@@ -6191,7 +6191,7 @@ Are you sure you want to continue?</source>
     <name>SomaFMService</name>
     <message>
       <source>Getting %1 channels</source>
-      <translation>Получение %1 каналов</translation>
+      <translation>Получение каналов %1</translation>
     </message>
   </context>
   <context>

src/translations/strawberry_tr_TR.ts

@@ -1187,7 +1187,7 @@ If there are no matches then it will use the largest image in the directory.</tr
     </message>
     <message>
       <source>Queue to play next</source>
-      <translation>Sıradaki Yap</translation>
+      <translation>Sıradaki yap</translation>
     </message>
     <message>
       <source>Search for this</source>
@@ -3496,7 +3496,7 @@ If there are no matches then it will use the largest image in the directory.</tr
     </message>
     <message>
       <source>Queue to play next</source>
-      <translation>Sıradaki Yap</translation>
+      <translation>Sıradaki yap</translation>
     </message>
     <message>
       <source>Unskip track</source>
@@ -4431,7 +4431,7 @@ If there are no matches then it will use the largest image in the directory.</tr
     </message>
     <message>
       <source>&amp;Hide %1</source>
-      <translation>&amp;%1&apos;i sakla</translation>
+      <translation>&amp;%1 ögesini sakla</translation>
     </message>
   </context>
   <context>
@@ -6407,7 +6407,7 @@ Devam etmek istediğinizden emin misiniz?</translation>
     </message>
     <message>
       <source>Queue to play next</source>
-      <translation>Sıradaki Yap</translation>
+      <translation>Sıradaki yap</translation>
     </message>
     <message>
       <source>Remove from favorites</source>