Use C++11 enum class

ext/libstrawberry-tagreader/tagreadergme.h

@@ -55,14 +55,22 @@ constexpr int XID6_OFFSET = (0x101C0 + 64);
 
 constexpr int NANO_PER_MS = 1000000;
 
-enum xID6_STATUS {
+enum class xID6_STATUS {
   ON = 0x26,
-  OFF = 0x27,
+  OFF = 0x27
 };
 
-enum xID6_ID { SongName = 0x01, GameName = 0x02, ArtistName = 0x03 };
+enum class xID6_ID {
+  SongName = 0x01,
+  GameName = 0x02,
+  ArtistName = 0x03
+};
 
-enum xID6_TYPE { Length = 0x0, String = 0x1, Integer = 0x4 };
+enum class xID6_TYPE {
+  Length = 0x0,
+  String = 0x1,
+  Integer = 0x4
+};
 
 void Read(const QFileInfo &file_info, spb::tagreader::SongMetadata *song_info);
 qint16 GetNextMemAddressAlign32bit(qint16 input);

src/analyzer/analyzerbase.cpp

@@ -108,7 +108,7 @@ void Analyzer::Base::paintEvent(QPaintEvent *e) {
   p.fillRect(e->rect(), palette().color(QPalette::Window));
 
   switch (engine_->state()) {
-    case Engine::Playing: {
+    case Engine::State::Playing: {
       const Engine::Scope &thescope = engine_->scope(timeout_);
       int i = 0;
 
@@ -126,7 +126,7 @@ void Analyzer::Base::paintEvent(QPaintEvent *e) {
 
       break;
     }
-    case Engine::Paused:
+    case Engine::State::Paused:
       is_playing_ = false;
       analyze(p, lastscope_, new_frame_);
       break;

src/analyzer/boomanalyzer.cpp

@@ -110,7 +110,7 @@ void BoomAnalyzer::transform(Scope &s) {
 
 void BoomAnalyzer::analyze(QPainter &p, const Scope &scope, const bool new_frame) {
 
-  if (!new_frame || engine_->state() == Engine::Paused) {
+  if (!new_frame || engine_->state() == Engine::State::Paused) {
     p.drawPixmap(0, 0, canvas_);
     return;
   }

src/analyzer/sonogram.cpp

@@ -44,7 +44,7 @@ void Sonogram::resizeEvent(QResizeEvent *e) {
 
 void Sonogram::analyze(QPainter &p, const Analyzer::Scope &s, bool new_frame) {
 
-  if (!new_frame || engine_->state() == Engine::Paused) {
+  if (!new_frame || engine_->state() == Engine::State::Paused) {
     p.drawPixmap(0, 0, canvas_);
     return;
   }

src/collection/collection.cpp

@@ -69,7 +69,7 @@ SCollection::SCollection(Application *app, QObject *parent)
   backend()->moveToThread(app->database()->thread());
   qLog(Debug) << backend_ << "moved to thread" << app->database()->thread();
 
-  backend_->Init(app->database(), app->task_manager(), Song::Source_Collection, kSongsTable, kFtsTable, kDirsTable, kSubdirsTable);
+  backend_->Init(app->database(), app->task_manager(), Song::Source::Collection, kSongsTable, kFtsTable, kDirsTable, kSubdirsTable);
 
   model_ = new CollectionModel(backend_, app_, this);
 
@@ -93,7 +93,7 @@ SCollection::~SCollection() {
 
 void SCollection::Init() {
 
-  watcher_ = new CollectionWatcher(Song::Source_Collection);
+  watcher_ = new CollectionWatcher(Song::Source::Collection);
   watcher_thread_ = new Thread(this);
 
 #ifndef Q_OS_WIN32
@@ -104,7 +104,7 @@ void SCollection::Init() {
 
   watcher_->moveToThread(watcher_thread_);
 
-  qLog(Debug) << watcher_ << "moved to thread" << watcher_thread_ << "with I/O priority" << io_priority_ << "and thread priority" << thread_priority_;
+  qLog(Debug) << watcher_ << "moved to thread" << watcher_thread_ << "with I/O priority" << static_cast<int>(io_priority_) << "and thread priority" << thread_priority_;
 
   watcher_thread_->start(thread_priority_);
 
@@ -184,7 +184,7 @@ void SCollection::ReloadSettings() {
 
   QSettings s;
   s.beginGroup(CollectionSettingsPage::kSettingsGroup);
-  io_priority_ = static_cast<Utilities::IoPriority>(s.value("io_priority", Utilities::IOPRIO_CLASS_IDLE).toInt());
+  io_priority_ = static_cast<Utilities::IoPriority>(s.value("io_priority", static_cast<int>(Utilities::IoPriority::IOPRIO_CLASS_IDLE)).toInt());
   thread_priority_ = static_cast<QThread::Priority>(s.value("thread_priority", QThread::Priority::IdlePriority).toInt());
   save_playcounts_to_files_ = s.value("save_playcounts", false).toBool();
   save_ratings_to_files_ = s.value("save_ratings", false).toBool();

src/collection/collectionbackend.cpp

@@ -60,7 +60,7 @@ CollectionBackend::CollectionBackend(QObject *parent)
     : CollectionBackendInterface(parent),
       db_(nullptr),
       task_manager_(nullptr),
-      source_(Song::Source_Unknown),
+      source_(Song::Source::Unknown),
       original_thread_(nullptr) {
 
   original_thread_ = thread();
@@ -1864,7 +1864,7 @@ SongList CollectionBackend::SmartPlaylistsFindSongs(const SmartPlaylistSearch &s
 SongList CollectionBackend::SmartPlaylistsGetAllSongs() {
 
   // Get all the songs!
-  return SmartPlaylistsFindSongs(SmartPlaylistSearch(SmartPlaylistSearch::Type_All, SmartPlaylistSearch::TermList(), SmartPlaylistSearch::Sort_FieldAsc, SmartPlaylistSearchTerm::Field_Artist, -1));
+  return SmartPlaylistsFindSongs(SmartPlaylistSearch(SmartPlaylistSearch::SearchType::All, SmartPlaylistSearch::TermList(), SmartPlaylistSearch::SortType::FieldAsc, SmartPlaylistSearchTerm::Field::Artist, -1));
 
 }
 

src/collection/collectionbackend.h

@@ -54,7 +54,7 @@ class CollectionBackendInterface : public QObject {
   explicit CollectionBackendInterface(QObject *parent = nullptr) : QObject(parent) {}
 
   struct Album {
-    Album() : filetype(Song::FileType_Unknown) {}
+    Album() : filetype(Song::FileType::Unknown) {}
     Album(const QString &_album_artist, const QString &_album, const QUrl &_art_automatic, const QUrl &_art_manual, const QList<QUrl> &_urls, const Song::FileType _filetype, const QString &_cue_path)
         : album_artist(_album_artist),
           album(_album),

src/collection/collectionfilteroptions.cpp

@@ -24,7 +24,7 @@
 
 #include "collectionfilteroptions.h"
 
-CollectionFilterOptions::CollectionFilterOptions() : filter_mode_(FilterMode_All), max_age_(-1) {}
+CollectionFilterOptions::CollectionFilterOptions() : filter_mode_(FilterMode::All), max_age_(-1) {}
 
 bool CollectionFilterOptions::Matches(const Song &song) const {
 

src/collection/collectionfilteroptions.h

@@ -34,10 +34,10 @@ class CollectionFilterOptions {
   // - use the duplicated songs view; by duplicated we mean those songs for which the (artist, album, title) tuple is found more than once in the songs table
   // - use the untagged songs view; by untagged we mean those for which at least one of the (artist, album, title) tags is empty
   // Please note that additional filtering based on FTS table (the filter attribute) won't work in Duplicates and Untagged modes.
-  enum FilterMode {
+  enum class FilterMode {
-    FilterMode_All,
+    All,
-    FilterMode_Duplicates,
+    Duplicates,
-    FilterMode_Untagged
+    Untagged
   };
 
   FilterMode filter_mode() const { return filter_mode_; }
@@ -50,7 +50,7 @@ class CollectionFilterOptions {
   }
   void set_max_age(const int max_age) { max_age_ = max_age; }
   void set_filter_text(const QString &filter_text) {
-    filter_mode_ = FilterMode_All;
+    filter_mode_ = FilterMode::All;
     filter_text_ = filter_text;
   }
 

src/collection/collectionfilterwidget.cpp

@@ -68,7 +68,7 @@ CollectionFilterWidget::CollectionFilterWidget(QWidget *parent)
       group_by_group_(nullptr),
       filter_delay_(new QTimer(this)),
       filter_applies_to_model_(true),
-      delay_behaviour_(DelayedOnLargeLibraries) {
+      delay_behaviour_(DelayBehaviour::DelayedOnLargeLibraries) {
 
   ui_->setupUi(this);
 
@@ -178,12 +178,13 @@ void CollectionFilterWidget::Init(CollectionModel *model) {
     if (s.contains(group_by_version())) version = s.value(group_by_version(), 0).toInt();
     if (version == 1) {
       model_->SetGroupBy(CollectionModel::Grouping(
-        CollectionModel::GroupBy(s.value(group_by_key(1), static_cast<int>(CollectionModel::GroupBy_AlbumArtist)).toInt()),
+        static_cast<CollectionModel::GroupBy>(s.value(group_by_key(1), static_cast<int>(CollectionModel::GroupBy::AlbumArtist)).toInt()),
-        CollectionModel::GroupBy(s.value(group_by_key(2), static_cast<int>(CollectionModel::GroupBy_AlbumDisc)).toInt()),
+        static_cast<CollectionModel::GroupBy>(s.value(group_by_key(2), static_cast<int>(CollectionModel::GroupBy::AlbumDisc)).toInt()),
-        CollectionModel::GroupBy(s.value(group_by_key(3), static_cast<int>(CollectionModel::GroupBy_None)).toInt())), s.value(separate_albums_by_grouping_key(), false).toBool());
+        static_cast<CollectionModel::GroupBy>(s.value(group_by_key(3), static_cast<int>(CollectionModel::GroupBy::None)).toInt())),
+        s.value(separate_albums_by_grouping_key(), false).toBool());
     }
     else {
-      model_->SetGroupBy(CollectionModel::Grouping(CollectionModel::GroupBy_AlbumArtist, CollectionModel::GroupBy_AlbumDisc, CollectionModel::GroupBy_None), false);
+      model_->SetGroupBy(CollectionModel::Grouping(CollectionModel::GroupBy::AlbumArtist, CollectionModel::GroupBy::AlbumDisc, CollectionModel::GroupBy::None), false);
     }
     s.endGroup();
   }
@@ -272,24 +273,24 @@ QActionGroup *CollectionFilterWidget::CreateGroupByActions(const QString &saved_
 
   QActionGroup *ret = new QActionGroup(parent);
 
-  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_AlbumArtist, CollectionModel::GroupBy_Album)));
+  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::AlbumArtist, CollectionModel::GroupBy::Album)));
-  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_AlbumArtist, CollectionModel::GroupBy_AlbumDisc)));
+  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::AlbumArtist, CollectionModel::GroupBy::AlbumDisc)));
-  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Year - Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_AlbumArtist, CollectionModel::GroupBy_YearAlbum)));
+  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Year - Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::AlbumArtist, CollectionModel::GroupBy::YearAlbum)));
-  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Year - Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_AlbumArtist, CollectionModel::GroupBy_YearAlbumDisc)));
+  ret->addAction(CreateGroupByAction(tr("Group by Album artist/Year - Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::AlbumArtist, CollectionModel::GroupBy::YearAlbumDisc)));
 
-  ret->addAction(CreateGroupByAction(tr("Group by Artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Artist, CollectionModel::GroupBy_Album)));
+  ret->addAction(CreateGroupByAction(tr("Group by Artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Artist, CollectionModel::GroupBy::Album)));
-  ret->addAction(CreateGroupByAction(tr("Group by Artist/Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Artist, CollectionModel::GroupBy_AlbumDisc)));
+  ret->addAction(CreateGroupByAction(tr("Group by Artist/Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Artist, CollectionModel::GroupBy::AlbumDisc)));
-  ret->addAction(CreateGroupByAction(tr("Group by Artist/Year - Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Artist, CollectionModel::GroupBy_YearAlbum)));
+  ret->addAction(CreateGroupByAction(tr("Group by Artist/Year - Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Artist, CollectionModel::GroupBy::YearAlbum)));
-  ret->addAction(CreateGroupByAction(tr("Group by Artist/Year - Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Artist, CollectionModel::GroupBy_YearAlbumDisc)));
+  ret->addAction(CreateGroupByAction(tr("Group by Artist/Year - Album - Disc"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Artist, CollectionModel::GroupBy::YearAlbumDisc)));
 
-  ret->addAction(CreateGroupByAction(tr("Group by Genre/Album artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Genre, CollectionModel::GroupBy_AlbumArtist, CollectionModel::GroupBy_Album)));
+  ret->addAction(CreateGroupByAction(tr("Group by Genre/Album artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Genre, CollectionModel::GroupBy::AlbumArtist, CollectionModel::GroupBy::Album)));
-  ret->addAction(CreateGroupByAction(tr("Group by Genre/Artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Genre, CollectionModel::GroupBy_Artist, CollectionModel::GroupBy_Album)));
+  ret->addAction(CreateGroupByAction(tr("Group by Genre/Artist/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Genre, CollectionModel::GroupBy::Artist, CollectionModel::GroupBy::Album)));
 
-  ret->addAction(CreateGroupByAction(tr("Group by Album Artist"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_AlbumArtist)));
+  ret->addAction(CreateGroupByAction(tr("Group by Album Artist"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::AlbumArtist)));
-  ret->addAction(CreateGroupByAction(tr("Group by Artist"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Artist)));
+  ret->addAction(CreateGroupByAction(tr("Group by Artist"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Artist)));
 
-  ret->addAction(CreateGroupByAction(tr("Group by Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Album)));
+  ret->addAction(CreateGroupByAction(tr("Group by Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Album)));
-  ret->addAction(CreateGroupByAction(tr("Group by Genre/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy_Genre, CollectionModel::GroupBy_Album)));
+  ret->addAction(CreateGroupByAction(tr("Group by Genre/Album"), parent, CollectionModel::Grouping(CollectionModel::GroupBy::Genre, CollectionModel::GroupBy::Album)));
 
   QAction *sep1 = new QAction(parent);
   sep1->setSeparator(true);
@@ -334,7 +335,7 @@ QAction *CollectionFilterWidget::CreateGroupByAction(const QString &text, QObjec
   QAction *ret = new QAction(text, parent);
   ret->setCheckable(true);
 
-  if (grouping.first != CollectionModel::GroupBy_None) {
+  if (grouping.first != CollectionModel::GroupBy::None) {
     ret->setProperty("group_by", QVariant::fromValue(grouping));
   }
 
@@ -459,7 +460,7 @@ void CollectionFilterWidget::SetFilterHint(const QString &hint) {
 void CollectionFilterWidget::SetFilterMode(CollectionFilterOptions::FilterMode filter_mode) {
 
   ui_->search_field->clear();
-  ui_->search_field->setEnabled(filter_mode == CollectionFilterOptions::FilterMode_All);
+  ui_->search_field->setEnabled(filter_mode == CollectionFilterOptions::FilterMode::All);
 
   model_->SetFilterMode(filter_mode);
 
@@ -509,7 +510,7 @@ void CollectionFilterWidget::FilterTextChanged(const QString &text) {
   // Searching with one or two characters can be very expensive on the database even with FTS,
   // so if there are a large number of songs in the database introduce a small delay before actually filtering the model,
   // so if the user is typing the first few characters of something it will be quicker.
-  const bool delay = (delay_behaviour_ == AlwaysDelayed) || (delay_behaviour_ == DelayedOnLargeLibraries && !text.isEmpty() && text.length() < 3 && model_->total_song_count() >= 100000);
+  const bool delay = (delay_behaviour_ == DelayBehaviour::AlwaysDelayed) || (delay_behaviour_ == DelayBehaviour::DelayedOnLargeLibraries && !text.isEmpty() && text.length() < 3 && model_->total_song_count() >= 100000);
 
   if (delay) {
     filter_delay_->start();

src/collection/collectionfilterwidget.h

@@ -54,7 +54,7 @@ class CollectionFilterWidget : public QWidget {
 
   static const int kFilterDelay = 500;  // msec
 
-  enum DelayBehaviour {
+  enum class DelayBehaviour {
     AlwaysInstant,
     DelayedOnLargeLibraries,
     AlwaysDelayed,

src/collection/collectionmodel.cpp

@@ -98,9 +98,9 @@ CollectionModel::CollectionModel(CollectionBackend *backend, Application *app, Q
 
   root_->lazy_loaded = true;
 
-  group_by_[0] = GroupBy_AlbumArtist;
+  group_by_[0] = GroupBy::AlbumArtist;
-  group_by_[1] = GroupBy_AlbumDisc;
+  group_by_[1] = GroupBy::AlbumDisc;
-  group_by_[2] = GroupBy_None;
+  group_by_[2] = GroupBy::None;
 
   cover_loader_options_.get_image_data_ = false;
   cover_loader_options_.get_image_ = true;
@@ -226,7 +226,7 @@ void CollectionModel::SongsDiscovered(const SongList &songs) {
     QString key;
     for (int i = 0; i < 3; ++i) {
       GroupBy group_by = group_by_[i];
-      if (group_by == GroupBy_None) break;
+      if (group_by == GroupBy::None) break;
 
       if (!key.isEmpty()) key.append("-");
 
@@ -260,7 +260,7 @@ void CollectionModel::SongsDiscovered(const SongList &songs) {
     if (!container->lazy_loaded && use_lazy_loading_) continue;
 
     // We've gone all the way down to the deepest level and everything was already lazy loaded, so now we have to create the song in the container.
-    song_nodes_.insert(song.id(), ItemFromSong(GroupBy_None, separate_albums_by_grouping_, true, false, container, song, -1));
+    song_nodes_.insert(song.id(), ItemFromSong(GroupBy::None, separate_albums_by_grouping_, true, false, container, song, -1));
   }
 
 }
@@ -302,76 +302,76 @@ QString CollectionModel::ContainerKey(const GroupBy group_by, const bool separat
   QString key;
 
   switch (group_by) {
-    case GroupBy_AlbumArtist:
+    case GroupBy::AlbumArtist:
       key = TextOrUnknown(song.effective_albumartist());
       break;
-    case GroupBy_Artist:
+    case GroupBy::Artist:
       key = TextOrUnknown(song.artist());
       break;
-    case GroupBy_Album:
+    case GroupBy::Album:
       key = TextOrUnknown(song.album());
       if (!song.album_id().isEmpty()) key.append("-" + song.album_id());
       if (separate_albums_by_grouping && !song.grouping().isEmpty()) key.append("-" + song.grouping());
       break;
-    case GroupBy_AlbumDisc:
+    case GroupBy::AlbumDisc:
       key = PrettyAlbumDisc(song.album(), song.disc());
       if (!song.album_id().isEmpty()) key.append("-" + song.album_id());
       if (separate_albums_by_grouping && !song.grouping().isEmpty()) key.append("-" + song.grouping());
       break;
-    case GroupBy_YearAlbum:
+    case GroupBy::YearAlbum:
       key = PrettyYearAlbum(song.year(), song.album());
       if (!song.album_id().isEmpty()) key.append("-" + song.album_id());
       if (separate_albums_by_grouping && !song.grouping().isEmpty()) key.append("-" + song.grouping());
       break;
-    case GroupBy_YearAlbumDisc:
+    case GroupBy::YearAlbumDisc:
       key = PrettyYearAlbumDisc(song.year(), song.album(), song.disc());
       if (!song.album_id().isEmpty()) key.append("-" + song.album_id());
       if (separate_albums_by_grouping && !song.grouping().isEmpty()) key.append("-" + song.grouping());
       break;
-    case GroupBy_OriginalYearAlbum:
+    case GroupBy::OriginalYearAlbum:
       key = PrettyYearAlbum(song.effective_originalyear(), song.album());
       if (!song.album_id().isEmpty()) key.append("-" + song.album_id());
       if (separate_albums_by_grouping && !song.grouping().isEmpty()) key.append("-" + song.grouping());
       break;
-    case GroupBy_OriginalYearAlbumDisc:
+    case GroupBy::OriginalYearAlbumDisc:
       key = PrettyYearAlbumDisc(song.effective_originalyear(), song.album(), song.disc());
       if (!song.album_id().isEmpty()) key.append("-" + song.album_id());
       if (separate_albums_by_grouping && !song.grouping().isEmpty()) key.append("-" + song.grouping());
       break;
-    case GroupBy_Disc:
+    case GroupBy::Disc:
       key = PrettyDisc(song.disc());
       break;
-    case GroupBy_Year:
+    case GroupBy::Year:
       key = QString::number(qMax(0, song.year()));
       break;
-    case GroupBy_OriginalYear:
+    case GroupBy::OriginalYear:
       key = QString::number(qMax(0, song.effective_originalyear()));
       break;
-    case GroupBy_Genre:
+    case GroupBy::Genre:
       key = TextOrUnknown(song.genre());
       break;
-    case GroupBy_Composer:
+    case GroupBy::Composer:
       key = TextOrUnknown(song.composer());
       break;
-    case GroupBy_Performer:
+    case GroupBy::Performer:
       key = TextOrUnknown(song.performer());
       break;
-    case GroupBy_Grouping:
+    case GroupBy::Grouping:
       key = TextOrUnknown(song.grouping());
       break;
-    case GroupBy_FileType:
+    case GroupBy::FileType:
       key = song.TextForFiletype();
       break;
-    case GroupBy_Samplerate:
+    case GroupBy::Samplerate:
       key = QString::number(qMax(0, song.samplerate()));
       break;
-    case GroupBy_Bitdepth:
+    case GroupBy::Bitdepth:
       key = QString::number(qMax(0, song.bitdepth()));
       break;
-    case GroupBy_Bitrate:
+    case GroupBy::Bitrate:
       key = QString::number(qMax(0, song.bitrate()));
       break;
-    case GroupBy_Format:
+    case GroupBy::Format:
       if (song.samplerate() <= 0) {
         key = song.TextForFiletype();
       }
@@ -384,9 +384,9 @@ QString CollectionModel::ContainerKey(const GroupBy group_by, const bool separat
         }
       }
       break;
-    case GroupBy_None:
+    case GroupBy::None:
-    case GroupByCount:
+    case GroupBy::GroupByCount:
-      qLog(Error) << "GroupBy_None";
+      qLog(Error) << "GroupBy::None";
       break;
   }
 
@@ -401,17 +401,17 @@ QString CollectionModel::DividerKey(const GroupBy group_by, CollectionItem *item
   if (item->sort_text.isEmpty()) return QString();
 
   switch (group_by) {
-    case GroupBy_AlbumArtist:
+    case GroupBy::AlbumArtist:
-    case GroupBy_Artist:
+    case GroupBy::Artist:
-    case GroupBy_Album:
+    case GroupBy::Album:
-    case GroupBy_AlbumDisc:
+    case GroupBy::AlbumDisc:
-    case GroupBy_Composer:
+    case GroupBy::Composer:
-    case GroupBy_Performer:
+    case GroupBy::Performer:
-    case GroupBy_Grouping:
+    case GroupBy::Grouping:
-    case GroupBy_Disc:
+    case GroupBy::Disc:
-    case GroupBy_Genre:
+    case GroupBy::Genre:
-    case GroupBy_Format:
+    case GroupBy::Format:
-    case GroupBy_FileType: {
+    case GroupBy::FileType: {
       QChar c = item->sort_text[0];
       if (c.isDigit()) return "0";
       if (c == ' ') return QString();
@@ -422,29 +422,29 @@ QString CollectionModel::DividerKey(const GroupBy group_by, CollectionItem *item
       return c;
     }
 
-    case GroupBy_Year:
+    case GroupBy::Year:
-    case GroupBy_OriginalYear:
+    case GroupBy::OriginalYear:
       return SortTextForNumber(item->sort_text.toInt() / 10 * 10);
 
-    case GroupBy_YearAlbum:
+    case GroupBy::YearAlbum:
-    case GroupBy_YearAlbumDisc:
+    case GroupBy::YearAlbumDisc:
       return SortTextForNumber(item->metadata.year());
 
-    case GroupBy_OriginalYearAlbum:
+    case GroupBy::OriginalYearAlbum:
-    case GroupBy_OriginalYearAlbumDisc:
+    case GroupBy::OriginalYearAlbumDisc:
       return SortTextForNumber(item->metadata.effective_originalyear());
 
-    case GroupBy_Samplerate:
+    case GroupBy::Samplerate:
       return SortTextForNumber(item->metadata.samplerate());
 
-    case GroupBy_Bitdepth:
+    case GroupBy::Bitdepth:
       return SortTextForNumber(item->metadata.bitdepth());
 
-    case GroupBy_Bitrate:
+    case GroupBy::Bitrate:
       return SortTextForNumber(item->metadata.bitrate());
 
-    case GroupBy_None:
+    case GroupBy::None:
-    case GroupByCount:
+    case GroupBy::GroupByCount:
       return QString();
   }
   qLog(Error) << "Unknown GroupBy" << group_by << "for item" << item->display_text;
@@ -457,46 +457,46 @@ QString CollectionModel::DividerDisplayText(const GroupBy group_by, const QStrin
   // Pretty display text for the dividers.
 
   switch (group_by) {
-    case GroupBy_AlbumArtist:
+    case GroupBy::AlbumArtist:
-    case GroupBy_Artist:
+    case GroupBy::Artist:
-    case GroupBy_Album:
+    case GroupBy::Album:
-    case GroupBy_AlbumDisc:
+    case GroupBy::AlbumDisc:
-    case GroupBy_Composer:
+    case GroupBy::Composer:
-    case GroupBy_Performer:
+    case GroupBy::Performer:
-    case GroupBy_Disc:
+    case GroupBy::Disc:
-    case GroupBy_Grouping:
+    case GroupBy::Grouping:
-    case GroupBy_Genre:
+    case GroupBy::Genre:
-    case GroupBy_FileType:
+    case GroupBy::FileType:
-    case GroupBy_Format:
+    case GroupBy::Format:
       if (key == "0") return "0-9";
       return key.toUpper();
 
-    case GroupBy_YearAlbum:
+    case GroupBy::YearAlbum:
-    case GroupBy_YearAlbumDisc:
+    case GroupBy::YearAlbumDisc:
-    case GroupBy_OriginalYearAlbum:
+    case GroupBy::OriginalYearAlbum:
-    case GroupBy_OriginalYearAlbumDisc:
+    case GroupBy::OriginalYearAlbumDisc:
       if (key == "0000") return tr("Unknown");
       return key.toUpper();
 
-    case GroupBy_Year:
+    case GroupBy::Year:
-    case GroupBy_OriginalYear:
+    case GroupBy::OriginalYear:
       if (key == "0000") return tr("Unknown");
       return QString::number(key.toInt());  // To remove leading 0s
 
-    case GroupBy_Samplerate:
+    case GroupBy::Samplerate:
       if (key == "000") return tr("Unknown");
       return QString::number(key.toInt());  // To remove leading 0s
 
-    case GroupBy_Bitdepth:
+    case GroupBy::Bitdepth:
       if (key == "000") return tr("Unknown");
       return QString::number(key.toInt());  // To remove leading 0s
 
-    case GroupBy_Bitrate:
+    case GroupBy::Bitrate:
       if (key == "000") return tr("Unknown");
       return QString::number(key.toInt());  // To remove leading 0s
 
-    case GroupBy_None:
+    case GroupBy::None:
-    case GroupByCount:
+    case GroupBy::GroupByCount:
       break;
   }
   qLog(Error) << "Unknown GroupBy" << group_by << "for divider key" << key;
@@ -727,7 +727,7 @@ QVariant CollectionModel::data(const QModelIndex &idx, const int role) const {
 
 QVariant CollectionModel::data(const CollectionItem *item, const int role) const {
 
-  GroupBy container_group_by = item->type == CollectionItem::Type_Container ? group_by_[item->container_level] : GroupBy_None;
+  GroupBy container_group_by = item->type == CollectionItem::Type_Container ? group_by_[item->container_level] : GroupBy::None;
 
   switch (role) {
     case Qt::DisplayRole:
@@ -738,15 +738,15 @@ QVariant CollectionModel::data(const CollectionItem *item, const int role) const
       switch (item->type) {
         case CollectionItem::Type_Container:
           switch (container_group_by) {
-            case GroupBy_Album:
+            case GroupBy::Album:
-            case GroupBy_AlbumDisc:
+            case GroupBy::AlbumDisc:
-            case GroupBy_YearAlbum:
+            case GroupBy::YearAlbum:
-            case GroupBy_YearAlbumDisc:
+            case GroupBy::YearAlbumDisc:
-            case GroupBy_OriginalYearAlbum:
+            case GroupBy::OriginalYearAlbum:
-            case GroupBy_OriginalYearAlbumDisc:
+            case GroupBy::OriginalYearAlbumDisc:
               return album_icon_;
-            case GroupBy_Artist:
+            case GroupBy::Artist:
-            case GroupBy_AlbumArtist:
+            case GroupBy::AlbumArtist:
               return artist_icon_;
             default:
               break;
@@ -764,7 +764,7 @@ QVariant CollectionModel::data(const CollectionItem *item, const int role) const
       return item->type == CollectionItem::Type_Divider;
 
     case Role_ContainerType:
-      return container_group_by;
+      return static_cast<int>(container_group_by);
 
     case Role_Key:
       return item->key;
@@ -830,7 +830,7 @@ CollectionQueryOptions CollectionModel::PrepareQuery(CollectionItem *parent) {
 
   // Information about what we want the children to be
   const int child_level = parent == root_ ? 0 : parent->container_level + 1;
-  const GroupBy child_group_by = child_level >= 3 ? GroupBy_None : group_by_[child_level];
+  const GroupBy child_group_by = child_level >= 3 ? GroupBy::None : group_by_[child_level];
 
   CollectionQueryOptions query_options;
 
@@ -894,7 +894,7 @@ void CollectionModel::PostQuery(CollectionItem *parent, const CollectionModel::Q
 
   // Information about what we want the children to be
   int child_level = parent == root_ ? 0 : parent->container_level + 1;
-  GroupBy child_group_by = child_level >= 3 ? GroupBy_None : group_by_[child_level];
+  GroupBy child_group_by = child_level >= 3 ? GroupBy::None : group_by_[child_level];
 
   if (result.create_va && parent->compilation_artist_node_ == nullptr) {
     CreateCompilationArtistNode(signal, parent);
@@ -906,7 +906,7 @@ void CollectionModel::PostQuery(CollectionItem *parent, const CollectionModel::Q
     CollectionItem *item = ItemFromQuery(child_group_by, separate_albums_by_grouping_, signal, child_level == 0, parent, row, child_level);
 
     // Save a pointer to it for later
-    if (child_group_by == GroupBy_None) {
+    if (child_group_by == GroupBy::None) {
       song_nodes_.insert(item->metadata.id(), item);
     }
     else {
@@ -997,86 +997,86 @@ void CollectionModel::SetQueryColumnSpec(const GroupBy group_by, const bool sepa
 
   // Say what group_by of thing we want to get back from the database.
   switch (group_by) {
-    case GroupBy_AlbumArtist:
+    case GroupBy::AlbumArtist:
       query_options->set_column_spec("DISTINCT effective_albumartist");
       break;
-    case GroupBy_Artist:
+    case GroupBy::Artist:
       query_options->set_column_spec("DISTINCT artist");
       break;
-    case GroupBy_Album:{
+    case GroupBy::Album:{
       QString query("DISTINCT album, album_id");
       if (separate_albums_by_grouping) query.append(", grouping");
       query_options->set_column_spec(query);
       break;
     }
-    case GroupBy_AlbumDisc:{
+    case GroupBy::AlbumDisc:{
       QString query("DISTINCT album, album_id, disc");
       if (separate_albums_by_grouping) query.append(", grouping");
       query_options->set_column_spec(query);
       break;
     }
-    case GroupBy_YearAlbum:{
+    case GroupBy::YearAlbum:{
       QString query("DISTINCT year, album, album_id");
       if (separate_albums_by_grouping) query.append(", grouping");
       query_options->set_column_spec(query);
       break;
     }
-    case GroupBy_YearAlbumDisc:{
+    case GroupBy::YearAlbumDisc:{
       QString query("DISTINCT year, album, album_id, disc");
       if (separate_albums_by_grouping) query.append(", grouping");
       query_options->set_column_spec(query);
       break;
     }
-    case GroupBy_OriginalYearAlbum:{
+    case GroupBy::OriginalYearAlbum:{
       QString query("DISTINCT year, originalyear, album, album_id");
       if (separate_albums_by_grouping) query.append(", grouping");
       query_options->set_column_spec(query);
       break;
     }
-    case GroupBy_OriginalYearAlbumDisc:{
+    case GroupBy::OriginalYearAlbumDisc:{
       QString query("DISTINCT year, originalyear, album, album_id, disc");
       if (separate_albums_by_grouping) query.append(", grouping");
       query_options->set_column_spec(query);
       break;
     }
-    case GroupBy_Disc:
+    case GroupBy::Disc:
       query_options->set_column_spec("DISTINCT disc");
       break;
-    case GroupBy_Year:
+    case GroupBy::Year:
       query_options->set_column_spec("DISTINCT year");
       break;
-    case GroupBy_OriginalYear:
+    case GroupBy::OriginalYear:
       query_options->set_column_spec("DISTINCT effective_originalyear");
       break;
-    case GroupBy_Genre:
+    case GroupBy::Genre:
       query_options->set_column_spec("DISTINCT genre");
       break;
-    case GroupBy_Composer:
+    case GroupBy::Composer:
       query_options->set_column_spec("DISTINCT composer");
       break;
-    case GroupBy_Performer:
+    case GroupBy::Performer:
       query_options->set_column_spec("DISTINCT performer");
       break;
-    case GroupBy_Grouping:
+    case GroupBy::Grouping:
       query_options->set_column_spec("DISTINCT grouping");
       break;
-    case GroupBy_FileType:
+    case GroupBy::FileType:
       query_options->set_column_spec("DISTINCT filetype");
       break;
-    case GroupBy_Format:
+    case GroupBy::Format:
       query_options->set_column_spec("DISTINCT filetype, samplerate, bitdepth");
       break;
-    case GroupBy_Samplerate:
+    case GroupBy::Samplerate:
       query_options->set_column_spec("DISTINCT samplerate");
       break;
-    case GroupBy_Bitdepth:
+    case GroupBy::Bitdepth:
       query_options->set_column_spec("DISTINCT bitdepth");
       break;
-    case GroupBy_Bitrate:
+    case GroupBy::Bitrate:
       query_options->set_column_spec("DISTINCT bitrate");
       break;
-    case GroupBy_None:
+    case GroupBy::None:
-    case GroupByCount:
+    case GroupBy::GroupByCount:
       query_options->set_column_spec("%songs_table.ROWID, " + Song::kColumnSpec);
       break;
   }
@@ -1088,7 +1088,7 @@ void CollectionModel::AddQueryWhere(const GroupBy group_by, const bool separate_
   // Say how we want the query to be filtered.  This is done once for each parent going up the tree.
 
   switch (group_by) {
-    case GroupBy_AlbumArtist:
+    case GroupBy::AlbumArtist:
       if (IsCompilationArtistNode(item)) {
         query_options->set_compilation_requirement(true);
       }
@@ -1098,7 +1098,7 @@ void CollectionModel::AddQueryWhere(const GroupBy group_by, const bool separate_
         query_options->AddWhere("effective_albumartist", item->metadata.effective_albumartist());
       }
       break;
-    case GroupBy_Artist:
+    case GroupBy::Artist:
       if (IsCompilationArtistNode(item)) {
         query_options->set_compilation_requirement(true);
       }
@@ -1108,38 +1108,38 @@ void CollectionModel::AddQueryWhere(const GroupBy group_by, const bool separate_
         query_options->AddWhere("artist", item->metadata.artist());
       }
       break;
-    case GroupBy_Album:
+    case GroupBy::Album:
       query_options->AddWhere("album", item->metadata.album());
       query_options->AddWhere("album_id", item->metadata.album_id());
       if (separate_albums_by_grouping) query_options->AddWhere("grouping", item->metadata.grouping());
       break;
-    case GroupBy_AlbumDisc:
+    case GroupBy::AlbumDisc:
       query_options->AddWhere("album", item->metadata.album());
       query_options->AddWhere("album_id", item->metadata.album_id());
       query_options->AddWhere("disc", item->metadata.disc());
       if (separate_albums_by_grouping) query_options->AddWhere("grouping", item->metadata.grouping());
       break;
-    case GroupBy_YearAlbum:
+    case GroupBy::YearAlbum:
       query_options->AddWhere("year", item->metadata.year());
       query_options->AddWhere("album", item->metadata.album());
       query_options->AddWhere("album_id", item->metadata.album_id());
       if (separate_albums_by_grouping) query_options->AddWhere("grouping", item->metadata.grouping());
       break;
-    case GroupBy_YearAlbumDisc:
+    case GroupBy::YearAlbumDisc:
       query_options->AddWhere("year", item->metadata.year());
       query_options->AddWhere("album", item->metadata.album());
       query_options->AddWhere("album_id", item->metadata.album_id());
       query_options->AddWhere("disc", item->metadata.disc());
       if (separate_albums_by_grouping) query_options->AddWhere("grouping", item->metadata.grouping());
       break;
-    case GroupBy_OriginalYearAlbum:
+    case GroupBy::OriginalYearAlbum:
       query_options->AddWhere("year", item->metadata.year());
       query_options->AddWhere("originalyear", item->metadata.originalyear());
       query_options->AddWhere("album", item->metadata.album());
       query_options->AddWhere("album_id", item->metadata.album_id());
       if (separate_albums_by_grouping) query_options->AddWhere("grouping", item->metadata.grouping());
       break;
-    case GroupBy_OriginalYearAlbumDisc:
+    case GroupBy::OriginalYearAlbumDisc:
       query_options->AddWhere("year", item->metadata.year());
       query_options->AddWhere("originalyear", item->metadata.originalyear());
       query_options->AddWhere("album", item->metadata.album());
@@ -1147,46 +1147,46 @@ void CollectionModel::AddQueryWhere(const GroupBy group_by, const bool separate_
       query_options->AddWhere("disc", item->metadata.disc());
       if (separate_albums_by_grouping) query_options->AddWhere("grouping", item->metadata.grouping());
       break;
-    case GroupBy_Disc:
+    case GroupBy::Disc:
       query_options->AddWhere("disc", item->metadata.disc());
       break;
-    case GroupBy_Year:
+    case GroupBy::Year:
       query_options->AddWhere("year", item->metadata.year());
       break;
-    case GroupBy_OriginalYear:
+    case GroupBy::OriginalYear:
       query_options->AddWhere("effective_originalyear", item->metadata.effective_originalyear());
       break;
-    case GroupBy_Genre:
+    case GroupBy::Genre:
       query_options->AddWhere("genre", item->metadata.genre());
       break;
-    case GroupBy_Composer:
+    case GroupBy::Composer:
       query_options->AddWhere("composer", item->metadata.composer());
       break;
-    case GroupBy_Performer:
+    case GroupBy::Performer:
       query_options->AddWhere("performer", item->metadata.performer());
       break;
-    case GroupBy_Grouping:
+    case GroupBy::Grouping:
       query_options->AddWhere("grouping", item->metadata.grouping());
       break;
-    case GroupBy_FileType:
+    case GroupBy::FileType:
-      query_options->AddWhere("filetype", item->metadata.filetype());
+      query_options->AddWhere("filetype", static_cast<int>(item->metadata.filetype()));
       break;
-    case GroupBy_Format:
+    case GroupBy::Format:
-      query_options->AddWhere("filetype", item->metadata.filetype());
+      query_options->AddWhere("filetype", static_cast<int>(item->metadata.filetype()));
       query_options->AddWhere("samplerate", item->metadata.samplerate());
       query_options->AddWhere("bitdepth", item->metadata.bitdepth());
       break;
-    case GroupBy_Samplerate:
+    case GroupBy::Samplerate:
       query_options->AddWhere("samplerate", item->metadata.samplerate());
       break;
-    case GroupBy_Bitdepth:
+    case GroupBy::Bitdepth:
       query_options->AddWhere("bitdepth", item->metadata.bitdepth());
       break;
-    case GroupBy_Bitrate:
+    case GroupBy::Bitrate:
       query_options->AddWhere("bitrate", item->metadata.bitrate());
       break;
-    case GroupBy_None:
+    case GroupBy::None:
-    case GroupByCount:
+    case GroupBy::GroupByCount:
       qLog(Error) << "Unknown GroupBy" << group_by << "used in filter";
       break;
   }
@@ -1195,7 +1195,7 @@ void CollectionModel::AddQueryWhere(const GroupBy group_by, const bool separate_
 
 CollectionItem *CollectionModel::InitItem(const GroupBy group_by, const bool signal, CollectionItem *parent, const int container_level) {
 
-  CollectionItem::Type item_type = group_by == GroupBy_None ? CollectionItem::Type_Song : CollectionItem::Type_Container;
+  CollectionItem::Type item_type = group_by == GroupBy::None ? CollectionItem::Type_Song : CollectionItem::Type_Container;
 
   if (signal) beginInsertRows(ItemToIndex(parent), static_cast<int>(parent->children.count()), static_cast<int>(parent->children.count()));
 
@@ -1217,21 +1217,21 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
   }
 
   switch (group_by) {
-    case GroupBy_AlbumArtist:{
+    case GroupBy::AlbumArtist:{
       item->metadata.set_albumartist(row.value(0).toString());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       item->display_text = TextOrUnknown(item->metadata.albumartist());
       item->sort_text = SortTextForArtist(item->metadata.albumartist());
       break;
     }
-    case GroupBy_Artist:{
+    case GroupBy::Artist:{
       item->metadata.set_artist(row.value(0).toString());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       item->display_text = TextOrUnknown(item->metadata.artist());
       item->sort_text = SortTextForArtist(item->metadata.artist());
       break;
     }
-    case GroupBy_Album:{
+    case GroupBy::Album:{
       item->metadata.set_album(row.value(0).toString());
       item->metadata.set_album_id(row.value(1).toString());
       item->metadata.set_grouping(row.value(2).toString());
@@ -1240,7 +1240,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForArtist(item->metadata.album());
       break;
     }
-    case GroupBy_AlbumDisc:{
+    case GroupBy::AlbumDisc:{
       item->metadata.set_album(row.value(0).toString());
       item->metadata.set_album_id(row.value(1).toString());
       item->metadata.set_disc(row.value(2).toInt());
@@ -1250,7 +1250,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = item->metadata.album() + SortTextForNumber(qMax(0, item->metadata.disc()));
       break;
     }
-    case GroupBy_YearAlbum:{
+    case GroupBy::YearAlbum:{
       item->metadata.set_year(row.value(0).toInt());
       item->metadata.set_album(row.value(1).toString());
       item->metadata.set_album_id(row.value(2).toString());
@@ -1260,7 +1260,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(qMax(0, item->metadata.year())) + item->metadata.grouping() + item->metadata.album();
       break;
     }
-    case GroupBy_YearAlbumDisc:{
+    case GroupBy::YearAlbumDisc:{
       item->metadata.set_year(row.value(0).toInt());
       item->metadata.set_album(row.value(1).toString());
       item->metadata.set_album_id(row.value(2).toString());
@@ -1271,7 +1271,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(qMax(0, item->metadata.year())) + item->metadata.album() + SortTextForNumber(qMax(0, item->metadata.disc()));
       break;
     }
-    case GroupBy_OriginalYearAlbum:{
+    case GroupBy::OriginalYearAlbum:{
       item->metadata.set_year(row.value(0).toInt());
       item->metadata.set_originalyear(row.value(1).toInt());
       item->metadata.set_album(row.value(2).toString());
@@ -1282,7 +1282,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(qMax(0, item->metadata.effective_originalyear())) + item->metadata.grouping() + item->metadata.album();
       break;
     }
-    case GroupBy_OriginalYearAlbumDisc:{
+    case GroupBy::OriginalYearAlbumDisc:{
       item->metadata.set_year(row.value(0).toInt());
       item->metadata.set_originalyear(row.value(1).toInt());
       item->metadata.set_album(row.value(2).toString());
@@ -1294,7 +1294,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(qMax(0, item->metadata.effective_originalyear())) + item->metadata.album() + SortTextForNumber(qMax(0, item->metadata.disc()));
       break;
     }
-    case GroupBy_Disc:{
+    case GroupBy::Disc:{
       item->metadata.set_disc(row.value(0).toInt());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       const int disc = qMax(0, row.value(0).toInt());
@@ -1302,7 +1302,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(disc);
       break;
     }
-    case GroupBy_Year:{
+    case GroupBy::Year:{
       item->metadata.set_year(row.value(0).toInt());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       const int year = qMax(0, item->metadata.year());
@@ -1310,7 +1310,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(year) + " ";
       break;
     }
-    case GroupBy_OriginalYear:{
+    case GroupBy::OriginalYear:{
       item->metadata.set_originalyear(row.value(0).toInt());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       const int year = qMax(0, item->metadata.originalyear());
@@ -1318,42 +1318,42 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(year) + " ";
       break;
     }
-    case GroupBy_Genre:{
+    case GroupBy::Genre:{
       item->metadata.set_genre(row.value(0).toString());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       item->display_text = TextOrUnknown(item->metadata.genre());
       item->sort_text = SortTextForArtist(item->metadata.genre());
       break;
     }
-    case GroupBy_Composer:{
+    case GroupBy::Composer:{
       item->metadata.set_composer(row.value(0).toString());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       item->display_text = TextOrUnknown(item->metadata.composer());
       item->sort_text = SortTextForArtist(item->metadata.composer());
       break;
     }
-    case GroupBy_Performer:{
+    case GroupBy::Performer:{
       item->metadata.set_performer(row.value(0).toString());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       item->display_text = TextOrUnknown(item->metadata.performer());
       item->sort_text = SortTextForArtist(item->metadata.performer());
       break;
     }
-    case GroupBy_Grouping:{
+    case GroupBy::Grouping:{
       item->metadata.set_grouping(row.value(0).toString());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       item->display_text = TextOrUnknown(item->metadata.grouping());
       item->sort_text = SortTextForArtist(item->metadata.grouping());
       break;
     }
-    case GroupBy_FileType:{
+    case GroupBy::FileType:{
       item->metadata.set_filetype(static_cast<Song::FileType>(row.value(0).toInt()));
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       item->display_text = item->metadata.TextForFiletype();
       item->sort_text = item->metadata.TextForFiletype();
       break;
     }
-    case GroupBy_Format:{
+    case GroupBy::Format:{
       item->metadata.set_filetype(static_cast<Song::FileType>(row.value(0).toInt()));
       item->metadata.set_samplerate(row.value(1).toInt());
       item->metadata.set_bitdepth(row.value(2).toInt());
@@ -1363,7 +1363,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = key;
       break;
     }
-    case GroupBy_Samplerate:{
+    case GroupBy::Samplerate:{
       item->metadata.set_samplerate(row.value(0).toInt());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       const int samplerate = qMax(0, item->metadata.samplerate());
@@ -1371,7 +1371,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(samplerate) + " ";
       break;
     }
-    case GroupBy_Bitdepth:{
+    case GroupBy::Bitdepth:{
       item->metadata.set_bitdepth(row.value(0).toInt());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       const int bitdepth = qMax(0, item->metadata.bitdepth());
@@ -1379,7 +1379,7 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(bitdepth) + " ";
       break;
     }
-    case GroupBy_Bitrate:{
+    case GroupBy::Bitrate:{
       item->metadata.set_bitrate(row.value(0).toInt());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, item->metadata));
       const int bitrate = qMax(0, item->metadata.bitrate());
@@ -1387,8 +1387,8 @@ CollectionItem *CollectionModel::ItemFromQuery(const GroupBy group_by, const boo
       item->sort_text = SortTextForNumber(bitrate) + " ";
       break;
     }
-    case GroupBy_None:
+    case GroupBy::None:
-    case GroupByCount:
+    case GroupBy::GroupByCount:
       item->metadata.InitFromQuery(row, true);
       item->key.append(TextOrUnknown(item->metadata.title()));
       item->display_text = item->metadata.TitleWithCompilationArtist();
@@ -1416,21 +1416,21 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
   }
 
   switch (group_by) {
-    case GroupBy_AlbumArtist:{
+    case GroupBy::AlbumArtist:{
       item->metadata.set_albumartist(s.effective_albumartist());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       item->display_text = TextOrUnknown(s.effective_albumartist());
       item->sort_text = SortTextForArtist(s.effective_albumartist());
       break;
     }
-    case GroupBy_Artist:{
+    case GroupBy::Artist:{
       item->metadata.set_artist(s.artist());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       item->display_text = TextOrUnknown(s.artist());
       item->sort_text = SortTextForArtist(s.artist());
       break;
     }
-    case GroupBy_Album:{
+    case GroupBy::Album:{
       item->metadata.set_album(s.album());
       item->metadata.set_album_id(s.album_id());
       item->metadata.set_grouping(s.grouping());
@@ -1439,7 +1439,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForArtist(s.album());
       break;
     }
-    case GroupBy_AlbumDisc:{
+    case GroupBy::AlbumDisc:{
       item->metadata.set_album(s.album());
       item->metadata.set_album_id(s.album_id());
       item->metadata.set_disc(s.disc());
@@ -1449,7 +1449,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = s.album() + SortTextForNumber(qMax(0, s.disc()));
       break;
     }
-    case GroupBy_YearAlbum:{
+    case GroupBy::YearAlbum:{
       item->metadata.set_year(s.year());
       item->metadata.set_album(s.album());
       item->metadata.set_album_id(s.album_id());
@@ -1459,7 +1459,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(qMax(0, s.year())) + s.grouping() + s.album();
       break;
     }
-    case GroupBy_YearAlbumDisc:{
+    case GroupBy::YearAlbumDisc:{
       item->metadata.set_year(s.year());
       item->metadata.set_album(s.album());
       item->metadata.set_album_id(s.album_id());
@@ -1470,7 +1470,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(qMax(0, s.year())) + s.album() + SortTextForNumber(qMax(0, s.disc()));
       break;
     }
-    case GroupBy_OriginalYearAlbum:{
+    case GroupBy::OriginalYearAlbum:{
       item->metadata.set_year(s.year());
       item->metadata.set_originalyear(s.originalyear());
       item->metadata.set_album(s.album());
@@ -1481,7 +1481,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(qMax(0, s.effective_originalyear())) + s.grouping() + s.album();
       break;
     }
-    case GroupBy_OriginalYearAlbumDisc:{
+    case GroupBy::OriginalYearAlbumDisc:{
       item->metadata.set_year(s.year());
       item->metadata.set_originalyear(s.originalyear());
       item->metadata.set_album(s.album());
@@ -1493,7 +1493,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(qMax(0, s.effective_originalyear())) + s.album() + SortTextForNumber(qMax(0, s.disc()));
       break;
     }
-    case GroupBy_Disc:{
+    case GroupBy::Disc:{
       item->metadata.set_disc(s.disc());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       const int disc = qMax(0, s.disc());
@@ -1501,7 +1501,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(disc);
       break;
     }
-    case GroupBy_Year:{
+    case GroupBy::Year:{
       item->metadata.set_year(s.year());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       const int year = qMax(0, s.year());
@@ -1509,7 +1509,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(year) + " ";
       break;
     }
-    case GroupBy_OriginalYear:{
+    case GroupBy::OriginalYear:{
       item->metadata.set_originalyear(s.effective_originalyear());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       const int year = qMax(0, s.effective_originalyear());
@@ -1517,42 +1517,42 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(year) + " ";
       break;
     }
-    case GroupBy_Genre:{
+    case GroupBy::Genre:{
       item->metadata.set_genre(s.genre());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       item->display_text = TextOrUnknown(s.genre());
       item->sort_text = SortTextForArtist(s.genre());
       break;
     }
-    case GroupBy_Composer:{
+    case GroupBy::Composer:{
       item->metadata.set_composer(s.composer());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       item->display_text = TextOrUnknown(s.composer());
       item->sort_text = SortTextForArtist(s.composer());
       break;
     }
-    case GroupBy_Performer:{
+    case GroupBy::Performer:{
       item->metadata.set_performer(s.performer());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       item->display_text = TextOrUnknown(s.performer());
       item->sort_text = SortTextForArtist(s.performer());
       break;
     }
-    case GroupBy_Grouping:{
+    case GroupBy::Grouping:{
       item->metadata.set_grouping(s.grouping());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       item->display_text = TextOrUnknown(s.grouping());
       item->sort_text = SortTextForArtist(s.grouping());
       break;
     }
-    case GroupBy_FileType:{
+    case GroupBy::FileType:{
       item->metadata.set_filetype(s.filetype());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       item->display_text = s.TextForFiletype();
       item->sort_text = s.TextForFiletype();
       break;
     }
-    case GroupBy_Format:{
+    case GroupBy::Format:{
       item->metadata.set_filetype(s.filetype());
       item->metadata.set_samplerate(s.samplerate());
       item->metadata.set_bitdepth(s.bitdepth());
@@ -1562,7 +1562,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = key;
       break;
     }
-    case GroupBy_Samplerate:{
+    case GroupBy::Samplerate:{
       item->metadata.set_samplerate(s.samplerate());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       const int samplerate = qMax(0, s.samplerate());
@@ -1570,7 +1570,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(samplerate) + " ";
       break;
     }
-    case GroupBy_Bitdepth:{
+    case GroupBy::Bitdepth:{
       item->metadata.set_bitdepth(s.bitdepth());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       const int bitdepth = qMax(0, s.bitdepth());
@@ -1578,7 +1578,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(bitdepth) + " ";
       break;
     }
-    case GroupBy_Bitrate:{
+    case GroupBy::Bitrate:{
       item->metadata.set_bitrate(s.bitrate());
       item->key.append(ContainerKey(group_by, separate_albums_by_grouping, s));
       const int bitrate = qMax(0, s.bitrate());
@@ -1586,8 +1586,8 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
       item->sort_text = SortTextForNumber(bitrate) + " ";
       break;
     }
-    case GroupBy_None:
+    case GroupBy::None:
-    case GroupByCount:{
+    case GroupBy::GroupByCount:{
       item->metadata = s;
       item->key.append(TextOrUnknown(s.title()));
       item->display_text = s.TitleWithCompilationArtist();
@@ -1610,7 +1610,7 @@ CollectionItem *CollectionModel::ItemFromSong(const GroupBy group_by, const bool
 
 void CollectionModel::FinishItem(const GroupBy group_by, const bool signal, const bool create_divider, CollectionItem *parent, CollectionItem *item) {
 
-  if (group_by == GroupBy_None) item->lazy_loaded = true;
+  if (group_by == GroupBy::None) item->lazy_loaded = true;
 
   if (signal) {
     endInsertRows();
@@ -1801,7 +1801,7 @@ bool CollectionModel::CompareItems(const CollectionItem *a, const CollectionItem
 qint64 CollectionModel::MaximumCacheSize(QSettings *s, const char *size_id, const char *size_unit_id, const qint64 cache_size_default) {
 
   qint64 size = s->value(size_id, cache_size_default).toInt();
-  int unit = s->value(size_unit_id, CollectionSettingsPage::CacheSizeUnit::CacheSizeUnit_MB).toInt() + 1;
+  int unit = s->value(size_unit_id, static_cast<int>(CollectionSettingsPage::CacheSizeUnit::MB)).toInt() + 1;
 
   do {
     size *= 1024;

src/collection/collectionmodel.h

@@ -83,34 +83,34 @@ class CollectionModel : public SimpleTreeModel<CollectionItem> {
   };
 
   // These values get saved in QSettings - don't change them
-  enum GroupBy {
+  enum class GroupBy {
-    GroupBy_None = 0,
+    None = 0,
-    GroupBy_AlbumArtist = 1,
+    AlbumArtist = 1,
-    GroupBy_Artist = 2,
+    Artist = 2,
-    GroupBy_Album = 3,
+    Album = 3,
-    GroupBy_AlbumDisc = 4,
+    AlbumDisc = 4,
-    GroupBy_YearAlbum = 5,
+    YearAlbum = 5,
-    GroupBy_YearAlbumDisc = 6,
+    YearAlbumDisc = 6,
-    GroupBy_OriginalYearAlbum = 7,
+    OriginalYearAlbum = 7,
-    GroupBy_OriginalYearAlbumDisc = 8,
+    OriginalYearAlbumDisc = 8,
-    GroupBy_Disc = 9,
+    Disc = 9,
-    GroupBy_Year = 10,
+    Year = 10,
-    GroupBy_OriginalYear = 11,
+    OriginalYear = 11,
-    GroupBy_Genre = 12,
+    Genre = 12,
-    GroupBy_Composer = 13,
+    Composer = 13,
-    GroupBy_Performer = 14,
+    Performer = 14,
-    GroupBy_Grouping = 15,
+    Grouping = 15,
-    GroupBy_FileType = 16,
+    FileType = 16,
-    GroupBy_Format = 17,
+    Format = 17,
-    GroupBy_Samplerate = 18,
+    Samplerate = 18,
-    GroupBy_Bitdepth = 19,
+    Bitdepth = 19,
-    GroupBy_Bitrate = 20,
+    Bitrate = 20,
     GroupByCount = 21,
   };
   Q_ENUM(GroupBy)
 
   struct Grouping {
-    explicit Grouping(GroupBy f = GroupBy_None, GroupBy s = GroupBy_None, GroupBy t = GroupBy_None)
+    explicit Grouping(GroupBy f = GroupBy::None, GroupBy s = GroupBy::None, GroupBy t = GroupBy::None)
         : first(f), second(s), third(t) {}
 
     GroupBy first;
@@ -181,9 +181,9 @@ class CollectionModel : public SimpleTreeModel<CollectionItem> {
   quint64 icon_cache_disk_size() { return sIconCache->cacheSize(); }
 
   static bool IsArtistGroupBy(const GroupBy group_by) {
-    return group_by == CollectionModel::GroupBy_Artist || group_by == CollectionModel::GroupBy_AlbumArtist;
+    return group_by == CollectionModel::GroupBy::Artist || group_by == CollectionModel::GroupBy::AlbumArtist;
   }
-  static bool IsAlbumGroupBy(const GroupBy group_by) { return group_by == GroupBy_Album || group_by == GroupBy_YearAlbum || group_by == GroupBy_AlbumDisc || group_by == GroupBy_YearAlbumDisc || group_by == GroupBy_OriginalYearAlbum || group_by == GroupBy_OriginalYearAlbumDisc; }
+  static bool IsAlbumGroupBy(const GroupBy group_by) { return group_by == GroupBy::Album || group_by == GroupBy::YearAlbum || group_by == GroupBy::AlbumDisc || group_by == GroupBy::YearAlbumDisc || group_by == GroupBy::OriginalYearAlbum || group_by == GroupBy::OriginalYearAlbumDisc; }
 
   void set_use_lazy_loading(const bool value) { use_lazy_loading_ = value; }
 

src/collection/collectionplaylistitem.cpp

@@ -29,12 +29,12 @@
 
 class SqlRow;
 
-CollectionPlaylistItem::CollectionPlaylistItem() : PlaylistItem(Song::Source_Collection) {
+CollectionPlaylistItem::CollectionPlaylistItem() : PlaylistItem(Song::Source::Collection) {
-  song_.set_source(Song::Source_Collection);
+  song_.set_source(Song::Source::Collection);
 }
 
-CollectionPlaylistItem::CollectionPlaylistItem(const Song &song) : PlaylistItem(Song::Source_Collection), song_(song) {
+CollectionPlaylistItem::CollectionPlaylistItem(const Song &song) : PlaylistItem(Song::Source::Collection), song_(song) {
-  song_.set_source(Song::Source_Collection);
+  song_.set_source(Song::Source::Collection);
 }
 
 QUrl CollectionPlaylistItem::Url() const { return song_.url(); }
@@ -50,7 +50,7 @@ bool CollectionPlaylistItem::InitFromQuery(const SqlRow &query) {
 
   // Rows from the songs tables come first
   song_.InitFromQuery(query, true);
-  song_.set_source(Song::Source_Collection);
+  song_.set_source(Song::Source::Collection);
   return song_.is_valid();
 
 }

src/collection/collectionplaylistitem.h

@@ -52,7 +52,7 @@ class CollectionPlaylistItem : public PlaylistItem {
 
  protected:
   QVariant DatabaseValue(DatabaseColumn column) const override;
-  Song DatabaseSongMetadata() const override { return Song(Song::Source_Collection); }
+  Song DatabaseSongMetadata() const override { return Song(Song::Source::Collection); }
 
  protected:
   Song song_;

src/collection/collectionquery.cpp

@@ -113,9 +113,9 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
   // Untagged mode could work with additional filtering but I'm disabling it just to be consistent
   // this way filtering is available only in the All mode.
   // Remember though that when you fix the Duplicates + FTS cooperation, enable the filtering in both Duplicates and Untagged modes.
-  duplicates_only_ = filter_options.filter_mode() == CollectionFilterOptions::FilterMode_Duplicates;
+  duplicates_only_ = filter_options.filter_mode() == CollectionFilterOptions::FilterMode::Duplicates;
 
-  if (filter_options.filter_mode() == CollectionFilterOptions::FilterMode_Untagged) {
+  if (filter_options.filter_mode() == CollectionFilterOptions::FilterMode::Untagged) {
     where_clauses_ << "(artist = '' OR album = '' OR title ='')";
   }
 

src/collection/collectionview.cpp

@@ -699,7 +699,7 @@ void CollectionView::DeleteFilesFinished(const SongList &songs_with_errors) {
   if (songs_with_errors.isEmpty()) return;
 
   OrganizeErrorDialog *dialog = new OrganizeErrorDialog(this);
-  dialog->Show(OrganizeErrorDialog::Type_Delete, songs_with_errors);
+  dialog->Show(OrganizeErrorDialog::OperationType::Delete, songs_with_errors);
   // It deletes itself when the user closes it
 
 }

src/collection/collectionwatcher.cpp

@@ -78,7 +78,7 @@ CollectionWatcher::CollectionWatcher(Song::Source source, QObject *parent)
       scan_on_startup_(true),
       monitor_(true),
       song_tracking_(false),
-      mark_songs_unavailable_(source_ == Song::Source_Collection),
+      mark_songs_unavailable_(source_ == Song::Source::Collection),
       expire_unavailable_songs_days_(60),
       overwrite_playcount_(false),
       overwrite_rating_(false),
@@ -143,7 +143,7 @@ void CollectionWatcher::ReloadSettings() {
   scan_on_startup_ = s.value("startup_scan", true).toBool();
   monitor_ = s.value("monitor", true).toBool();
   QStringList filters = s.value("cover_art_patterns", QStringList() << "front" << "cover").toStringList();
-  if (source_ == Song::Source_Collection) {
+  if (source_ == Song::Source::Collection) {
     song_tracking_ = s.value("song_tracking", false).toBool();
     mark_songs_unavailable_ = song_tracking_ ? true : s.value("mark_songs_unavailable", true).toBool();
   }
@@ -239,7 +239,7 @@ void CollectionWatcher::ScanTransaction::AddToProgressMax(const quint64 n) {
 void CollectionWatcher::ScanTransaction::CommitNewOrUpdatedSongs() {
 
   if (!deleted_songs.isEmpty()) {
-    if (mark_songs_unavailable_ && watcher_->source() == Song::Source_Collection) {
+    if (mark_songs_unavailable_ && watcher_->source() == Song::Source::Collection) {
       emit watcher_->SongsUnavailable(deleted_songs);
     }
     else {

src/collection/groupbydialog.cpp

@@ -74,26 +74,26 @@ GroupByDialog::GroupByDialog(QWidget *parent) : QDialog(parent), ui_(new Ui_Grou
   ui_->setupUi(this);
   Reset();
 
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_None, 0));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::None, 0));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Artist, 1));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Artist, 1));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_AlbumArtist, 2));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::AlbumArtist, 2));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Album, 3));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Album, 3));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_AlbumDisc, 4));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::AlbumDisc, 4));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Disc, 5));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Disc, 5));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Format, 6));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Format, 6));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Genre, 7));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Genre, 7));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Year, 8));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Year, 8));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_YearAlbum, 9));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::YearAlbum, 9));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_YearAlbumDisc, 10));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::YearAlbumDisc, 10));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_OriginalYear, 11));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::OriginalYear, 11));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_OriginalYearAlbum, 12));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::OriginalYearAlbum, 12));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Composer, 13));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Composer, 13));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Performer, 14));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Performer, 14));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Grouping, 15));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Grouping, 15));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_FileType, 16));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::FileType, 16));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Samplerate, 17));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Samplerate, 17));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Bitdepth, 18));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Bitdepth, 18));
-  p_->mapping_.insert(Mapping(CollectionModel::GroupBy_Bitrate, 19));
+  p_->mapping_.insert(Mapping(CollectionModel::GroupBy::Bitrate, 19));
 
   QObject::connect(ui_->buttonbox->button(QDialogButtonBox::Reset), &QPushButton::clicked, this, &GroupByDialog::Reset);
 

src/collection/savedgroupingmanager.cpp

@@ -83,68 +83,68 @@ QString SavedGroupingManager::GetSavedGroupingsSettingsGroup(const QString &sett
 QString SavedGroupingManager::GroupByToString(const CollectionModel::GroupBy g) {
 
   switch (g) {
-    case CollectionModel::GroupBy_None:
+    case CollectionModel::GroupBy::None:
-    case CollectionModel::GroupByCount: {
+    case CollectionModel::GroupBy::GroupByCount: {
       return tr("None");
     }
-    case CollectionModel::GroupBy_AlbumArtist: {
+    case CollectionModel::GroupBy::AlbumArtist: {
       return tr("Album artist");
     }
-    case CollectionModel::GroupBy_Artist: {
+    case CollectionModel::GroupBy::Artist: {
       return tr("Artist");
     }
-    case CollectionModel::GroupBy_Album: {
+    case CollectionModel::GroupBy::Album: {
       return tr("Album");
     }
-    case CollectionModel::GroupBy_AlbumDisc: {
+    case CollectionModel::GroupBy::AlbumDisc: {
       return tr("Album - Disc");
     }
-    case CollectionModel::GroupBy_YearAlbum: {
+    case CollectionModel::GroupBy::YearAlbum: {
       return tr("Year - Album");
     }
-    case CollectionModel::GroupBy_YearAlbumDisc: {
+    case CollectionModel::GroupBy::YearAlbumDisc: {
       return tr("Year - Album - Disc");
     }
-    case CollectionModel::GroupBy_OriginalYearAlbum: {
+    case CollectionModel::GroupBy::OriginalYearAlbum: {
       return tr("Original year - Album");
     }
-    case CollectionModel::GroupBy_OriginalYearAlbumDisc: {
+    case CollectionModel::GroupBy::OriginalYearAlbumDisc: {
       return tr("Original year - Album - Disc");
     }
-    case CollectionModel::GroupBy_Disc: {
+    case CollectionModel::GroupBy::Disc: {
       return tr("Disc");
     }
-    case CollectionModel::GroupBy_Year: {
+    case CollectionModel::GroupBy::Year: {
       return tr("Year");
     }
-    case CollectionModel::GroupBy_OriginalYear: {
+    case CollectionModel::GroupBy::OriginalYear: {
       return tr("Original year");
     }
-    case CollectionModel::GroupBy_Genre: {
+    case CollectionModel::GroupBy::Genre: {
       return tr("Genre");
     }
-    case CollectionModel::GroupBy_Composer: {
+    case CollectionModel::GroupBy::Composer: {
       return tr("Composer");
     }
-    case CollectionModel::GroupBy_Performer: {
+    case CollectionModel::GroupBy::Performer: {
       return tr("Performer");
     }
-    case CollectionModel::GroupBy_Grouping: {
+    case CollectionModel::GroupBy::Grouping: {
       return tr("Grouping");
     }
-    case CollectionModel::GroupBy_FileType: {
+    case CollectionModel::GroupBy::FileType: {
       return tr("File type");
     }
-    case CollectionModel::GroupBy_Format: {
+    case CollectionModel::GroupBy::Format: {
       return tr("Format");
     }
-    case CollectionModel::GroupBy_Samplerate: {
+    case CollectionModel::GroupBy::Samplerate: {
       return tr("Sample rate");
     }
-    case CollectionModel::GroupBy_Bitdepth: {
+    case CollectionModel::GroupBy::Bitdepth: {
       return tr("Bit depth");
     }
-    case CollectionModel::GroupBy_Bitrate: {
+    case CollectionModel::GroupBy::Bitrate: {
       return tr("Bitrate");
     }
   }

src/context/contextview.cpp

@@ -338,11 +338,11 @@ void ContextView::ReloadSettings() {
   s.beginGroup(ContextSettingsPage::kSettingsGroup);
   title_fmt_ = s.value(ContextSettingsPage::kSettingsTitleFmt, "%title% - %artist%").toString();
   summary_fmt_ = s.value(ContextSettingsPage::kSettingsSummaryFmt, "%album%").toString();
-  action_show_album_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::ALBUM], true).toBool());
+  action_show_album_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::ALBUM)], true).toBool());
-  action_show_data_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::TECHNICAL_DATA], false).toBool());
+  action_show_data_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::TECHNICAL_DATA)], false).toBool());
-  action_show_output_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::ENGINE_AND_DEVICE], false).toBool());
+  action_show_output_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::ENGINE_AND_DEVICE)], false).toBool());
-  action_show_lyrics_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::SONG_LYRICS], true).toBool());
+  action_show_lyrics_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::SONG_LYRICS)], true).toBool());
-  action_search_lyrics_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::SEARCH_LYRICS], true).toBool());
+  action_search_lyrics_->setChecked(s.value(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::SEARCH_LYRICS)], true).toBool());
   font_headline_ = s.value("font_headline", font().family()).toString();
   font_normal_ = s.value("font_normal", font().family()).toString();
   font_size_headline_ = s.value("font_size_headline", ContextSettingsPage::kDefaultFontSizeHeadline).toReal();
@@ -544,7 +544,7 @@ void ContextView::SetSong() {
 
   if (action_show_output_->isChecked()) {
     widget_play_output_->show();
-    Engine::EngineType enginetype(Engine::None);
+    Engine::EngineType enginetype(Engine::EngineType::None);
     if (app_->player()->engine()) enginetype = app_->player()->engine()->type();
     QIcon icon_engine = IconLoader::Load(EngineName(enginetype), true, 32);
 
@@ -739,7 +739,7 @@ void ContextView::ActionShowAlbum() {
 
   QSettings s;
   s.beginGroup(ContextSettingsPage::kSettingsGroup);
-  s.setValue(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::ALBUM], action_show_album_->isChecked());
+  s.setValue(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::ALBUM)], action_show_album_->isChecked());
   s.endGroup();
   if (song_playing_.is_valid()) SetSong();
 
@@ -749,7 +749,7 @@ void ContextView::ActionShowData() {
 
   QSettings s;
   s.beginGroup(ContextSettingsPage::kSettingsGroup);
-  s.setValue(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::TECHNICAL_DATA], action_show_data_->isChecked());
+  s.setValue(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::TECHNICAL_DATA)], action_show_data_->isChecked());
   s.endGroup();
   if (song_playing_.is_valid()) SetSong();
 
@@ -759,7 +759,7 @@ void ContextView::ActionShowOutput() {
 
   QSettings s;
   s.beginGroup(ContextSettingsPage::kSettingsGroup);
-  s.setValue(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::ENGINE_AND_DEVICE], action_show_output_->isChecked());
+  s.setValue(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::ENGINE_AND_DEVICE)], action_show_output_->isChecked());
   s.endGroup();
   if (song_playing_.is_valid()) SetSong();
 
@@ -769,7 +769,7 @@ void ContextView::ActionShowLyrics() {
 
   QSettings s;
   s.beginGroup(ContextSettingsPage::kSettingsGroup);
-  s.setValue(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::SONG_LYRICS], action_show_lyrics_->isChecked());
+  s.setValue(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::SONG_LYRICS)], action_show_lyrics_->isChecked());
   s.endGroup();
 
   if (song_playing_.is_valid()) SetSong();
@@ -782,7 +782,7 @@ void ContextView::ActionSearchLyrics() {
 
   QSettings s;
   s.beginGroup(ContextSettingsPage::kSettingsGroup);
-  s.setValue(ContextSettingsPage::kSettingsGroupEnable[ContextSettingsPage::ContextSettingsOrder::SEARCH_LYRICS], action_search_lyrics_->isChecked());
+  s.setValue(ContextSettingsPage::kSettingsGroupEnable[static_cast<int>(ContextSettingsPage::ContextSettingsOrder::SEARCH_LYRICS)], action_search_lyrics_->isChecked());
   s.endGroup();
 
   if (song_playing_.is_valid()) SetSong();

src/core/commandlineoptions.cpp

@@ -81,8 +81,8 @@ const char *CommandlineOptions::kVersionText = "Strawberry %1";
 CommandlineOptions::CommandlineOptions(int argc, char **argv)
     : argc_(argc),
       argv_(argv),
-      url_list_action_(UrlList_None),
+      url_list_action_(UrlListAction::None),
-      player_action_(Player_None),
+      player_action_(PlayerAction::None),
       set_volume_(-1),
       volume_modifier_(0),
       seek_to_(-1),
@@ -128,13 +128,13 @@ bool CommandlineOptions::Parse() {
       {"previous", no_argument, nullptr, 'r'},
       {"next", no_argument, nullptr, 'f'},
       {"volume", required_argument, nullptr, 'v'},
-      {"volume-up", no_argument, nullptr, VolumeUp},
+      {"volume-up", no_argument, nullptr, LongOptions::VolumeUp},
-      {"volume-down", no_argument, nullptr, VolumeDown},
+      {"volume-down", no_argument, nullptr, LongOptions::VolumeDown},
-      {"volume-increase-by", required_argument, nullptr, VolumeIncreaseBy},
+      {"volume-increase-by", required_argument, nullptr, LongOptions::VolumeIncreaseBy},
-      {"volume-decrease-by", required_argument, nullptr, VolumeDecreaseBy},
+      {"volume-decrease-by", required_argument, nullptr, LongOptions::VolumeDecreaseBy},
-      {"seek-to", required_argument, nullptr, SeekTo},
+      {"seek-to", required_argument, nullptr, LongOptions::SeekTo},
-      {"seek-by", required_argument, nullptr, SeekBy},
+      {"seek-by", required_argument, nullptr, LongOptions::SeekBy},
-      {"restart-or-previous", no_argument, nullptr, RestartOrPrevious},
+      {"restart-or-previous", no_argument, nullptr, LongOptions::RestartOrPrevious},
       {"create", required_argument, nullptr, 'c'},
       {"append", no_argument, nullptr, 'a'},
       {"load", no_argument, nullptr, 'l'},
@@ -144,10 +144,10 @@ bool CommandlineOptions::Parse() {
       {"toggle-pretty-osd", no_argument, nullptr, 'y'},
       {"language", required_argument, nullptr, 'g'},
       {"resize-window", required_argument, nullptr, 'w'},
-      {"quiet", no_argument, nullptr, Quiet},
+      {"quiet", no_argument, nullptr, LongOptions::Quiet},
-      {"verbose", no_argument, nullptr, Verbose},
+      {"verbose", no_argument, nullptr, LongOptions::Verbose},
-      {"log-levels", required_argument, nullptr, LogLevels},
+      {"log-levels", required_argument, nullptr, LongOptions::LogLevels},
-      {"version", no_argument, nullptr, Version},
+      {"version", no_argument, nullptr, LongOptions::Version},
       {nullptr, 0, nullptr, 0}};
 
   // Parse the arguments
@@ -198,39 +198,39 @@ bool CommandlineOptions::Parse() {
       }
 
       case 'p':
-        player_action_ = Player_Play;
+        player_action_ = PlayerAction::Play;
         break;
       case 't':
-        player_action_ = Player_PlayPause;
+        player_action_ = PlayerAction::PlayPause;
         break;
       case 'u':
-        player_action_ = Player_Pause;
+        player_action_ = PlayerAction::Pause;
         break;
       case 's':
-        player_action_ = Player_Stop;
+        player_action_ = PlayerAction::Stop;
         break;
       case 'q':
-        player_action_ = Player_StopAfterCurrent;
+        player_action_ = PlayerAction::StopAfterCurrent;
         break;
       case 'r':
-        player_action_ = Player_Previous;
+        player_action_ = PlayerAction::Previous;
         break;
       case 'f':
-        player_action_ = Player_Next;
+        player_action_ = PlayerAction::Next;
         break;
       case 'i':
-        player_action_ = Player_PlayPlaylist;
+        player_action_ = PlayerAction::PlayPlaylist;
         playlist_name_ = QString(optarg);
         break;
       case 'c':
-        url_list_action_ = UrlList_CreateNew;
+        url_list_action_ = UrlListAction::CreateNew;
         playlist_name_ = QString(optarg);
         break;
       case 'a':
-        url_list_action_ = UrlList_Append;
+        url_list_action_ = UrlListAction::Append;
         break;
       case 'l':
-        url_list_action_ = UrlList_Load;
+        url_list_action_ = UrlListAction::Load;
         break;
       case 'o':
         show_osd_ = true;
@@ -241,22 +241,22 @@ bool CommandlineOptions::Parse() {
       case 'g':
         language_ = QString(optarg);
         break;
-      case VolumeUp:
+      case LongOptions::VolumeUp:
         volume_modifier_ = +4;
         break;
-      case VolumeDown:
+      case LongOptions::VolumeDown:
         volume_modifier_ = -4;
         break;
-      case Quiet:
+      case LongOptions::Quiet:
         log_levels_ = "1";
         break;
-      case Verbose:
+      case LongOptions::Verbose:
         log_levels_ = "3";
         break;
-      case LogLevels:
+      case LongOptions::LogLevels:
         log_levels_ = QString(optarg);
         break;
-      case Version: {
+      case LongOptions::Version: {
         QString version_text = QString(kVersionText).arg(STRAWBERRY_VERSION_DISPLAY);
         std::cout << version_text.toLocal8Bit().constData() << std::endl;
         std::exit(0);
@@ -266,28 +266,28 @@ bool CommandlineOptions::Parse() {
         if (!ok) set_volume_ = -1;
         break;
 
-      case VolumeIncreaseBy:
+      case LongOptions::VolumeIncreaseBy:
         volume_modifier_ = QString(optarg).toInt(&ok);
         if (!ok) volume_modifier_ = 0;
         break;
 
-      case VolumeDecreaseBy:
+      case LongOptions::VolumeDecreaseBy:
         volume_modifier_ = -QString(optarg).toInt(&ok);
         if (!ok) volume_modifier_ = 0;
         break;
 
-      case SeekTo:
+      case LongOptions::SeekTo:
         seek_to_ = QString(optarg).toInt(&ok);
         if (!ok) seek_to_ = -1;
         break;
 
-      case SeekBy:
+      case LongOptions::SeekBy:
         seek_by_ = QString(optarg).toInt(&ok);
         if (!ok) seek_by_ = 0;
         break;
 
-      case RestartOrPrevious:
+      case LongOptions::RestartOrPrevious:
-        player_action_ = Player_RestartOrPrevious;
+        player_action_ = PlayerAction::RestartOrPrevious;
         break;
 
       case 'k':
@@ -297,7 +297,7 @@ bool CommandlineOptions::Parse() {
 
       case 'w':
         window_size_ = QString(optarg);
-        player_action_ = Player_ResizeWindow;
+        player_action_ = PlayerAction::ResizeWindow;
         break;
 
       case '?':
@@ -323,7 +323,7 @@ bool CommandlineOptions::Parse() {
 }
 
 bool CommandlineOptions::is_empty() const {
-  return player_action_ == Player_None &&
+  return player_action_ == PlayerAction::None &&
          set_volume_ == -1 &&
          volume_modifier_ == 0 &&
          seek_to_ == -1 &&
@@ -335,7 +335,7 @@ bool CommandlineOptions::is_empty() const {
 }
 
 bool CommandlineOptions::contains_play_options() const {
-  return player_action_ != Player_None || play_track_at_ != -1 || !urls_.isEmpty();
+  return player_action_ != PlayerAction::None || play_track_at_ != -1 || !urls_.isEmpty();
 }
 
 QByteArray CommandlineOptions::Serialize() const {

src/core/commandlineoptions.h

@@ -41,24 +41,24 @@ class CommandlineOptions {
 
   // Don't change the values or order, these get serialised and sent to
   // possibly a different version of Strawberry
-  enum UrlListAction {
+  enum class UrlListAction {
-    UrlList_Append = 0,
+    Append = 0,
-    UrlList_Load = 1,
+    Load = 1,
-    UrlList_None = 2,
+    None = 2,
-    UrlList_CreateNew = 3,
+    CreateNew = 3
   };
-  enum PlayerAction {
+  enum class PlayerAction {
-    Player_None = 0,
+    None = 0,
-    Player_Play = 1,
+    Play = 1,
-    Player_PlayPause = 2,
+    PlayPause = 2,
-    Player_Pause = 3,
+    Pause = 3,
-    Player_Stop = 4,
+    Stop = 4,
-    Player_Previous = 5,
+    Previous = 5,
-    Player_Next = 6,
+    Next = 6,
-    Player_RestartOrPrevious = 7,
+    RestartOrPrevious = 7,
-    Player_StopAfterCurrent = 8,
+    StopAfterCurrent = 8,
-    Player_PlayPlaylist = 9,
+    PlayPlaylist = 9,
-    Player_ResizeWindow = 10
+    ResizeWindow = 10
   };
 
   bool Parse();

src/core/mainwindow.cpp

@@ -293,13 +293,13 @@ MainWindow::MainWindow(Application *app, std::shared_ptr<SystemTrayIcon> tray_ic
       }),
       smartplaylists_view_(new SmartPlaylistsViewContainer(app, this)),
 #ifdef HAVE_SUBSONIC
-      subsonic_view_(new InternetSongsView(app_, app->internet_services()->ServiceBySource(Song::Source_Subsonic), SubsonicSettingsPage::kSettingsGroup, SettingsDialog::Page_Subsonic, this)),
+      subsonic_view_(new InternetSongsView(app_, app->internet_services()->ServiceBySource(Song::Source::Subsonic), SubsonicSettingsPage::kSettingsGroup, SettingsDialog::Page::Subsonic, this)),
 #endif
 #ifdef HAVE_TIDAL
-      tidal_view_(new InternetTabsView(app_, app->internet_services()->ServiceBySource(Song::Source_Tidal), TidalSettingsPage::kSettingsGroup, SettingsDialog::Page_Tidal, this)),
+      tidal_view_(new InternetTabsView(app_, app->internet_services()->ServiceBySource(Song::Source::Tidal), TidalSettingsPage::kSettingsGroup, SettingsDialog::Page::Tidal, this)),
 #endif
 #ifdef HAVE_QOBUZ
-      qobuz_view_(new InternetTabsView(app_, app->internet_services()->ServiceBySource(Song::Source_Qobuz), QobuzSettingsPage::kSettingsGroup, SettingsDialog::Page_Qobuz, this)),
+      qobuz_view_(new InternetTabsView(app_, app->internet_services()->ServiceBySource(Song::Source::Qobuz), QobuzSettingsPage::kSettingsGroup, SettingsDialog::Page::Qobuz, this)),
 #endif
       radio_view_(new RadioViewContainer(this)),
       lastfm_import_dialog_(new LastFMImportDialog(app_->lastfm_import(), this)),
@@ -331,10 +331,10 @@ MainWindow::MainWindow(Application *app, std::shared_ptr<SystemTrayIcon> tray_ic
       track_slider_timer_(new QTimer(this)),
       keep_running_(false),
       playing_widget_(true),
-      doubleclick_addmode_(BehaviourSettingsPage::AddBehaviour_Append),
+      doubleclick_addmode_(BehaviourSettingsPage::AddBehaviour::Append),
-      doubleclick_playmode_(BehaviourSettingsPage::PlayBehaviour_Never),
+      doubleclick_playmode_(BehaviourSettingsPage::PlayBehaviour::Never),
-      doubleclick_playlist_addmode_(BehaviourSettingsPage::PlaylistAddBehaviour_Play),
+      doubleclick_playlist_addmode_(BehaviourSettingsPage::PlaylistAddBehaviour::Play),
-      menu_playmode_(BehaviourSettingsPage::PlayBehaviour_Never),
+      menu_playmode_(BehaviourSettingsPage::PlayBehaviour::Never),
       initialized_(false),
       was_maximized_(true),
       was_minimized_(false),
@@ -700,7 +700,7 @@ MainWindow::MainWindow(Application *app, std::shared_ptr<SystemTrayIcon> tray_ic
   QObject::connect(tidal_view_->albums_collection_view(), &InternetCollectionView::AddToPlaylistSignal, this, &MainWindow::AddToPlaylist);
   QObject::connect(tidal_view_->songs_collection_view(), &InternetCollectionView::AddToPlaylistSignal, this, &MainWindow::AddToPlaylist);
   QObject::connect(tidal_view_->search_view(), &InternetSearchView::AddToPlaylist, this, &MainWindow::AddToPlaylist);
-  if (TidalService *tidalservice = qobject_cast<TidalService*>(app_->internet_services()->ServiceBySource(Song::Source_Tidal))) {
+  if (TidalService *tidalservice = qobject_cast<TidalService*>(app_->internet_services()->ServiceBySource(Song::Source::Tidal))) {
     QObject::connect(this, &MainWindow::AuthorizationUrlReceived, tidalservice, &TidalService::AuthorizationUrlReceived);
   }
 #endif
@@ -920,10 +920,9 @@ MainWindow::MainWindow(Application *app, std::shared_ptr<SystemTrayIcon> tray_ic
   }
 
   ui_->tabs->setCurrentIndex(settings_.value("current_tab", 1).toInt());
-  FancyTabWidget::Mode default_mode = FancyTabWidget::Mode_LargeSidebar;
+  FancyTabWidget::Mode default_mode = FancyTabWidget::Mode::LargeSidebar;
-  int tab_mode_int = settings_.value("tab_mode", default_mode).toInt();
+  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>(tab_mode_int);
+  if (tab_mode == FancyTabWidget::Mode::None) tab_mode = default_mode;
-  if (tab_mode == FancyTabWidget::Mode_None) tab_mode = default_mode;
   ui_->tabs->SetMode(tab_mode);
 
   TabSwitched();
@@ -946,26 +945,26 @@ MainWindow::MainWindow(Application *app, std::shared_ptr<SystemTrayIcon> tray_ic
 #else
   QSettings s;
   s.beginGroup(BehaviourSettingsPage::kSettingsGroup);
-  BehaviourSettingsPage::StartupBehaviour behaviour = BehaviourSettingsPage::StartupBehaviour(s.value("startupbehaviour", BehaviourSettingsPage::Startup_Remember).toInt());
+  const BehaviourSettingsPage::StartupBehaviour startupbehaviour = static_cast<BehaviourSettingsPage::StartupBehaviour>(s.value("startupbehaviour", static_cast<int>(BehaviourSettingsPage::StartupBehaviour::Remember)).toInt());
   s.endGroup();
-  switch (behaviour) {
+  switch (startupbehaviour) {
-    case BehaviourSettingsPage::Startup_Show:
+    case BehaviourSettingsPage::StartupBehaviour::Show:
       show();
       break;
-    case BehaviourSettingsPage::Startup_ShowMaximized:
+    case BehaviourSettingsPage::StartupBehaviour::ShowMaximized:
       setWindowState(windowState() | Qt::WindowMaximized);
       show();
       break;
-    case BehaviourSettingsPage::Startup_ShowMinimized:
+    case BehaviourSettingsPage::StartupBehaviour::ShowMinimized:
       setWindowState(windowState() | Qt::WindowMinimized);
       show();
       break;
-    case BehaviourSettingsPage::Startup_Hide:
+    case BehaviourSettingsPage::StartupBehaviour::Hide:
       if (tray_icon_->IsSystemTrayAvailable() && tray_icon_->isVisible()) {
         break;
       }
       [[fallthrough]];
-    case BehaviourSettingsPage::Startup_Remember:
+    case BehaviourSettingsPage::StartupBehaviour::Remember:
     default: {
 
       was_maximized_ = settings_.value("maximized", true).toBool();
@@ -1067,10 +1066,10 @@ void MainWindow::ReloadSettings() {
   playing_widget_ = s.value("playing_widget", true).toBool();
   bool trayicon_progress = s.value("trayicon_progress", false).toBool();
   if (playing_widget_ != ui_->widget_playing->IsEnabled()) TabSwitched();
-  doubleclick_addmode_ = BehaviourSettingsPage::AddBehaviour(s.value("doubleclick_addmode", BehaviourSettingsPage::AddBehaviour_Append).toInt());
+  doubleclick_addmode_ = static_cast<BehaviourSettingsPage::AddBehaviour>(s.value("doubleclick_addmode", static_cast<int>(BehaviourSettingsPage::AddBehaviour::Append)).toInt());
-  doubleclick_playmode_ = BehaviourSettingsPage::PlayBehaviour(s.value("doubleclick_playmode", BehaviourSettingsPage::PlayBehaviour_Never).toInt());
+  doubleclick_playmode_ = static_cast<BehaviourSettingsPage::PlayBehaviour>(s.value("doubleclick_playmode", static_cast<int>(BehaviourSettingsPage::PlayBehaviour::Never)).toInt());
-  doubleclick_playlist_addmode_ = BehaviourSettingsPage::PlaylistAddBehaviour(s.value("doubleclick_playlist_addmode", BehaviourSettingsPage::PlayBehaviour_Never).toInt());
+  doubleclick_playlist_addmode_ = static_cast<BehaviourSettingsPage::PlaylistAddBehaviour>(s.value("doubleclick_playlist_addmode", static_cast<int>(BehaviourSettingsPage::PlayBehaviour::Never)).toInt());
-  menu_playmode_ = BehaviourSettingsPage::PlayBehaviour(s.value("menu_playmode", BehaviourSettingsPage::PlayBehaviour_Never).toInt());
+  menu_playmode_ = static_cast<BehaviourSettingsPage::PlayBehaviour>(s.value("menu_playmode", static_cast<int>(BehaviourSettingsPage::PlayBehaviour::Never)).toInt());
   s.endGroup();
 
   s.beginGroup(AppearanceSettingsPage::kSettingsGroup);
@@ -1224,7 +1223,7 @@ void MainWindow::Exit() {
     if (app_->player()->engine()->is_fadeout_enabled()) {
       // To shut down the application when fadeout will be finished
       QObject::connect(app_->player()->engine(), &EngineBase::FadeoutFinishedSignal, this, &MainWindow::DoExit);
-      if (app_->player()->GetState() == Engine::Playing) {
+      if (app_->player()->GetState() == Engine::State::Playing) {
         app_->player()->Stop();
         ignore_close_ = true;
         close();
@@ -1322,8 +1321,8 @@ void MainWindow::MediaPlaying() {
 
   PlaylistItemPtr item(app_->player()->GetCurrentItem());
   if (item) {
-    enable_play_pause = !(item->options() & PlaylistItem::PauseDisabled);
+    enable_play_pause = !(item->options() & PlaylistItem::Option::PauseDisabled);
-    can_seek = !(item->options() & PlaylistItem::SeekDisabled);
+    can_seek = !(item->options() & PlaylistItem::Option::SeekDisabled);
   }
   ui_->action_play_pause->setEnabled(enable_play_pause);
   ui_->track_slider->SetCanSeek(can_seek);
@@ -1437,8 +1436,8 @@ void MainWindow::SavePlaybackStatus() {
   QSettings s;
 
   s.beginGroup(Player::kSettingsGroup);
-  s.setValue("playback_state", app_->player()->GetState());
+  s.setValue("playback_state", static_cast<int>(app_->player()->GetState()));
-  if (app_->player()->GetState() == Engine::Playing || app_->player()->GetState() == Engine::Paused) {
+  if (app_->player()->GetState() == Engine::State::Playing || app_->player()->GetState() == Engine::State::Paused) {
     s.setValue("playback_playlist", app_->playlist_manager()->active()->id());
     s.setValue("playback_position", app_->player()->engine()->position_nanosec() / kNsecPerSec);
   }
@@ -1456,14 +1455,14 @@ void MainWindow::LoadPlaybackStatus() {
   QSettings s;
 
   s.beginGroup(BehaviourSettingsPage::kSettingsGroup);
-  bool resume_playback = s.value("resumeplayback", false).toBool();
+  const bool resume_playback = s.value("resumeplayback", false).toBool();
   s.endGroup();
 
   s.beginGroup(Player::kSettingsGroup);
-  Engine::State playback_state = static_cast<Engine::State>(s.value("playback_state", Engine::Empty).toInt());
+  const Engine::State playback_state = static_cast<Engine::State>(s.value("playback_state", static_cast<int>(Engine::State::Empty)).toInt());
   s.endGroup();
 
-  if (resume_playback && playback_state != Engine::Empty && playback_state != Engine::Idle) {
+  if (resume_playback && playback_state != Engine::State::Empty && playback_state != Engine::State::Idle) {
     std::shared_ptr<QMetaObject::Connection> connection = std::make_shared<QMetaObject::Connection>();
     *connection = QObject::connect(app_->playlist_manager(), &PlaylistManager::AllPlaylistsLoaded, this, [this, connection]() {
       QObject::disconnect(*connection);
@@ -1479,7 +1478,7 @@ void MainWindow::ResumePlayback() {
 
   QSettings s;
   s.beginGroup(Player::kSettingsGroup);
-  Engine::State playback_state = static_cast<Engine::State>(s.value("playback_state", Engine::Empty).toInt());
+  const Engine::State playback_state = static_cast<Engine::State>(s.value("playback_state", static_cast<int>(Engine::State::Empty)).toInt());
   int playback_playlist = s.value("playback_playlist", -1).toInt();
   int playback_position = s.value("playback_position", 0).toInt();
   s.endGroup();
@@ -1487,7 +1486,7 @@ void MainWindow::ResumePlayback() {
   if (playback_playlist == app_->playlist_manager()->current()->id()) {
     // Set active to current to resume playback on correct playlist.
     app_->playlist_manager()->SetActiveToCurrent();
-    if (playback_state == Engine::Paused) {
+    if (playback_state == Engine::State::Paused) {
       std::shared_ptr<QMetaObject::Connection> connection = std::make_shared<QMetaObject::Connection>();
       *connection = QObject::connect(app_->player(), &Player::Playing, app_->player(), [this, connection]() {
         QObject::disconnect(*connection);
@@ -1499,7 +1498,7 @@ void MainWindow::ResumePlayback() {
 
   // Reset saved playback status so we don't resume again from the same position.
   s.beginGroup(Player::kSettingsGroup);
-  s.setValue("playback_state", Engine::Empty);
+  s.setValue("playback_state", static_cast<int>(Engine::State::Empty));
   s.setValue("playback_playlist", -1);
   s.setValue("playback_position", 0);
   s.endGroup();
@@ -1517,7 +1516,7 @@ void MainWindow::PlayIndex(const QModelIndex &idx, Playlist::AutoScroll autoscro
   }
 
   app_->playlist_manager()->SetActiveToCurrent();
-  app_->player()->PlayAt(row, 0, Engine::Manual, autoscroll, true);
+  app_->player()->PlayAt(row, 0, Engine::TrackChangeType::Manual, autoscroll, true);
 
 }
 
@@ -1532,16 +1531,16 @@ void MainWindow::PlaylistDoubleClick(const QModelIndex &idx) {
   }
 
   switch (doubleclick_playlist_addmode_) {
-    case BehaviourSettingsPage::PlaylistAddBehaviour_Play:
+    case BehaviourSettingsPage::PlaylistAddBehaviour::Play:
       app_->playlist_manager()->SetActiveToCurrent();
-      app_->player()->PlayAt(source_idx.row(), 0, Engine::Manual, Playlist::AutoScroll_Never, true, true);
+      app_->player()->PlayAt(source_idx.row(), 0, Engine::TrackChangeType::Manual, Playlist::AutoScroll::Never, true, true);
       break;
 
-    case BehaviourSettingsPage::PlaylistAddBehaviour_Enqueue:
+    case BehaviourSettingsPage::PlaylistAddBehaviour::Enqueue:
       app_->playlist_manager()->current()->queue()->ToggleTracks(QModelIndexList() << source_idx);
-      if (app_->player()->GetState() != Engine::Playing) {
+      if (app_->player()->GetState() != Engine::State::Playing) {
         app_->playlist_manager()->SetActiveToCurrent();
-        app_->player()->PlayAt(app_->playlist_manager()->current()->queue()->TakeNext(), 0, Engine::Manual, Playlist::AutoScroll_Never, true);
+        app_->player()->PlayAt(app_->playlist_manager()->current()->queue()->TakeNext(), 0, Engine::TrackChangeType::Manual, Playlist::AutoScroll::Never, true);
       }
       break;
   }
@@ -1694,22 +1693,22 @@ void MainWindow::UpdateTrackSliderPosition() {
 void MainWindow::ApplyAddBehaviour(const BehaviourSettingsPage::AddBehaviour b, MimeData *mimedata) {
 
   switch (b) {
-    case BehaviourSettingsPage::AddBehaviour_Append:
+    case BehaviourSettingsPage::AddBehaviour::Append:
       mimedata->clear_first_ = false;
       mimedata->enqueue_now_ = false;
       break;
 
-    case BehaviourSettingsPage::AddBehaviour_Enqueue:
+    case BehaviourSettingsPage::AddBehaviour::Enqueue:
       mimedata->clear_first_ = false;
       mimedata->enqueue_now_ = true;
       break;
 
-    case BehaviourSettingsPage::AddBehaviour_Load:
+    case BehaviourSettingsPage::AddBehaviour::Load:
       mimedata->clear_first_ = true;
       mimedata->enqueue_now_ = false;
       break;
 
-    case BehaviourSettingsPage::AddBehaviour_OpenInNew:
+    case BehaviourSettingsPage::AddBehaviour::OpenInNew:
       mimedata->open_in_new_playlist_ = true;
       break;
   }
@@ -1718,16 +1717,16 @@ void MainWindow::ApplyAddBehaviour(const BehaviourSettingsPage::AddBehaviour b,
 void MainWindow::ApplyPlayBehaviour(const BehaviourSettingsPage::PlayBehaviour b, MimeData *mimedata) const {
 
   switch (b) {
-    case BehaviourSettingsPage::PlayBehaviour_Always:
+    case BehaviourSettingsPage::PlayBehaviour::Always:
       mimedata->play_now_ = true;
       break;
 
-    case BehaviourSettingsPage::PlayBehaviour_Never:
+    case BehaviourSettingsPage::PlayBehaviour::Never:
       mimedata->play_now_ = false;
       break;
 
-    case BehaviourSettingsPage::PlayBehaviour_IfStopped:
+    case BehaviourSettingsPage::PlayBehaviour::IfStopped:
-      mimedata->play_now_ = !(app_->player()->GetState() == Engine::Playing);
+      mimedata->play_now_ = !(app_->player()->GetState() == Engine::State::Playing);
       break;
   }
 }
@@ -1762,7 +1761,7 @@ void MainWindow::AddToPlaylist(QMimeData *q_mimedata) {
 void MainWindow::AddToPlaylistFromAction(QAction *action) {
 
   const int destination = action->data().toInt();
-  PlaylistItemList items;
+  PlaylistItemPtrList items;
   SongList songs;
 
   // Get the selected playlist items
@@ -1813,7 +1812,7 @@ void MainWindow::PlaylistRightClick(const QPoint global_pos, const QModelIndex &
   playlist_menu_index_ = source_index;
 
   // Is this song currently playing?
-  if (app_->playlist_manager()->current()->current_row() == source_index.row() && app_->player()->GetState() == Engine::Playing) {
+  if (app_->playlist_manager()->current()->current_row() == source_index.row() && app_->player()->GetState() == Engine::State::Playing) {
     playlist_play_pause_->setText(tr("Pause"));
     playlist_play_pause_->setIcon(IconLoader::Load("media-playback-pause"));
   }
@@ -1824,7 +1823,7 @@ void MainWindow::PlaylistRightClick(const QPoint global_pos, const QModelIndex &
 
   // Are we allowed to pause?
   if (source_index.isValid()) {
-    playlist_play_pause_->setEnabled(app_->playlist_manager()->current()->current_row() != source_index.row() || !(app_->playlist_manager()->current()->item_at(source_index.row())->options() & PlaylistItem::PauseDisabled));
+    playlist_play_pause_->setEnabled(app_->playlist_manager()->current()->current_row() != source_index.row() || !(app_->playlist_manager()->current()->item_at(source_index.row())->options() & PlaylistItem::Option::PauseDisabled));
   }
   else {
     playlist_play_pause_->setEnabled(false);
@@ -1853,7 +1852,7 @@ void MainWindow::PlaylistRightClick(const QPoint global_pos, const QModelIndex &
     if (!item) continue;
 
     if (item->Metadata().url().isLocalFile()) ++local_songs;
-    if (item->Metadata().source() == Song::Source_Collection) ++collection_songs;
+    if (item->Metadata().source() == Song::Source::Collection) ++collection_songs;
 
     if (item->Metadata().has_cue()) {
       cue_selected = true;
@@ -2033,10 +2032,10 @@ void MainWindow::PlaylistRightClick(const QPoint global_pos, const QModelIndex &
 void MainWindow::PlaylistPlay() {
 
   if (app_->playlist_manager()->current()->current_row() == playlist_menu_index_.row()) {
-    app_->player()->PlayPause(Playlist::AutoScroll_Never);
+    app_->player()->PlayPause(0, Playlist::AutoScroll::Never);
   }
   else {
-    PlayIndex(playlist_menu_index_, Playlist::AutoScroll_Never);
+    PlayIndex(playlist_menu_index_, Playlist::AutoScroll::Never);
   }
 
 }
@@ -2057,7 +2056,7 @@ void MainWindow::RescanSongs() {
     if (item->IsLocalCollectionItem()) {
       songs << item->Metadata();
     }
-    else if (item->Metadata().source() == Song::Source_LocalFile) {
+    else if (item->Metadata().source() == Song::Source::LocalFile) {
       QPersistentModelIndex persistent_index = QPersistentModelIndex(source_index);
       app_->playlist_manager()->current()->ItemReload(persistent_index, item->OriginalMetadata(), false);
     }
@@ -2072,7 +2071,7 @@ void MainWindow::RescanSongs() {
 void MainWindow::EditTracks() {
 
   SongList songs;
-  PlaylistItemList items;
+  PlaylistItemPtrList items;
 
   for (const QModelIndex &proxy_index : ui_->playlist->view()->selectionModel()->selectedRows()) {
     const QModelIndex source_index = app_->playlist_manager()->current()->filter()->mapToSource(proxy_index);
@@ -2164,7 +2163,7 @@ void MainWindow::SelectionSetValue() {
       QPersistentModelIndex persistent_index = QPersistentModelIndex(source_index);
       QObject::connect(reply, &TagReaderReply::Finished, this, [this, reply, persistent_index]() { SongSaveComplete(reply, persistent_index); }, Qt::QueuedConnection);
     }
-    else if (song.source() == Song::Source_Stream) {
+    else if (song.source() == Song::Source::Stream) {
       app_->playlist_manager()->current()->setData(source_index, column_value, 0);
     }
   }
@@ -2199,7 +2198,7 @@ void MainWindow::AddFile() {
   PlaylistParser parser(app_->collection_backend());
 
   // Show dialog
-  QStringList file_names = QFileDialog::getOpenFileNames(this, tr("Add file"), directory, QString("%1 (%2);;%3;;%4").arg(tr("Music"), FileView::kFileFilter, parser.filters(PlaylistParser::Type_Load), tr(kAllFilesFilterSpec)));
+  QStringList file_names = QFileDialog::getOpenFileNames(this, tr("Add file"), directory, QString("%1 (%2);;%3;;%4").arg(tr("Music"), FileView::kFileFilter, parser.filters(PlaylistParser::Type::Load), tr(kAllFilesFilterSpec)));
 
   if (file_names.isEmpty()) return;
 
@@ -2335,30 +2334,30 @@ void MainWindow::CommandlineOptionsReceived(const quint32 instanceId, const QByt
 void MainWindow::CommandlineOptionsReceived(const CommandlineOptions &options) {
 
   switch (options.player_action()) {
-    case CommandlineOptions::Player_Play:
+    case CommandlineOptions::PlayerAction::Play:
       if (options.urls().empty()) {
         app_->player()->Play();
       }
       break;
-    case CommandlineOptions::Player_PlayPause:
+    case CommandlineOptions::PlayerAction::PlayPause:
-      app_->player()->PlayPause(Playlist::AutoScroll_Maybe);
+      app_->player()->PlayPause(0, Playlist::AutoScroll::Maybe);
       break;
-    case CommandlineOptions::Player_Pause:
+    case CommandlineOptions::PlayerAction::Pause:
       app_->player()->Pause();
       break;
-    case CommandlineOptions::Player_Stop:
+    case CommandlineOptions::PlayerAction::Stop:
       app_->player()->Stop();
       break;
-    case CommandlineOptions::Player_StopAfterCurrent:
+    case CommandlineOptions::PlayerAction::StopAfterCurrent:
       app_->player()->StopAfterCurrent();
       break;
-    case CommandlineOptions::Player_Previous:
+    case CommandlineOptions::PlayerAction::Previous:
       app_->player()->Previous();
       break;
-    case CommandlineOptions::Player_Next:
+    case CommandlineOptions::PlayerAction::Next:
       app_->player()->Next();
       break;
-    case CommandlineOptions::Player_PlayPlaylist:
+    case CommandlineOptions::PlayerAction::PlayPlaylist:
       if (options.playlist_name().isEmpty()) {
         qLog(Error) << "ERROR: playlist name missing";
       }
@@ -2366,11 +2365,11 @@ void MainWindow::CommandlineOptionsReceived(const CommandlineOptions &options) {
         app_->player()->PlayPlaylist(options.playlist_name());
       }
       break;
-    case CommandlineOptions::Player_RestartOrPrevious:
+    case CommandlineOptions::PlayerAction::RestartOrPrevious:
       app_->player()->RestartOrPrevious();
       break;
 
-    case CommandlineOptions::Player_ResizeWindow:{
+    case CommandlineOptions::PlayerAction::ResizeWindow:{
       if (options.window_size().contains('x') && options.window_size().length() >= 4) {
         QString str_w = options.window_size().left(options.window_size().indexOf('x'));
         QString str_h = options.window_size().right(options.window_size().length() - options.window_size().indexOf('x') - 1);
@@ -2407,7 +2406,7 @@ void MainWindow::CommandlineOptionsReceived(const CommandlineOptions &options) {
       break;
     }
 
-    case CommandlineOptions::Player_None:
+    case CommandlineOptions::PlayerAction::None:
       break;
 
   }
@@ -2427,22 +2426,22 @@ void MainWindow::CommandlineOptionsReceived(const CommandlineOptions &options) {
     // Behaviour depends on command line options, so set it here
     mimedata->override_user_settings_ = true;
 
-    if (options.player_action() == CommandlineOptions::Player_Play) mimedata->play_now_ = true;
+    if (options.player_action() == CommandlineOptions::PlayerAction::Play) mimedata->play_now_ = true;
     else ApplyPlayBehaviour(doubleclick_playmode_, mimedata);
 
     switch (options.url_list_action()) {
-      case CommandlineOptions::UrlList_Load:
+      case CommandlineOptions::UrlListAction::Load:
         mimedata->clear_first_ = true;
         break;
-      case CommandlineOptions::UrlList_Append:
+      case CommandlineOptions::UrlListAction::Append:
         // Nothing to do
         break;
-      case CommandlineOptions::UrlList_None:
+      case CommandlineOptions::UrlListAction::None:
         ApplyAddBehaviour(doubleclick_addmode_, mimedata);
         break;
-      case CommandlineOptions::UrlList_CreateNew:
+      case CommandlineOptions::UrlListAction::CreateNew:
         mimedata->name_for_new_playlist_ = options.playlist_name();
-        ApplyAddBehaviour(BehaviourSettingsPage::AddBehaviour_OpenInNew, mimedata);
+        ApplyAddBehaviour(BehaviourSettingsPage::AddBehaviour::OpenInNew, mimedata);
         break;
     }
 
@@ -2462,7 +2461,7 @@ void MainWindow::CommandlineOptionsReceived(const CommandlineOptions &options) {
     app_->player()->SeekTo(app_->player()->engine()->position_nanosec() / kNsecPerSec + options.seek_by());
   }
 
-  if (options.play_track_at() != -1) app_->player()->PlayAt(options.play_track_at(), 0, Engine::Manual, Playlist::AutoScroll_Maybe, true);
+  if (options.play_track_at() != -1) app_->player()->PlayAt(options.play_track_at(), 0, Engine::TrackChangeType::Manual, Playlist::AutoScroll::Maybe, true);
 
   if (options.show_osd()) app_->player()->ShowOSD();
 
@@ -2540,7 +2539,7 @@ void MainWindow::AddFilesToTranscoder() {
 }
 
 void MainWindow::ShowCollectionConfig() {
-  settings_dialog_->OpenAtPage(SettingsDialog::Page_Collection);
+  settings_dialog_->OpenAtPage(SettingsDialog::Page::Collection);
 }
 
 void MainWindow::TaskCountChanged(const int count) {
@@ -2610,7 +2609,7 @@ void MainWindow::EditFileTags(const QList<QUrl> &urls) {
     Song song;
     song.set_url(url);
     song.set_valid(true);
-    song.set_filetype(Song::FileType_MPEG);
+    song.set_filetype(Song::FileType::MPEG);
     songs << song;
   }
 
@@ -2755,13 +2754,13 @@ void MainWindow::PlaylistCopyToDevice() {
 void MainWindow::ChangeCollectionFilterMode(QAction *action) {
 
   if (action == collection_show_duplicates_) {
-    collection_view_->filter_widget()->SetFilterMode(CollectionFilterOptions::FilterMode_Duplicates);
+    collection_view_->filter_widget()->SetFilterMode(CollectionFilterOptions::FilterMode::Duplicates);
   }
   else if (action == collection_show_untagged_) {
-    collection_view_->filter_widget()->SetFilterMode(CollectionFilterOptions::FilterMode_Untagged);
+    collection_view_->filter_widget()->SetFilterMode(CollectionFilterOptions::FilterMode::Untagged);
   }
   else {
-    collection_view_->filter_widget()->SetFilterMode(CollectionFilterOptions::FilterMode_All);
+    collection_view_->filter_widget()->SetFilterMode(CollectionFilterOptions::FilterMode::All);
   }
 
 }
@@ -2972,7 +2971,7 @@ void MainWindow::HandleNotificationPreview(const OSDBase::Behaviour type, const
   else {
     qLog(Debug) << "The current playlist is empty, showing a fake song";
     // Create a fake song
-    Song fake(Song::Source_LocalFile);
+    Song fake(Song::Source::LocalFile);
     fake.Init("Title", "Artist", "Album", 123);
     fake.set_genre("Classical");
     fake.set_composer("Anonymous");
@@ -2996,7 +2995,7 @@ void MainWindow::ShowConsole() {
 void MainWindow::keyPressEvent(QKeyEvent *e) {
 
   if (e->key() == Qt::Key_Space) {
-    app_->player()->PlayPause(Playlist::AutoScroll_Never);
+    app_->player()->PlayPause(0, Playlist::AutoScroll::Never);
     e->accept();
   }
   else if (e->key() == Qt::Key_Left) {
@@ -3159,17 +3158,17 @@ void MainWindow::PlaylistDelete() {
 
   if (DeleteConfirmationDialog::warning(files) != QDialogButtonBox::Yes) return;
 
-  if (app_->player()->GetState() == Engine::Playing && app_->playlist_manager()->current()->rowCount() == selected_songs.count()) {
+  if (app_->player()->GetState() == Engine::State::Playing && app_->playlist_manager()->current()->rowCount() == selected_songs.count()) {
     app_->player()->Stop();
   }
 
   ui_->playlist->view()->RemoveSelected();
 
-  if (app_->player()->GetState() == Engine::Playing && is_current_item) {
+  if (app_->player()->GetState() == Engine::State::Playing && is_current_item) {
     app_->player()->Next();
   }
 
-  std::shared_ptr<MusicStorage> storage = std::make_shared<FilesystemMusicStorage>(Song::Source_LocalFile, "/");
+  std::shared_ptr<MusicStorage> storage = std::make_shared<FilesystemMusicStorage>(Song::Source::LocalFile, "/");
   DeleteFiles *delete_files = new DeleteFiles(app_->task_manager(), storage, true);
   //QObject::connect(delete_files, &DeleteFiles::Finished, this, &MainWindow::DeleteFinished);
   delete_files->Start(selected_songs);

src/core/mainwindow.h

@@ -331,7 +331,7 @@ class MainWindow : public QMainWindow, public PlatformInterface {
   std::unique_ptr<TagFetcher> tag_fetcher_;
 #endif
   std::unique_ptr<TrackSelectionDialog> track_selection_dialog_;
-  PlaylistItemList autocomplete_tag_items_;
+  PlaylistItemPtrList autocomplete_tag_items_;
 
   SmartPlaylistsViewContainer *smartplaylists_view_;
 

src/core/metatypes.cpp

@@ -38,7 +38,6 @@
 #include <QByteArray>
 #include <QUrl>
 #include <QImage>
-#include <QNetworkCookie>
 #include <QNetworkReply>
 #include <QItemSelection>
 #ifdef HAVE_DBUS
@@ -78,17 +77,18 @@
 #  include "device/mtpconnection.h"
 #endif
 
+#include "settings/playlistsettingspage.h"
+
+#include "smartplaylists/smartplaylistsearchterm.h"
+#include "smartplaylists/smartplaylistsitem.h"
+
 void RegisterMetaTypes() {
 
   qRegisterMetaType<const char*>("const char*");
   qRegisterMetaType<QList<int>>("QList<int>");
-  qRegisterMetaType<QList<QUrl>>("QList<QUrl>");
   qRegisterMetaType<QVector<int>>("QVector<int>");
+  qRegisterMetaType<QList<QUrl>>("QList<QUrl>");
   qRegisterMetaType<QFileInfo>("QFileInfo");
-  qRegisterMetaType<QAbstractSocket::SocketState>();
-  qRegisterMetaType<QAbstractSocket::SocketState>("QAbstractSocket::SocketState");
-  qRegisterMetaType<QNetworkCookie>("QNetworkCookie");
-  qRegisterMetaType<QList<QNetworkCookie>>("QList<QNetworkCookie>");
   qRegisterMetaType<QNetworkReply*>("QNetworkReply*");
   qRegisterMetaType<QNetworkReply**>("QNetworkReply**");
   qRegisterMetaType<QItemSelection>("QItemSelection");
@@ -98,16 +98,12 @@ void RegisterMetaTypes() {
   qRegisterMetaTypeStreamOperators<QMap<int, Qt::Alignment>>("ColumnAlignmentMap");
   qRegisterMetaTypeStreamOperators<QMap<int, int>>("ColumnAlignmentIntMap");
 #endif
-  qRegisterMetaType<CollectionDirectory>("Directory");
-  qRegisterMetaType<CollectionDirectoryList>("DirectoryList");
-  qRegisterMetaType<CollectionSubdirectory>("Subdirectory");
-  qRegisterMetaType<CollectionSubdirectoryList>("SubdirectoryList");
   qRegisterMetaType<Song>("Song");
   qRegisterMetaType<SongList>("SongList");
   qRegisterMetaType<SongMap>("SongMap");
-  qRegisterMetaType<QList<Song>>("QList<Song>");
+  qRegisterMetaType<Song::Source>("Song::Source");
-  qRegisterMetaType<QMap<QString, Song>>("QMap<QString, Song>");
+  qRegisterMetaType<Song::FileType>("Song::FileType");
-  qRegisterMetaType<Engine::EngineType>("EngineType");
+  qRegisterMetaType<Engine::EngineType>("Engine::EngineType");
   qRegisterMetaType<Engine::SimpleMetaBundle>("Engine::SimpleMetaBundle");
   qRegisterMetaType<Engine::State>("Engine::State");
   qRegisterMetaType<Engine::TrackChangeFlags>("Engine::TrackChangeFlags");
@@ -117,23 +113,29 @@ void RegisterMetaTypes() {
   qRegisterMetaType<GstElement*>("GstElement*");
   qRegisterMetaType<GstEnginePipeline*>("GstEnginePipeline*");
 #endif
+  qRegisterMetaType<CollectionDirectory>("CollectionDirectory");
+  qRegisterMetaType<CollectionDirectoryList>("CollectionDirectoryList");
+  qRegisterMetaType<CollectionSubdirectory>("CollectionSubdirectory");
+  qRegisterMetaType<CollectionSubdirectoryList>("CollectionSubdirectoryList");
+  qRegisterMetaType<CollectionModel::Grouping>("CollectionModel::Grouping");
   qRegisterMetaType<PlaylistItemPtr>("PlaylistItemPtr");
-  qRegisterMetaType<PlaylistItemList>("PlaylistItemList");
+  qRegisterMetaType<PlaylistItemPtrList>("PlaylistItemPtrList");
-  qRegisterMetaType<QList<PlaylistItemPtr>>("QList<PlaylistItemPtr>");
   qRegisterMetaType<PlaylistSequence::RepeatMode>("PlaylistSequence::RepeatMode");
   qRegisterMetaType<PlaylistSequence::ShuffleMode>("PlaylistSequence::ShuffleMode");
   qRegisterMetaType<AlbumCoverLoaderResult>("AlbumCoverLoaderResult");
   qRegisterMetaType<AlbumCoverLoaderResult::Type>("AlbumCoverLoaderResult::Type");
   qRegisterMetaType<CoverProviderSearchResult>("CoverProviderSearchResult");
-  qRegisterMetaType<CoverSearchStatistics>("CoverSearchStatistics");
-  qRegisterMetaType<QList<CoverProviderSearchResult>>("QList<CoverProviderSearchResult>");
   qRegisterMetaType<CoverProviderSearchResults>("CoverProviderSearchResults");
+  qRegisterMetaType<CoverSearchStatistics>("CoverSearchStatistics");
+
   qRegisterMetaType<Equalizer::Params>("Equalizer::Params");
+
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
   qRegisterMetaTypeStreamOperators<Equalizer::Params>("Equalizer::Params");
 #endif
+
 #ifdef HAVE_DBUS
-  qDBusRegisterMetaType<QList<QByteArray>>();
+  qDBusRegisterMetaType<QByteArrayList>();
   qDBusRegisterMetaType<QImage>();
   qDBusRegisterMetaType<TrackMetadata>();
   qDBusRegisterMetaType<Track_Ids>();
@@ -144,15 +146,21 @@ void RegisterMetaTypes() {
   qDBusRegisterMetaType<ManagedObjectList>();
 #endif
 
-  qRegisterMetaType<InternetSearchView::ResultList>("InternetSearchView::ResultList");
   qRegisterMetaType<InternetSearchView::Result>("InternetSearchView::Result");
+  qRegisterMetaType<InternetSearchView::ResultList>("InternetSearchView::ResultList");
 
-  qRegisterMetaType<PlaylistGeneratorPtr>("PlaylistGeneratorPtr");
+  qRegisterMetaType<RadioChannel>("RadioChannel");
-
   qRegisterMetaType<RadioChannelList>("RadioChannelList");
 
 #ifdef HAVE_LIBMTP
   qRegisterMetaType<MtpConnection*>("MtpConnection*");
 #endif
 
+  qRegisterMetaType<PlaylistSettingsPage::PathType>("PlaylistSettingsPage::PathType");
+
+  qRegisterMetaType<PlaylistGeneratorPtr>("PlaylistGeneratorPtr");
+  qRegisterMetaType<SmartPlaylistSearchTerm::Operator>("SmartPlaylistSearchTerm::Operator");
+  qRegisterMetaType<SmartPlaylistSearchTerm::OperatorList>("SmartPlaylistSearchTerm::OperatorList");
+  qRegisterMetaType<SmartPlaylistsItem::Type>("SmartPlaylistsItem::Type");
+
 }

src/core/mpris2.cpp

@@ -164,7 +164,7 @@ void Mpris2::PlaylistManagerInitialized() {
 
 void Mpris2::EngineStateChanged(Engine::State newState) {
 
-  if (newState != Engine::Playing && newState != Engine::Paused) {
+  if (newState != Engine::State::Playing && newState != Engine::State::Paused) {
     last_metadata_ = QVariantMap();
     EmitNotification("Metadata");
   }
@@ -172,7 +172,7 @@ void Mpris2::EngineStateChanged(Engine::State newState) {
   EmitNotification("CanPlay");
   EmitNotification("CanPause");
   EmitNotification("PlaybackStatus", PlaybackStatus(newState));
-  if (newState == Engine::Playing) EmitNotification("CanSeek", CanSeek(newState));
+  if (newState == Engine::State::Playing) EmitNotification("CanSeek", CanSeek(newState));
 
 }
 
@@ -307,8 +307,8 @@ QString Mpris2::PlaybackStatus() const {
 QString Mpris2::PlaybackStatus(Engine::State state) const {
 
   switch (state) {
-    case Engine::Playing: return "Playing";
+    case Engine::State::Playing: return "Playing";
-    case Engine::Paused: return "Paused";
+    case Engine::State::Paused: return "Paused";
     default: return "Stopped";
   }
 
@@ -321,9 +321,9 @@ QString Mpris2::LoopStatus() const {
   }
 
   switch (app_->playlist_manager()->sequence()->repeat_mode()) {
-    case PlaylistSequence::Repeat_Album:
+    case PlaylistSequence::RepeatMode::Album:
-    case PlaylistSequence::Repeat_Playlist: return "Playlist";
+    case PlaylistSequence::RepeatMode::Playlist: return "Playlist";
-    case PlaylistSequence::Repeat_Track: return "Track";
+    case PlaylistSequence::RepeatMode::Track: return "Track";
     default: return "None";
   }
 
@@ -331,16 +331,16 @@ QString Mpris2::LoopStatus() const {
 
 void Mpris2::SetLoopStatus(const QString &value) {
 
-  PlaylistSequence::RepeatMode mode = PlaylistSequence::Repeat_Off;
+  PlaylistSequence::RepeatMode mode = PlaylistSequence::RepeatMode::Off;
 
   if (value == "None") {
-    mode = PlaylistSequence::Repeat_Off;
+    mode = PlaylistSequence::RepeatMode::Off;
   }
   else if (value == "Track") {
-    mode = PlaylistSequence::Repeat_Track;
+    mode = PlaylistSequence::RepeatMode::Track;
   }
   else if (value == "Playlist") {
-    mode = PlaylistSequence::Repeat_Playlist;
+    mode = PlaylistSequence::RepeatMode::Playlist;
   }
 
   app_->playlist_manager()->active()->sequence()->SetRepeatMode(mode);
@@ -359,12 +359,12 @@ void Mpris2::SetRate(double rate) {
 
 bool Mpris2::Shuffle() const {
 
-  return app_->playlist_manager()->sequence()->shuffle_mode() != PlaylistSequence::Shuffle_Off;
+  return app_->playlist_manager()->sequence()->shuffle_mode() != PlaylistSequence::ShuffleMode::Off;
 
 }
 
 void Mpris2::SetShuffle(bool enable) {
-  app_->playlist_manager()->active()->sequence()->SetShuffleMode(enable ? PlaylistSequence::Shuffle_All : PlaylistSequence::Shuffle_Off);
+  app_->playlist_manager()->active()->sequence()->SetShuffleMode(enable ? PlaylistSequence::ShuffleMode::All : PlaylistSequence::ShuffleMode::Off);
 }
 
 QVariantMap Mpris2::Metadata() const { return last_metadata_; }
@@ -447,13 +447,13 @@ bool Mpris2::CanPlay() const {
 
 // This one's a bit different than MPRIS 1 - we want this to be true even when the song is already paused or stopped.
 bool Mpris2::CanPause() const {
-  return (app_->player()->GetCurrentItem() && app_->player()->GetState() == Engine::Playing && !(app_->player()->GetCurrentItem()->options() & PlaylistItem::PauseDisabled)) || PlaybackStatus() == "Paused" || PlaybackStatus() == "Stopped";
+  return (app_->player()->GetCurrentItem() && app_->player()->GetState() == Engine::State::Playing && !(app_->player()->GetCurrentItem()->options() & PlaylistItem::Option::PauseDisabled)) || PlaybackStatus() == "Paused" || PlaybackStatus() == "Stopped";
 }
 
 bool Mpris2::CanSeek() const { return CanSeek(app_->player()->GetState()); }
 
 bool Mpris2::CanSeek(Engine::State state) const {
-  return app_->player()->GetCurrentItem() && state != Engine::Empty && !app_->player()->GetCurrentItem()->Metadata().is_stream();
+  return app_->player()->GetCurrentItem() && state != Engine::State::Empty && !app_->player()->GetCurrentItem()->Metadata().is_stream();
 }
 
 bool Mpris2::CanControl() const { return true; }
@@ -471,7 +471,7 @@ void Mpris2::Previous() {
 }
 
 void Mpris2::Pause() {
-  if (CanPause() && app_->player()->GetState() != Engine::Paused) {
+  if (CanPause() && app_->player()->GetState() != Engine::State::Paused) {
     app_->player()->Pause();
   }
 }

src/core/musicstorage.h

@@ -50,7 +50,7 @@ class MusicStorage {
   };
 
   // Values are saved in the database - don't change
-  enum TranscodeMode {
+  enum class TranscodeMode {
     Transcode_Always = 1,
     Transcode_Never = 2,
     Transcode_Unsupported = 3,
@@ -83,8 +83,8 @@ class MusicStorage {
   virtual QString LocalPath() const { return QString(); }
   virtual std::optional<int> collection_directory_id() const { return std::optional<int>(); }
 
-  virtual TranscodeMode GetTranscodeMode() const { return Transcode_Never; }
+  virtual TranscodeMode GetTranscodeMode() const { return TranscodeMode::Transcode_Never; }
-  virtual Song::FileType GetTranscodeFormat() const { return Song::FileType_Unknown; }
+  virtual Song::FileType GetTranscodeFormat() const { return Song::FileType::Unknown; }
   virtual bool GetSupportedFiletypes(QList<Song::FileType> *ret) { Q_UNUSED(ret); return true; }
 
   virtual bool StartCopy(QList<Song::FileType> *supported_types) { Q_UNUSED(supported_types); return true; }

src/core/networkproxyfactory.cpp

@@ -35,7 +35,7 @@ NetworkProxyFactory *NetworkProxyFactory::sInstance = nullptr;
 const char *NetworkProxyFactory::kSettingsGroup = "NetworkProxy";
 
 NetworkProxyFactory::NetworkProxyFactory()
-    : mode_(Mode_System),
+    : mode_(Mode::System),
       type_(QNetworkProxy::HttpProxy),
       port_(8080),
       use_authentication_(false) {
@@ -81,7 +81,7 @@ void NetworkProxyFactory::ReloadSettings() {
   QSettings s;
   s.beginGroup(kSettingsGroup);
 
-  mode_ = Mode(s.value("mode", Mode_System).toInt());
+  mode_ = static_cast<Mode>(s.value("mode", static_cast<int>(Mode::System)).toInt());
   type_ = QNetworkProxy::ProxyType(s.value("type", QNetworkProxy::HttpProxy).toInt());
   hostname_ = s.value("hostname").toString();
   port_ = s.value("port", 8080).toInt();
@@ -100,7 +100,7 @@ QList<QNetworkProxy> NetworkProxyFactory::queryProxy(const QNetworkProxyQuery &q
   QNetworkProxy ret;
 
   switch (mode_) {
-    case Mode_System:
+    case Mode::System:
 #ifdef Q_OS_LINUX
       Q_UNUSED(query);
 
@@ -125,11 +125,11 @@ QList<QNetworkProxy> NetworkProxyFactory::queryProxy(const QNetworkProxyQuery &q
       return systemProxyForQuery(query);
 #endif
 
-    case Mode_Direct:
+    case Mode::Direct:
       ret.setType(QNetworkProxy::NoProxy);
       break;
 
-    case Mode_Manual:
+    case Mode::Manual:
       ret.setType(type_);
       ret.setHostName(hostname_);
       ret.setPort(port_);

src/core/networkproxyfactory.h

@@ -34,7 +34,11 @@
 class NetworkProxyFactory : public QNetworkProxyFactory {
  public:
   // These values are persisted
-  enum Mode { Mode_System = 0, Mode_Direct = 1, Mode_Manual = 2, };
+  enum class Mode {
+    System = 0,
+    Direct = 1,
+    Manual = 2
+  };
 
   static NetworkProxyFactory *Instance();
   static const char *kSettingsGroup;

src/core/player.cpp

@@ -79,22 +79,22 @@ Player::Player(Application *app, QObject *parent)
 #endif
       analyzer_(nullptr),
       equalizer_(nullptr),
-      stream_change_type_(Engine::First),
+      stream_change_type_(Engine::TrackChangeType::First),
-      autoscroll_(Playlist::AutoScroll_Maybe),
+      autoscroll_(Playlist::AutoScroll::Maybe),
-      last_state_(Engine::Empty),
+      last_state_(Engine::State::Empty),
       nb_errors_received_(0),
       volume_(100),
       volume_before_mute_(100),
       last_pressed_previous_(QDateTime::currentDateTime()),
       continue_on_error_(false),
       greyout_(true),
-      menu_previousmode_(BehaviourSettingsPage::PreviousBehaviour_DontRestart),
+      menu_previousmode_(BehaviourSettingsPage::PreviousBehaviour::DontRestart),
       seek_step_sec_(10),
       play_offset_nanosec_(0) {
 
   QSettings s;
   s.beginGroup(BackendSettingsPage::kSettingsGroup);
-  Engine::EngineType enginetype = Engine::EngineTypeFromName(s.value("engine", EngineName(Engine::GStreamer)).toString().toLower());
+  Engine::EngineType enginetype = Engine::EngineTypeFromName(s.value("engine", EngineName(Engine::EngineType::GStreamer)).toString().toLower());
   s.endGroup();
 
   CreateEngine(enginetype);
@@ -103,14 +103,14 @@ Player::Player(Application *app, QObject *parent)
 
 Engine::EngineType Player::CreateEngine(Engine::EngineType enginetype) {
 
-  Engine::EngineType use_enginetype(Engine::None);
+  Engine::EngineType use_enginetype(Engine::EngineType::None);
 
-  for (int i = 0; use_enginetype == Engine::None; i++) {
+  for (int i = 0; use_enginetype == Engine::EngineType::None; i++) {
     switch (enginetype) {
-      case Engine::None:
+      case Engine::EngineType::None:
 #ifdef HAVE_GSTREAMER
-      case Engine::GStreamer:{
+      case Engine::EngineType::GStreamer:{
-        use_enginetype=Engine::GStreamer;
+        use_enginetype=Engine::EngineType::GStreamer;
         std::unique_ptr<GstEngine> gst_engine(new GstEngine(app_->task_manager()));
         gst_engine->SetStartup(gst_startup_);
         engine_.reset(gst_engine.release());
@@ -118,8 +118,8 @@ Engine::EngineType Player::CreateEngine(Engine::EngineType enginetype) {
       }
 #endif
 #ifdef HAVE_VLC
-      case Engine::VLC:
+      case Engine::EngineType::VLC:
-        use_enginetype = Engine::VLC;
+        use_enginetype = Engine::EngineType::VLC;
         engine_ = std::make_shared<VLCEngine>(app_->task_manager());
         break;
 #endif
@@ -127,7 +127,7 @@ Engine::EngineType Player::CreateEngine(Engine::EngineType enginetype) {
         if (i > 0) {
           qFatal("No engine available!");
         }
-        enginetype = Engine::None;
+        enginetype = Engine::EngineType::None;
         break;
     }
   }
@@ -157,7 +157,7 @@ void Player::Init() {
 
   if (!engine_) {
     s.beginGroup(BackendSettingsPage::kSettingsGroup);
-    Engine::EngineType enginetype = Engine::EngineTypeFromName(s.value("engine", EngineName(Engine::GStreamer)).toString().toLower());
+    Engine::EngineType enginetype = Engine::EngineTypeFromName(s.value("engine", EngineName(Engine::EngineType::GStreamer)).toString().toLower());
     s.endGroup();
     CreateEngine(enginetype);
   }
@@ -205,7 +205,7 @@ void Player::ReloadSettings() {
   s.endGroup();
 
   s.beginGroup(BehaviourSettingsPage::kSettingsGroup);
-  menu_previousmode_ = BehaviourSettingsPage::PreviousBehaviour(s.value("menu_previousmode", BehaviourSettingsPage::PreviousBehaviour_DontRestart).toInt());
+  menu_previousmode_ = static_cast<BehaviourSettingsPage::PreviousBehaviour>(s.value("menu_previousmode", static_cast<int>(BehaviourSettingsPage::PreviousBehaviour::DontRestart)).toInt());
   seek_step_sec_ = s.value("seek_step_sec", 10).toInt();
   s.endGroup();
 
@@ -230,7 +230,7 @@ void Player::SaveVolume() {
   s.beginGroup(kSettingsGroup);
   s.setValue("volume", volume_);
   s.endGroup();
-  
+
 }
 
 void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
@@ -265,19 +265,19 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
   }
 
   switch (result.type_) {
-    case UrlHandler::LoadResult::Error:
+    case UrlHandler::LoadResult::Type::Error:
       if (is_current) {
         InvalidSongRequested(result.original_url_);
       }
       emit Error(result.error_);
       break;
 
-    case UrlHandler::LoadResult::NoMoreTracks:
+    case UrlHandler::LoadResult::Type::NoMoreTracks:
       qLog(Debug) << "URL handler for" << result.original_url_ << "said no more tracks" << is_current;
       if (is_current) NextItem(stream_change_type_, autoscroll_);
       break;
 
-    case UrlHandler::LoadResult::TrackAvailable: {
+    case UrlHandler::LoadResult::Type::TrackAvailable: {
 
       qLog(Debug) << "URL handler for" << result.original_url_ << "returned" << result.stream_url_;
 
@@ -300,9 +300,9 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
 
       // If there was no filetype in the song's metadata, use the one provided by URL handler, if there is one.
       if (
-        (song.filetype() == Song::FileType_Unknown && result.filetype_ != Song::FileType_Unknown)
+        (song.filetype() == Song::FileType::Unknown && result.filetype_ != Song::FileType::Unknown)
         ||
-        (song.filetype() == Song::FileType_Stream && result.filetype_ != Song::FileType_Stream)
+        (song.filetype() == Song::FileType::Stream && result.filetype_ != Song::FileType::Stream)
          )
       {
         song.set_filetype(result.filetype_);
@@ -353,7 +353,7 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
       break;
     }
 
-    case UrlHandler::LoadResult::WillLoadAsynchronously:
+    case UrlHandler::LoadResult::Type::WillLoadAsynchronously:
       qLog(Debug) << "URL handler for" << result.original_url_ << "is loading asynchronously";
 
       // We'll get called again later with either NoMoreTracks or TrackAvailable
@@ -363,7 +363,7 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
 
 }
 
-void Player::Next() { NextInternal(Engine::Manual, Playlist::AutoScroll_Always); }
+void Player::Next() { NextInternal(Engine::TrackChangeType::Manual, Playlist::AutoScroll::Always); }
 
 void Player::NextInternal(const Engine::TrackChangeFlags change, const Playlist::AutoScroll autoscroll) {
 
@@ -384,10 +384,10 @@ void Player::NextItem(const Engine::TrackChangeFlags change, const Playlist::Aut
   Playlist *active_playlist = app_->playlist_manager()->active();
 
   // If we received too many errors in auto change, with repeat enabled, we stop
-  if (change == Engine::Auto) {
+  if (change == Engine::TrackChangeType::Auto) {
     const PlaylistSequence::RepeatMode repeat_mode = active_playlist->sequence()->repeat_mode();
-    if (repeat_mode != PlaylistSequence::Repeat_Off) {
+    if (repeat_mode != PlaylistSequence::RepeatMode::Off) {
-      if ((repeat_mode == PlaylistSequence::Repeat_Track && nb_errors_received_ >= 3) || (nb_errors_received_ >= app_->playlist_manager()->active()->filter()->rowCount())) {
+      if ((repeat_mode == PlaylistSequence::RepeatMode::Track && nb_errors_received_ >= 3) || (nb_errors_received_ >= app_->playlist_manager()->active()->filter()->rowCount())) {
         // We received too many "Error" state changes: probably looping over a playlist which contains only unavailable elements: stop now.
         nb_errors_received_ = 0;
         Stop();
@@ -397,7 +397,7 @@ void Player::NextItem(const Engine::TrackChangeFlags change, const Playlist::Aut
   }
 
   // Manual track changes override "Repeat track"
-  const bool ignore_repeat_track = change & Engine::Manual;
+  const bool ignore_repeat_track = change & Engine::TrackChangeType::Manual;
 
   int i = active_playlist->next_row(ignore_repeat_track);
   if (i == -1) {
@@ -413,7 +413,7 @@ void Player::NextItem(const Engine::TrackChangeFlags change, const Playlist::Aut
 }
 
 void Player::PlayPlaylist(const QString &playlist_name) {
-  PlayPlaylistInternal(Engine::Manual, Playlist::AutoScroll_Always, playlist_name);
+  PlayPlaylistInternal(Engine::TrackChangeType::Manual, Playlist::AutoScroll::Always, playlist_name);
 }
 
 void Player::PlayPlaylistInternal(const Engine::TrackChangeFlags change, const Playlist::AutoScroll autoscroll, const QString &playlist_name) {
@@ -472,22 +472,22 @@ void Player::TrackEnded() {
     app_->playlist_manager()->collection_backend()->IncrementPlayCountAsync(current_item_->Metadata().id());
   }
 
-  if (HandleStopAfter(Playlist::AutoScroll_Maybe)) return;
+  if (HandleStopAfter(Playlist::AutoScroll::Maybe)) return;
 
-  NextInternal(Engine::Auto, Playlist::AutoScroll_Maybe);
+  NextInternal(Engine::TrackChangeType::Auto, Playlist::AutoScroll::Maybe);
 
 }
 
 void Player::PlayPause(const quint64 offset_nanosec, const Playlist::AutoScroll autoscroll) {
 
   switch (engine_->state()) {
-    case Engine::Paused:
+    case Engine::State::Paused:
       UnPause();
       emit Resumed();
       break;
 
-    case Engine::Playing: {
+    case Engine::State::Playing: {
-      if (current_item_->options() & PlaylistItem::PauseDisabled) {
+      if (current_item_->options() & PlaylistItem::Option::PauseDisabled) {
         Stop();
       }
       else {
@@ -498,9 +498,9 @@ void Player::PlayPause(const quint64 offset_nanosec, const Playlist::AutoScroll
       break;
     }
 
-    case Engine::Empty:
+    case Engine::State::Empty:
-    case Engine::Error:
+    case Engine::State::Error:
-    case Engine::Idle: {
+    case Engine::State::Idle: {
       pause_time_ = QDateTime();
       play_offset_nanosec_ = offset_nanosec;
       app_->playlist_manager()->SetActivePlaylist(app_->playlist_manager()->current_id());
@@ -508,7 +508,7 @@ void Player::PlayPause(const quint64 offset_nanosec, const Playlist::AutoScroll
       int i = app_->playlist_manager()->active()->current_row();
       if (i == -1) i = app_->playlist_manager()->active()->last_played_row();
       if (i == -1) i = 0;
-      PlayAt(i, offset_nanosec, Engine::First, autoscroll, true);
+      PlayAt(i, offset_nanosec, Engine::TrackChangeType::First, autoscroll, true);
       break;
     }
   }
@@ -568,45 +568,45 @@ void Player::StopAfterCurrent() {
 bool Player::PreviousWouldRestartTrack() const {
 
   // Check if it has been over two seconds since previous button was pressed
-  return menu_previousmode_ == BehaviourSettingsPage::PreviousBehaviour_Restart && last_pressed_previous_.isValid() && last_pressed_previous_.secsTo(QDateTime::currentDateTime()) >= 2;
+  return menu_previousmode_ == BehaviourSettingsPage::PreviousBehaviour::Restart && last_pressed_previous_.isValid() && last_pressed_previous_.secsTo(QDateTime::currentDateTime()) >= 2;
 
 }
 
-void Player::Previous() { PreviousItem(Engine::Manual); }
+void Player::Previous() { PreviousItem(Engine::TrackChangeType::Manual); }
 
 void Player::PreviousItem(const Engine::TrackChangeFlags change) {
 
   pause_time_ = QDateTime();
   play_offset_nanosec_ = 0;
 
-  const bool ignore_repeat_track = change & Engine::Manual;
+  const bool ignore_repeat_track = change & Engine::TrackChangeType::Manual;
 
-  if (menu_previousmode_ == BehaviourSettingsPage::PreviousBehaviour_Restart) {
+  if (menu_previousmode_ == BehaviourSettingsPage::PreviousBehaviour::Restart) {
     // Check if it has been over two seconds since previous button was pressed
     QDateTime now = QDateTime::currentDateTime();
     if (last_pressed_previous_.isValid() && last_pressed_previous_.secsTo(now) >= 2) {
       last_pressed_previous_ = now;
-      PlayAt(app_->playlist_manager()->active()->current_row(), 0, change, Playlist::AutoScroll_Always, false, true);
+      PlayAt(app_->playlist_manager()->active()->current_row(), 0, change, Playlist::AutoScroll::Always, false, true);
       return;
     }
     last_pressed_previous_ = now;
   }
 
   int i = app_->playlist_manager()->active()->previous_row(ignore_repeat_track);
-  app_->playlist_manager()->active()->set_current_row(i, Playlist::AutoScroll_Always, false);
+  app_->playlist_manager()->active()->set_current_row(i, Playlist::AutoScroll::Always, false);
   if (i == -1) {
     Stop();
-    PlayAt(i, 0, change, Playlist::AutoScroll_Always, true);
+    PlayAt(i, 0, change, Playlist::AutoScroll::Always, true);
     return;
   }
 
-  PlayAt(i, 0, change, Playlist::AutoScroll_Always, false);
+  PlayAt(i, 0, change, Playlist::AutoScroll::Always, false);
 
 }
 
 void Player::EngineStateChanged(const Engine::State state) {
 
-  if (state == Engine::Error) {
+  if (state == Engine::State::Error) {
     nb_errors_received_++;
   }
   else {
@@ -614,21 +614,21 @@ void Player::EngineStateChanged(const Engine::State state) {
   }
 
   switch (state) {
-    case Engine::Paused:
+    case Engine::State::Paused:
       pause_time_ = QDateTime::currentDateTime();
       play_offset_nanosec_ = engine_->position_nanosec();
       emit Paused();
       break;
-    case Engine::Playing:
+    case Engine::State::Playing:
       pause_time_ = QDateTime();
       play_offset_nanosec_ = 0;
       emit Playing();
       break;
-    case Engine::Error:
+    case Engine::State::Error:
       emit Error();
       [[fallthrough]];
-    case Engine::Empty:
+    case Engine::State::Empty:
-    case Engine::Idle:
+    case Engine::State::Idle:
       pause_time_ = QDateTime();
       play_offset_nanosec_ = 0;
       emit Stopped();
@@ -700,12 +700,12 @@ void Player::PlayAt(const int index, const quint64 offset_nanosec, Engine::Track
   pause_time_ = QDateTime();
   play_offset_nanosec_ = offset_nanosec;
 
-  if (current_item_ && change == Engine::Manual && engine_->position_nanosec() != engine_->length_nanosec()) {
+  if (current_item_ && change == Engine::TrackChangeType::Manual && engine_->position_nanosec() != engine_->length_nanosec()) {
     emit TrackSkipped(current_item_);
   }
 
   if (current_item_ && app_->playlist_manager()->active()->has_item_at(index) && current_item_->Metadata().IsOnSameAlbum(app_->playlist_manager()->active()->item_at(index)->Metadata())) {
-    change |= Engine::SameAlbum;
+    change |= Engine::TrackChangeType::SameAlbum;
   }
 
   if (reshuffle) app_->playlist_manager()->active()->ReshuffleIndices();
@@ -761,7 +761,7 @@ void Player::SeekTo(const quint64 seconds) {
   emit Seeked(nanosec / 1000);
 
   if (seconds == 0) {
-    app_->playlist_manager()->active()->InformOfCurrentSongChange(Playlist::AutoScroll_Maybe, false);
+    app_->playlist_manager()->active()->InformOfCurrentSongChange(Playlist::AutoScroll::Maybe, false);
   }
 
 }
@@ -776,7 +776,7 @@ void Player::SeekBackward() {
 
 void Player::EngineMetadataReceived(const Engine::SimpleMetaBundle &bundle) {
 
-  if (bundle.type == Engine::SimpleMetaBundle::Type_Any || bundle.type == Engine::SimpleMetaBundle::Type_Current) {
+  if (bundle.type == Engine::SimpleMetaBundle::Type::Any || bundle.type == Engine::SimpleMetaBundle::Type::Current) {
     PlaylistItemPtr item = app_->playlist_manager()->active()->current_item();
     if (item && bundle.url == item->Url()) {
       Song song = item->Metadata();
@@ -786,7 +786,7 @@ void Player::EngineMetadataReceived(const Engine::SimpleMetaBundle &bundle) {
     }
   }
 
-  if (bundle.type == Engine::SimpleMetaBundle::Type_Any || bundle.type == Engine::SimpleMetaBundle::Type_Next) {
+  if (bundle.type == Engine::SimpleMetaBundle::Type::Any || bundle.type == Engine::SimpleMetaBundle::Type::Next) {
     int next_row = app_->playlist_manager()->active()->next_row();
     if (next_row != -1) {
       PlaylistItemPtr next_item = app_->playlist_manager()->active()->item_at(next_row);
@@ -828,10 +828,10 @@ void Player::Pause() { engine_->Pause(); }
 void Player::Play(const quint64 offset_nanosec) {
 
   switch (GetState()) {
-    case Engine::Playing:
+    case Engine::State::Playing:
       SeekTo(offset_nanosec);
       break;
-    case Engine::Paused:
+    case Engine::State::Paused:
       UnPause();
       break;
     default:
@@ -880,18 +880,18 @@ void Player::TrackAboutToEnd() {
   // Get the actual track URL rather than the stream URL.
   if (url_handlers_.contains(url.scheme())) {
     if (loading_async_.contains(url)) return;
-    autoscroll_ = Playlist::AutoScroll_Maybe;
+    autoscroll_ = Playlist::AutoScroll::Maybe;
     UrlHandler::LoadResult result = url_handlers_[url.scheme()]->StartLoading(url);
     switch (result.type_) {
-      case UrlHandler::LoadResult::Error:
+      case UrlHandler::LoadResult::Type::Error:
         emit Error(result.error_);
         return;
-      case UrlHandler::LoadResult::NoMoreTracks:
+      case UrlHandler::LoadResult::Type::NoMoreTracks:
         return;
-      case UrlHandler::LoadResult::WillLoadAsynchronously:
+      case UrlHandler::LoadResult::Type::WillLoadAsynchronously:
         loading_async_ << url;
         return;
-      case UrlHandler::LoadResult::TrackAvailable:
+      case UrlHandler::LoadResult::Type::TrackAvailable:
         qLog(Debug) << "URL handler for" << result.original_url_ << "returned" << result.stream_url_;
         url = result.stream_url_;
         Song song = next_item->Metadata();
@@ -929,7 +929,7 @@ void Player::InvalidSongRequested(const QUrl &url) {
     return;
   }
 
-  NextItem(Engine::Auto, Playlist::AutoScroll_Maybe);
+  NextItem(Engine::TrackChangeType::Auto, Playlist::AutoScroll::Maybe);
 
 }
 

src/core/player.h

@@ -77,7 +77,7 @@ class PlayerInterface : public QObject {
   virtual void PlayAt(const int index, const quint64 offset_nanosec, Engine::TrackChangeFlags change, const Playlist::AutoScroll autoscroll, const bool reshuffle, const bool force_inform = false) = 0;
 
   // If there's currently a song playing, pause it, otherwise play the track that was playing last, or the first one on the playlist
-  virtual void PlayPause(const quint64 offset_nanosec = 0, const Playlist::AutoScroll autoscroll = Playlist::AutoScroll_Always) = 0;
+  virtual void PlayPause(const quint64 offset_nanosec = 0, const Playlist::AutoScroll autoscroll = Playlist::AutoScroll::Always) = 0;
   virtual void PlayPauseHelper() = 0;
   virtual void RestartOrPrevious() = 0;
 
@@ -164,7 +164,7 @@ class Player : public PlayerInterface {
   void SaveVolume() override;
 
   void PlayAt(const int index, const quint64 offset_nanosec, Engine::TrackChangeFlags change, const Playlist::AutoScroll autoscroll, const bool reshuffle, const bool force_inform = false) override;
-  void PlayPause(const quint64 offset_nanosec = 0, const Playlist::AutoScroll autoscroll = Playlist::AutoScroll_Always) override;
+  void PlayPause(const quint64 offset_nanosec = 0, const Playlist::AutoScroll autoscroll = Playlist::AutoScroll::Always) override;
   void PlayPauseHelper() override { PlayPause(play_offset_nanosec_); }
   void RestartOrPrevious() override;
   void Next() override;

src/core/song.cpp

@@ -158,7 +158,7 @@ const QStringList Song::kAcceptedExtensions = QStringList() << "wav" << "flac" <
 
 struct Song::Private : public QSharedData {
 
-  explicit Private(Source source = Source_Unknown);
+  explicit Private(Source source = Source::Unknown);
 
   bool valid_;
   int id_;
@@ -229,7 +229,7 @@ struct Song::Private : public QSharedData {
 
 };
 
-Song::Private::Private(Song::Source source)
+Song::Private::Private(const Source source)
     : valid_(false),
       id_(-1),
 
@@ -248,7 +248,7 @@ Song::Private::Private(Song::Source source)
 
       source_(source),
       directory_id_(-1),
-      filetype_(FileType_Unknown),
+      filetype_(FileType::Unknown),
       filesize_(-1),
       mtime_(-1),
       ctime_(-1),
@@ -270,7 +270,7 @@ Song::Private::Private(Song::Source source)
 
       {}
 
-Song::Song(Song::Source source) : d(new Private(source)) {}
+Song::Song(const Source source) : d(new Private(source)) {}
 Song::Song(const Song &other) = default;
 Song::~Song() = default;
 
@@ -353,16 +353,16 @@ void Song::clear_art_automatic() { d->art_automatic_.clear(); }
 void Song::clear_art_manual() { d->art_manual_.clear(); }
 
 bool Song::additional_tags_supported() const {
-  return d->filetype_ == FileType_FLAC ||
+  return d->filetype_ == FileType::FLAC ||
-         d->filetype_ == FileType_WavPack ||
+         d->filetype_ == FileType::WavPack ||
-         d->filetype_ == FileType_OggFlac ||
+         d->filetype_ == FileType::OggFlac ||
-         d->filetype_ == FileType_OggVorbis ||
+         d->filetype_ == FileType::OggVorbis ||
-         d->filetype_ == FileType_OggOpus ||
+         d->filetype_ == FileType::OggOpus ||
-         d->filetype_ == FileType_OggSpeex ||
+         d->filetype_ == FileType::OggSpeex ||
-         d->filetype_ == FileType_MPEG ||
+         d->filetype_ == FileType::MPEG ||
-         d->filetype_ == FileType_MP4 ||
+         d->filetype_ == FileType::MP4 ||
-         d->filetype_ == FileType_MPC ||
+         d->filetype_ == FileType::MPC ||
-         d->filetype_ == FileType_APE;
+         d->filetype_ == FileType::APE;
 }
 
 bool Song::albumartist_supported() const {
@@ -374,15 +374,15 @@ bool Song::composer_supported() const {
 }
 
 bool Song::performer_supported() const {
-  return d->filetype_ == FileType_FLAC ||
+  return d->filetype_ == FileType::FLAC ||
-         d->filetype_ == FileType_WavPack ||
+         d->filetype_ == FileType::WavPack ||
-         d->filetype_ == FileType_OggFlac ||
+         d->filetype_ == FileType::OggFlac ||
-         d->filetype_ == FileType_OggVorbis ||
+         d->filetype_ == FileType::OggVorbis ||
-         d->filetype_ == FileType_OggOpus ||
+         d->filetype_ == FileType::OggOpus ||
-         d->filetype_ == FileType_OggSpeex ||
+         d->filetype_ == FileType::OggSpeex ||
-         d->filetype_ == FileType_MPEG ||
+         d->filetype_ == FileType::MPEG ||
-         d->filetype_ == FileType_MPC ||
+         d->filetype_ == FileType::MPC ||
-         d->filetype_ == FileType_APE;
+         d->filetype_ == FileType::APE;
 }
 
 bool Song::grouping_supported() const {
@@ -398,17 +398,17 @@ bool Song::compilation_supported() const {
 }
 
 bool Song::rating_supported() const {
-  return d->filetype_ == FileType_FLAC ||
+  return d->filetype_ == FileType::FLAC ||
-         d->filetype_ == FileType_WavPack ||
+         d->filetype_ == FileType::WavPack ||
-         d->filetype_ == FileType_OggFlac ||
+         d->filetype_ == FileType::OggFlac ||
-         d->filetype_ == FileType_OggVorbis ||
+         d->filetype_ == FileType::OggVorbis ||
-         d->filetype_ == FileType_OggOpus ||
+         d->filetype_ == FileType::OggOpus ||
-         d->filetype_ == FileType_OggSpeex ||
+         d->filetype_ == FileType::OggSpeex ||
-         d->filetype_ == FileType_MPEG ||
+         d->filetype_ == FileType::MPEG ||
-         d->filetype_ == FileType_MP4 ||
+         d->filetype_ == FileType::MP4 ||
-         d->filetype_ == FileType_ASF ||
+         d->filetype_ == FileType::ASF ||
-         d->filetype_ == FileType_MPC ||
+         d->filetype_ == FileType::MPC ||
-         d->filetype_ == FileType_APE;
+         d->filetype_ == FileType::APE;
 }
 
 bool Song::comment_supported() const {
@@ -421,11 +421,11 @@ bool Song::lyrics_supported() const {
 
 bool Song::save_embedded_cover_supported(const FileType filetype) {
 
-  return filetype == FileType_FLAC ||
+  return filetype == FileType::FLAC ||
-         filetype == FileType_OggVorbis ||
+         filetype == FileType::OggVorbis ||
-         filetype == FileType_OggOpus ||
+         filetype == FileType::OggOpus ||
-         filetype == FileType_MPEG ||
+         filetype == FileType::MPEG ||
-         filetype == FileType_MP4;
+         filetype == FileType::MP4;
 
 }
 
@@ -438,14 +438,14 @@ bool Song::has_cue() const { return !d->cue_path_.isEmpty(); }
 
 float Song::rating() const { return d->rating_; }
 
-bool Song::is_collection_song() const { return d->source_ == Source_Collection; }
+bool Song::is_collection_song() const { return d->source_ == Source::Collection; }
 bool Song::is_metadata_good() const { return !d->url_.isEmpty() && !d->artist_.isEmpty() && !d->title_.isEmpty(); }
-bool Song::is_stream() const { return is_radio() || d->source_ == Source_Tidal || d->source_ == Source_Subsonic || d->source_ == Source_Qobuz; }
+bool Song::is_stream() const { return is_radio() || d->source_ == Source::Tidal || d->source_ == Source::Subsonic || d->source_ == Source::Qobuz; }
-bool Song::is_radio() const { return d->source_ == Source_Stream || d->source_ == Source_SomaFM || d->source_ == Source_RadioParadise; }
+bool Song::is_radio() const { return d->source_ == Source::Stream || d->source_ == Source::SomaFM || d->source_ == Source::RadioParadise; }
-bool Song::is_cdda() const { return d->source_ == Source_CDDA; }
+bool Song::is_cdda() const { return d->source_ == Source::CDDA; }
 bool Song::is_compilation() const { return (d->compilation_ || d->compilation_detected_ || d->compilation_on_) && !d->compilation_off_; }
-bool Song::stream_url_can_expire() const { return d->source_ == Song::Source_Tidal || d->source_ == Song::Source_Qobuz; }
+bool Song::stream_url_can_expire() const { return d->source_ == Source::Tidal || d->source_ == Source::Qobuz; }
-bool Song::is_module_music() const { return d->filetype_ == Song::FileType_MOD || d->filetype_ == Song::FileType_S3M || d->filetype_ == Song::FileType_XM || d->filetype_ == Song::FileType_IT; }
+bool Song::is_module_music() const { return d->filetype_ == FileType::MOD || d->filetype_ == FileType::S3M || d->filetype_ == FileType::XM || d->filetype_ == FileType::IT; }
 
 bool Song::art_automatic_is_valid() const {
   return !d->art_automatic_.isEmpty() &&
@@ -551,55 +551,55 @@ QString Song::JoinSpec(const QString &table) {
 
 Song::Source Song::SourceFromURL(const QUrl &url) {
 
-  if (url.isLocalFile()) return Source_LocalFile;
+  if (url.isLocalFile()) return Source::LocalFile;
-  else if (url.scheme() == "cdda") return Source_CDDA;
+  else if (url.scheme() == "cdda") return Source::CDDA;
-  else if (url.scheme() == "tidal") return Source_Tidal;
+  else if (url.scheme() == "tidal") return Source::Tidal;
-  else if (url.scheme() == "subsonic") return Source_Subsonic;
+  else if (url.scheme() == "subsonic") return Source::Subsonic;
-  else if (url.scheme() == "qobuz") return Source_Qobuz;
+  else if (url.scheme() == "qobuz") return Source::Qobuz;
   else if (url.scheme() == "http" || url.scheme() == "https" || url.scheme() == "rtsp") {
-    if (url.host().endsWith("tidal.com", Qt::CaseInsensitive)) { return Source_Tidal; }
+    if (url.host().endsWith("tidal.com", Qt::CaseInsensitive)) { return Source::Tidal; }
-    if (url.host().endsWith("qobuz.com", Qt::CaseInsensitive)) { return Source_Qobuz; }
+    if (url.host().endsWith("qobuz.com", Qt::CaseInsensitive)) { return Source::Qobuz; }
-    if (url.host().endsWith("somafm.com", Qt::CaseInsensitive)) { return Source_SomaFM; }
+    if (url.host().endsWith("somafm.com", Qt::CaseInsensitive)) { return Source::SomaFM; }
-    if (url.host().endsWith("radioparadise.com", Qt::CaseInsensitive)) { return Source_RadioParadise; }
+    if (url.host().endsWith("radioparadise.com", Qt::CaseInsensitive)) { return Source::RadioParadise; }
-    return Source_Stream;
+    return Source::Stream;
   }
-  else return Source_Unknown;
+  else return Source::Unknown;
 
 }
 
-QString Song::TextForSource(Source source) {
+QString Song::TextForSource(const Source source) {
 
   switch (source) {
-    case Song::Source_LocalFile:     return "file";
+    case Source::LocalFile:     return "file";
-    case Song::Source_Collection:    return "collection";
+    case Source::Collection:    return "collection";
-    case Song::Source_CDDA:          return "cd";
+    case Source::CDDA:          return "cd";
-    case Song::Source_Device:        return "device";
+    case Source::Device:        return "device";
-    case Song::Source_Stream:        return "stream";
+    case Source::Stream:        return "stream";
-    case Song::Source_Tidal:         return "tidal";
+    case Source::Tidal:         return "tidal";
-    case Song::Source_Subsonic:      return "subsonic";
+    case Source::Subsonic:      return "subsonic";
-    case Song::Source_Qobuz:         return "qobuz";
+    case Source::Qobuz:         return "qobuz";
-    case Song::Source_SomaFM:        return "somafm";
+    case Source::SomaFM:        return "somafm";
-    case Song::Source_RadioParadise: return "radioparadise";
+    case Source::RadioParadise: return "radioparadise";
-    case Song::Source_Unknown:       return "unknown";
+    case Source::Unknown:       return "unknown";
   }
   return "unknown";
 
 }
 
-QString Song::DescriptionForSource(Source source) {
+QString Song::DescriptionForSource(const Source source) {
 
   switch (source) {
-    case Song::Source_LocalFile:     return "File";
+    case Source::LocalFile:     return "File";
-    case Song::Source_Collection:    return "Collection";
+    case Source::Collection:    return "Collection";
-    case Song::Source_CDDA:          return "CD";
+    case Source::CDDA:          return "CD";
-    case Song::Source_Device:        return "Device";
+    case Source::Device:        return "Device";
-    case Song::Source_Stream:        return "Stream";
+    case Source::Stream:        return "Stream";
-    case Song::Source_Tidal:         return "Tidal";
+    case Source::Tidal:         return "Tidal";
-    case Song::Source_Subsonic:      return "Subsonic";
+    case Source::Subsonic:      return "Subsonic";
-    case Song::Source_Qobuz:         return "Qobuz";
+    case Source::Qobuz:         return "Qobuz";
-    case Song::Source_SomaFM:        return "SomaFM";
+    case Source::SomaFM:        return "SomaFM";
-    case Song::Source_RadioParadise: return "Radio Paradise";
+    case Source::RadioParadise: return "Radio Paradise";
-    case Song::Source_Unknown:       return "Unknown";
+    case Source::Unknown:       return "Unknown";
   }
   return "unknown";
 
@@ -607,132 +607,132 @@ QString Song::DescriptionForSource(Source source) {
 
 Song::Source Song::SourceFromText(const QString &source) {
 
-  if (source.compare("file", Qt::CaseInsensitive) == 0) return Source_LocalFile;
+  if (source.compare("file", Qt::CaseInsensitive) == 0) return Source::LocalFile;
-  if (source.compare("collection", Qt::CaseInsensitive) == 0) return Source_Collection;
+  if (source.compare("collection", Qt::CaseInsensitive) == 0) return Source::Collection;
-  if (source.compare("cd", Qt::CaseInsensitive) == 0) return Source_CDDA;
+  if (source.compare("cd", Qt::CaseInsensitive) == 0) return Source::CDDA;
-  if (source.compare("device", Qt::CaseInsensitive) == 0) return Source_Device;
+  if (source.compare("device", Qt::CaseInsensitive) == 0) return Source::Device;
-  if (source.compare("stream", Qt::CaseInsensitive) == 0) return Source_Stream;
+  if (source.compare("stream", Qt::CaseInsensitive) == 0) return Source::Stream;
-  if (source.compare("tidal", Qt::CaseInsensitive) == 0) return Source_Tidal;
+  if (source.compare("tidal", Qt::CaseInsensitive) == 0) return Source::Tidal;
-  if (source.compare("subsonic", Qt::CaseInsensitive) == 0) return Source_Subsonic;
+  if (source.compare("subsonic", Qt::CaseInsensitive) == 0) return Source::Subsonic;
-  if (source.compare("qobuz", Qt::CaseInsensitive) == 0) return Source_Qobuz;
+  if (source.compare("qobuz", Qt::CaseInsensitive) == 0) return Source::Qobuz;
-  if (source.compare("somafm", Qt::CaseInsensitive) == 0) return Source_SomaFM;
+  if (source.compare("somafm", Qt::CaseInsensitive) == 0) return Source::SomaFM;
-  if (source.compare("radioparadise", Qt::CaseInsensitive) == 0) return Source_RadioParadise;
+  if (source.compare("radioparadise", Qt::CaseInsensitive) == 0) return Source::RadioParadise;
 
-  return Source_Unknown;
+  return Source::Unknown;
 
 }
 
-QIcon Song::IconForSource(Source source) {
+QIcon Song::IconForSource(const Source source) {
 
   switch (source) {
-    case Song::Source_LocalFile:     return IconLoader::Load("folder-sound");
+    case Source::LocalFile:     return IconLoader::Load("folder-sound");
-    case Song::Source_Collection:    return IconLoader::Load("library-music");
+    case Source::Collection:    return IconLoader::Load("library-music");
-    case Song::Source_CDDA:          return IconLoader::Load("media-optical");
+    case Source::CDDA:          return IconLoader::Load("media-optical");
-    case Song::Source_Device:        return IconLoader::Load("device");
+    case Source::Device:        return IconLoader::Load("device");
-    case Song::Source_Stream:        return IconLoader::Load("applications-internet");
+    case Source::Stream:        return IconLoader::Load("applications-internet");
-    case Song::Source_Tidal:         return IconLoader::Load("tidal");
+    case Source::Tidal:         return IconLoader::Load("tidal");
-    case Song::Source_Subsonic:      return IconLoader::Load("subsonic");
+    case Source::Subsonic:      return IconLoader::Load("subsonic");
-    case Song::Source_Qobuz:         return IconLoader::Load("qobuz");
+    case Source::Qobuz:         return IconLoader::Load("qobuz");
-    case Song::Source_SomaFM:        return IconLoader::Load("somafm");
+    case Source::SomaFM:        return IconLoader::Load("somafm");
-    case Song::Source_RadioParadise: return IconLoader::Load("radioparadise");
+    case Source::RadioParadise: return IconLoader::Load("radioparadise");
-    case Song::Source_Unknown:       return IconLoader::Load("edit-delete");
+    case Source::Unknown:       return IconLoader::Load("edit-delete");
   }
   return IconLoader::Load("edit-delete");
 
 }
 
-QString Song::TextForFiletype(FileType filetype) {
+QString Song::TextForFiletype(const FileType filetype) {
 
   switch (filetype) {
-    case Song::FileType_WAV:         return "Wav";
+    case FileType::WAV:         return "Wav";
-    case Song::FileType_FLAC:        return "FLAC";
+    case FileType::FLAC:        return "FLAC";
-    case Song::FileType_WavPack:     return "WavPack";
+    case FileType::WavPack:     return "WavPack";
-    case Song::FileType_OggFlac:     return "Ogg FLAC";
+    case FileType::OggFlac:     return "Ogg FLAC";
-    case Song::FileType_OggVorbis:   return "Ogg Vorbis";
+    case FileType::OggVorbis:   return "Ogg Vorbis";
-    case Song::FileType_OggOpus:     return "Ogg Opus";
+    case FileType::OggOpus:     return "Ogg Opus";
-    case Song::FileType_OggSpeex:    return "Ogg Speex";
+    case FileType::OggSpeex:    return "Ogg Speex";
-    case Song::FileType_MPEG:        return "MP3";
+    case FileType::MPEG:        return "MP3";
-    case Song::FileType_MP4:         return "MP4 AAC";
+    case FileType::MP4:         return "MP4 AAC";
-    case Song::FileType_ASF:         return "Windows Media audio";
+    case FileType::ASF:         return "Windows Media audio";
-    case Song::FileType_AIFF:        return "AIFF";
+    case FileType::AIFF:        return "AIFF";
-    case Song::FileType_MPC:         return "MPC";
+    case FileType::MPC:         return "MPC";
-    case Song::FileType_TrueAudio:   return "TrueAudio";
+    case FileType::TrueAudio:   return "TrueAudio";
-    case Song::FileType_DSF:         return "DSF";
+    case FileType::DSF:         return "DSF";
-    case Song::FileType_DSDIFF:      return "DSDIFF";
+    case FileType::DSDIFF:      return "DSDIFF";
-    case Song::FileType_PCM:         return "PCM";
+    case FileType::PCM:         return "PCM";
-    case Song::FileType_APE:         return "Monkey's Audio";
+    case FileType::APE:         return "Monkey's Audio";
-    case Song::FileType_MOD:         return "Module Music Format";
+    case FileType::MOD:         return "Module Music Format";
-    case Song::FileType_S3M:         return "Module Music Format";
+    case FileType::S3M:         return "Module Music Format";
-    case Song::FileType_XM:          return "Module Music Format";
+    case FileType::XM:          return "Module Music Format";
-    case Song::FileType_IT:          return "Module Music Format";
+    case FileType::IT:          return "Module Music Format";
-    case Song::FileType_CDDA:        return "CDDA";
+    case FileType::CDDA:        return "CDDA";
-    case Song::FileType_SPC:         return "SNES SPC700";
+    case FileType::SPC:         return "SNES SPC700";
-    case Song::FileType_VGM:         return "VGM";
+    case FileType::VGM:         return "VGM";
-    case Song::FileType_Stream:      return "Stream";
+    case FileType::Stream:      return "Stream";
-    case Song::FileType_Unknown:
+    case FileType::Unknown:
     default:                         return QObject::tr("Unknown");
   }
 
 }
 
-QString Song::ExtensionForFiletype(FileType filetype) {
+QString Song::ExtensionForFiletype(const FileType filetype) {
 
   switch (filetype) {
-    case Song::FileType_WAV:         return "wav";
+    case FileType::WAV:         return "wav";
-    case Song::FileType_FLAC:        return "flac";
+    case FileType::FLAC:        return "flac";
-    case Song::FileType_WavPack:     return "wv";
+    case FileType::WavPack:     return "wv";
-    case Song::FileType_OggFlac:     return "flac";
+    case FileType::OggFlac:     return "flac";
-    case Song::FileType_OggVorbis:   return "ogg";
+    case FileType::OggVorbis:   return "ogg";
-    case Song::FileType_OggOpus:     return "opus";
+    case FileType::OggOpus:     return "opus";
-    case Song::FileType_OggSpeex:    return "spx";
+    case FileType::OggSpeex:    return "spx";
-    case Song::FileType_MPEG:        return "mp3";
+    case FileType::MPEG:        return "mp3";
-    case Song::FileType_MP4:         return "mp4";
+    case FileType::MP4:         return "mp4";
-    case Song::FileType_ASF:         return "wma";
+    case FileType::ASF:         return "wma";
-    case Song::FileType_AIFF:        return "aiff";
+    case FileType::AIFF:        return "aiff";
-    case Song::FileType_MPC:         return "mpc";
+    case FileType::MPC:         return "mpc";
-    case Song::FileType_TrueAudio:   return "tta";
+    case FileType::TrueAudio:   return "tta";
-    case Song::FileType_DSF:         return "dsf";
+    case FileType::DSF:         return "dsf";
-    case Song::FileType_DSDIFF:      return "dsd";
+    case FileType::DSDIFF:      return "dsd";
-    case Song::FileType_APE:         return "ape";
+    case FileType::APE:         return "ape";
-    case Song::FileType_MOD:         return "mod";
+    case FileType::MOD:         return "mod";
-    case Song::FileType_S3M:         return "s3m";
+    case FileType::S3M:         return "s3m";
-    case Song::FileType_XM:          return "xm";
+    case FileType::XM:          return "xm";
-    case Song::FileType_IT:          return "it";
+    case FileType::IT:          return "it";
-    case Song::FileType_SPC:         return "spc";
+    case FileType::SPC:         return "spc";
-    case Song::FileType_VGM:         return "vgm";
+    case FileType::VGM:         return "vgm";
-    case Song::FileType_Unknown:
+    case FileType::Unknown:
     default:                         return "dat";
   }
 
 }
 
-QIcon Song::IconForFiletype(FileType filetype) {
+QIcon Song::IconForFiletype(const FileType filetype) {
 
   switch (filetype) {
-    case Song::FileType_WAV:         return IconLoader::Load("wav");
+    case FileType::WAV:         return IconLoader::Load("wav");
-    case Song::FileType_FLAC:        return IconLoader::Load("flac");
+    case FileType::FLAC:        return IconLoader::Load("flac");
-    case Song::FileType_WavPack:     return IconLoader::Load("wavpack");
+    case FileType::WavPack:     return IconLoader::Load("wavpack");
-    case Song::FileType_OggFlac:     return IconLoader::Load("flac");
+    case FileType::OggFlac:     return IconLoader::Load("flac");
-    case Song::FileType_OggVorbis:   return IconLoader::Load("vorbis");
+    case FileType::OggVorbis:   return IconLoader::Load("vorbis");
-    case Song::FileType_OggOpus:     return IconLoader::Load("opus");
+    case FileType::OggOpus:     return IconLoader::Load("opus");
-    case Song::FileType_OggSpeex:    return IconLoader::Load("speex");
+    case FileType::OggSpeex:    return IconLoader::Load("speex");
-    case Song::FileType_MPEG:        return IconLoader::Load("mp3");
+    case FileType::MPEG:        return IconLoader::Load("mp3");
-    case Song::FileType_MP4:         return IconLoader::Load("mp4");
+    case FileType::MP4:         return IconLoader::Load("mp4");
-    case Song::FileType_ASF:         return IconLoader::Load("wma");
+    case FileType::ASF:         return IconLoader::Load("wma");
-    case Song::FileType_AIFF:        return IconLoader::Load("aiff");
+    case FileType::AIFF:        return IconLoader::Load("aiff");
-    case Song::FileType_MPC:         return IconLoader::Load("mpc");
+    case FileType::MPC:         return IconLoader::Load("mpc");
-    case Song::FileType_TrueAudio:   return IconLoader::Load("trueaudio");
+    case FileType::TrueAudio:   return IconLoader::Load("trueaudio");
-    case Song::FileType_DSF:         return IconLoader::Load("dsf");
+    case FileType::DSF:         return IconLoader::Load("dsf");
-    case Song::FileType_DSDIFF:      return IconLoader::Load("dsd");
+    case FileType::DSDIFF:      return IconLoader::Load("dsd");
-    case Song::FileType_PCM:         return IconLoader::Load("pcm");
+    case FileType::PCM:         return IconLoader::Load("pcm");
-    case Song::FileType_APE:         return IconLoader::Load("ape");
+    case FileType::APE:         return IconLoader::Load("ape");
-    case Song::FileType_MOD:         return IconLoader::Load("mod");
+    case FileType::MOD:         return IconLoader::Load("mod");
-    case Song::FileType_S3M:         return IconLoader::Load("s3m");
+    case FileType::S3M:         return IconLoader::Load("s3m");
-    case Song::FileType_XM:          return IconLoader::Load("xm");
+    case FileType::XM:          return IconLoader::Load("xm");
-    case Song::FileType_IT:          return IconLoader::Load("it");
+    case FileType::IT:          return IconLoader::Load("it");
-    case Song::FileType_CDDA:        return IconLoader::Load("cd");
+    case FileType::CDDA:        return IconLoader::Load("cd");
-    case Song::FileType_Stream:      return IconLoader::Load("applications-internet");
+    case FileType::Stream:      return IconLoader::Load("applications-internet");
-    case Song::FileType_Unknown:
+    case FileType::Unknown:
     default:                         return IconLoader::Load("edit-delete");
   }
 
@@ -740,17 +740,17 @@ QIcon Song::IconForFiletype(FileType filetype) {
 
 bool Song::IsFileLossless() const {
   switch (filetype()) {
-    case Song::FileType_WAV:
+    case FileType::WAV:
-    case Song::FileType_FLAC:
+    case FileType::FLAC:
-    case Song::FileType_OggFlac:
+    case FileType::OggFlac:
-    case Song::FileType_WavPack:
+    case FileType::WavPack:
-    case Song::FileType_AIFF:
+    case FileType::AIFF:
-    case Song::FileType_DSF:
+    case FileType::DSF:
-    case Song::FileType_DSDIFF:
+    case FileType::DSDIFF:
-    case Song::FileType_APE:
+    case FileType::APE:
-    case Song::FileType_TrueAudio:
+    case FileType::TrueAudio:
-    case Song::FileType_PCM:
+    case FileType::PCM:
-    case Song::FileType_CDDA:
+    case FileType::CDDA:
       return true;
     default:
       return false;
@@ -759,103 +759,103 @@ bool Song::IsFileLossless() const {
 
 Song::FileType Song::FiletypeByMimetype(const QString &mimetype) {
 
-  if (mimetype.compare("audio/wav", Qt::CaseInsensitive) == 0 || mimetype.compare("audio/x-wav", Qt::CaseInsensitive) == 0) return Song::FileType_WAV;
+  if (mimetype.compare("audio/wav", Qt::CaseInsensitive) == 0 || mimetype.compare("audio/x-wav", Qt::CaseInsensitive) == 0) return FileType::WAV;
-  else if (mimetype.compare("audio/x-flac", Qt::CaseInsensitive) == 0) return Song::FileType_FLAC;
+  else if (mimetype.compare("audio/x-flac", Qt::CaseInsensitive) == 0) return FileType::FLAC;
-  else if (mimetype.compare("audio/x-wavpack", Qt::CaseInsensitive) == 0) return Song::FileType_WavPack;
+  else if (mimetype.compare("audio/x-wavpack", Qt::CaseInsensitive) == 0) return FileType::WavPack;
-  else if (mimetype.compare("audio/x-vorbis", Qt::CaseInsensitive) == 0) return Song::FileType_OggVorbis;
+  else if (mimetype.compare("audio/x-vorbis", Qt::CaseInsensitive) == 0) return FileType::OggVorbis;
-  else if (mimetype.compare("audio/x-opus", Qt::CaseInsensitive) == 0) return Song::FileType_OggOpus;
+  else if (mimetype.compare("audio/x-opus", Qt::CaseInsensitive) == 0) return FileType::OggOpus;
-  else if (mimetype.compare("audio/x-speex", Qt::CaseInsensitive) == 0)  return Song::FileType_OggSpeex;
+  else if (mimetype.compare("audio/x-speex", Qt::CaseInsensitive) == 0)  return FileType::OggSpeex;
   // Gstreamer returns audio/mpeg for both MP3 and MP4/AAC.
-  // else if (mimetype.compare("audio/mpeg", Qt::CaseInsensitive) == 0) return Song::FileType_MPEG;
+  // else if (mimetype.compare("audio/mpeg", Qt::CaseInsensitive) == 0) return FileType::MPEG;
-  else if (mimetype.compare("audio/aac", Qt::CaseInsensitive) == 0) return Song::FileType_MP4;
+  else if (mimetype.compare("audio/aac", Qt::CaseInsensitive) == 0) return FileType::MP4;
-  else if (mimetype.compare("audio/x-wma", Qt::CaseInsensitive) == 0) return Song::FileType_ASF;
+  else if (mimetype.compare("audio/x-wma", Qt::CaseInsensitive) == 0) return FileType::ASF;
-  else if (mimetype.compare("audio/aiff", Qt::CaseInsensitive) == 0 || mimetype.compare("audio/x-aiff", Qt::CaseInsensitive) == 0) return Song::FileType_AIFF;
+  else if (mimetype.compare("audio/aiff", Qt::CaseInsensitive) == 0 || mimetype.compare("audio/x-aiff", Qt::CaseInsensitive) == 0) return FileType::AIFF;
-  else if (mimetype.compare("application/x-project", Qt::CaseInsensitive) == 0) return Song::FileType_MPC;
+  else if (mimetype.compare("application/x-project", Qt::CaseInsensitive) == 0) return FileType::MPC;
-  else if (mimetype.compare("audio/x-dsf", Qt::CaseInsensitive) == 0) return Song::FileType_DSF;
+  else if (mimetype.compare("audio/x-dsf", Qt::CaseInsensitive) == 0) return FileType::DSF;
-  else if (mimetype.compare("audio/x-dsd", Qt::CaseInsensitive) == 0) return Song::FileType_DSDIFF;
+  else if (mimetype.compare("audio/x-dsd", Qt::CaseInsensitive) == 0) return FileType::DSDIFF;
-  else if (mimetype.compare("audio/x-ape", Qt::CaseInsensitive) == 0 || mimetype.compare("application/x-ape", Qt::CaseInsensitive) == 0 || mimetype.compare("audio/x-ffmpeg-parsed-ape", Qt::CaseInsensitive) == 0) return Song::FileType_APE;
+  else if (mimetype.compare("audio/x-ape", Qt::CaseInsensitive) == 0 || mimetype.compare("application/x-ape", Qt::CaseInsensitive) == 0 || mimetype.compare("audio/x-ffmpeg-parsed-ape", Qt::CaseInsensitive) == 0) return FileType::APE;
-  else if (mimetype.compare("audio/x-mod", Qt::CaseInsensitive) == 0) return Song::FileType_MOD;
+  else if (mimetype.compare("audio/x-mod", Qt::CaseInsensitive) == 0) return FileType::MOD;
-  else if (mimetype.compare("audio/x-s3m", Qt::CaseInsensitive) == 0) return Song::FileType_S3M;
+  else if (mimetype.compare("audio/x-s3m", Qt::CaseInsensitive) == 0) return FileType::S3M;
-  else if (mimetype.compare("audio/x-spc", Qt::CaseInsensitive) == 0) return Song::FileType_SPC;
+  else if (mimetype.compare("audio/x-spc", Qt::CaseInsensitive) == 0) return FileType::SPC;
-  else if (mimetype.compare("audio/x-vgm", Qt::CaseInsensitive) == 0) return Song::FileType_VGM;
+  else if (mimetype.compare("audio/x-vgm", Qt::CaseInsensitive) == 0) return FileType::VGM;
 
-  else return Song::FileType_Unknown;
+  else return FileType::Unknown;
 
 }
 
 Song::FileType Song::FiletypeByDescription(const QString &text) {
 
-  if (text.compare("WAV", Qt::CaseInsensitive) == 0) return Song::FileType_WAV;
+  if (text.compare("WAV", Qt::CaseInsensitive) == 0) return FileType::WAV;
-  else if (text.compare("Free Lossless Audio Codec (FLAC)", Qt::CaseInsensitive) == 0) return Song::FileType_FLAC;
+  else if (text.compare("Free Lossless Audio Codec (FLAC)", Qt::CaseInsensitive) == 0) return FileType::FLAC;
-  else if (text.compare("Wavpack", Qt::CaseInsensitive) == 0) return Song::FileType_WavPack;
+  else if (text.compare("Wavpack", Qt::CaseInsensitive) == 0) return FileType::WavPack;
-  else if (text.compare("Vorbis", Qt::CaseInsensitive) == 0) return Song::FileType_OggVorbis;
+  else if (text.compare("Vorbis", Qt::CaseInsensitive) == 0) return FileType::OggVorbis;
-  else if (text.compare("Opus", Qt::CaseInsensitive) == 0) return Song::FileType_OggOpus;
+  else if (text.compare("Opus", Qt::CaseInsensitive) == 0) return FileType::OggOpus;
-  else if (text.compare("Speex", Qt::CaseInsensitive) == 0) return Song::FileType_OggSpeex;
+  else if (text.compare("Speex", Qt::CaseInsensitive) == 0) return FileType::OggSpeex;
-  else if (text.compare("MPEG-1 Layer 3 (MP3)", Qt::CaseInsensitive) == 0) return Song::FileType_MPEG;
+  else if (text.compare("MPEG-1 Layer 3 (MP3)", Qt::CaseInsensitive) == 0) return FileType::MPEG;
-  else if (text.compare("MPEG-4 AAC", Qt::CaseInsensitive) == 0) return Song::FileType_MP4;
+  else if (text.compare("MPEG-4 AAC", Qt::CaseInsensitive) == 0) return FileType::MP4;
-  else if (text.compare("WMA", Qt::CaseInsensitive) == 0) return Song::FileType_ASF;
+  else if (text.compare("WMA", Qt::CaseInsensitive) == 0) return FileType::ASF;
-  else if (text.compare("Audio Interchange File Format", Qt::CaseInsensitive) == 0) return Song::FileType_AIFF;
+  else if (text.compare("Audio Interchange File Format", Qt::CaseInsensitive) == 0) return FileType::AIFF;
-  else if (text.compare("MPC", Qt::CaseInsensitive) == 0) return Song::FileType_MPC;
+  else if (text.compare("MPC", Qt::CaseInsensitive) == 0) return FileType::MPC;
-  else if (text.compare("audio/x-dsf", Qt::CaseInsensitive) == 0) return Song::FileType_DSF;
+  else if (text.compare("audio/x-dsf", Qt::CaseInsensitive) == 0) return FileType::DSF;
-  else if (text.compare("audio/x-dsd", Qt::CaseInsensitive) == 0) return Song::FileType_DSDIFF;
+  else if (text.compare("audio/x-dsd", Qt::CaseInsensitive) == 0) return FileType::DSDIFF;
-  else if (text.compare("audio/x-ffmpeg-parsed-ape", Qt::CaseInsensitive) == 0) return Song::FileType_APE;
+  else if (text.compare("audio/x-ffmpeg-parsed-ape", Qt::CaseInsensitive) == 0) return FileType::APE;
-  else if (text.compare("Module Music Format (MOD)", Qt::CaseInsensitive) == 0) return Song::FileType_MOD;
+  else if (text.compare("Module Music Format (MOD)", Qt::CaseInsensitive) == 0) return FileType::MOD;
-  else if (text.compare("Module Music Format (MOD)", Qt::CaseInsensitive) == 0) return Song::FileType_S3M;
+  else if (text.compare("Module Music Format (MOD)", Qt::CaseInsensitive) == 0) return FileType::S3M;
-  else if (text.compare("SNES SPC700", Qt::CaseInsensitive) == 0) return Song::FileType_SPC;
+  else if (text.compare("SNES SPC700", Qt::CaseInsensitive) == 0) return FileType::SPC;
-  else if (text.compare("VGM", Qt::CaseInsensitive) == 0) return Song::FileType_VGM;
+  else if (text.compare("VGM", Qt::CaseInsensitive) == 0) return FileType::VGM;
-  else return Song::FileType_Unknown;
+  else return FileType::Unknown;
 
 }
 
 Song::FileType Song::FiletypeByExtension(const QString &ext) {
 
-  if (ext.compare("wav", Qt::CaseInsensitive) == 0 || ext.compare("wave", Qt::CaseInsensitive) == 0) return Song::FileType_WAV;
+  if (ext.compare("wav", Qt::CaseInsensitive) == 0 || ext.compare("wave", Qt::CaseInsensitive) == 0) return FileType::WAV;
-  else if (ext.compare("flac", Qt::CaseInsensitive) == 0) return Song::FileType_FLAC;
+  else if (ext.compare("flac", Qt::CaseInsensitive) == 0) return FileType::FLAC;
-  else if (ext.compare("wavpack", Qt::CaseInsensitive) == 0 || ext.compare("wv", Qt::CaseInsensitive) == 0) return Song::FileType_WavPack;
+  else if (ext.compare("wavpack", Qt::CaseInsensitive) == 0 || ext.compare("wv", Qt::CaseInsensitive) == 0) return FileType::WavPack;
-  else if (ext.compare("ogg", Qt::CaseInsensitive) == 0 || ext.compare("oga", Qt::CaseInsensitive) == 0) return Song::FileType_OggVorbis;
+  else if (ext.compare("ogg", Qt::CaseInsensitive) == 0 || ext.compare("oga", Qt::CaseInsensitive) == 0) return FileType::OggVorbis;
-  else if (ext.compare("opus", Qt::CaseInsensitive) == 0) return Song::FileType_OggOpus;
+  else if (ext.compare("opus", Qt::CaseInsensitive) == 0) return FileType::OggOpus;
-  else if (ext.compare("speex", Qt::CaseInsensitive) == 0 || ext.compare("spx", Qt::CaseInsensitive) == 0) return Song::FileType_OggSpeex;
+  else if (ext.compare("speex", Qt::CaseInsensitive) == 0 || ext.compare("spx", Qt::CaseInsensitive) == 0) return FileType::OggSpeex;
-  else if (ext.compare("mp3", Qt::CaseInsensitive) == 0) return Song::FileType_MPEG;
+  else if (ext.compare("mp3", Qt::CaseInsensitive) == 0) return FileType::MPEG;
-  else if (ext.compare("mp4", Qt::CaseInsensitive) == 0 || ext.compare("m4a", Qt::CaseInsensitive) == 0 || ext.compare("aac", Qt::CaseInsensitive) == 0) return Song::FileType_MP4;
+  else if (ext.compare("mp4", Qt::CaseInsensitive) == 0 || ext.compare("m4a", Qt::CaseInsensitive) == 0 || ext.compare("aac", Qt::CaseInsensitive) == 0) return FileType::MP4;
-  else if (ext.compare("asf", Qt::CaseInsensitive) == 0 || ext.compare("wma", Qt::CaseInsensitive) == 0) return Song::FileType_ASF;
+  else if (ext.compare("asf", Qt::CaseInsensitive) == 0 || ext.compare("wma", Qt::CaseInsensitive) == 0) return FileType::ASF;
-  else if (ext.compare("aiff", Qt::CaseInsensitive) == 0 || ext.compare("aif", Qt::CaseInsensitive) == 0 || ext.compare("aifc", Qt::CaseInsensitive) == 0) return Song::FileType_AIFF;
+  else if (ext.compare("aiff", Qt::CaseInsensitive) == 0 || ext.compare("aif", Qt::CaseInsensitive) == 0 || ext.compare("aifc", Qt::CaseInsensitive) == 0) return FileType::AIFF;
-  else if (ext.compare("mpc", Qt::CaseInsensitive) == 0 || ext.compare("mp+", Qt::CaseInsensitive) == 0 || ext.compare("mpp", Qt::CaseInsensitive) == 0) return Song::FileType_MPC;
+  else if (ext.compare("mpc", Qt::CaseInsensitive) == 0 || ext.compare("mp+", Qt::CaseInsensitive) == 0 || ext.compare("mpp", Qt::CaseInsensitive) == 0) return FileType::MPC;
-  else if (ext.compare("dsf", Qt::CaseInsensitive) == 0) return Song::FileType_DSF;
+  else if (ext.compare("dsf", Qt::CaseInsensitive) == 0) return FileType::DSF;
-  else if (ext.compare("dsd", Qt::CaseInsensitive) == 0 || ext.compare("dff", Qt::CaseInsensitive) == 0) return Song::FileType_DSDIFF;
+  else if (ext.compare("dsd", Qt::CaseInsensitive) == 0 || ext.compare("dff", Qt::CaseInsensitive) == 0) return FileType::DSDIFF;
-  else if (ext.compare("ape", Qt::CaseInsensitive) == 0) return Song::FileType_APE;
+  else if (ext.compare("ape", Qt::CaseInsensitive) == 0) return FileType::APE;
   else if (ext.compare("mod", Qt::CaseInsensitive) == 0 ||
            ext.compare("module", Qt::CaseInsensitive) == 0 ||
            ext.compare("nst", Qt::CaseInsensitive) == 0||
-           ext.compare("wow", Qt::CaseInsensitive) == 0) return Song::FileType_MOD;
+           ext.compare("wow", Qt::CaseInsensitive) == 0) return FileType::MOD;
-  else if (ext.compare("s3m", Qt::CaseInsensitive) == 0) return Song::FileType_S3M;
+  else if (ext.compare("s3m", Qt::CaseInsensitive) == 0) return FileType::S3M;
-  else if (ext.compare("xm", Qt::CaseInsensitive) == 0) return Song::FileType_XM;
+  else if (ext.compare("xm", Qt::CaseInsensitive) == 0) return FileType::XM;
-  else if (ext.compare("it", Qt::CaseInsensitive) == 0) return Song::FileType_IT;
+  else if (ext.compare("it", Qt::CaseInsensitive) == 0) return FileType::IT;
-  else if (ext.compare("spc", Qt::CaseInsensitive) == 0) return Song::FileType_SPC;
+  else if (ext.compare("spc", Qt::CaseInsensitive) == 0) return FileType::SPC;
-  else if (ext.compare("vgm", Qt::CaseInsensitive) == 0) return Song::FileType_VGM;
+  else if (ext.compare("vgm", Qt::CaseInsensitive) == 0) return FileType::VGM;
 
-  else return Song::FileType_Unknown;
+  else return FileType::Unknown;
 
 }
 
-QString Song::ImageCacheDir(const Song::Source source) {
+QString Song::ImageCacheDir(const Source source) {
 
   switch (source) {
-    case Song::Source_Collection:
+    case Source::Collection:
       return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/collectionalbumcovers";
-    case Song::Source_Subsonic:
+    case Source::Subsonic:
       return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/subsonicalbumcovers";
-    case Song::Source_Tidal:
+    case Source::Tidal:
       return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/tidalalbumcovers";
-    case Song::Source_Qobuz:
+    case Source::Qobuz:
       return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/qobuzalbumcovers";
-    case Song::Source_Device:
+    case Source::Device:
       return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/devicealbumcovers";
-    case Song::Source_LocalFile:
+    case Source::LocalFile:
-    case Song::Source_CDDA:
+    case Source::CDDA:
-    case Song::Source_Stream:
+    case Source::Stream:
-    case Song::Source_SomaFM:
+    case Source::SomaFM:
-    case Song::Source_RadioParadise:
+    case Source::RadioParadise:
-    case Song::Source_Unknown:
+    case Source::Unknown:
       return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/albumcovers";
   }
 
@@ -899,7 +899,7 @@ void Song::Init(const QString &title, const QString &artist, const QString &albu
 
 void Song::InitFromProtobuf(const spb::tagreader::SongMetadata &pb) {
 
-  if (d->source_ == Source_Unknown) d->source_ = Source_LocalFile;
+  if (d->source_ == Source::Unknown) d->source_ = Source::LocalFile;
 
   d->init_from_file_ = true;
   d->valid_ = pb.valid();
@@ -1068,7 +1068,7 @@ void Song::InitFromFilePartial(const QString &filename, const QFileInfo &fileinf
 
   set_url(QUrl::fromLocalFile(filename));
   d->valid_ = true;
-  d->source_ = Source_LocalFile;
+  d->source_ = Source::LocalFile;
   d->filetype_ = FiletypeByExtension(fileinfo.suffix());
   d->basefilename_ = fileinfo.fileName();
   d->title_ = fileinfo.fileName();
@@ -1091,7 +1091,7 @@ void Song::InitArtManual() {
 
 void Song::InitArtAutomatic() {
 
-  if (d->source_ == Source_LocalFile && d->url_.isLocalFile() && d->art_automatic_.isEmpty()) {
+  if (d->source_ == Source::LocalFile && d->url_.isLocalFile() && d->art_automatic_.isEmpty()) {
     // Pick the first image file in the album directory.
     QFileInfo file(d->url_.toLocalFile());
     QDir dir(file.path());
@@ -1127,7 +1127,7 @@ void Song::InitFromItdb(Itdb_Track *track, const QString &prefix) {
   d->samplerate_ = track->samplerate;
   d->bitdepth_ = -1; //track->bitdepth;
 
-  d->source_ = Source_Device;
+  d->source_ = Source::Device;
   QString filename = QString::fromLocal8Bit(track->ipod_path);
   filename.replace(':', '/');
   if (prefix.contains("://")) {
@@ -1138,7 +1138,7 @@ void Song::InitFromItdb(Itdb_Track *track, const QString &prefix) {
   }
   d->basefilename_ = QFileInfo(filename).fileName();
 
-  d->filetype_ = track->type2 ? FileType_MPEG : FileType_MP4;
+  d->filetype_ = track->type2 ? FileType::MPEG : FileType::MP4;
   d->filesize_ = track->size;
   d->mtime_ = track->time_modified;
   d->ctime_ = track->time_added;
@@ -1150,7 +1150,7 @@ void Song::InitFromItdb(Itdb_Track *track, const QString &prefix) {
   if (itdb_track_has_thumbnails(track) && !d->artist_.isEmpty() && !d->title_.isEmpty()) {
     GdkPixbuf *pixbuf = static_cast<GdkPixbuf*>(itdb_track_get_thumbnail(track, -1, -1));
     if (pixbuf) {
-      QString cover_path = ImageCacheDir(Source_Device);
+      QString cover_path = ImageCacheDir(Source::Device);
       QDir dir(cover_path);
       if (!dir.exists()) dir.mkpath(cover_path);
       QString cover_file = cover_path + "/" + Utilities::Sha1CoverHash(effective_albumartist(), effective_album()).toHex() + ".jpg";
@@ -1184,8 +1184,8 @@ void Song::ToItdb(Itdb_Track *track) const {
   track->bitrate = d->bitrate_;
   track->samplerate = d->samplerate_;
 
-  track->type1 = (d->filetype_ == FileType_MPEG ? 1 : 0);
+  track->type1 = (d->filetype_ == FileType::MPEG ? 1 : 0);
-  track->type2 = (d->filetype_ == FileType_MPEG ? 1 : 0);
+  track->type2 = (d->filetype_ == FileType::MPEG ? 1 : 0);
   track->mediatype = 1;  // Audio
   track->size = static_cast<uint>(d->filesize_);
   track->time_modified = d->mtime_;
@@ -1202,7 +1202,7 @@ void Song::ToItdb(Itdb_Track *track) const {
 void Song::InitFromMTP(const LIBMTP_track_t *track, const QString &host) {
 
   d->valid_ = true;
-  d->source_ = Source_Device;
+  d->source_ = Source::Device;
 
   set_title(QString::fromUtf8(track->title));
   set_artist(QString::fromUtf8(track->artist));
@@ -1226,19 +1226,19 @@ void Song::InitFromMTP(const LIBMTP_track_t *track, const QString &host) {
   d->playcount_ = track->usecount;
 
   switch (track->filetype) {
-      case LIBMTP_FILETYPE_WAV:  d->filetype_ = FileType_WAV;       break;
+    case LIBMTP_FILETYPE_WAV:  d->filetype_ = FileType::WAV;       break;
-      case LIBMTP_FILETYPE_MP3:  d->filetype_ = FileType_MPEG;      break;
+    case LIBMTP_FILETYPE_MP3:  d->filetype_ = FileType::MPEG;      break;
-      case LIBMTP_FILETYPE_WMA:  d->filetype_ = FileType_ASF;       break;
+    case LIBMTP_FILETYPE_WMA:  d->filetype_ = FileType::ASF;       break;
-      case LIBMTP_FILETYPE_OGG:  d->filetype_ = FileType_OggVorbis; break;
+    case LIBMTP_FILETYPE_OGG:  d->filetype_ = FileType::OggVorbis; break;
-      case LIBMTP_FILETYPE_MP4:  d->filetype_ = FileType_MP4;       break;
+    case LIBMTP_FILETYPE_MP4:  d->filetype_ = FileType::MP4;       break;
-      case LIBMTP_FILETYPE_AAC:  d->filetype_ = FileType_MP4;       break;
+    case LIBMTP_FILETYPE_AAC:  d->filetype_ = FileType::MP4;       break;
-      case LIBMTP_FILETYPE_FLAC: d->filetype_ = FileType_OggFlac;   break;
+    case LIBMTP_FILETYPE_FLAC: d->filetype_ = FileType::OggFlac;   break;
-      case LIBMTP_FILETYPE_MP2:  d->filetype_ = FileType_MPEG;      break;
+    case LIBMTP_FILETYPE_MP2:  d->filetype_ = FileType::MPEG;      break;
-      case LIBMTP_FILETYPE_M4A:  d->filetype_ = FileType_MP4;       break;
+    case LIBMTP_FILETYPE_M4A:  d->filetype_ = FileType::MP4;       break;
-      default:
+    default:
-        d->filetype_ = FileType_Unknown;
+      d->filetype_ = FileType::Unknown;
-        d->valid_ = false;
+      d->valid_ = false;
-        break;
+      break;
   }
 
 }
@@ -1276,14 +1276,14 @@ void Song::ToMTP(LIBMTP_track_t *track) const {
   track->usecount = d->playcount_;
 
   switch (d->filetype_) {
-    case FileType_ASF:       track->filetype = LIBMTP_FILETYPE_ASF;         break;
+    case FileType::ASF:       track->filetype = LIBMTP_FILETYPE_ASF;         break;
-    case FileType_MP4:       track->filetype = LIBMTP_FILETYPE_MP4;         break;
+    case FileType::MP4:       track->filetype = LIBMTP_FILETYPE_MP4;         break;
-    case FileType_MPEG:      track->filetype = LIBMTP_FILETYPE_MP3;         break;
+    case FileType::MPEG:      track->filetype = LIBMTP_FILETYPE_MP3;         break;
-    case FileType_FLAC:
+    case FileType::FLAC:
-    case FileType_OggFlac:   track->filetype = LIBMTP_FILETYPE_FLAC;        break;
+    case FileType::OggFlac:   track->filetype = LIBMTP_FILETYPE_FLAC;        break;
-    case FileType_OggSpeex:
+    case FileType::OggSpeex:
-    case FileType_OggVorbis: track->filetype = LIBMTP_FILETYPE_OGG;         break;
+    case FileType::OggVorbis: track->filetype = LIBMTP_FILETYPE_OGG;         break;
-    case FileType_WAV:       track->filetype = LIBMTP_FILETYPE_WAV;         break;
+    case FileType::WAV:       track->filetype = LIBMTP_FILETYPE_WAV;         break;
     default:                 track->filetype = LIBMTP_FILETYPE_UNDEF_AUDIO; break;
   }
 
@@ -1335,7 +1335,7 @@ bool Song::MergeFromSimpleMetaBundle(const Engine::SimpleMetaBundle &bundle) {
   if (bundle.length > 0) set_length_nanosec(bundle.length);
   if (bundle.year > 0) d->year_ = bundle.year;
   if (bundle.track > 0) d->track_ = bundle.track;
-  if (bundle.filetype != FileType_Unknown) d->filetype_ = bundle.filetype;
+  if (bundle.filetype != FileType::Unknown) d->filetype_ = bundle.filetype;
   if (bundle.samplerate > 0) d->samplerate_ = bundle.samplerate;
   if (bundle.bitdepth > 0) d->bitdepth_ = bundle.bitdepth;
   if (bundle.bitrate > 0) d->bitrate_ = bundle.bitrate;
@@ -1375,10 +1375,10 @@ void Song::BindToQuery(SqlQuery *query) const {
   query->BindIntValue(":samplerate", d->samplerate_);
   query->BindIntValue(":bitdepth", d->bitdepth_);
 
-  query->BindValue(":source", d->source_);
+  query->BindValue(":source", static_cast<int>(d->source_));
   query->BindNotNullIntValue(":directory_id", d->directory_id_);
   query->BindUrlValue(":url", d->url_);
-  query->BindValue(":filetype", d->filetype_);
+  query->BindValue(":filetype", static_cast<int>(d->filetype_));
   query->BindLongLongValueOrZero(":filesize", d->filesize_);
   query->BindLongLongValueOrZero(":mtime", d->mtime_);
   query->BindLongLongValueOrZero(":ctime", d->ctime_);
@@ -1564,7 +1564,7 @@ bool Song::IsAllMetadataEqual(const Song &other) const {
 }
 
 bool Song::IsEditable() const {
-  return d->valid_ && d->url_.isValid() && (d->url_.isLocalFile() || d->source_ == Source_Stream) && !has_cue();
+  return d->valid_ && d->url_.isValid() && (d->url_.isLocalFile() || d->source_ == Source::Stream) && !has_cue();
 }
 
 bool Song::operator==(const Song &other) const {

src/core/song.h

@@ -65,53 +65,53 @@ class Song {
 
  public:
 
-  enum Source {
+  enum class Source {
-    Source_Unknown = 0,
+    Unknown = 0,
-    Source_LocalFile = 1,
+    LocalFile = 1,
-    Source_Collection = 2,
+    Collection = 2,
-    Source_CDDA = 3,
+    CDDA = 3,
-    Source_Device = 4,
+    Device = 4,
-    Source_Stream = 5,
+    Stream = 5,
-    Source_Tidal = 6,
+    Tidal = 6,
-    Source_Subsonic = 7,
+    Subsonic = 7,
-    Source_Qobuz = 8,
+    Qobuz = 8,
-    Source_SomaFM = 9,
+    SomaFM = 9,
-    Source_RadioParadise = 10
+    RadioParadise = 10
   };
 
   // Don't change these values - they're stored in the database, and defined in the tag reader protobuf.
   // If a new lossless file is added, also add it to IsFileLossless().
 
-  enum FileType {
+  enum class FileType {
-    FileType_Unknown = 0,
+    Unknown = 0,
-    FileType_WAV = 1,
+    WAV = 1,
-    FileType_FLAC = 2,
+    FLAC = 2,
-    FileType_WavPack = 3,
+    WavPack = 3,
-    FileType_OggFlac = 4,
+    OggFlac = 4,
-    FileType_OggVorbis = 5,
+    OggVorbis = 5,
-    FileType_OggOpus = 6,
+    OggOpus = 6,
-    FileType_OggSpeex = 7,
+    OggSpeex = 7,
-    FileType_MPEG = 8,
+    MPEG = 8,
-    FileType_MP4 = 9,
+    MP4 = 9,
-    FileType_ASF = 10,
+    ASF = 10,
-    FileType_AIFF = 11,
+    AIFF = 11,
-    FileType_MPC = 12,
+    MPC = 12,
-    FileType_TrueAudio = 13,
+    TrueAudio = 13,
-    FileType_DSF = 14,
+    DSF = 14,
-    FileType_DSDIFF = 15,
+    DSDIFF = 15,
-    FileType_PCM = 16,
+    PCM = 16,
-    FileType_APE = 17,
+    APE = 17,
-    FileType_MOD = 18,
+    MOD = 18,
-    FileType_S3M = 19,
+    S3M = 19,
-    FileType_XM = 20,
+    XM = 20,
-    FileType_IT = 21,
+    IT = 21,
-    FileType_SPC = 22,
+    SPC = 22,
-    FileType_VGM = 23,
+    VGM = 23,
-    FileType_CDDA = 90,
+    CDDA = 90,
-    FileType_Stream = 91,
+    Stream = 91
   };
 
-  Song(Song::Source source = Song::Source_Unknown);
+  Song(Source source = Source::Unknown);
   Song(const Song &other);
   ~Song();
 
@@ -139,13 +139,13 @@ class Song {
   static QString JoinSpec(const QString &table);
 
   static Source SourceFromURL(const QUrl &url);
-  static QString TextForSource(Source source);
+  static QString TextForSource(const Source source);
-  static QString DescriptionForSource(Source source);
+  static QString DescriptionForSource(const Source source);
-  static Song::Source SourceFromText(const QString &source);
+  static Source SourceFromText(const QString &source);
-  static QIcon IconForSource(Source source);
+  static QIcon IconForSource(const Source source);
-  static QString TextForFiletype(FileType filetype);
+  static QString TextForFiletype(const FileType filetype);
-  static QString ExtensionForFiletype(FileType filetype);
+  static QString ExtensionForFiletype(const FileType filetype);
-  static QIcon IconForFiletype(FileType filetype);
+  static QIcon IconForFiletype(const FileType filetype);
 
   QString TextForSource() const { return TextForSource(source()); }
   QString DescriptionForSource() const { return DescriptionForSource(source()); }
@@ -157,7 +157,7 @@ class Song {
   static FileType FiletypeByMimetype(const QString &mimetype);
   static FileType FiletypeByDescription(const QString &text);
   static FileType FiletypeByExtension(const QString &ext);
-  static QString ImageCacheDir(const Song::Source source);
+  static QString ImageCacheDir(const Source source);
 
   // Sort songs alphabetically using their pretty title
   static int CompareSongsName(const Song &song1, const Song &song2);

src/core/songloader.cpp

@@ -72,7 +72,7 @@ SongLoader::SongLoader(CollectionBackendInterface *collection, const Player *pla
       playlist_parser_(new PlaylistParser(collection, this)),
       cue_parser_(new CueParser(collection, this)),
       timeout_(kDefaultTimeout),
-      state_(WaitingForType),
+      state_(State::WaitingForType),
       success_(false),
       parser_(nullptr),
       collection_(collection),
@@ -100,7 +100,7 @@ SongLoader::~SongLoader() {
 
 #ifdef HAVE_GSTREAMER
   if (pipeline_) {
-    state_ = Finished;
+    state_ = State::Finished;
     gst_element_set_state(pipeline_.get(), GST_STATE_NULL);
   }
 #endif
@@ -109,7 +109,7 @@ SongLoader::~SongLoader() {
 
 SongLoader::Result SongLoader::Load(const QUrl &url) {
 
-  if (url.isEmpty()) return Error;
+  if (url.isEmpty()) return Result::Error;
 
   url_ = url;
 
@@ -121,13 +121,13 @@ SongLoader::Result SongLoader::Load(const QUrl &url) {
     // The URI scheme indicates that it can't possibly be a playlist,
     // or we have a custom handler for the URL, so add it as a raw stream.
     AddAsRawStream();
-    return Success;
+    return Result::Success;
   }
 
-  if (player_->engine()->type() == Engine::GStreamer) {
+  if (player_->engine()->type() == Engine::EngineType::GStreamer) {
 #ifdef HAVE_GSTREAMER
     preload_func_ = std::bind(&SongLoader::LoadRemote, this);
-    return BlockingLoadRequired;
+    return Result::BlockingLoadRequired;
 #else
     errors_ << tr("You need GStreamer for this URL.");
     return Error;
@@ -135,10 +135,10 @@ SongLoader::Result SongLoader::Load(const QUrl &url) {
   }
   else {
     errors_ << tr("You need GStreamer for this URL.");
-    return Error;
+    return Result::Error;
   }
 
-  return Success;
+  return Result::Success;
 
 }
 
@@ -149,7 +149,7 @@ SongLoader::Result SongLoader::LoadFilenamesBlocking() {
   }
   else {
     errors_ << tr("Preload function was not set for blocking operation.");
-    return Error;
+    return Result::Error;
   }
 
 }
@@ -162,44 +162,44 @@ SongLoader::Result SongLoader::LoadLocalPartial(const QString &filename) {
 
   if (!fileinfo.exists()) {
     errors_ << tr("File %1 does not exist.").arg(filename);
-    return Error;
+    return Result::Error;
   }
 
   // First check to see if it's a directory - if so we can load all the songs inside right away.
   if (fileinfo.isDir()) {
     LoadLocalDirectory(filename);
-    return Success;
+    return Result::Success;
   }
 
   // Assume it's just a normal file
   if (TagReaderClient::Instance()->IsMediaFileBlocking(filename) || Song::kAcceptedExtensions.contains(fileinfo.suffix(), Qt::CaseInsensitive)) {
-    Song song(Song::Source_LocalFile);
+    Song song(Song::Source::LocalFile);
     song.InitFromFilePartial(filename, fileinfo);
     if (song.is_valid()) {
       songs_ << song;
-      return Success;
+      return Result::Success;
     }
   }
 
   errors_ << QObject::tr("File %1 is not recognized as a valid audio file.").arg(filename);
-  return Error;
+  return Result::Error;
 
 }
 
 SongLoader::Result SongLoader::LoadAudioCD() {
 
 #if defined(HAVE_AUDIOCD) && defined(HAVE_GSTREAMER)
-  if (player_->engine()->type() == Engine::GStreamer) {
+  if (player_->engine()->type() == Engine::EngineType::GStreamer) {
     CddaSongLoader *cdda_song_loader = new CddaSongLoader(QUrl(), this);
     QObject::connect(cdda_song_loader, &CddaSongLoader::SongsDurationLoaded, this, &SongLoader::AudioCDTracksLoadFinishedSlot);
     QObject::connect(cdda_song_loader, &CddaSongLoader::SongsMetadataLoaded, this, &SongLoader::AudioCDTracksTagsLoaded);
     cdda_song_loader->LoadSongs();
-    return Success;
+    return Result::Success;
   }
   else {
 #endif
     errors_ << tr("CD playback is only available with the GStreamer engine.");
-    return Error;
+    return Result::Error;
 #if defined(HAVE_AUDIOCD) && defined(HAVE_GSTREAMER)
   }
 #endif
@@ -243,7 +243,7 @@ SongLoader::Result SongLoader::LoadLocal(const QString &filename) {
   if (query.Exec() && query.Next()) {
     // We may have many results when the file has many sections
     do {
-      Song song(Song::Source_Collection);
+      Song song(Song::Source::Collection);
       song.InitFromQuery(query, true);
 
       if (song.is_valid()) {
@@ -251,12 +251,12 @@ SongLoader::Result SongLoader::LoadLocal(const QString &filename) {
       }
     } while (query.Next());
 
-    return Success;
+    return Result::Success;
   }
 
   // It's not in the database, load it asynchronously.
   preload_func_ = std::bind(&SongLoader::LoadLocalAsync, this, filename);
-  return BlockingLoadRequired;
+  return Result::BlockingLoadRequired;
 
 }
 
@@ -266,20 +266,20 @@ SongLoader::Result SongLoader::LoadLocalAsync(const QString &filename) {
 
   if (!fileinfo.exists()) {
     errors_ << tr("File %1 does not exist.").arg(filename);
-    return Error;
+    return Result::Error;
   }
 
   // First check to see if it's a directory - if so we will load all the songs inside right away.
   if (fileinfo.isDir()) {
     LoadLocalDirectory(filename);
-    return Success;
+    return Result::Success;
   }
 
   // It's a local file, so check if it looks like a playlist. Read the first few bytes.
   QFile file(filename);
   if (!file.open(QIODevice::ReadOnly)) {
     errors_ << tr("Could not open file %1 for reading: %2").arg(filename, file.errorString());
-    return Error;
+    return Result::Error;
   }
   QByteArray data(file.read(PlaylistParser::kMagicSize));
   file.close();
@@ -287,13 +287,13 @@ SongLoader::Result SongLoader::LoadLocalAsync(const QString &filename) {
   ParserBase *parser = playlist_parser_->ParserForMagic(data);
   if (!parser) {
     // Check the file extension as well, maybe the magic failed, or it was a basic M3U file which is just a plain list of filenames.
-    parser = playlist_parser_->ParserForExtension(PlaylistParser::Type_Load, fileinfo.suffix().toLower());
+    parser = playlist_parser_->ParserForExtension(PlaylistParser::Type::Load, fileinfo.suffix().toLower());
   }
 
   if (parser) {  // It's a playlist!
     qLog(Debug) << "Parsing using" << parser->name();
     LoadPlaylist(parser, filename);
-    return Success;
+    return Result::Success;
   }
 
   // Check if it's a CUE file
@@ -307,26 +307,26 @@ SongLoader::Result SongLoader::LoadLocalAsync(const QString &filename) {
       for (const Song &song : songs) {
         if (song.is_valid()) songs_ << song;
       }
-      return Success;
+      return Result::Success;
     }
     else {
       errors_ << tr("Could not open CUE file %1 for reading: %2").arg(matching_cue, cue.errorString());
-      return Error;
+      return Result::Error;
     }
   }
 
   // Assume it's just a normal file
   if (TagReaderClient::Instance()->IsMediaFileBlocking(filename) || Song::kAcceptedExtensions.contains(fileinfo.suffix(), Qt::CaseInsensitive)) {
-    Song song(Song::Source_LocalFile);
+    Song song(Song::Source::LocalFile);
     song.InitFromFilePartial(filename, fileinfo);
     if (song.is_valid()) {
       songs_ << song;
-      return Success;
+      return Result::Success;
     }
   }
 
   errors_ << QObject::tr("File %1 is not recognized as a valid audio file.").arg(filename);
-  return Error;
+  return Result::Error;
 
 }
 
@@ -342,7 +342,7 @@ void SongLoader::EffectiveSongLoad(Song *song) {
 
   if (!song || !song->url().isLocalFile()) return;
 
-  if (song->init_from_file() && song->filetype() != Song::FileType_Unknown) {
+  if (song->init_from_file() && song->filetype() != Song::FileType::Unknown) {
     // Maybe we loaded the metadata already, for example from a cuesheet.
     return;
   }
@@ -409,7 +409,7 @@ void SongLoader::AddAsRawStream() {
 
   Song song(Song::SourceFromURL(url_));
   song.set_valid(true);
-  song.set_filetype(Song::FileType_Stream);
+  song.set_filetype(Song::FileType::Stream);
   song.set_url(url_);
   song.set_title(url_.toString());
   songs_ << song;
@@ -417,7 +417,7 @@ void SongLoader::AddAsRawStream() {
 }
 
 void SongLoader::Timeout() {
-  state_ = Finished;
+  state_ = State::Finished;
   success_ = false;
   StopTypefind();
 }
@@ -475,7 +475,7 @@ SongLoader::Result SongLoader::LoadRemote() {
   GstElement *source = gst_element_make_from_uri(GST_URI_SRC, url_.toEncoded().constData(), nullptr, nullptr);
   if (!source) {
     errors_ << tr("Couldn't create GStreamer source element for %1").arg(url_.toString());
-    return Error;
+    return Result::Error;
   }
   g_object_set(source, "ssl-strict", FALSE, nullptr);
 
@@ -508,7 +508,7 @@ SongLoader::Result SongLoader::LoadRemote() {
   // Wait until loading is finished
   loop.exec();
 
-  return Success;
+  return Result::Success;
 
 }
 #endif
@@ -518,14 +518,14 @@ void SongLoader::TypeFound(GstElement*, uint, GstCaps *caps, void *self) {
 
   SongLoader *instance = static_cast<SongLoader*>(self);
 
-  if (instance->state_ != WaitingForType) return;
+  if (instance->state_ != State::WaitingForType) return;
 
   // Check the mimetype
   instance->mime_type_ = gst_structure_get_name(gst_caps_get_structure(caps, 0));
   qLog(Debug) << "Mime type is" << instance->mime_type_;
   if (instance->mime_type_ == "text/plain" || instance->mime_type_ == "text/uri-list") {
     // Yeah it might be a playlist, let's get some data and have a better look
-    instance->state_ = WaitingForMagic;
+    instance->state_ = State::WaitingForMagic;
     return;
   }
 
@@ -540,7 +540,7 @@ GstPadProbeReturn SongLoader::DataReady(GstPad*, GstPadProbeInfo *info, gpointer
 
   SongLoader *instance = reinterpret_cast<SongLoader*>(self);
 
-  if (instance->state_ == Finished) {
+  if (instance->state_ == State::Finished) {
     return GST_PAD_PROBE_OK;
   }
 
@@ -553,7 +553,7 @@ GstPadProbeReturn SongLoader::DataReady(GstPad*, GstPadProbeInfo *info, gpointer
   qLog(Debug) << "Received total" << instance->buffer_.size() << "bytes";
   gst_buffer_unmap(buffer, &map);
 
-  if (instance->state_ == WaitingForMagic && (instance->buffer_.size() >= PlaylistParser::kMagicSize || !instance->IsPipelinePlaying())) {
+  if (instance->state_ == State::WaitingForMagic && (instance->buffer_.size() >= PlaylistParser::kMagicSize || !instance->IsPipelinePlaying())) {
     // Got enough that we can test the magic
     instance->MagicReady();
   }
@@ -604,7 +604,7 @@ GstBusSyncReply SongLoader::BusCallbackSync(GstBus*, GstMessage *msg, gpointer s
 #ifdef HAVE_GSTREAMER
 void SongLoader::ErrorMessageReceived(GstMessage *msg) {
 
-  if (state_ == Finished) return;
+  if (state_ == State::Finished) return;
 
   GError *error = nullptr;
   gchar *debugs = nullptr;
@@ -618,9 +618,9 @@ void SongLoader::ErrorMessageReceived(GstMessage *msg) {
   g_error_free(error);
   g_free(debugs);
 
-  if (state_ == WaitingForType && message_str == gst_error_get_message(GST_STREAM_ERROR, GST_STREAM_ERROR_TYPE_NOT_FOUND)) {
+  if (state_ == State::WaitingForType && message_str == gst_error_get_message(GST_STREAM_ERROR, GST_STREAM_ERROR_TYPE_NOT_FOUND)) {
     // Don't give up - assume it's a playlist and see if one of our parsers can read it.
-    state_ = WaitingForMagic;
+    state_ = State::WaitingForMagic;
     return;
   }
 
@@ -632,24 +632,24 @@ void SongLoader::ErrorMessageReceived(GstMessage *msg) {
 #ifdef HAVE_GSTREAMER
 void SongLoader::EndOfStreamReached() {
 
-  qLog(Debug) << Q_FUNC_INFO << state_;
+  qLog(Debug) << Q_FUNC_INFO << static_cast<int>(state_);
   switch (state_) {
-    case Finished:
+    case State::Finished:
       break;
 
-    case WaitingForMagic:
+    case State::WaitingForMagic:
       // Do the magic on the data we have already
       MagicReady();
-      if (state_ == Finished) break;
+      if (state_ == State::Finished) break;
     // It looks like a playlist, so parse it
 
     [[fallthrough]];
-    case WaitingForData:
+    case State::WaitingForData:
       // It's a playlist and we've got all the data - finish and parse it
       StopTypefindAsync(true);
       break;
 
-    case WaitingForType:
+    case State::WaitingForType:
       StopTypefindAsync(false);
       break;
   }
@@ -680,7 +680,7 @@ void SongLoader::MagicReady() {
     StopTypefindAsync(true);
   }
 
-  state_ = WaitingForData;
+  state_ = State::WaitingForData;
 
   if (!IsPipelinePlaying()) {
     EndOfStreamReached();
@@ -708,7 +708,7 @@ bool SongLoader::IsPipelinePlaying() {
 #ifdef HAVE_GSTREAMER
 void SongLoader::StopTypefindAsync(bool success) {
 
-  state_ = Finished;
+  state_ = State::Finished;
   success_ = success;
 
   QMetaObject::invokeMethod(this, "StopTypefind", Qt::QueuedConnection);

src/core/songloader.h

@@ -60,10 +60,10 @@ class SongLoader : public QObject {
   explicit SongLoader(CollectionBackendInterface *collection, const Player *player, QObject *parent = nullptr);
   ~SongLoader() override;
 
-  enum Result {
+  enum class Result {
     Success,
     Error,
-    BlockingLoadRequired,
+    BlockingLoadRequired
   };
 
   static const int kDefaultTimeout;
@@ -101,7 +101,12 @@ class SongLoader : public QObject {
 #endif  // HAVE_AUDIOCD && HAVE_GSTREAMER
 
  private:
-  enum State { WaitingForType, WaitingForMagic, WaitingForData, Finished };
+  enum class State {
+    WaitingForType,
+    WaitingForMagic,
+    WaitingForData,
+    Finished
+  };
 
   Result LoadLocal(const QString &filename);
   SongLoader::Result LoadLocalAsync(const QString &filename);

src/core/thread.cpp

@@ -25,7 +25,7 @@
 void Thread::run() {
 
 #ifndef Q_OS_WIN32
-  if (io_priority_ != Utilities::IOPRIO_CLASS_NONE) {
+  if (io_priority_ != Utilities::IoPriority::IOPRIO_CLASS_NONE) {
     Utilities::SetThreadIOPriority(io_priority_);
   }
 #endif

src/core/thread.h

@@ -31,7 +31,7 @@ class Thread : public QThread {
   Q_OBJECT
 
  public:
-  explicit Thread(QObject *parent = nullptr) : QThread(parent), io_priority_(Utilities::IOPRIO_CLASS_NONE) {}
+  explicit Thread(QObject *parent = nullptr) : QThread(parent), io_priority_(Utilities::IoPriority::IOPRIO_CLASS_NONE) {}
 
   void SetIoPriority(Utilities::IoPriority priority) {
     io_priority_ = priority;

src/core/urlhandler.cpp

@@ -44,7 +44,7 @@ UrlHandler::LoadResult::LoadResult(const QUrl &original_url, const Type type, co
 UrlHandler::LoadResult::LoadResult(const QUrl &original_url, const Type type, const QString &error) :
   original_url_(original_url),
   type_(type),
-  filetype_(Song::FileType_Stream),
+  filetype_(Song::FileType::Stream),
   samplerate_(-1),
   bit_depth_(-1),
   length_nanosec_(-1),

src/core/urlhandler.h

@@ -42,7 +42,7 @@ class UrlHandler : public QObject {
 
   // Returned by StartLoading() and LoadNext(), indicates what the player should do when it wants to load a URL.
   struct LoadResult {
-    enum Type {
+    enum class Type {
       // There wasn't a track available, and the player should move on to the next playlist item.
       NoMoreTracks,
 
@@ -57,7 +57,7 @@ class UrlHandler : public QObject {
       Error,
     };
 
-    explicit LoadResult(const QUrl &original_url = QUrl(), const Type type = NoMoreTracks, const QUrl &stream_url = QUrl(), const Song::FileType filetype = Song::FileType_Stream, const int samplerate = -1, const int bit_depth = -1, const qint64 length_nanosec = -1, const QString &error = QString());
+    explicit LoadResult(const QUrl &original_url = QUrl(), const Type type = Type::NoMoreTracks, const QUrl &stream_url = QUrl(), const Song::FileType filetype = Song::FileType::Stream, const int samplerate = -1, const int bit_depth = -1, const qint64 length_nanosec = -1, const QString &error = QString());
 
     explicit LoadResult(const QUrl &original_url, const Type type, const QString &error);
 

src/covermanager/albumcoverchoicecontroller.cpp

@@ -98,8 +98,8 @@ AlbumCoverChoiceController::AlbumCoverChoiceController(QWidget *parent)
       separator2_(nullptr),
       show_cover_(nullptr),
       search_cover_auto_(nullptr),
-      save_cover_type_(CollectionSettingsPage::SaveCoverType_Cache),
+      save_cover_type_(CollectionSettingsPage::SaveCoverType::Cache),
-      save_cover_filename_(CollectionSettingsPage::SaveCoverFilename_Pattern),
+      save_cover_filename_(CollectionSettingsPage::SaveCoverFilename::Pattern),
       cover_overwrite_(false),
       cover_lowercase_(true),
       cover_replace_spaces_(true),
@@ -146,8 +146,8 @@ void AlbumCoverChoiceController::ReloadSettings() {
 
   QSettings s;
   s.beginGroup(CollectionSettingsPage::kSettingsGroup);
-  save_cover_type_ = CollectionSettingsPage::SaveCoverType(s.value("save_cover_type", CollectionSettingsPage::SaveCoverType_Cache).toInt());
+  save_cover_type_ = static_cast<CollectionSettingsPage::SaveCoverType>(s.value("save_cover_type", static_cast<int>(CollectionSettingsPage::SaveCoverType::Cache)).toInt());
-  save_cover_filename_ = CollectionSettingsPage::SaveCoverFilename(s.value("save_cover_filename", CollectionSettingsPage::SaveCoverFilename_Pattern).toInt());
+  save_cover_filename_ = static_cast<CollectionSettingsPage::SaveCoverFilename>(s.value("save_cover_filename", static_cast<int>(CollectionSettingsPage::SaveCoverFilename::Pattern)).toInt());
   cover_pattern_ = s.value("cover_pattern", "%albumartist-%album").toString();
   cover_overwrite_ = s.value("cover_overwrite", false).toBool();
   cover_lowercase_ = s.value("cover_lowercase", false).toBool();
@@ -214,14 +214,14 @@ QUrl AlbumCoverChoiceController::LoadCoverFromFile(Song *song) {
   if (QImage(cover_file).isNull()) return QUrl();
 
   switch (get_save_album_cover_type()) {
-    case CollectionSettingsPage::SaveCoverType_Embedded:
+    case CollectionSettingsPage::SaveCoverType::Embedded:
       if (song->save_embedded_cover_supported()) {
         SaveCoverEmbeddedAutomatic(*song, cover_file);
         return QUrl::fromLocalFile(Song::kEmbeddedCover);
       }
       [[fallthrough]];
-    case CollectionSettingsPage::SaveCoverType_Cache:
+    case CollectionSettingsPage::SaveCoverType::Cache:
-    case CollectionSettingsPage::SaveCoverType_Album:{
+    case CollectionSettingsPage::SaveCoverType::Album:{
       QUrl cover_url = QUrl::fromLocalFile(cover_file);
       SaveArtManualToSong(song, cover_url);
       return cover_url;
@@ -540,7 +540,7 @@ void AlbumCoverChoiceController::SaveArtAutomaticToSong(Song *song, const QUrl &
     song->clear_art_manual();
   }
 
-  if (song->source() == Song::Source_Collection) {
+  if (song->source() == Song::Source::Collection) {
     app_->collection_backend()->UpdateAutomaticAlbumArtAsync(song->effective_albumartist(), song->album(), art_automatic, song->has_embedded_cover());
   }
 
@@ -559,20 +559,20 @@ void AlbumCoverChoiceController::SaveArtManualToSong(Song *song, const QUrl &art
 
   // Update the backends.
   switch (song->source()) {
-    case Song::Source_Collection:
+    case Song::Source::Collection:
       app_->collection_backend()->UpdateManualAlbumArtAsync(song->effective_albumartist(), song->album(), art_manual, clear_art_automatic);
       break;
-    case Song::Source_LocalFile:
+    case Song::Source::LocalFile:
-    case Song::Source_CDDA:
+    case Song::Source::CDDA:
-    case Song::Source_Device:
+    case Song::Source::Device:
-    case Song::Source_Stream:
+    case Song::Source::Stream:
-    case Song::Source_RadioParadise:
+    case Song::Source::RadioParadise:
-    case Song::Source_SomaFM:
+    case Song::Source::SomaFM:
-    case Song::Source_Unknown:
+    case Song::Source::Unknown:
       break;
-    case Song::Source_Tidal:
+    case Song::Source::Tidal:
-    case Song::Source_Qobuz:
+    case Song::Source::Qobuz:
-    case Song::Source_Subsonic:
+    case Song::Source::Subsonic:
       InternetService *service = app_->internet_services()->ServiceBySource(song->source());
       if (!service) break;
       if (service->artists_collection_backend()) {
@@ -618,7 +618,7 @@ QUrl AlbumCoverChoiceController::SaveCoverToFileAutomatic(const Song::Source sou
 
   QFile file(filepath);
   // Don't overwrite when saving in album dir if the filename is set to pattern unless "force_overwrite" is set.
-  if (source == Song::Source_Collection && !cover_overwrite_ && !force_overwrite && get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType_Album && save_cover_filename_ == CollectionSettingsPage::SaveCoverFilename_Pattern && file.exists()) {
+  if (source == Song::Source::Collection && !cover_overwrite_ && !force_overwrite && get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType::Album && save_cover_filename_ == CollectionSettingsPage::SaveCoverFilename::Pattern && file.exists()) {
     while (file.exists()) {
       QFileInfo fileinfo(file.fileName());
       file.setFileName(fileinfo.path() + "/0" + fileinfo.fileName());
@@ -653,7 +653,7 @@ QUrl AlbumCoverChoiceController::SaveCoverToFileAutomatic(const Song::Source sou
 
 void AlbumCoverChoiceController::SaveCoverEmbeddedAutomatic(const Song &song, const AlbumCoverImageResult &result) {
 
-  if (song.source() == Song::Source_Collection) {
+  if (song.source() == Song::Source::Collection) {
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     QFuture<SongList> future = QtConcurrent::run(&CollectionBackend::GetAlbumSongs, app_->collection_backend(), song.effective_albumartist(), song.effective_album(), CollectionFilterOptions());
 #else
@@ -698,7 +698,7 @@ void AlbumCoverChoiceController::SaveCoverEmbeddedAutomatic(const Song &song, co
 
 void AlbumCoverChoiceController::SaveCoverEmbeddedAutomatic(const Song &song, const QString &cover_filename) {
 
-  if (song.source() == Song::Source_Collection) {
+  if (song.source() == Song::Source::Collection) {
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     QFuture<SongList> future = QtConcurrent::run(&CollectionBackend::GetAlbumSongs, app_->collection_backend(), song.effective_albumartist(), song.effective_album(), CollectionFilterOptions());
 #else
@@ -758,7 +758,7 @@ QUrl AlbumCoverChoiceController::SaveCover(Song *song, const QDropEvent *e) {
     const QString suffix = QFileInfo(filename).suffix().toLower();
 
     if (IsKnownImageExtension(suffix)) {
-      if (get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType_Embedded && song->save_embedded_cover_supported()) {
+      if (get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType::Embedded && song->save_embedded_cover_supported()) {
         SaveCoverEmbeddedAutomatic(*song, filename);
         return QUrl::fromLocalFile(Song::kEmbeddedCover);
       }
@@ -784,7 +784,7 @@ QUrl AlbumCoverChoiceController::SaveCoverAutomatic(Song *song, const AlbumCover
 
   QUrl cover_url;
   switch(get_save_album_cover_type()) {
-    case CollectionSettingsPage::SaveCoverType_Embedded:{
+    case CollectionSettingsPage::SaveCoverType::Embedded:{
       if (song->save_embedded_cover_supported()) {
         SaveCoverEmbeddedAutomatic(*song, result);
         cover_url = QUrl::fromLocalFile(Song::kEmbeddedCover);
@@ -792,8 +792,8 @@ QUrl AlbumCoverChoiceController::SaveCoverAutomatic(Song *song, const AlbumCover
       }
     }
     [[fallthrough]];
-    case CollectionSettingsPage::SaveCoverType_Cache:
+    case CollectionSettingsPage::SaveCoverType::Cache:
-    case CollectionSettingsPage::SaveCoverType_Album:{
+    case CollectionSettingsPage::SaveCoverType::Album:{
       cover_url = SaveCoverToFileAutomatic(song, result);
       if (!cover_url.isEmpty()) SaveArtManualToSong(song, cover_url);
       break;

src/covermanager/albumcoverchoicecontroller.h

@@ -69,7 +69,7 @@ class AlbumCoverChoiceController : public QWidget {
   void Init(Application *app);
   void ReloadSettings();
 
-  CollectionSettingsPage::SaveCoverType get_save_album_cover_type() const { return (save_embedded_cover_override_ ? CollectionSettingsPage::SaveCoverType_Embedded : save_cover_type_); }
+  CollectionSettingsPage::SaveCoverType get_save_album_cover_type() const { return (save_embedded_cover_override_ ? CollectionSettingsPage::SaveCoverType::Embedded : save_cover_type_); }
   CollectionSettingsPage::SaveCoverType get_collection_save_album_cover_type() const { return save_cover_type_; }
 
   // Getters for all QActions implemented by this controller.

src/covermanager/albumcoverexport.cpp

@@ -52,9 +52,9 @@ AlbumCoverExport::DialogResult AlbumCoverExport::Exec() {
 
   // Restore last accepted settings
   ui_->fileName->setText(s.value("fileName", "cover").toString());
-  ui_->doNotOverwrite->setChecked(s.value("overwrite", OverwriteMode_None).toInt() == OverwriteMode_None);
+  ui_->doNotOverwrite->setChecked(static_cast<OverwriteMode>(s.value("overwrite", static_cast<int>(OverwriteMode::None)).toInt()) == OverwriteMode::None);
-  ui_->overwriteAll->setChecked(s.value("overwrite", OverwriteMode_All).toInt() == OverwriteMode_All);
+  ui_->overwriteAll->setChecked(static_cast<OverwriteMode>(s.value("overwrite", static_cast<int>(OverwriteMode::All)).toInt()) == OverwriteMode::All);
-  ui_->overwriteSmaller->setChecked(s.value("overwrite", OverwriteMode_Smaller).toInt() == OverwriteMode_Smaller);
+  ui_->overwriteSmaller->setChecked(static_cast<OverwriteMode>(s.value("overwrite", static_cast<int>(OverwriteMode::Smaller)).toInt()) == OverwriteMode::Smaller);
   ui_->forceSize->setChecked(s.value("forceSize", false).toBool());
   ui_->width->setText(s.value("width", "").toString());
   ui_->height->setText(s.value("height", "").toString());
@@ -71,13 +71,13 @@ AlbumCoverExport::DialogResult AlbumCoverExport::Exec() {
     if (fileName.isEmpty()) {
       fileName = "cover";
     }
-    OverwriteMode overwrite = ui_->doNotOverwrite->isChecked() ? OverwriteMode_None : (ui_->overwriteAll->isChecked() ? OverwriteMode_All : OverwriteMode_Smaller);
+    OverwriteMode overwrite_mode = ui_->doNotOverwrite->isChecked() ? OverwriteMode::None : (ui_->overwriteAll->isChecked() ? OverwriteMode::All : OverwriteMode::Smaller);
     bool forceSize = ui_->forceSize->isChecked();
     QString width = ui_->width->text();
     QString height = ui_->height->text();
 
     s.setValue("fileName", fileName);
-    s.setValue("overwrite", overwrite);
+    s.setValue("overwrite", static_cast<int>(overwrite_mode));
     s.setValue("forceSize", forceSize);
     s.setValue("width", width);
     s.setValue("height", height);
@@ -85,7 +85,7 @@ AlbumCoverExport::DialogResult AlbumCoverExport::Exec() {
     s.setValue("export_embedded", ui_->export_embedded->isChecked());
 
     result.filename_ = fileName;
-    result.overwrite_ = overwrite;
+    result.overwrite_ = overwrite_mode;
     result.forcesize_ = forceSize;
     result.width_ = width.toInt();
     result.height_ = height.toInt();

src/covermanager/albumcoverexport.h

@@ -39,10 +39,10 @@ class AlbumCoverExport : public QDialog {
   explicit AlbumCoverExport(QWidget *parent = nullptr);
   ~AlbumCoverExport() override;
 
-  enum OverwriteMode {
+  enum class OverwriteMode {
-    OverwriteMode_None = 0,
+    None = 0,
-    OverwriteMode_All = 1,
+    All = 1,
-    OverwriteMode_Smaller = 2
+    Smaller = 2
   };
 
   struct DialogResult {
@@ -63,7 +63,7 @@ class AlbumCoverExport : public QDialog {
     }
 
     bool RequiresCoverProcessing() const {
-      return IsSizeForced() || overwrite_ == OverwriteMode_Smaller;
+      return IsSizeForced() || overwrite_ == OverwriteMode::Smaller;
     }
   };
 

src/covermanager/albumcoverfetcher.h

@@ -100,7 +100,7 @@ Q_DECLARE_METATYPE(CoverProviderSearchResult)
 
 // This is a complete result of a single search request (a list of results, each describing one image, actually).
 using CoverProviderSearchResults = QList<CoverProviderSearchResult>;
-Q_DECLARE_METATYPE(QList<CoverProviderSearchResult>)
+Q_DECLARE_METATYPE(CoverProviderSearchResults)
 
 // This class searches for album covers for a given query or artist/album and returns URLs. It's NOT thread-safe.
 class AlbumCoverFetcher : public QObject {

src/covermanager/albumcoverloader.cpp

@@ -63,8 +63,8 @@ AlbumCoverLoader::AlbumCoverLoader(QObject *parent)
       load_image_async_id_(1),
       save_image_async_id_(1),
       network_(new NetworkAccessManager(this)),
-      save_cover_type_(CollectionSettingsPage::SaveCoverType_Cache),
+      save_cover_type_(CollectionSettingsPage::SaveCoverType::Cache),
-      save_cover_filename_(CollectionSettingsPage::SaveCoverFilename_Pattern),
+      save_cover_filename_(CollectionSettingsPage::SaveCoverFilename::Pattern),
       cover_overwrite_(false),
       cover_lowercase_(true),
       cover_replace_spaces_(true),
@@ -94,8 +94,8 @@ void AlbumCoverLoader::ReloadSettings() {
 
   QSettings s;
   s.beginGroup(CollectionSettingsPage::kSettingsGroup);
-  save_cover_type_ = CollectionSettingsPage::SaveCoverType(s.value("save_cover_type", CollectionSettingsPage::SaveCoverType_Cache).toInt());
+  save_cover_type_ = static_cast<CollectionSettingsPage::SaveCoverType>(s.value("save_cover_type", static_cast<int>(CollectionSettingsPage::SaveCoverType::Cache)).toInt());
-  save_cover_filename_ = CollectionSettingsPage::SaveCoverFilename(s.value("save_cover_filename", CollectionSettingsPage::SaveCoverFilename_Pattern).toInt());
+  save_cover_filename_ = static_cast<CollectionSettingsPage::SaveCoverFilename>(s.value("save_cover_filename", static_cast<int>(CollectionSettingsPage::SaveCoverFilename::Pattern)).toInt());
   cover_pattern_ = s.value("cover_pattern", "%albumartist-%album").toString();
   cover_overwrite_ = s.value("cover_overwrite", false).toBool();
   cover_lowercase_ = s.value("cover_lowercase", false).toBool();
@@ -132,7 +132,7 @@ QString AlbumCoverLoader::CoverFilePath(const Song &song, const QString &album_d
 QString AlbumCoverLoader::CoverFilePath(const Song::Source source, const QString &artist, const QString &album, const QString &album_id, const QString &album_dir, const QUrl &cover_url, const QString &extension) {
 
   QString path;
-  if (source == Song::Source_Collection && save_cover_type_ == CollectionSettingsPage::SaveCoverType_Album && !album_dir.isEmpty()) {
+  if (source == Song::Source::Collection && save_cover_type_ == CollectionSettingsPage::SaveCoverType::Album && !album_dir.isEmpty()) {
     path = album_dir;
   }
   else {
@@ -150,9 +150,9 @@ QString AlbumCoverLoader::CoverFilePath(const Song::Source source, const QString
   }
 
   QString filename;
-  if (source == Song::Source_Collection &&
+  if (source == Song::Source::Collection &&
-      save_cover_type_ == CollectionSettingsPage::SaveCoverType_Album &&
+      save_cover_type_ == CollectionSettingsPage::SaveCoverType::Album &&
-      save_cover_filename_ == CollectionSettingsPage::SaveCoverFilename_Pattern &&
+      save_cover_filename_ == CollectionSettingsPage::SaveCoverFilename::Pattern &&
       !cover_pattern_.isEmpty()) {
     filename = CoverFilenameFromVariable(artist, album);
     filename.remove(OrganizeFormat::kInvalidFatCharacters).remove('/').remove('\\');
@@ -179,27 +179,27 @@ QString AlbumCoverLoader::CoverFilenameFromSource(const Song::Source source, con
   QString filename;
 
   switch (source) {
-    case Song::Source_Tidal:
+    case Song::Source::Tidal:
       if (!album_id.isEmpty()) {
         filename = album_id + "-" + cover_url.fileName();
         break;
       }
       [[fallthrough]];
-    case Song::Source_Subsonic:
+    case Song::Source::Subsonic:
-    case Song::Source_Qobuz:
+    case Song::Source::Qobuz:
       if (!album_id.isEmpty()) {
         filename = album_id;
         break;
       }
       [[fallthrough]];
-    case Song::Source_Collection:
+    case Song::Source::Collection:
-    case Song::Source_LocalFile:
+    case Song::Source::LocalFile:
-    case Song::Source_CDDA:
+    case Song::Source::CDDA:
-    case Song::Source_Device:
+    case Song::Source::Device:
-    case Song::Source_Stream:
+    case Song::Source::Stream:
-    case Song::Source_SomaFM:
+    case Song::Source::SomaFM:
-    case Song::Source_RadioParadise:
+    case Song::Source::RadioParadise:
-    case Song::Source_Unknown:
+    case Song::Source::Unknown:
       filename = Utilities::Sha1CoverHash(artist, album).toHex();
       break;
   }
@@ -380,7 +380,7 @@ AlbumCoverLoader::TryLoadResult AlbumCoverLoader::TryLoadImage(Task *task) {
   }
 
   // For local files and streams initialize art if found.
-  if ((task->song.source() == Song::Source_LocalFile || task->song.is_radio()) && !task->song.art_manual_is_valid() && !task->song.art_automatic_is_valid()) {
+  if ((task->song.source() == Song::Source::LocalFile || task->song.is_radio()) && !task->song.art_manual_is_valid() && !task->song.art_automatic_is_valid()) {
     switch (task->state) {
       case State_None:
         break;

src/covermanager/albumcoverloader.h

@@ -74,7 +74,7 @@ class AlbumCoverLoader : public QObject {
   QString CoverFilePath(const Song::Source source, const QString &artist, const QString &album, const QString &album_id, const QString &album_dir, const QUrl &cover_url, const QString &extension = QString());
 
   quint64 LoadImageAsync(const AlbumCoverLoaderOptions &options, const Song &song);
-  quint64 LoadImageAsync(const AlbumCoverLoaderOptions &options, const QUrl &art_automatic, const QUrl &art_manual, const QUrl &song_url = QUrl(), const Song::Source song_source = Song::Source_Unknown);
+  quint64 LoadImageAsync(const AlbumCoverLoaderOptions &options, const QUrl &art_automatic, const QUrl &art_manual, const QUrl &song_url = QUrl(), const Song::Source song_source = Song::Source::Unknown);
   quint64 LoadImageAsync(const AlbumCoverLoaderOptions &options, const AlbumCoverImageResult &album_cover);
   quint64 LoadImageAsync(const AlbumCoverLoaderOptions &options, const QImage &image);
 

src/covermanager/albumcovermanager.cpp

@@ -317,7 +317,7 @@ void AlbumCoverManager::SaveSettings() {
   s.beginGroup(kSettingsGroup);
   s.setValue("geometry", saveGeometry());
   s.setValue("splitter_state", ui_->splitter->saveState());
-  s.setValue("save_cover_type", album_cover_choice_controller_->get_save_album_cover_type());
+  s.setValue("save_cover_type", static_cast<int>(album_cover_choice_controller_->get_save_album_cover_type()));
   s.endGroup();
 
 }
@@ -417,7 +417,7 @@ void AlbumCoverManager::ArtistChanged(QListWidgetItem *current) {
     AlbumItem *item = new AlbumItem(icon_nocover_item_, display_text, ui_->albums);
     item->setData(Role_AlbumArtist, info.album_artist);
     item->setData(Role_Album, info.album);
-    item->setData(Role_Filetype, info.filetype);
+    item->setData(Role_Filetype, QVariant::fromValue(info.filetype));
     item->setData(Role_CuePath, info.cue_path);
     item->setData(Qt::TextAlignmentRole, QVariant(Qt::AlignTop | Qt::AlignHCenter));
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
@@ -469,12 +469,12 @@ void AlbumCoverManager::UpdateFilter() {
   const bool hide_with_covers = filter_without_covers_->isChecked();
   const bool hide_without_covers = filter_with_covers_->isChecked();
 
-  HideCovers hide = Hide_None;
+  HideCovers hide_covers = HideCovers::None;
   if (hide_with_covers) {
-    hide = Hide_WithCovers;
+    hide_covers = HideCovers::WithCovers;
   }
   else if (hide_without_covers) {
-    hide = Hide_WithoutCovers;
+    hide_covers = HideCovers::WithoutCovers;
   }
 
   qint32 total_count = 0;
@@ -482,7 +482,7 @@ void AlbumCoverManager::UpdateFilter() {
 
   for (int i = 0; i < ui_->albums->count(); ++i) {
     AlbumItem *item = static_cast<AlbumItem*>(ui_->albums->item(i));
-    bool should_hide = ShouldHide(*item, filter, hide);
+    bool should_hide = ShouldHide(*item, filter, hide_covers);
     item->setHidden(should_hide);
 
     if (!should_hide) {
@@ -498,13 +498,13 @@ void AlbumCoverManager::UpdateFilter() {
 
 }
 
-bool AlbumCoverManager::ShouldHide(const AlbumItem &item, const QString &filter, HideCovers hide) const {
+bool AlbumCoverManager::ShouldHide(const AlbumItem &item, const QString &filter, const HideCovers hide_covers) const {
 
   bool has_cover = ItemHasCover(item);
-  if (hide == Hide_WithCovers && has_cover) {
+  if (hide_covers == HideCovers::WithCovers && has_cover) {
     return true;
   }
-  else if (hide == Hide_WithoutCovers && !has_cover) {
+  else if (hide_covers == HideCovers::WithoutCovers && !has_cover) {
     return true;
   }
 
@@ -642,7 +642,7 @@ Song AlbumCoverManager::GetFirstSelectedAsSong() {
 
 Song AlbumCoverManager::ItemAsSong(AlbumItem *item) {
 
-  Song result(Song::Source_Collection);
+  Song result(Song::Source::Collection);
 
   QString title = item->data(Role_Album).toString();
   QString artist_name = item->data(Role_AlbumArtist).toString();
@@ -781,13 +781,13 @@ void AlbumCoverManager::SaveImageToAlbums(Song *song, const AlbumCoverImageResul
 
   QUrl cover_url = result.cover_url;
   switch (album_cover_choice_controller_->get_save_album_cover_type()) {
-    case CollectionSettingsPage::SaveCoverType_Cache:
+    case CollectionSettingsPage::SaveCoverType::Cache:
-    case CollectionSettingsPage::SaveCoverType_Album:
+    case CollectionSettingsPage::SaveCoverType::Album:
       if (cover_url.isEmpty() || !cover_url.isValid() || !cover_url.isLocalFile()) {
         cover_url = album_cover_choice_controller_->SaveCoverToFileAutomatic(song, result);
       }
       break;
-    case CollectionSettingsPage::SaveCoverType_Embedded:
+    case CollectionSettingsPage::SaveCoverType::Embedded:
       cover_url = QUrl::fromLocalFile(Song::kEmbeddedCover);
       break;
   }
@@ -798,14 +798,14 @@ void AlbumCoverManager::SaveImageToAlbums(Song *song, const AlbumCoverImageResul
   for (QListWidgetItem *item : context_menu_items_) {
     AlbumItem *album_item = static_cast<AlbumItem*>(item);
     switch (album_cover_choice_controller_->get_save_album_cover_type()) {
-      case CollectionSettingsPage::SaveCoverType_Cache:
+      case CollectionSettingsPage::SaveCoverType::Cache:
-      case CollectionSettingsPage::SaveCoverType_Album:{
+      case CollectionSettingsPage::SaveCoverType::Album:{
         Song current_song = ItemAsSong(album_item);
         album_cover_choice_controller_->SaveArtManualToSong(&current_song, cover_url);
         UpdateCoverInList(album_item, cover_url);
         break;
       }
-      case CollectionSettingsPage::SaveCoverType_Embedded:{
+      case CollectionSettingsPage::SaveCoverType::Embedded:{
         urls << album_item->urls;
         album_items << album_item;
         break;
@@ -813,7 +813,7 @@ void AlbumCoverManager::SaveImageToAlbums(Song *song, const AlbumCoverImageResul
     }
   }
 
-  if (album_cover_choice_controller_->get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType_Embedded && !urls.isEmpty()) {
+  if (album_cover_choice_controller_->get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType::Embedded && !urls.isEmpty()) {
     quint64 id = -1;
     if (result.is_jpeg()) {
       id = app_->album_cover_loader()->SaveEmbeddedCoverAsync(urls, result.image_data);
@@ -971,7 +971,7 @@ void AlbumCoverManager::SaveAndSetCover(AlbumItem *item, const AlbumCoverImageRe
   const Song::FileType filetype = static_cast<Song::FileType>(item->data(Role_Filetype).toInt());
   const bool has_cue = !item->data(Role_CuePath).toString().isEmpty();
 
-  if (album_cover_choice_controller_->get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType_Embedded && Song::save_embedded_cover_supported(filetype) && !has_cue) {
+  if (album_cover_choice_controller_->get_save_album_cover_type() == CollectionSettingsPage::SaveCoverType::Embedded && Song::save_embedded_cover_supported(filetype) && !has_cue) {
     if (result.is_jpeg()) {
       quint64 id = app_->album_cover_loader()->SaveEmbeddedCoverAsync(urls, result.image_data);
       cover_save_tasks_.insert(id, item);
@@ -991,7 +991,7 @@ void AlbumCoverManager::SaveAndSetCover(AlbumItem *item, const AlbumCoverImageRe
       cover_url = result.cover_url;
     }
     else if (!result.image_data.isEmpty() || !result.image.isNull()) {
-      cover_url = album_cover_choice_controller_->SaveCoverToFileAutomatic(Song::Source_Collection, albumartist, album, QString(), urls.first().adjusted(QUrl::RemoveFilename).path(), result, false);
+      cover_url = album_cover_choice_controller_->SaveCoverToFileAutomatic(Song::Source::Collection, albumartist, album, QString(), urls.first().adjusted(QUrl::RemoveFilename).path(), result, false);
     }
 
     if (cover_url.isEmpty()) return;

src/covermanager/albumcovermanager.h

@@ -116,10 +116,10 @@ class AlbumCoverManager : public QMainWindow {
     Role_Image
   };
 
-  enum HideCovers {
+  enum class HideCovers {
-    Hide_None,
+    None,
-    Hide_WithCovers,
+    WithCovers,
-    Hide_WithoutCovers
+    WithoutCovers
   };
 
   void LoadGeometry();
@@ -136,7 +136,7 @@ class AlbumCoverManager : public QMainWindow {
   static Song ItemAsSong(AlbumItem *item);
 
   void UpdateStatusText();
-  bool ShouldHide(const AlbumItem &item, const QString &filter, HideCovers hide) const;
+  bool ShouldHide(const AlbumItem &item, const QString &filter, const HideCovers hide_covers) const;
   void SaveAndSetCover(AlbumItem *item, const AlbumCoverImageResult &result);
 
   void SaveImageToAlbums(Song *song, const AlbumCoverImageResult &result);

src/covermanager/coverexportrunnable.cpp

@@ -122,16 +122,16 @@ void CoverExportRunnable::ProcessAndExportCover() {
   QString new_file = dir + '/' + dialog_result_.filename_ + '.' + (cover_path == Song::kEmbeddedCover ? "jpg" : extension);
 
   // If the file exists, do not override!
-  if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode_None && QFile::exists(new_file)) {
+  if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode::None && QFile::exists(new_file)) {
     EmitCoverSkipped();
     return;
   }
 
   // we're handling overwrite as remove + copy so we need to delete the old file first
-  if (QFile::exists(new_file) && dialog_result_.overwrite_ != AlbumCoverExport::OverwriteMode_None) {
+  if (QFile::exists(new_file) && dialog_result_.overwrite_ != AlbumCoverExport::OverwriteMode::None) {
 
     // if the mode is "overwrite smaller" then skip the cover if a bigger one is already available in the folder
-    if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode_Smaller) {
+    if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode::Smaller) {
       QImage existing;
       existing.load(new_file);
 
@@ -168,13 +168,13 @@ void CoverExportRunnable::ExportCover() {
   QString new_file = dir + '/' + dialog_result_.filename_ + '.' + (cover_path == Song::kEmbeddedCover ? "jpg" : extension);
 
   // If the file exists, do not override!
-  if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode_None && QFile::exists(new_file)) {
+  if (dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode::None && QFile::exists(new_file)) {
     EmitCoverSkipped();
     return;
   }
 
   // We're handling overwrite as remove + copy so we need to delete the old file first
-  if (dialog_result_.overwrite_ != AlbumCoverExport::OverwriteMode_None && QFile::exists(new_file)) {
+  if (dialog_result_.overwrite_ != AlbumCoverExport::OverwriteMode::None && QFile::exists(new_file)) {
     if (!QFile::remove(new_file)) {
       EmitCoverSkipped();
       return;

src/covermanager/discogscoverprovider.cpp

@@ -128,10 +128,10 @@ void DiscogsCoverProvider::SendSearchRequest(std::shared_ptr<DiscogsCoverSearchC
                                  << Param("release_title", search->album.toLower());
 
   switch (search->type) {
-    case DiscogsCoverType_Master:
+    case DiscogsCoverType::Master:
       params << Param("type", "master");
       break;
-    case DiscogsCoverType_Release:
+    case DiscogsCoverType::Release:
       params << Param("type", "release");
       break;
   }
@@ -296,8 +296,8 @@ void DiscogsCoverProvider::HandleSearchReply(QNetworkReply *reply, const int id)
   }
 
   if (search->requests_release_.count() == 0) {
-    if (search->type == DiscogsCoverType_Master) {
+    if (search->type == DiscogsCoverType::Master) {
-      search->type = DiscogsCoverType_Release;
+      search->type = DiscogsCoverType::Release;
       queue_search_requests_.enqueue(search);
     }
     else {

src/covermanager/discogscoverprovider.h

@@ -55,9 +55,9 @@ class DiscogsCoverProvider : public JsonCoverProvider {
   bool StartSearch(const QString &artist, const QString &album, const QString &title, const int id) override;
   void CancelSearch(const int id) override;
 
-  enum DiscogsCoverType {
+  enum class DiscogsCoverType {
-    DiscogsCoverType_Master,
+    Master,
-    DiscogsCoverType_Release,
+    Release
   };
 
   struct DiscogsCoverReleaseContext {
@@ -67,7 +67,7 @@ class DiscogsCoverProvider : public JsonCoverProvider {
     QUrl url;
   };
   struct DiscogsCoverSearchContext {
-    explicit DiscogsCoverSearchContext(const int _id = 0, const QString &_artist = QString(), const QString &_album = QString(), const DiscogsCoverType _type = DiscogsCoverType_Master) : id(_id), artist(_artist), album(_album), type(_type) {}
+    explicit DiscogsCoverSearchContext(const int _id = 0, const QString &_artist = QString(), const QString &_album = QString(), const DiscogsCoverType _type = DiscogsCoverType::Master) : id(_id), artist(_artist), album(_album), type(_type) {}
     int id;
     QString artist;
     QString album;

src/covermanager/lastfmcoverprovider.h

@@ -48,7 +48,7 @@ class LastFmCoverProvider : public JsonCoverProvider {
   void QueryFinished(QNetworkReply *reply, const int id, const QString &type);
 
  private:
-  enum LastFmImageSize {
+  enum class LastFmImageSize {
     Unknown,
     Small = 34,
     Medium = 64,

src/device/cddasongloader.cpp

@@ -128,10 +128,10 @@ void CddaSongLoader::LoadSongs() {
   songs.reserve(num_tracks);
   for (int track_number = 1; track_number <= num_tracks; ++track_number) {
     // Init song
-    Song song(Song::Source_CDDA);
+    Song song(Song::Source::CDDA);
     song.set_id(track_number);
     song.set_valid(true);
-    song.set_filetype(Song::FileType_CDDA);
+    song.set_filetype(Song::FileType::CDDA);
     song.set_url(GetUrlFromTrack(track_number));
     song.set_title(QString("Track %1").arg(track_number));
     song.set_track(track_number);
@@ -221,7 +221,7 @@ void CddaSongLoader::AudioCDTagsLoaded(const QString &artist, const QString &alb
   songs.reserve(results.count());
   int track_number = 1;
   for (const MusicBrainzClient::Result &ret : results) {
-    Song song(Song::Source_CDDA);
+    Song song(Song::Source::CDDA);
     song.set_artist(artist);
     song.set_album(album);
     song.set_title(ret.title_);
@@ -229,7 +229,7 @@ void CddaSongLoader::AudioCDTagsLoaded(const QString &artist, const QString &alb
     song.set_track(track_number);
     song.set_year(ret.year_);
     song.set_id(track_number);
-    song.set_filetype(Song::FileType_CDDA);
+    song.set_filetype(Song::FileType::CDDA);
     song.set_valid(true);
     // We need to set url: that's how playlist will find the correct item to update
     song.set_url(GetUrlFromTrack(track_number++));

src/device/connecteddevice.cpp

@@ -61,7 +61,7 @@ ConnectedDevice::ConnectedDevice(const QUrl &url, DeviceLister *lister, const QS
 
   backend_->Init(app_->database(),
                  app_->task_manager(),
-                 Song::Source_Device,
+                 Song::Source::Device,
                  QString("device_%1_songs").arg(database_id),
                  QString("device_%1_fts").arg(database_id),
                  QString("device_%1_directories").arg(database_id),
@@ -154,10 +154,10 @@ MusicStorage::TranscodeMode ConnectedDevice::GetTranscodeMode() const {
 Song::FileType ConnectedDevice::GetTranscodeFormat() const {
 
   DeviceInfo *info = manager_->FindDeviceById(unique_id_);
-  if (!info) return Song::FileType_Unknown;
+  if (!info) return Song::FileType::Unknown;
 
   QModelIndex idx = manager_->ItemToIndex(info);
-  if (!idx.isValid()) return Song::FileType_Unknown;
+  if (!idx.isValid()) return Song::FileType::Unknown;
 
   return static_cast<Song::FileType>(idx.data(DeviceManager::Role_TranscodeFormat).toInt());
 
@@ -167,4 +167,3 @@ void ConnectedDevice::BackendTotalSongCountUpdated(int count) {
   song_count_ = count;
   emit SongCountUpdated(count);
 }
-

src/device/connecteddevice.h

@@ -46,7 +46,7 @@ class ConnectedDevice : public QObject, public virtual MusicStorage, public std:
   explicit ConnectedDevice(const QUrl &url, DeviceLister *lister, const QString &unique_id, DeviceManager *manager, Application *app, const int database_id, const bool first_time, QObject *parent = nullptr);
   ~ConnectedDevice() override;
 
-  Song::Source source() const override { return Song::Source_Device; }
+  Song::Source source() const override { return Song::Source::Device; }
 
   virtual bool Init() = 0;
   virtual bool IsLoading() { return false; }

src/device/devicedatabasebackend.cpp

@@ -128,8 +128,8 @@ int DeviceDatabaseBackend::AddDevice(const Device &device) {
   q.BindValue(":friendly_name", device.friendly_name_);
   q.BindValue(":size", device.size_);
   q.BindValue(":icon", device.icon_name_);
-  q.BindValue(":transcode_mode", device.transcode_mode_);
+  q.BindValue(":transcode_mode", static_cast<int>(device.transcode_mode_));
-  q.BindValue(":transcode_format", device.transcode_format_);
+  q.BindValue(":transcode_format", static_cast<int>(device.transcode_format_));
   if (!q.Exec()) {
     db_->ReportErrors(q);
     return -1;
@@ -194,8 +194,8 @@ void DeviceDatabaseBackend::SetDeviceOptions(const int id, const QString &friend
       " WHERE ROWID=:id");
   q.BindValue(":friendly_name", friendly_name);
   q.BindValue(":icon_name", icon_name);
-  q.BindValue(":transcode_mode", mode);
+  q.BindValue(":transcode_mode", static_cast<int>(mode));
-  q.BindValue(":transcode_format", format);
+  q.BindValue(":transcode_format", static_cast<int>(format));
   q.BindValue(":id", id);
   if (!q.Exec()) {
     db_->ReportErrors(q);

src/device/deviceinfo.h

@@ -64,8 +64,8 @@ class DeviceInfo : public SimpleTreeItem<DeviceInfo> {
       : SimpleTreeItem<DeviceInfo>(Type_Root, _model),
         database_id_(-1),
         size_(0),
-        transcode_mode_(MusicStorage::Transcode_Unsupported),
+        transcode_mode_(MusicStorage::TranscodeMode::Transcode_Unsupported),
-        transcode_format_(Song::FileType_Unknown),
+        transcode_format_(Song::FileType::Unknown),
         task_percentage_(-1),
         unmount_(false),
         forget_(false) {}
@@ -74,8 +74,8 @@ class DeviceInfo : public SimpleTreeItem<DeviceInfo> {
       : SimpleTreeItem<DeviceInfo>(_type, _parent),
         database_id_(-1),
         size_(0),
-        transcode_mode_(MusicStorage::Transcode_Unsupported),
+        transcode_mode_(MusicStorage::TranscodeMode::Transcode_Unsupported),
-        transcode_format_(Song::FileType_Unknown),
+        transcode_format_(Song::FileType::Unknown),
         task_percentage_(-1),
         unmount_(false),
         forget_(false) {}

src/device/devicemanager.cpp

@@ -370,10 +370,10 @@ QVariant DeviceManager::data(const QModelIndex &idx, int role) const {
     }
 
     case Role_TranscodeMode:
-      return info->transcode_mode_;
+      return static_cast<int>(info->transcode_mode_);
 
     case Role_TranscodeFormat:
-      return info->transcode_format_;
+      return static_cast<int>(info->transcode_format_);
 
     case Role_SongCount:
       if (!info->device_) return QVariant();

src/device/deviceproperties.cpp

@@ -106,7 +106,7 @@ void DeviceProperties::ShowDevice(const QModelIndex &idx) {
 #ifdef HAVE_GSTREAMER
     // Load the transcode formats the first time the dialog is shown
     for (const TranscoderPreset &preset : Transcoder::GetAllPresets()) {
-      ui_->transcode_format->addItem(preset.name_, preset.filetype_);
+      ui_->transcode_format->addItem(preset.name_, QVariant::fromValue(preset.filetype_));
     }
     ui_->transcode_format->model()->sort(0);
 #endif
@@ -209,15 +209,15 @@ void DeviceProperties::UpdateFormats() {
   // Transcode mode
   MusicStorage::TranscodeMode mode = static_cast<MusicStorage::TranscodeMode>(index_.data(DeviceManager::Role_TranscodeMode).toInt());
   switch (mode) {
-    case MusicStorage::Transcode_Always:
+    case MusicStorage::TranscodeMode::Transcode_Always:
       ui_->transcode_all->setChecked(true);
       break;
 
-    case MusicStorage::Transcode_Never:
+    case MusicStorage::TranscodeMode::Transcode_Never:
       ui_->transcode_off->setChecked(true);
       break;
 
-    case MusicStorage::Transcode_Unsupported:
+    case MusicStorage::TranscodeMode::Transcode_Unsupported:
     default:
       ui_->transcode_unsupported->setChecked(true);
       break;
@@ -262,13 +262,13 @@ void DeviceProperties::accept() {
   QDialog::accept();
 
   // Transcode mode
-  MusicStorage::TranscodeMode mode = MusicStorage::Transcode_Unsupported;
+  MusicStorage::TranscodeMode mode = MusicStorage::TranscodeMode::Transcode_Unsupported;
   if (ui_->transcode_all->isChecked())
-    mode = MusicStorage::Transcode_Always;
+    mode = MusicStorage::TranscodeMode::Transcode_Always;
   else if (ui_->transcode_off->isChecked())
-    mode = MusicStorage::Transcode_Never;
+    mode = MusicStorage::TranscodeMode::Transcode_Never;
   else if (ui_->transcode_unsupported->isChecked())
-    mode = MusicStorage::Transcode_Unsupported;
+    mode = MusicStorage::TranscodeMode::Transcode_Unsupported;
 
   // Transcode format
   Song::FileType format = static_cast<Song::FileType>(ui_->transcode_format->itemData(ui_->transcode_format->currentIndex()).toInt());
@@ -316,7 +316,7 @@ void DeviceProperties::UpdateFormatsFinished() {
 #ifdef HAVE_GSTREAMER
   // Set the format combobox item
   TranscoderPreset preset = Transcoder::PresetForFileType(static_cast<Song::FileType>(index_.data(DeviceManager::Role_TranscodeFormat).toInt()));
-  if (preset.filetype_ == Song::FileType_Unknown) {
+  if (preset.filetype_ == Song::FileType::Unknown) {
     // The user hasn't chosen a format for this device yet,
     // so work our way down a list of some preferred formats, picking the first one that is supported
     preset = Transcoder::PresetForFileType(Transcoder::PickBestFormat(supported_formats_));

src/device/deviceview.cpp

@@ -460,7 +460,7 @@ void DeviceView::DeleteFinished(const SongList &songs_with_errors) {
   if (songs_with_errors.isEmpty()) return;
 
   OrganizeErrorDialog *dialog = new OrganizeErrorDialog(this);
-  dialog->Show(OrganizeErrorDialog::Type_Delete, songs_with_errors);
+  dialog->Show(OrganizeErrorDialog::OperationType::Delete, songs_with_errors);
   // It deletes itself when the user closes it
 
 }

src/device/filesystemdevice.cpp

@@ -39,9 +39,9 @@
 class DeviceLister;
 
 FilesystemDevice::FilesystemDevice(const QUrl &url, DeviceLister *lister, const QString &unique_id, DeviceManager *manager, Application *app, const int database_id, const bool first_time, QObject *parent)
-    : FilesystemMusicStorage(Song::Source_Device, url.toLocalFile()),
+    : FilesystemMusicStorage(Song::Source::Device, url.toLocalFile()),
       ConnectedDevice(url, lister, unique_id, manager, app, database_id, first_time, parent),
-      watcher_(new CollectionWatcher(Song::Source_Device)),
+      watcher_(new CollectionWatcher(Song::Source::Device)),
       watcher_thread_(new QThread(this)) {
 
   watcher_->moveToThread(watcher_thread_);

src/device/filesystemdevice.h

@@ -46,7 +46,7 @@ class FilesystemDevice : public ConnectedDevice, public virtual FilesystemMusicS
   Q_INVOKABLE FilesystemDevice(const QUrl &url, DeviceLister *lister, const QString &unique_id, DeviceManager *manager, Application *app, const int database_id, const bool first_time, QObject *parent = nullptr);
   ~FilesystemDevice() override;
 
-  Song::Source source() const final { return Song::Source_Device; }
+  Song::Source source() const final { return Song::Source::Device; }
 
   bool Init() override;
   void CloseAsync();

src/device/gpoddevice.cpp

@@ -384,7 +384,7 @@ void GPodDevice::FinishDelete(bool success) {
 }
 
 bool GPodDevice::GetSupportedFiletypes(QList<Song::FileType> *ret) {
-  *ret << Song::FileType_MP4;
+  *ret << Song::FileType::MP4;
-  *ret << Song::FileType_MPEG;
+  *ret << Song::FileType::MPEG;
   return true;
 }

src/device/gpodloader.cpp

@@ -39,7 +39,7 @@ GPodLoader::GPodLoader(const QString &mount_point, TaskManager *task_manager, Co
     : QObject(parent),
       device_(device),
       mount_point_(mount_point),
-      type_(Song::FileType_Unknown),
+      type_(Song::FileType::Unknown),
       task_manager_(task_manager),
       backend_(backend),
       abort_(false) {
@@ -93,11 +93,11 @@ Itdb_iTunesDB *GPodLoader::TryLoad() {
 
     Itdb_Track *track = static_cast<Itdb_Track*>(tracks->data);
 
-    Song song(Song::Source_Device);
+    Song song(Song::Source::Device);
     song.InitFromItdb(track, prefix);
     song.set_directory_id(1);
 
-    if (type_ != Song::FileType_Unknown) song.set_filetype(type_);
+    if (type_ != Song::FileType::Unknown) song.set_filetype(type_);
     songs << song;
   }
 

src/device/mtpconnection.cpp

@@ -120,21 +120,21 @@ bool MtpConnection::GetSupportedFiletypes(QList<Song::FileType> *ret) {
 
   for (int i = 0; i < length; ++i) {
     switch (static_cast<LIBMTP_filetype_t>(list[i])) {
-      case LIBMTP_FILETYPE_WAV:  *ret << Song::FileType_WAV; break;
+      case LIBMTP_FILETYPE_WAV:  *ret << Song::FileType::WAV; break;
       case LIBMTP_FILETYPE_MP2:
-      case LIBMTP_FILETYPE_MP3:  *ret << Song::FileType_MPEG; break;
+      case LIBMTP_FILETYPE_MP3:  *ret << Song::FileType::MPEG; break;
-      case LIBMTP_FILETYPE_WMA:  *ret << Song::FileType_ASF; break;
+      case LIBMTP_FILETYPE_WMA:  *ret << Song::FileType::ASF; break;
       case LIBMTP_FILETYPE_MP4:
       case LIBMTP_FILETYPE_M4A:
-      case LIBMTP_FILETYPE_AAC:  *ret << Song::FileType_MP4; break;
+      case LIBMTP_FILETYPE_AAC:  *ret << Song::FileType::MP4; break;
       case LIBMTP_FILETYPE_FLAC:
-        *ret << Song::FileType_FLAC;
+        *ret << Song::FileType::FLAC;
-        *ret << Song::FileType_OggFlac;
+        *ret << Song::FileType::OggFlac;
         break;
       case LIBMTP_FILETYPE_OGG:
-        *ret << Song::FileType_OggVorbis;
+        *ret << Song::FileType::OggVorbis;
-        *ret << Song::FileType_OggSpeex;
+        *ret << Song::FileType::OggSpeex;
-        *ret << Song::FileType_OggFlac;
+        *ret << Song::FileType::OggFlac;
         break;
       default:
         qLog(Error) << "Unknown MTP file format" << LIBMTP_Get_Filetype_Description(static_cast<LIBMTP_filetype_t>(list[i]));

src/device/mtpdevice.cpp

@@ -173,7 +173,7 @@ bool MtpDevice::CopyToStorage(const CopyJob &job) {
   if (ret != 0) return false;
 
   // Add it to our CollectionModel
-  Song metadata_on_device(Song::Source_Device);
+  Song metadata_on_device(Song::Source::Device);
   metadata_on_device.InitFromMTP(&track, url_.host());
   metadata_on_device.set_directory_id(1);
   metadata_on_device.set_artist(metadata_on_device.effective_albumartist());
@@ -260,21 +260,21 @@ bool MtpDevice::GetSupportedFiletypes(QList<Song::FileType> *ret, LIBMTP_mtpdevi
 
   for (int i = 0; i < length; ++i) {
     switch (static_cast<LIBMTP_filetype_t>(list[i])) {
-      case LIBMTP_FILETYPE_WAV:  *ret << Song::FileType_WAV; break;
+      case LIBMTP_FILETYPE_WAV:  *ret << Song::FileType::WAV; break;
       case LIBMTP_FILETYPE_MP2:
-      case LIBMTP_FILETYPE_MP3:  *ret << Song::FileType_MPEG; break;
+      case LIBMTP_FILETYPE_MP3:  *ret << Song::FileType::MPEG; break;
-      case LIBMTP_FILETYPE_WMA:  *ret << Song::FileType_ASF; break;
+      case LIBMTP_FILETYPE_WMA:  *ret << Song::FileType::ASF; break;
       case LIBMTP_FILETYPE_MP4:
       case LIBMTP_FILETYPE_M4A:
-      case LIBMTP_FILETYPE_AAC:  *ret << Song::FileType_MP4; break;
+      case LIBMTP_FILETYPE_AAC:  *ret << Song::FileType::MP4; break;
       case LIBMTP_FILETYPE_FLAC:
-        *ret << Song::FileType_FLAC;
+        *ret << Song::FileType::FLAC;
-        *ret << Song::FileType_OggFlac;
+        *ret << Song::FileType::OggFlac;
         break;
       case LIBMTP_FILETYPE_OGG:
-        *ret << Song::FileType_OggVorbis;
+        *ret << Song::FileType::OggVorbis;
-        *ret << Song::FileType_OggSpeex;
+        *ret << Song::FileType::OggSpeex;
-        *ret << Song::FileType_OggFlac;
+        *ret << Song::FileType::OggFlac;
         break;
       default:
         qLog(Error) << "Unknown MTP file format" << LIBMTP_Get_Filetype_Description(static_cast<LIBMTP_filetype_t>(list[i]));

src/device/mtploader.cpp

@@ -78,7 +78,7 @@ bool MtpLoader::TryLoad() {
 
     LIBMTP_track_t *track = tracks;
 
-    Song song(Song::Source_Device);
+    Song song(Song::Source::Device);
     song.InitFromMTP(track, url_.host());
     if (song.is_valid() && !song.artist().isEmpty() && !song.title().isEmpty()) {
       song.set_directory_id(1);

src/dialogs/edittagdialog.cpp

@@ -341,7 +341,7 @@ bool EditTagDialog::eventFilter(QObject *o, QEvent *e) {
         if (event->mimeData()->hasImage()) {
           QImage image = qvariant_cast<QImage>(event->mimeData()->imageData());
           if (!image.isNull()) {
-            UpdateCover(UpdateCoverAction_New, AlbumCoverImageResult(image));
+            UpdateCover(UpdateCoverAction::New, AlbumCoverImageResult(image));
           }
         }
         break;
@@ -404,7 +404,7 @@ QList<EditTagDialog::Data> EditTagDialog::LoadData(const SongList &songs) {
 
 }
 
-void EditTagDialog::SetSongs(const SongList &s, const PlaylistItemList &items) {
+void EditTagDialog::SetSongs(const SongList &s, const PlaylistItemPtrList &items) {
 
   // Show the loading indicator
   if (!SetLoading(tr("Loading tracks") + "...")) return;
@@ -438,7 +438,7 @@ void EditTagDialog::SetSongsFinished() {
     ui_->tab_widget->setEnabled(false);
 
     // Show a summary with empty information
-    UpdateSummaryTab(Song(), UpdateCoverAction_None);
+    UpdateSummaryTab(Song(), UpdateCoverAction::None);
     ui_->tab_widget->setCurrentWidget(ui_->tab_summary);
 
     SetSongListVisibility(false);
@@ -614,7 +614,7 @@ void EditTagDialog::SelectionChanged() {
   ui_->tab_widget->setTabEnabled(ui_->tab_widget->indexOf(ui_->tab_lyrics), !multiple);
 
   if (multiple) {
-    UpdateSummaryTab(Song(), UpdateCoverAction_None);
+    UpdateSummaryTab(Song(), UpdateCoverAction::None);
     UpdateStatisticsTab(Song());
   }
   else {
@@ -636,11 +636,11 @@ void EditTagDialog::SelectionChanged() {
   bool comment_enabled = false;
   bool lyrics_enabled = false;
   for (const QModelIndex &idx : indexes) {
-    if (data_[idx.row()].cover_action_ == UpdateCoverAction_None) {
+    if (data_[idx.row()].cover_action_ == UpdateCoverAction::None) {
       data_[idx.row()].cover_result_ = AlbumCoverImageResult();
     }
     const Song &song = data_[idx.row()].original_;
-    if (data_[idx.row()].cover_action_ != first_cover_action || (first_cover_action != UpdateCoverAction_None && data_[idx.row()].cover_result_.image_data != data_[indexes.first().row()].cover_result_.image_data)) {
+    if (data_[idx.row()].cover_action_ != first_cover_action || (first_cover_action != UpdateCoverAction::None && data_[idx.row()].cover_result_.image_data != data_[indexes.first().row()].cover_result_.image_data)) {
       action_different = true;
     }
     if (data_[idx.row()].cover_action_ != first_cover_action ||
@@ -693,7 +693,7 @@ void EditTagDialog::SelectionChanged() {
 
   const bool enable_change_art = first_song.is_collection_song();
   ui_->tags_art_button->setEnabled(enable_change_art);
-  if ((art_different && first_cover_action != UpdateCoverAction_New) || action_different) {
+  if ((art_different && first_cover_action != UpdateCoverAction::New) || action_different) {
     tags_cover_art_id_ = -1;  // Cancels any pending art load.
     ui_->tags_art->clear();
     ui_->tags_art->setText(kArtDifferentHintText);
@@ -717,7 +717,7 @@ void EditTagDialog::SelectionChanged() {
     album_cover_choice_controller_->unset_cover_action()->setEnabled(enable_change_art && !first_song.has_manually_unset_cover());
     album_cover_choice_controller_->clear_cover_action()->setEnabled(enable_change_art && !first_song.art_manual().isEmpty());
     album_cover_choice_controller_->delete_cover_action()->setEnabled(enable_change_art && first_song.has_valid_art() && !first_song.has_manually_unset_cover());
-    if (data_[indexes.first().row()].cover_action_ == UpdateCoverAction_None) {
+    if (data_[indexes.first().row()].cover_action_ == UpdateCoverAction::None) {
       tags_cover_art_id_ = app_->album_cover_loader()->LoadImageAsync(cover_options_, first_song);
     }
     else {
@@ -728,7 +728,7 @@ void EditTagDialog::SelectionChanged() {
 
   ui_->tags_summary->setText(summary);
 
-  const bool embedded_cover = (first_song.save_embedded_cover_supported() && (first_song.has_embedded_cover() || album_cover_choice_controller_->get_collection_save_album_cover_type() == CollectionSettingsPage::SaveCoverType_Embedded));
+  const bool embedded_cover = (first_song.save_embedded_cover_supported() && (first_song.has_embedded_cover() || album_cover_choice_controller_->get_collection_save_album_cover_type() == CollectionSettingsPage::SaveCoverType::Embedded));
   ui_->checkbox_embedded_cover->setChecked(embedded_cover);
   album_cover_choice_controller_->set_save_embedded_cover_override(embedded_cover);
 
@@ -831,21 +831,21 @@ QString EditTagDialog::GetArtSummary(const Song &song, const UpdateCoverAction c
 
   QString summary;
 
-  if (cover_action != UpdateCoverAction_None) {
+  if (cover_action != UpdateCoverAction::None) {
     switch (cover_action) {
-      case UpdateCoverAction_Clear:
+      case UpdateCoverAction::Clear:
         summary = tr("Cover changed: Will be cleared when saved.").toHtmlEscaped();
         break;
-      case UpdateCoverAction_Unset:
+      case UpdateCoverAction::Unset:
         summary = tr("Cover changed: Will be unset when saved.").toHtmlEscaped();
         break;
-      case UpdateCoverAction_Delete:
+      case UpdateCoverAction::Delete:
         summary = tr("Cover changed: Will be deleted when saved.").toHtmlEscaped();
         break;
-      case UpdateCoverAction_New:
+      case UpdateCoverAction::New:
         summary = tr("Cover changed: Will set new when saved.").toHtmlEscaped();
         break;
-      case UpdateCoverAction_None:
+      case UpdateCoverAction::None:
         break;
     }
   }
@@ -981,7 +981,7 @@ void EditTagDialog::LoadCoverFromFile() {
   if (!song) return;
 
   AlbumCoverImageResult result = album_cover_choice_controller_->LoadImageFromFile(song);
-  if (result.is_valid()) UpdateCover(UpdateCoverAction_New, result);
+  if (result.is_valid()) UpdateCover(UpdateCoverAction::New, result);
 
 }
 
@@ -999,7 +999,7 @@ void EditTagDialog::LoadCoverFromURL() {
   if (ui_->song_list->selectionModel()->selectedIndexes().isEmpty()) return;
 
   AlbumCoverImageResult result = album_cover_choice_controller_->LoadImageFromURL();
-  if (result.is_valid()) UpdateCover(UpdateCoverAction_New, result);
+  if (result.is_valid()) UpdateCover(UpdateCoverAction::New, result);
 
 }
 
@@ -1009,7 +1009,7 @@ void EditTagDialog::SearchForCover() {
   if (!song) return;
 
   AlbumCoverImageResult result = album_cover_choice_controller_->SearchForImage(song);
-  if (result.is_valid()) UpdateCover(UpdateCoverAction_New, result);
+  if (result.is_valid()) UpdateCover(UpdateCoverAction::New, result);
 
 }
 
@@ -1020,7 +1020,7 @@ void EditTagDialog::UnsetCover() {
 
   song->set_manually_unset_cover();
 
-  UpdateCover(UpdateCoverAction_Unset);
+  UpdateCover(UpdateCoverAction::Unset);
 
 }
 
@@ -1032,13 +1032,13 @@ void EditTagDialog::ClearCover() {
   song->clear_art_automatic();
   song->clear_art_manual();
 
-  UpdateCover(UpdateCoverAction_Clear);
+  UpdateCover(UpdateCoverAction::Clear);
 
 }
 
 void EditTagDialog::DeleteCover() {
 
-  UpdateCover(UpdateCoverAction_Delete);
+  UpdateCover(UpdateCoverAction::Delete);
 
 }
 
@@ -1061,13 +1061,13 @@ void EditTagDialog::UpdateCover(const UpdateCoverAction action, const AlbumCover
   for (const QModelIndex &idx : indexes) {
     data_[idx.row()].cover_action_ = action;
     data_[idx.row()].cover_result_ = result;
-    if (action == UpdateCoverAction_New) {
+    if (action == UpdateCoverAction::New) {
       data_[idx.row()].current_.clear_art_manual();
     }
-    else if (action == UpdateCoverAction_Unset) {
+    else if (action == UpdateCoverAction::Unset) {
       data_[idx.row()].current_.set_manually_unset_cover();
     }
-    else if (action == UpdateCoverAction_Clear || action == UpdateCoverAction_Delete) {
+    else if (action == UpdateCoverAction::Clear || action == UpdateCoverAction::Delete) {
       data_[idx.row()].current_.clear_art_manual();
       data_[idx.row()].current_.clear_art_automatic();
     }
@@ -1083,13 +1083,13 @@ void EditTagDialog::UpdateCover(const UpdateCoverAction action, const AlbumCover
       if (data_[i].current_.effective_albumartist() == artist && data_[i].current_.album() == album) {
         data_[i].cover_action_ = action;
         data_[i].cover_result_ = result;
-        if (action == UpdateCoverAction_New) {
+        if (action == UpdateCoverAction::New) {
           data_[i].current_.clear_art_manual();
         }
-        else if (action == UpdateCoverAction_Unset) {
+        else if (action == UpdateCoverAction::Unset) {
           data_[i].current_.set_manually_unset_cover();
         }
-        else if (action == UpdateCoverAction_Clear || action == UpdateCoverAction_Delete) {
+        else if (action == UpdateCoverAction::Clear || action == UpdateCoverAction::Delete) {
           data_[i].current_.clear_art_manual();
           data_[i].current_.clear_art_automatic();
         }
@@ -1168,22 +1168,22 @@ void EditTagDialog::SaveData() {
 
     QString embedded_cover_from_file;
     // If embedded album cover is selected, and it isn't saved to the tags, then save it even if no action was done.
-    if (ui_->checkbox_embedded_cover->isChecked() && ref.cover_action_ == UpdateCoverAction_None && !ref.original_.has_embedded_cover() && ref.original_.save_embedded_cover_supported()) {
+    if (ui_->checkbox_embedded_cover->isChecked() && ref.cover_action_ == UpdateCoverAction::None && !ref.original_.has_embedded_cover() && ref.original_.save_embedded_cover_supported()) {
       if (ref.original_.art_manual().isValid() && ref.original_.art_manual().isLocalFile() && QFile::exists(ref.original_.art_manual().toLocalFile())) {
-        ref.cover_action_ = UpdateCoverAction_New;
+        ref.cover_action_ = UpdateCoverAction::New;
         embedded_cover_from_file = ref.original_.art_manual().toLocalFile();
       }
       else if (ref.original_.art_automatic().isValid() && ref.original_.art_automatic().isLocalFile() && QFile::exists(ref.original_.art_automatic().toLocalFile())) {
-        ref.cover_action_ = UpdateCoverAction_New;
+        ref.cover_action_ = UpdateCoverAction::New;
         embedded_cover_from_file = ref.original_.art_automatic().toLocalFile();
       }
     }
 
-    if (ref.cover_action_ != UpdateCoverAction_None) {
+    if (ref.cover_action_ != UpdateCoverAction::None) {
       switch (ref.cover_action_) {
-        case UpdateCoverAction_None:
+        case UpdateCoverAction::None:
           break;
-        case UpdateCoverAction_New:{
+        case UpdateCoverAction::New:{
           if ((!ref.current_.effective_albumartist().isEmpty() && !ref.current_.album().isEmpty()) &&
               (!ui_->checkbox_embedded_cover->isChecked() || !ref.original_.save_embedded_cover_supported())) {
             QUrl cover_url;
@@ -1204,13 +1204,13 @@ void EditTagDialog::SaveData() {
           }
           break;
         }
-        case UpdateCoverAction_Unset:
+        case UpdateCoverAction::Unset:
           ref.current_.set_manually_unset_cover();
           break;
-        case UpdateCoverAction_Clear:
+        case UpdateCoverAction::Clear:
           ref.current_.clear_art_manual();
           break;
-        case UpdateCoverAction_Delete:{
+        case UpdateCoverAction::Delete:{
           if (!ref.original_.art_automatic().isEmpty()) {
             if (ref.original_.art_automatic().isValid() && !ref.original_.has_embedded_cover() && ref.original_.art_automatic().isLocalFile()) {
               QString art_automatic = ref.original_.art_automatic().toLocalFile();
@@ -1233,7 +1233,7 @@ void EditTagDialog::SaveData() {
         }
       }
       if (ui_->checkbox_embedded_cover->isChecked() && ref.original_.save_embedded_cover_supported()) {
-        if (ref.cover_action_ == UpdateCoverAction_New) {
+        if (ref.cover_action_ == UpdateCoverAction::New) {
           if (ref.cover_result_.is_jpeg()) { // Save JPEG data directly.
             ++save_art_pending_;
             TagReaderReply *reply = TagReaderClient::Instance()->SaveEmbeddedArt(ref.current_.url().toLocalFile(), ref.cover_result_.image_data);
@@ -1268,7 +1268,7 @@ void EditTagDialog::SaveData() {
             watcher->setFuture(future);
           }
         }
-        else if (ref.cover_action_ == UpdateCoverAction_Delete) {
+        else if (ref.cover_action_ == UpdateCoverAction::Delete) {
           ++save_art_pending_;
           TagReaderReply *reply = TagReaderClient::Instance()->SaveEmbeddedArt(ref.current_.url().toLocalFile(), QByteArray());
           QObject::connect(reply, &TagReaderReply::Finished, this, [this, reply, ref]() {
@@ -1435,18 +1435,18 @@ void EditTagDialog::SongSaveArtComplete(TagReaderReply *reply, const QString &fi
       song = collection_songs_.take(song.id());
     }
     switch (cover_action) {
-      case UpdateCoverAction_None:
+      case UpdateCoverAction::None:
         break;
-      case UpdateCoverAction_New:
+      case UpdateCoverAction::New:
         song.clear_art_manual();
         song.set_embedded_cover();
         break;
-      case UpdateCoverAction_Clear:
+      case UpdateCoverAction::Clear:
-      case UpdateCoverAction_Delete:
+      case UpdateCoverAction::Delete:
         song.clear_art_automatic();
         song.clear_art_manual();
         break;
-      case UpdateCoverAction_Unset:
+      case UpdateCoverAction::Unset:
         song.clear_art_automatic();
         song.set_manually_unset_cover();
         break;

src/dialogs/edittagdialog.h

@@ -70,9 +70,9 @@ class EditTagDialog : public QDialog {
   static const char *kTagsDifferentHintText;
   static const char *kArtDifferentHintText;
 
-  void SetSongs(const SongList &songs, const PlaylistItemList &items = PlaylistItemList());
+  void SetSongs(const SongList &songs, const PlaylistItemPtrList &items = PlaylistItemPtrList());
 
-  PlaylistItemList playlist_items() const { return playlist_items_; }
+  PlaylistItemPtrList playlist_items() const { return playlist_items_; }
 
   void accept() override;
 
@@ -85,15 +85,15 @@ class EditTagDialog : public QDialog {
   void hideEvent(QHideEvent *e) override;
 
  private:
-  enum UpdateCoverAction {
+  enum class UpdateCoverAction {
-    UpdateCoverAction_None = 0,
+    None = 0,
-    UpdateCoverAction_Clear,
+    Clear,
-    UpdateCoverAction_Unset,
+    Unset,
-    UpdateCoverAction_Delete,
+    Delete,
-    UpdateCoverAction_New,
+    New
   };
   struct Data {
-    explicit Data(const Song &song = Song()) : original_(song), current_(song), cover_action_(UpdateCoverAction_None) {}
+    explicit Data(const Song &song = Song()) : original_(song), current_(song), cover_action_(UpdateCoverAction::None) {}
 
     static QVariant value(const Song &song, const QString &id);
     QVariant original_value(const QString &id) const { return value(original_, id); }
@@ -189,7 +189,7 @@ class EditTagDialog : public QDialog {
 
   bool loading_;
 
-  PlaylistItemList playlist_items_;
+  PlaylistItemPtrList playlist_items_;
   QList<Data> data_;
   QList<FieldData> fields_;
 

src/engine/engine_fwd.h

@@ -20,9 +20,15 @@ class Base;
  *
  * It is vital to be Idle just after the track has ended!
  */
-enum State { Empty, Idle, Playing, Paused, Error };
+enum class State {
+  Empty,
+  Idle,
+  Playing,
+  Paused,
+  Error
+};
 
-enum TrackChangeType {
+enum class TrackChangeType {
   // One of:
   First = 0x01,
   Manual = 0x02,
@@ -39,4 +45,7 @@ Q_DECLARE_FLAGS(TrackChangeFlags, TrackChangeType)
 
 using EngineBase = Engine::Base;
 
+Q_DECLARE_METATYPE(Engine::State)
+Q_DECLARE_METATYPE(Engine::TrackChangeType)
+
 #endif  // ENGINE_FWD_H

src/engine/enginebase.cpp

@@ -159,8 +159,8 @@ void Engine::Base::ReloadSettings() {
   s.endGroup();
 
   s.beginGroup(NetworkProxySettingsPage::kSettingsGroup);
-  NetworkProxyFactory::Mode proxy_mode = NetworkProxyFactory::Mode(s.value("mode", NetworkProxyFactory::Mode_System).toInt());
+  const NetworkProxyFactory::Mode proxy_mode = static_cast<NetworkProxyFactory::Mode>(s.value("mode", static_cast<int>(NetworkProxyFactory::Mode::System)).toInt());
-  if (proxy_mode == NetworkProxyFactory::Mode_Manual && s.contains("engine") && s.value("engine").toBool()) {
+  if (proxy_mode == NetworkProxyFactory::Mode::Manual && s.contains("engine") && s.value("engine").toBool()) {
     QString proxy_host = s.value("hostname").toString();
     int proxy_port = s.value("port").toInt();
     if (proxy_host.isEmpty() || proxy_port <= 0) {

src/engine/enginebase.h

@@ -223,11 +223,11 @@ class Base : public QObject {
 };
 
 struct SimpleMetaBundle {
-  SimpleMetaBundle() : type(Type_Any), length(-1), year(-1), track(-1), filetype(Song::FileType_Unknown), samplerate(-1), bitdepth(-1), bitrate(-1) {}
+  SimpleMetaBundle() : type(Type::Any), length(-1), year(-1), track(-1), filetype(Song::FileType::Unknown), samplerate(-1), bitdepth(-1), bitrate(-1) {}
-  enum Type {
+  enum class Type {
-    Type_Any,
+    Any,
-    Type_Current,
+    Current,
-    Type_Next,
+    Next
   };
   Type type;
   QUrl url;
@@ -250,5 +250,6 @@ struct SimpleMetaBundle {
 }  // namespace Engine
 
 Q_DECLARE_METATYPE(EngineBase::OutputDetails)
+Q_DECLARE_METATYPE(Engine::SimpleMetaBundle)
 
 #endif  // ENGINEBASE_H

src/engine/enginetype.cpp

@@ -27,26 +27,26 @@ namespace Engine {
 
 Engine::EngineType EngineTypeFromName(const QString &enginename) {
   QString lower = enginename.toLower();
-  if (lower == "gstreamer")     return Engine::GStreamer;
+  if (lower == "gstreamer")     return Engine::EngineType::GStreamer;
-  else if (lower == "vlc")      return Engine::VLC;
+  else if (lower == "vlc")      return Engine::EngineType::VLC;
-  else                          return Engine::None;
+  else                          return Engine::EngineType::None;
 }
 
 QString EngineName(const Engine::EngineType enginetype) {
   switch (enginetype) {
-    case Engine::GStreamer:     return QString("gstreamer");
+    case Engine::EngineType::GStreamer:     return QString("gstreamer");
-    case Engine::VLC:           return QString("vlc");
+    case Engine::EngineType::VLC:           return QString("vlc");
-    case Engine::None:
+    case Engine::EngineType::None:
-    default:                    return QString("None");
+    default:                                return QString("None");
   }
 }
 
 QString EngineDescription(Engine::EngineType enginetype) {
   switch (enginetype) {
-    case Engine::GStreamer:	return QString("GStreamer");
+    case Engine::EngineType::GStreamer:	return QString("GStreamer");
-    case Engine::VLC:		return QString("VLC");
+    case Engine::EngineType::VLC:	return QString("VLC");
-    case Engine::None:
+    case Engine::EngineType::None:
-    default:			return QString("None");
+    default:			        return QString("None");
 
   }
 }

src/engine/enginetype.h

@@ -27,7 +27,7 @@
 
 namespace Engine {
 
-enum EngineType {
+enum class EngineType {
   None,
   GStreamer,
   VLC,

src/engine/gstengine.cpp

@@ -72,7 +72,7 @@ const char *GstEngine::kOSXAudioSink = "osxaudiosink";
 const int GstEngine::kDiscoveryTimeoutS = 10;
 
 GstEngine::GstEngine(TaskManager *task_manager, QObject *parent)
-    : Engine::Base(Engine::GStreamer, parent),
+    : Engine::Base(Engine::EngineType::GStreamer, parent),
       task_manager_(task_manager),
       gst_startup_(nullptr),
       discoverer_(nullptr),
@@ -137,19 +137,19 @@ bool GstEngine::Init() {
 
 Engine::State GstEngine::state() const {
 
-  if (!current_pipeline_) return stream_url_.isEmpty() ? Engine::Empty : Engine::Idle;
+  if (!current_pipeline_) return stream_url_.isEmpty() ? Engine::State::Empty : Engine::State::Idle;
 
   switch (current_pipeline_->state()) {
     case GST_STATE_NULL:
-      return Engine::Empty;
+      return Engine::State::Empty;
     case GST_STATE_READY:
-      return Engine::Idle;
+      return Engine::State::Idle;
     case GST_STATE_PLAYING:
-      return Engine::Playing;
+      return Engine::State::Playing;
     case GST_STATE_PAUSED:
-      return Engine::Paused;
+      return Engine::State::Paused;
     default:
-      return Engine::Empty;
+      return Engine::State::Empty;
   }
 
 }
@@ -181,12 +181,12 @@ bool GstEngine::Load(const QUrl &stream_url, const QUrl &original_url, Engine::T
 
   QByteArray gst_url = FixupUrl(stream_url);
 
-  bool crossfade = current_pipeline_ && ((crossfade_enabled_ && change & Engine::Manual) || (autocrossfade_enabled_ && change & Engine::Auto) || ((crossfade_enabled_ || autocrossfade_enabled_) && change & Engine::Intro));
+  bool crossfade = current_pipeline_ && ((crossfade_enabled_ && change & Engine::TrackChangeType::Manual) || (autocrossfade_enabled_ && change & Engine::TrackChangeType::Auto) || ((crossfade_enabled_ || autocrossfade_enabled_) && change & Engine::TrackChangeType::Intro));
 
-  if (change & Engine::Auto && change & Engine::SameAlbum && !crossfade_same_album_)
+  if (change & Engine::TrackChangeType::Auto && change & Engine::TrackChangeType::SameAlbum && !crossfade_same_album_)
     crossfade = false;
 
-  if (!crossfade && current_pipeline_ && current_pipeline_->stream_url() == gst_url && change & Engine::Auto) {
+  if (!crossfade && current_pipeline_ && current_pipeline_->stream_url() == gst_url && change & Engine::TrackChangeType::Auto) {
     // We're not crossfading, and the pipeline is already playing the URI we want, so just do nothing.
     return true;
   }
@@ -275,7 +275,7 @@ void GstEngine::Stop(const bool stop_after) {
 
   current_pipeline_.reset();
   BufferingFinished();
-  emit StateChanged(Engine::Empty);
+  emit StateChanged(Engine::State::Empty);
 
 }
 
@@ -289,7 +289,7 @@ void GstEngine::Pause() {
     current_pipeline_->StartFader(fadeout_pause_duration_nanosec_, QTimeLine::Forward, QEasingCurve::InOutQuad, false);
     is_fading_out_to_pause_ = false;
     has_faded_out_ = false;
-    emit StateChanged(Engine::Playing);
+    emit StateChanged(Engine::State::Playing);
     return;
   }
 
@@ -299,7 +299,7 @@ void GstEngine::Pause() {
     }
     else {
       current_pipeline_->SetState(GST_STATE_PAUSED);
-      emit StateChanged(Engine::Paused);
+      emit StateChanged(Engine::State::Paused);
       StopTimers();
     }
   }
@@ -321,7 +321,7 @@ void GstEngine::Unpause() {
       has_faded_out_ = false;
     }
 
-    emit StateChanged(Engine::Playing);
+    emit StateChanged(Engine::State::Playing);
 
     StartTimers();
   }
@@ -542,7 +542,7 @@ void GstEngine::HandlePipelineError(const int pipeline_id, const int domain, con
 
   current_pipeline_.reset();
   BufferingFinished();
-  emit StateChanged(Engine::Error);
+  emit StateChanged(Engine::State::Error);
 
   if (
       (domain == static_cast<int>(GST_RESOURCE_ERROR) && (
@@ -596,7 +596,7 @@ void GstEngine::FadeoutPauseFinished() {
 
   fadeout_pause_pipeline_->SetState(GST_STATE_PAUSED);
   current_pipeline_->SetState(GST_STATE_PAUSED);
-  emit StateChanged(Engine::Paused);
+  emit StateChanged(Engine::State::Paused);
   StopTimers();
 
   is_fading_out_to_pause_ = false;
@@ -651,7 +651,7 @@ void GstEngine::PlayDone(const GstStateChangeReturn ret, const quint64 offset_na
     Seek(offset_nanosec);
   }
 
-  emit StateChanged(Engine::Playing);
+  emit StateChanged(Engine::State::Playing);
   // We've successfully started playing a media stream with this url
   emit ValidSongRequested(stream_url_);
 
@@ -828,7 +828,7 @@ std::shared_ptr<GstEnginePipeline> GstEngine::CreatePipeline(const QByteArray &g
   if (!ret->InitFromUrl(gst_url, original_url, end_nanosec, error)) {
     ret.reset();
     emit Error(error);
-    emit StateChanged(Engine::Error);
+    emit StateChanged(Engine::State::Error);
     emit FatalError();
   }
 
@@ -919,11 +919,11 @@ void GstEngine::StreamDiscovered(GstDiscoverer*, GstDiscovererInfo *info, GError
 
     Engine::SimpleMetaBundle bundle;
     if (discovered_url == instance->current_pipeline_->stream_url()) {
-      bundle.type = Engine::SimpleMetaBundle::Type_Current;
+      bundle.type = Engine::SimpleMetaBundle::Type::Current;
       bundle.url = instance->current_pipeline_->original_url();
     }
     else if (discovered_url == instance->current_pipeline_->next_stream_url()) {
-      bundle.type = Engine::SimpleMetaBundle::Type_Next;
+      bundle.type = Engine::SimpleMetaBundle::Type::Next;
       bundle.url = instance->current_pipeline_->next_original_url();
     }
     bundle.stream_url = QUrl(discovered_url);
@@ -940,19 +940,19 @@ void GstEngine::StreamDiscovered(GstDiscoverer*, GstDiscovererInfo *info, GError
       QString mimetype = gst_structure_get_name(gst_structure);
       if (!mimetype.isEmpty() && mimetype != "audio/mpeg") {
         bundle.filetype = Song::FiletypeByMimetype(mimetype);
-        if (bundle.filetype == Song::FileType_Unknown) {
+        if (bundle.filetype == Song::FileType::Unknown) {
           qLog(Error) << "Unknown mimetype" << mimetype;
         }
       }
     }
 
-    if (bundle.filetype == Song::FileType_Unknown) {
+    if (bundle.filetype == Song::FileType::Unknown) {
       gchar *codec_description = gst_pb_utils_get_codec_description(caps);
       QString filetype_description = (codec_description ? QString(codec_description) : QString());
       g_free(codec_description);
       if (!filetype_description.isEmpty()) {
         bundle.filetype = Song::FiletypeByDescription(filetype_description);
-        if (bundle.filetype == Song::FileType_Unknown) {
+        if (bundle.filetype == Song::FileType::Unknown) {
           qLog(Error) << "Unknown filetype" << filetype_description;
         }
       }

src/engine/gstenginepipeline.cpp

@@ -1292,7 +1292,7 @@ void GstEnginePipeline::TagMessageReceived(GstMessage *msg) {
   gst_message_parse_tag(msg, &taglist);
 
   Engine::SimpleMetaBundle bundle;
-  bundle.type = Engine::SimpleMetaBundle::Type_Current;
+  bundle.type = Engine::SimpleMetaBundle::Type::Current;
   bundle.url = original_url_;
   bundle.title = ParseStrTag(taglist, GST_TAG_TITLE);
   bundle.artist = ParseStrTag(taglist, GST_TAG_ARTIST);

src/engine/vlcengine.cpp

@@ -39,10 +39,10 @@
 #include "vlcscopedref.h"
 
 VLCEngine::VLCEngine(TaskManager *task_manager, QObject *parent)
-    : Engine::Base(Engine::VLC, parent),
+    : Engine::Base(Engine::EngineType::VLC, parent),
       instance_(nullptr),
       player_(nullptr),
-      state_(Engine::Empty) {
+      state_(Engine::State::Empty) {
 
   Q_UNUSED(task_manager);
 
@@ -52,7 +52,7 @@ VLCEngine::VLCEngine(TaskManager *task_manager, QObject *parent)
 
 VLCEngine::~VLCEngine() {
 
-  if (state_ == Engine::Playing || state_ == Engine::Paused) {
+  if (state_ == Engine::State::Playing || state_ == Engine::State::Paused) {
     libvlc_media_player_stop(player_);
   }
 
@@ -197,7 +197,7 @@ void VLCEngine::SetVolumeSW(const uint percent) {
 
 qint64 VLCEngine::position_nanosec() const {
 
-  if (state_ == Engine::Empty) return 0;
+  if (state_ == Engine::State::Empty) return 0;
   const qint64 result = (position() * kNsecPerMsec);
   return qMax(0LL, result);
 
@@ -205,7 +205,7 @@ qint64 VLCEngine::position_nanosec() const {
 
 qint64 VLCEngine::length_nanosec() const {
 
-  if (state_ == Engine::Empty) return 0;
+  if (state_ == Engine::State::Empty) return 0;
   const qint64 result = (end_nanosec_ - static_cast<qint64>(beginning_nanosec_));
   if (result > 0) {
     return result;
@@ -293,31 +293,31 @@ void VLCEngine::StateChangedCallback(const libvlc_event_t *e, void *data) {
 
     case libvlc_MediaPlayerStopped:{
       const Engine::State state = engine->state_;
-      engine->state_ = Engine::Empty;
+      engine->state_ = Engine::State::Empty;
-      if (state == Engine::Playing) {
+      if (state == Engine::State::Playing) {
         emit engine->StateChanged(engine->state_);
       }
       break;
     }
 
     case libvlc_MediaPlayerEncounteredError:
-      engine->state_ = Engine::Error;
+      engine->state_ = Engine::State::Error;
       emit engine->StateChanged(engine->state_);
       emit engine->FatalError();
       break;
 
     case libvlc_MediaPlayerPlaying:
-      engine->state_ = Engine::Playing;
+      engine->state_ = Engine::State::Playing;
       emit engine->StateChanged(engine->state_);
       break;
 
     case libvlc_MediaPlayerPaused:
-      engine->state_ = Engine::Paused;
+      engine->state_ = Engine::State::Paused;
       emit engine->StateChanged(engine->state_);
       break;
 
     case libvlc_MediaPlayerEndReached:
-      engine->state_ = Engine::Idle;
+      engine->state_ = Engine::State::Idle;
       emit engine->TrackEnded();
       break;
   }

src/globalshortcuts/globalshortcutsbackend-gnome.cpp

@@ -42,7 +42,7 @@ const char *GlobalShortcutsBackendGnome::kService2 = "org.gnome.SettingsDaemon";
 const char *GlobalShortcutsBackendGnome::kPath = "/org/gnome/SettingsDaemon/MediaKeys";
 
 GlobalShortcutsBackendGnome::GlobalShortcutsBackendGnome(GlobalShortcutsManager *manager, QObject *parent)
-    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type_Gnome, parent),
+    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type::Gnome, parent),
       interface_(nullptr),
       is_connected_(false) {}
 

src/globalshortcuts/globalshortcutsbackend-kde.cpp

@@ -42,7 +42,7 @@ const char *GlobalShortcutsBackendKDE::kKdeService = "org.kde.kglobalaccel";
 const char *GlobalShortcutsBackendKDE::kKdePath = "/kglobalaccel";
 
 GlobalShortcutsBackendKDE::GlobalShortcutsBackendKDE(GlobalShortcutsManager *manager, QObject *parent)
-    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type_KDE, parent),
+    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type::KDE, parent),
       interface_(nullptr),
       component_(nullptr) {}
 

src/globalshortcuts/globalshortcutsbackend-macos.mm

@@ -76,7 +76,7 @@ class GlobalShortcutsBackendMacOSPrivate : boost::noncopyable {
 };
 
 GlobalShortcutsBackendMacOS::GlobalShortcutsBackendMacOS(GlobalShortcutsManager *manager, QObject *parent)
-    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type_MacOS, parent),
+    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type::macOS, parent),
       p_(new GlobalShortcutsBackendMacOSPrivate(this)) {}
 
 GlobalShortcutsBackendMacOS::~GlobalShortcutsBackendMacOS() {}

src/globalshortcuts/globalshortcutsbackend-mate.cpp

@@ -40,7 +40,7 @@ const char *GlobalShortcutsBackendMate::kService2 = "org.mate.SettingsDaemon";
 const char *GlobalShortcutsBackendMate::kPath = "/org/mate/SettingsDaemon/MediaKeys";
 
 GlobalShortcutsBackendMate::GlobalShortcutsBackendMate(GlobalShortcutsManager *manager, QObject *parent)
-    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type_Mate, parent),
+    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type::Mate, parent),
       interface_(nullptr),
       is_connected_(false) {}
 

src/globalshortcuts/globalshortcutsbackend-win.cpp

@@ -34,7 +34,7 @@
 #include "globalshortcut.h"
 
 GlobalShortcutsBackendWin::GlobalShortcutsBackendWin(GlobalShortcutsManager *manager, QObject *parent)
-    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type_Win, parent),
+    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type::Win, parent),
       gshortcut_init_(nullptr) {}
 
 GlobalShortcutsBackendWin::~GlobalShortcutsBackendWin() {

src/globalshortcuts/globalshortcutsbackend-x11.cpp

@@ -34,7 +34,7 @@
 #include "globalshortcut.h"
 
 GlobalShortcutsBackendX11::GlobalShortcutsBackendX11(GlobalShortcutsManager *manager, QObject *parent)
-    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type_X11, parent),
+    : GlobalShortcutsBackend(manager, GlobalShortcutsBackend::Type::X11, parent),
       gshortcut_init_(nullptr) {}
 
 GlobalShortcutsBackendX11::~GlobalShortcutsBackendX11() { GlobalShortcutsBackendX11::DoUnregister(); }

src/globalshortcuts/globalshortcutsbackend.cpp

@@ -34,19 +34,19 @@ GlobalShortcutsBackend::GlobalShortcutsBackend(GlobalShortcutsManager *manager,
 QString GlobalShortcutsBackend::name() const {
 
   switch (type_) {
-    case Type_None:
+    case Type::None:
       return "None";
-    case Type_KDE:
+    case Type::KDE:
       return "KDE";
-    case Type_Gnome:
+    case Type::Gnome:
       return "Gnome";
-    case Type_Mate:
+    case Type::Mate:
       return "Mate";
-    case Type_X11:
+    case Type::X11:
       return "X11";
-    case Type_MacOS:
+    case Type::macOS:
       return "macOS";
-    case Type_Win:
+    case Type::Win:
       return "Windows";
   }
 

src/globalshortcuts/globalshortcutsbackend.h

@@ -32,14 +32,14 @@ class GlobalShortcutsBackend : public QObject {
   Q_OBJECT
 
  public:
-  enum Type {
+  enum class Type {
-    Type_None = 0,
+    None = 0,
-    Type_KDE,
+    KDE,
-    Type_Gnome,
+    Gnome,
-    Type_Mate,
+    Mate,
-    Type_X11,
+    X11,
-    Type_MacOS,
+    macOS,
-    Type_Win
+    Win
   };
 
   explicit GlobalShortcutsBackend(GlobalShortcutsManager *manager, const Type type, QObject *parent = nullptr);

src/globalshortcuts/globalshortcutsmanager.cpp

@@ -107,28 +107,28 @@ void GlobalShortcutsManager::ReloadSettings() {
   backends_enabled_.clear();
 
 #ifdef Q_OS_MACOS
-  backends_enabled_ << GlobalShortcutsBackend::Type_MacOS;
+  backends_enabled_ << GlobalShortcutsBackend::Type::macOS;
 #endif
 
 #ifdef Q_OS_WIN
-  backends_enabled_ << GlobalShortcutsBackend::Type_Win;
+  backends_enabled_ << GlobalShortcutsBackend::Type::Win;
 #endif
 
 #if defined(Q_OS_UNIX) && !defined(Q_OS_MACOS) && defined(HAVE_DBUS)
   if (settings_.value("use_kde", true).toBool()) {
-    backends_enabled_ << GlobalShortcutsBackend::Type_KDE;
+    backends_enabled_ << GlobalShortcutsBackend::Type::KDE;
   }
   if (settings_.value("use_gnome", true).toBool()) {
-    backends_enabled_ << GlobalShortcutsBackend::Type_Gnome;
+    backends_enabled_ << GlobalShortcutsBackend::Type::Gnome;
   }
   if (settings_.value("use_mate", true).toBool()) {
-    backends_enabled_ << GlobalShortcutsBackend::Type_Mate;
+    backends_enabled_ << GlobalShortcutsBackend::Type::Mate;
   }
 #endif
 
 #ifdef HAVE_X11_GLOBALSHORTCUTS
   if (settings_.value("use_x11", false).toBool()) {
-    backends_enabled_ << GlobalShortcutsBackend::Type_X11;
+    backends_enabled_ << GlobalShortcutsBackend::Type::X11;
   }
 #endif
 

src/internet/internetplaylistitem.cpp

@@ -64,8 +64,8 @@ QVariant InternetPlaylistItem::DatabaseValue(DatabaseColumn column) const {
 void InternetPlaylistItem::InitMetadata() {
 
   if (metadata_.title().isEmpty()) metadata_.set_title(metadata_.url().toString());
-  if (metadata_.source() == Song::Source_Unknown) metadata_.set_source(Song::Source_Stream);
+  if (metadata_.source() == Song::Source::Unknown) metadata_.set_source(Song::Source::Stream);
-  if (metadata_.filetype() == Song::FileType_Unknown) metadata_.set_filetype(Song::FileType_Stream);
+  if (metadata_.filetype() == Song::FileType::Unknown) metadata_.set_filetype(Song::FileType::Stream);
   metadata_.set_valid(true);
 
 }

src/internet/internetsearchmodel.cpp

@@ -45,9 +45,9 @@ InternetSearchModel::InternetSearchModel(InternetService *service, QObject *pare
       artist_icon_(IconLoader::Load("folder-sound")),
       album_icon_(IconLoader::Load("cdcase")) {
 
-  group_by_[0] = CollectionModel::GroupBy_AlbumArtist;
+  group_by_[0] = CollectionModel::GroupBy::AlbumArtist;
-  group_by_[1] = CollectionModel::GroupBy_AlbumDisc;
+  group_by_[1] = CollectionModel::GroupBy::AlbumDisc;
-  group_by_[2] = CollectionModel::GroupBy_None;
+  group_by_[2] = CollectionModel::GroupBy::None;
 
   QList<QSize> nocover_sizes = album_icon_.availableSizes();
   no_cover_icon_ = album_icon_.pixmap(nocover_sizes.last()).scaled(CollectionModel::kPrettyCoverSize, CollectionModel::kPrettyCoverSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
@@ -88,7 +88,7 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
 
   switch (group_by_[level]) {
 
-    case CollectionModel::GroupBy_AlbumArtist:
+    case CollectionModel::GroupBy::AlbumArtist:
       if (s.is_compilation()) {
         display_text = tr("Various artists");
         sort_text = "aaaaaa";
@@ -100,7 +100,7 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       has_artist_icon = true;
       break;
 
-    case CollectionModel::GroupBy_Artist:
+    case CollectionModel::GroupBy::Artist:
       if (s.is_compilation()) {
         display_text = tr("Various artists");
         sort_text = "aaaaaa";
@@ -112,14 +112,14 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       has_artist_icon = true;
       break;
 
-    case CollectionModel::GroupBy_Album:
+    case CollectionModel::GroupBy::Album:
       display_text = CollectionModel::TextOrUnknown(s.album());
       sort_text = CollectionModel::SortTextForArtist(s.album());
       unique_tag = s.album_id();
       has_album_icon = true;
       break;
 
-    case CollectionModel::GroupBy_AlbumDisc:{
+    case CollectionModel::GroupBy::AlbumDisc:{
       int disc = qMax(0, s.disc());
       display_text = CollectionModel::PrettyAlbumDisc(s.album(), disc);
       sort_text = s.album() + CollectionModel::SortTextForNumber(disc);
@@ -128,7 +128,7 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       break;
     }
 
-    case CollectionModel::GroupBy_YearAlbum:{
+    case CollectionModel::GroupBy::YearAlbum:{
       int year = qMax(0, s.year());
       display_text = CollectionModel::PrettyYearAlbum(year, s.album());
       sort_text = CollectionModel::SortTextForNumber(year) + s.album();
@@ -137,7 +137,7 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       break;
     }
 
-    case CollectionModel::GroupBy_YearAlbumDisc:{
+    case CollectionModel::GroupBy::YearAlbumDisc:{
       int year = qMax(0, s.year());
       int disc = qMax(0, s.disc());
       display_text = CollectionModel::PrettyYearAlbumDisc(year, s.album(), disc);
@@ -147,7 +147,7 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       break;
     }
 
-    case CollectionModel::GroupBy_OriginalYearAlbum:{
+    case CollectionModel::GroupBy::OriginalYearAlbum:{
       int year = qMax(0, s.effective_originalyear());
       display_text = CollectionModel::PrettyYearAlbum(year, s.album());
       sort_text = CollectionModel::SortTextForNumber(year) + s.album();
@@ -156,7 +156,7 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       break;
     }
 
-    case CollectionModel::GroupBy_OriginalYearAlbumDisc:{
+    case CollectionModel::GroupBy::OriginalYearAlbumDisc:{
       const int year = qMax(0, s.effective_originalyear());
       const int disc = qMax(0, s.disc());
       display_text = CollectionModel::PrettyYearAlbumDisc(year, s.album(), disc);
@@ -166,56 +166,56 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       break;
     }
 
-    case CollectionModel::GroupBy_Disc:
+    case CollectionModel::GroupBy::Disc:
       display_text = CollectionModel::PrettyDisc(s.disc());
       sort_text = CollectionModel::SortTextForArtist(display_text);
       has_album_icon = true;
       break;
 
-    case CollectionModel::GroupBy_Year:{
+    case CollectionModel::GroupBy::Year:{
       const int year = qMax(0, s.year());
       display_text = QString::number(year);
       sort_text = CollectionModel::SortTextForNumber(year) + " ";
       break;
     }
 
-    case CollectionModel::GroupBy_OriginalYear:{
+    case CollectionModel::GroupBy::OriginalYear:{
       const int year = qMax(0, s.effective_originalyear());
       display_text = QString::number(year);
       sort_text = CollectionModel::SortTextForNumber(year) + " ";
       break;
     }
 
-    case CollectionModel::GroupBy_Genre:
+    case CollectionModel::GroupBy::Genre:
       display_text = CollectionModel::TextOrUnknown(s.genre());
       sort_text = CollectionModel::SortTextForArtist(s.genre());
       has_album_icon = true;
       break;
 
-    case CollectionModel::GroupBy_Composer:
+    case CollectionModel::GroupBy::Composer:
       display_text = CollectionModel::TextOrUnknown(s.composer());
       sort_text = CollectionModel::SortTextForArtist(s.composer());
       has_album_icon = true;
       break;
 
-    case CollectionModel::GroupBy_Performer:
+    case CollectionModel::GroupBy::Performer:
       display_text = CollectionModel::TextOrUnknown(s.performer());
       sort_text = CollectionModel::SortTextForArtist(s.performer());
       has_album_icon = true;
       break;
 
-    case CollectionModel::GroupBy_Grouping:
+    case CollectionModel::GroupBy::Grouping:
       display_text = CollectionModel::TextOrUnknown(s.grouping());
       sort_text = CollectionModel::SortTextForArtist(s.grouping());
       has_album_icon = true;
       break;
 
-    case CollectionModel::GroupBy_FileType:
+    case CollectionModel::GroupBy::FileType:
       display_text = s.TextForFiletype();
       sort_text = display_text;
       break;
 
-    case CollectionModel::GroupBy_Format:
+    case CollectionModel::GroupBy::Format:
       if (s.samplerate() <= 0) {
         display_text = s.TextForFiletype();
       }
@@ -230,23 +230,23 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
       sort_text = display_text;
       break;
 
-    case CollectionModel::GroupBy_Samplerate:
+    case CollectionModel::GroupBy::Samplerate:
       display_text = QString::number(s.samplerate());
       sort_text = display_text;
       break;
 
-    case CollectionModel::GroupBy_Bitdepth:
+    case CollectionModel::GroupBy::Bitdepth:
       display_text = QString::number(s.bitdepth());
       sort_text = display_text;
       break;
 
-    case CollectionModel::GroupBy_Bitrate:
+    case CollectionModel::GroupBy::Bitrate:
       display_text = QString::number(s.bitrate());
       sort_text = display_text;
       break;
 
-    case CollectionModel::GroupBy_None:
+    case CollectionModel::GroupBy::None:
-    case CollectionModel::GroupByCount:
+    case CollectionModel::GroupBy::GroupByCount:
       return parent;
   }
 
@@ -262,7 +262,7 @@ QStandardItem *InternetSearchModel::BuildContainers(const Song &s, QStandardItem
   else {
     container = new QStandardItem(display_text);
     container->setData(sort_text, CollectionModel::Role_SortText);
-    container->setData(group_by_[level], CollectionModel::Role_ContainerType);
+    container->setData(static_cast<int>(group_by_[level]), CollectionModel::Role_ContainerType);
 
     if (has_artist_icon) {
       container->setIcon(artist_icon_);

src/internet/internetsearchview.cpp

@@ -102,7 +102,7 @@ InternetSearchView::InternetSearchView(QWidget *parent)
       current_proxy_(front_proxy_),
       swap_models_timer_(new QTimer(this)),
       use_pretty_covers_(true),
-      search_type_(InternetSearchView::SearchType_Artists),
+      search_type_(InternetSearchView::SearchType::Artists),
       search_error_(false),
       last_search_id_(0),
       searches_next_id_(1) {
@@ -222,15 +222,15 @@ void InternetSearchView::ReloadSettings() {
 
   // Internet search settings
 
-  search_type_ = InternetSearchView::SearchType(s.value("type", static_cast<int>(InternetSearchView::SearchType_Artists)).toInt());
+  search_type_ = static_cast<InternetSearchView::SearchType>(s.value("type", static_cast<int>(InternetSearchView::SearchType::Artists)).toInt());
   switch (search_type_) {
-    case InternetSearchView::SearchType_Artists:
+    case InternetSearchView::SearchType::Artists:
       ui_->radiobutton_search_artists->setChecked(true);
       break;
-    case InternetSearchView::SearchType_Albums:
+    case InternetSearchView::SearchType::Albums:
       ui_->radiobutton_search_albums->setChecked(true);
       break;
-    case InternetSearchView::SearchType_Songs:
+    case InternetSearchView::SearchType::Songs:
       ui_->radiobutton_search_songs->setChecked(true);
       break;
   }
@@ -238,12 +238,12 @@ void InternetSearchView::ReloadSettings() {
   int group_by_version = s.value("search_group_by_version", 0).toInt();
   if (group_by_version == 1 && s.contains("search_group_by1") && s.contains("search_group_by2") && s.contains("search_group_by3")) {
     SetGroupBy(CollectionModel::Grouping(
-        CollectionModel::GroupBy(s.value("search_group_by1", static_cast<int>(CollectionModel::GroupBy_AlbumArtist)).toInt()),
+        static_cast<CollectionModel::GroupBy>(s.value("search_group_by1", static_cast<int>(CollectionModel::GroupBy::AlbumArtist)).toInt()),
-        CollectionModel::GroupBy(s.value("search_group_by2", static_cast<int>(CollectionModel::GroupBy_AlbumDisc)).toInt()),
+        static_cast<CollectionModel::GroupBy>(s.value("search_group_by2", static_cast<int>(CollectionModel::GroupBy::AlbumDisc)).toInt()),
-        CollectionModel::GroupBy(s.value("search_group_by3", static_cast<int>(CollectionModel::GroupBy_None)).toInt())));
+        static_cast<CollectionModel::GroupBy>(s.value("search_group_by3", static_cast<int>(CollectionModel::GroupBy::None)).toInt())));
   }
   else {
-    SetGroupBy(CollectionModel::Grouping(CollectionModel::GroupBy_AlbumArtist, CollectionModel::GroupBy_AlbumDisc, CollectionModel::GroupBy_None));
+    SetGroupBy(CollectionModel::Grouping(CollectionModel::GroupBy::AlbumArtist, CollectionModel::GroupBy::AlbumDisc, CollectionModel::GroupBy::None));
   }
   s.endGroup();
 
@@ -732,15 +732,15 @@ void InternetSearchView::SetGroupBy(const CollectionModel::Grouping g) {
 }
 
 void InternetSearchView::SearchArtistsClicked(const bool) {
-  SetSearchType(InternetSearchView::SearchType_Artists);
+  SetSearchType(InternetSearchView::SearchType::Artists);
 }
 
 void InternetSearchView::SearchAlbumsClicked(const bool) {
-  SetSearchType(InternetSearchView::SearchType_Albums);
+  SetSearchType(InternetSearchView::SearchType::Albums);
 }
 
 void InternetSearchView::SearchSongsClicked(const bool) {
-  SetSearchType(InternetSearchView::SearchType_Songs);
+  SetSearchType(InternetSearchView::SearchType::Songs);
 }
 
 void InternetSearchView::SetSearchType(const InternetSearchView::SearchType type) {

src/internet/internetsearchview.h

@@ -72,10 +72,10 @@ class InternetSearchView : public QWidget {
   explicit InternetSearchView(QWidget *parent = nullptr);
   ~InternetSearchView() override;
 
-  enum SearchType {
+  enum class SearchType {
-    SearchType_Artists = 1,
+    Artists = 1,
-    SearchType_Albums = 2,
+    Albums = 2,
-    SearchType_Songs = 3,
+    Songs = 3
   };
   struct Result {
     Song metadata_;

src/moodbar/moodbarcontroller.cpp

@@ -60,15 +60,15 @@ void MoodbarController::CurrentSongChanged(const Song &song) {
   const MoodbarLoader::Result result = app_->moodbar_loader()->Load(song.url(), song.has_cue(), &data, &pipeline);
 
   switch (result) {
-    case MoodbarLoader::CannotLoad:
+    case MoodbarLoader::Result::CannotLoad:
       emit CurrentMoodbarDataChanged(QByteArray());
       break;
 
-    case MoodbarLoader::Loaded:
+    case MoodbarLoader::Result::Loaded:
       emit CurrentMoodbarDataChanged(data);
       break;
 
-    case MoodbarLoader::WillLoadAsync:
+    case MoodbarLoader::Result::WillLoadAsync:
       // Emit an empty array for now so the GUI reverts to a normal progress
       // bar.  Our slot will be called when the data is actually loaded.
       emit CurrentMoodbarDataChanged(QByteArray());
@@ -94,9 +94,9 @@ void MoodbarController::AsyncLoadComplete(MoodbarPipeline *pipeline, const QUrl
   }
   // Did we stop the song?
   switch (app_->player()->GetState()) {
-    case Engine::Error:
+    case Engine::State::Error:
-    case Engine::Empty:
+    case Engine::State::Empty:
-    case Engine::Idle:
+    case Engine::State::Idle:
       return;
 
     default:

src/moodbar/moodbaritemdelegate.cpp

@@ -43,14 +43,14 @@
 
 #include "settings/moodbarsettingspage.h"
 
-MoodbarItemDelegate::Data::Data() : state_(State_None) {}
+MoodbarItemDelegate::Data::Data() : state_(State::None) {}
 
 MoodbarItemDelegate::MoodbarItemDelegate(Application *app, PlaylistView *view, QObject *parent)
     : QItemDelegate(parent),
       app_(app),
       view_(view),
       enabled_(false),
-      style_(MoodbarRenderer::Style_Normal) {
+      style_(MoodbarRenderer::MoodbarStyle::Normal) {
 
   QObject::connect(app_, &Application::SettingsChanged, this, &MoodbarItemDelegate::ReloadSettings);
   ReloadSettings();
@@ -62,7 +62,7 @@ void MoodbarItemDelegate::ReloadSettings() {
   QSettings s;
   s.beginGroup(MoodbarSettingsPage::kSettingsGroup);
   enabled_ = s.value("enabled", false).toBool();
-  MoodbarRenderer::MoodbarStyle new_style = static_cast<MoodbarRenderer::MoodbarStyle>(s.value("style", MoodbarRenderer::Style_Normal).toInt());
+  const MoodbarRenderer::MoodbarStyle new_style = static_cast<MoodbarRenderer::MoodbarStyle>(s.value("style", static_cast<int>(MoodbarRenderer::MoodbarStyle::Normal)).toInt());
   s.endGroup();
 
   if (!enabled_) {
@@ -113,13 +113,13 @@ QPixmap MoodbarItemDelegate::PixmapForIndex(const QModelIndex &idx, const QSize
   data->desired_size_ = size;
 
   switch (data->state_) {
-    case Data::State_CannotLoad:
+    case Data::State::CannotLoad:
-    case Data::State_LoadingData:
+    case Data::State::LoadingData:
-    case Data::State_LoadingColors:
+    case Data::State::LoadingColors:
-    case Data::State_LoadingImage:
+    case Data::State::LoadingImage:
       return data->pixmap_;
 
-    case Data::State_Loaded:
+    case Data::State::Loaded:
       // Is the pixmap the right size?
       if (data->pixmap_.size() != size) {
         StartLoadingImage(url, data);
@@ -127,7 +127,7 @@ QPixmap MoodbarItemDelegate::PixmapForIndex(const QModelIndex &idx, const QSize
 
       return data->pixmap_;
 
-    case Data::State_None:
+    case Data::State::None:
       break;
   }
 
@@ -140,22 +140,22 @@ QPixmap MoodbarItemDelegate::PixmapForIndex(const QModelIndex &idx, const QSize
 
 void MoodbarItemDelegate::StartLoadingData(const QUrl &url, const bool has_cue, Data *data) {
 
-  data->state_ = Data::State_LoadingData;
+  data->state_ = Data::State::LoadingData;
 
   // Load a mood file for this song and generate some colors from it
   QByteArray bytes;
   MoodbarPipeline *pipeline = nullptr;
   switch (app_->moodbar_loader()->Load(url, has_cue, &bytes, &pipeline)) {
-    case MoodbarLoader::CannotLoad:
+    case MoodbarLoader::Result::CannotLoad:
-      data->state_ = Data::State_CannotLoad;
+      data->state_ = Data::State::CannotLoad;
       break;
 
-    case MoodbarLoader::Loaded:
+    case MoodbarLoader::Result::Loaded:
       // We got the data immediately.
       StartLoadingColors(url, bytes, data);
       break;
 
-    case MoodbarLoader::WillLoadAsync:
+    case MoodbarLoader::Result::WillLoadAsync:
       // Maybe in a little while.
       QObject::connect(pipeline, &MoodbarPipeline::Finished, this, [this, url, pipeline]() { DataLoaded(url, pipeline); });
       break;
@@ -179,7 +179,7 @@ void MoodbarItemDelegate::ReloadAllColors() {
   for (const QUrl &url : data_.keys()) {
     Data *data = data_[url];
 
-    if (data->state_ == Data::State_Loaded) {
+    if (data->state_ == Data::State::Loaded) {
       StartLoadingData(url, false, data);
     }
   }
@@ -197,7 +197,7 @@ void MoodbarItemDelegate::DataLoaded(const QUrl &url, MoodbarPipeline *pipeline)
   }
 
   if (!pipeline->success()) {
-    data->state_ = Data::State_CannotLoad;
+    data->state_ = Data::State::CannotLoad;
     return;
   }
 
@@ -208,7 +208,7 @@ void MoodbarItemDelegate::DataLoaded(const QUrl &url, MoodbarPipeline *pipeline)
 
 void MoodbarItemDelegate::StartLoadingColors(const QUrl &url, const QByteArray &bytes, Data *data) {
 
-  data->state_ = Data::State_LoadingColors;
+  data->state_ = Data::State::LoadingColors;
 
   QFuture<ColorVector> future = QtConcurrent::run(MoodbarRenderer::Colors, bytes, style_, qApp->palette());
   QFutureWatcher<ColorVector> *watcher = new QFutureWatcher<ColorVector>();
@@ -239,7 +239,7 @@ void MoodbarItemDelegate::ColorsLoaded(const QUrl &url, const ColorVector &color
 
 void MoodbarItemDelegate::StartLoadingImage(const QUrl &url, Data *data) {
 
-  data->state_ = Data::State_LoadingImage;
+  data->state_ = Data::State::LoadingImage;
 
   QFuture<QImage> future = QtConcurrent::run(MoodbarRenderer::RenderToImage, data->colors_, data->desired_size_);
   QFutureWatcher<QImage> *watcher = new QFutureWatcher<QImage>();
@@ -269,7 +269,7 @@ void MoodbarItemDelegate::ImageLoaded(const QUrl &url, const QImage &image) {
   }
 
   data->pixmap_ = QPixmap::fromImage(image);
-  data->state_ = Data::State_Loaded;
+  data->state_ = Data::State::Loaded;
 
   Playlist *playlist = view_->playlist();
   const PlaylistFilter *filter = playlist->filter();

src/moodbar/moodbaritemdelegate.h

@@ -58,13 +58,13 @@ class MoodbarItemDelegate : public QItemDelegate {
   struct Data {
     Data();
 
-    enum State {
+    enum class State {
-      State_None,
+      None,
-      State_CannotLoad,
+      CannotLoad,
-      State_LoadingData,
+      LoadingData,
-      State_LoadingColors,
+      LoadingColors,
-      State_LoadingImage,
+      LoadingImage,
-      State_Loaded
+      Loaded
     };
 
     QSet<QPersistentModelIndex> indexes_;

src/moodbar/moodbarloader.cpp

@@ -94,13 +94,13 @@ QStringList MoodbarLoader::MoodFilenames(const QString &song_filename) {
 MoodbarLoader::Result MoodbarLoader::Load(const QUrl &url, const bool has_cue, QByteArray *data, MoodbarPipeline **async_pipeline) {
 
   if (!url.isLocalFile() || has_cue) {
-    return CannotLoad;
+    return Result::CannotLoad;
   }
 
   // Are we in the middle of loading this moodbar already?
   if (requests_.contains(url)) {
     *async_pipeline = requests_[url];
-    return WillLoadAsync;
+    return Result::WillLoadAsync;
   }
 
   // Check if a mood file exists for this file already
@@ -113,7 +113,7 @@ MoodbarLoader::Result MoodbarLoader::Load(const QUrl &url, const bool has_cue, Q
         qLog(Info) << "Loading moodbar data from" << possible_mood_file;
         *data = f.readAll();
         f.close();
-        return Loaded;
+        return Result::Loaded;
       }
       else {
         qLog(Error) << "Failed to load moodbar data from" << possible_mood_file << f.errorString();
@@ -127,7 +127,7 @@ MoodbarLoader::Result MoodbarLoader::Load(const QUrl &url, const bool has_cue, Q
     qLog(Info) << "Loading cached moodbar data for" << filename;
     *data = cache_device->readAll();
     if (!data->isEmpty()) {
-      return Loaded;
+      return Result::Loaded;
     }
   }
 
@@ -144,7 +144,7 @@ MoodbarLoader::Result MoodbarLoader::Load(const QUrl &url, const bool has_cue, Q
   MaybeTakeNextRequest();
 
   *async_pipeline = pipeline;
-  return WillLoadAsync;
+  return Result::WillLoadAsync;
 
 }
 

src/moodbar/moodbarloader.h

@@ -39,7 +39,7 @@ class MoodbarLoader : public QObject {
   explicit MoodbarLoader(Application *app, QObject *parent = nullptr);
   ~MoodbarLoader() override;
 
-  enum Result {
+  enum class Result {
     // The URL isn't a local file or the moodbar plugin was not available -
     // moodbar data can never be loaded.
     CannotLoad,

src/moodbar/moodbarpipeline.cpp

@@ -78,7 +78,7 @@ void MoodbarPipeline::Start() {
 
   Q_ASSERT(QThread::currentThread() != qApp->thread());
 
-  Utilities::SetThreadIOPriority(Utilities::IOPRIO_CLASS_IDLE);
+  Utilities::SetThreadIOPriority(Utilities::IoPriority::IOPRIO_CLASS_IDLE);
 
   if (pipeline_) {
     return;

src/moodbar/moodbarproxystyle.cpp

@@ -52,8 +52,8 @@ MoodbarProxyStyle::MoodbarProxyStyle(Application *app, QSlider *slider, QObject*
       app_(app),
       slider_(slider),
       enabled_(true),
-      moodbar_style_(MoodbarRenderer::Style_Normal),
+      moodbar_style_(MoodbarRenderer::MoodbarStyle::Normal),
-      state_(MoodbarOff),
+      state_(State::MoodbarOff),
       fade_timeline_(new QTimeLine(1000, this)),
       moodbar_colors_dirty_(true),
       moodbar_pixmap_dirty_(true),
@@ -82,7 +82,7 @@ void MoodbarProxyStyle::ReloadSettings() {
   NextState();
 
   // Get the style, and redraw if there's a change.
-  MoodbarRenderer::MoodbarStyle new_style = static_cast<MoodbarRenderer::MoodbarStyle>(s.value("style", MoodbarRenderer::Style_Normal).toInt());
+  const MoodbarRenderer::MoodbarStyle new_style = static_cast<MoodbarRenderer::MoodbarStyle>(s.value("style", static_cast<int>(MoodbarRenderer::MoodbarStyle::Normal)).toInt());
 
   s.endGroup();
 
@@ -129,13 +129,13 @@ void MoodbarProxyStyle::NextState() {
     show_moodbar_action_->setChecked(enabled_);
   }
 
-  if ((visible && (state_ == MoodbarOn || state_ == FadingToOn)) || (!visible && (state_ == MoodbarOff || state_ == FadingToOff))) {
+  if ((visible && (state_ == State::MoodbarOn || state_ == State::FadingToOn)) || (!visible && (state_ == State::MoodbarOff || state_ == State::FadingToOff))) {
     return;
   }
 
   const QTimeLine::Direction direction = visible ? QTimeLine::Forward : QTimeLine::Backward;
 
-  if (state_ == MoodbarOn || state_ == MoodbarOff) {
+  if (state_ == State::MoodbarOn || state_ == State::MoodbarOff) {
     // Start the fade from the beginning.
     fade_timeline_->setDirection(direction);
     fade_timeline_->start();
@@ -151,7 +151,7 @@ void MoodbarProxyStyle::NextState() {
     fade_timeline_->resume();
   }
 
-  state_ = visible ? FadingToOn : FadingToOff;
+  state_ = visible ? State::FadingToOn : State::FadingToOff;
 
 }
 
@@ -198,16 +198,16 @@ void MoodbarProxyStyle::Render(ComplexControl control, const QStyleOptionSlider
   const qreal fade_value = fade_timeline_->currentValue();
 
   // Have we finished fading?
-  if (state_ == FadingToOn && fade_value == 1.0) {
+  if (state_ == State::FadingToOn && fade_value == 1.0) {
-    state_ = MoodbarOn;
+    state_ = State::MoodbarOn;
   }
-  else if (state_ == FadingToOff && fade_value == 0.0) {
+  else if (state_ == State::FadingToOff && fade_value == 0.0) {
-    state_ = MoodbarOff;
+    state_ = State::MoodbarOff;
   }
 
   switch (state_) {
-    case FadingToOn:
+    case State::FadingToOn:
-    case FadingToOff:
+    case State::FadingToOff:
       // Update the cached pixmaps if necessary
       if (fade_source_.isNull()) {
         // Draw the normal slider into the fade source pixmap.
@@ -224,7 +224,7 @@ void MoodbarProxyStyle::Render(ComplexControl control, const QStyleOptionSlider
       }
 
       if (fade_target_.isNull()) {
-        if (state_ == FadingToOn) {
+        if (state_ == State::FadingToOn) {
           EnsureMoodbarRendered(option);
         }
         fade_target_ = moodbar_pixmap_;
@@ -240,12 +240,12 @@ void MoodbarProxyStyle::Render(ComplexControl control, const QStyleOptionSlider
       painter->setOpacity(1.0);
       break;
 
-    case MoodbarOff:
+    case State::MoodbarOff:
       // It's a normal slider widget.
       QProxyStyle::drawComplexControl(control, option, painter, widget);
       break;
 
-    case MoodbarOn:
+    case State::MoodbarOn:
       EnsureMoodbarRendered(option);
       painter->drawPixmap(option->rect, moodbar_pixmap_);
       DrawArrow(option, painter);
@@ -276,12 +276,12 @@ QRect MoodbarProxyStyle::subControlRect(ComplexControl cc, const QStyleOptionCom
   }
 
   switch (state_) {
-    case MoodbarOff:
+    case State::MoodbarOff:
-    case FadingToOff:
+    case State::FadingToOff:
       break;
 
-    case MoodbarOn:
+    case State::MoodbarOn:
-    case FadingToOn:
+    case State::FadingToOn:
       switch (sc) {
         case SC_SliderGroove:
           return opt->rect.adjusted(kMarginSize, kMarginSize, -kMarginSize, -kMarginSize);
@@ -376,7 +376,7 @@ void MoodbarProxyStyle::ShowContextMenu(const QPoint pos) {
     QMenu *styles_menu = context_menu_->addMenu(tr("Moodbar style"));
     style_action_group_ = new QActionGroup(styles_menu);
 
-    for (int i = 0; i < MoodbarRenderer::StyleCount; ++i) {
+    for (int i = 0; i < static_cast<int>(MoodbarRenderer::MoodbarStyle::StyleCount); ++i) {
       const MoodbarRenderer::MoodbarStyle style = static_cast<MoodbarRenderer::MoodbarStyle>(i);
 
       QAction *action = style_action_group_->addAction(MoodbarRenderer::StyleName(style));

src/moodbar/moodbarproxystyle.h

@@ -70,7 +70,12 @@ class MoodbarProxyStyle : public QProxyStyle {
   static const int kArrowWidth;
   static const int kArrowHeight;
 
-  enum State { MoodbarOn, MoodbarOff, FadingToOn, FadingToOff };
+  enum class State {
+    MoodbarOn,
+    MoodbarOff,
+    FadingToOn,
+    FadingToOff
+  };
 
  private:
   void NextState();

src/moodbar/moodbarrenderer.cpp

@@ -37,19 +37,19 @@ ColorVector MoodbarRenderer::Colors(const QByteArray &data, const MoodbarStyle s
   // Set some parameters based on the moodbar style
   StyleProperties properties;
   switch (style) {
-    case Style_Angry:
+    case MoodbarStyle::Angry:
       properties = StyleProperties(samples / 360 * 9, 45, -45, 200, 100);
       break;
-    case Style_Frozen:
+    case MoodbarStyle::Frozen:
       properties = StyleProperties(samples / 360 * 1, 140, 160, 50, 100);
       break;
-    case Style_Happy:
+    case MoodbarStyle::Happy:
       properties = StyleProperties(samples / 360 * 2, 0, 359, 150, 250);
       break;
-    case Style_Normal:
+    case MoodbarStyle::Normal:
       properties = StyleProperties(samples / 360 * 3, 0, 359, 100, 100);
       break;
-    case Style_SystemPalette:
+    case MoodbarStyle::SystemPalette:
     default: {
       const QColor highlight_color(palette.color(QPalette::Active, QPalette::Highlight));
 
@@ -163,15 +163,15 @@ QImage MoodbarRenderer::RenderToImage(const ColorVector &colors, const QSize siz
 QString MoodbarRenderer::StyleName(const MoodbarStyle style) {
 
   switch (style) {
-    case Style_Normal:
+    case MoodbarStyle::Normal:
       return QObject::tr("Normal");
-    case Style_Angry:
+    case MoodbarStyle::Angry:
       return QObject::tr("Angry");
-    case Style_Frozen:
+    case MoodbarStyle::Frozen:
       return QObject::tr("Frozen");
-    case Style_Happy:
+    case MoodbarStyle::Happy:
       return QObject::tr("Happy");
-    case Style_SystemPalette:
+    case MoodbarStyle::SystemPalette:
       return QObject::tr("System colors");
 
     default: