diff --git a/src/core/mainwindow.cpp b/src/core/mainwindow.cpp
index c7f096a2e..868ada020 100644
--- a/src/core/mainwindow.cpp
+++ b/src/core/mainwindow.cpp
@@ -848,7 +848,7 @@ MainWindow::MainWindow(Application *app, SharedPtr<SystemTrayIcon> tray_icon, OS
 
   // Context
   QObject::connect(&*app_->playlist_manager(), &PlaylistManager::CurrentSongChanged, context_view_, &ContextView::SongChanged);
-  QObject::connect(&*app_->playlist_manager(), &PlaylistManager::SongMetadataChanged, context_view_, &ContextView::SongChanged);
+  QObject::connect(&*app_->playlist_manager(), &PlaylistManager::CurrentSongMetadataChanged, context_view_, &ContextView::SongChanged);
   QObject::connect(&*app_->player(), &Player::PlaylistFinished, context_view_, &ContextView::Stopped);
   QObject::connect(&*app_->player(), &Player::Playing, context_view_, &ContextView::Playing);
   QObject::connect(&*app_->player(), &Player::Stopped, context_view_, &ContextView::Stopped);
@@ -2008,7 +2008,7 @@ void MainWindow::PlaylistRightClick(const QPoint global_pos, const QModelIndex &
 
   playlist_open_in_browser_->setVisible(selected > 0 && local_songs == selected);
 
-  bool track_column = (index.column() == Playlist::Column_Track);
+  const bool track_column = (index.column() == static_cast<int>(Playlist::Column::Track));
   ui_->action_renumber_tracks->setVisible(local_songs > 0 && !cue_selected && editable >= 2 && track_column);
   ui_->action_selection_set_value->setVisible(editable >= 2 && !cue_selected && !track_column);
   ui_->action_edit_value->setVisible(editable > 0 && !cue_selected);
@@ -2770,7 +2770,7 @@ void MainWindow::PlaylistOpenInBrowser() {
   for (const QModelIndex &proxy_index : ui_->playlist->view()->selectionModel()->selectedRows()) {
     const QModelIndex source_index = app_->playlist_manager()->current()->filter()->mapToSource(proxy_index);
     if (!source_index.isValid()) continue;
-    urls << QUrl(source_index.sibling(source_index.row(), Playlist::Column_Filename).data().toString());
+    urls << QUrl(source_index.sibling(source_index.row(), static_cast<int>(Playlist::Column::Filename)).data().toString());
   }
 
   Utilities::OpenInFileBrowser(urls);
diff --git a/src/core/player.cpp b/src/core/player.cpp
index c6c390279..d9dce8fd5 100644
--- a/src/core/player.cpp
+++ b/src/core/player.cpp
@@ -252,8 +252,12 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
   }
 
   // Might've been an async load, so check we're still on the same item
-  PlaylistItemPtr item = app_->playlist_manager()->active()->current_item();
-  if (!item) {
+  const int current_row = app_->playlist_manager()->active()->current_row();
+  if (current_row == -1) {
+    return;
+  }
+  PlaylistItemPtr current_item = app_->playlist_manager()->active()->current_item();
+  if (!current_item) {
     return;
   }
   int next_row = app_->playlist_manager()->active()->next_row();
@@ -263,10 +267,10 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
     next_item = app_->playlist_manager()->active()->item_at(next_row);
   }
 
-  bool is_current(false);
-  bool is_next(false);
+  bool is_current = false;
+  bool is_next = false;
 
-  if (result.media_url_ == item->Url()) {
+  if (result.media_url_ == current_item->Url()) {
     is_current = true;
   }
   else if (has_next_row && next_item->Url() == result.media_url_) {
@@ -294,10 +298,10 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
       qLog(Debug) << "URL handler for" << result.media_url_ << "returned" << result.stream_url_;
 
       Song song;
-      if (is_current) song = item->Metadata();
+      if (is_current) song = current_item->Metadata();
       else if (is_next) song = next_item->Metadata();
 
-      bool update(false);
+      bool update = false;
 
       // Set the stream url in the temporary metadata.
       if (
@@ -341,23 +345,20 @@ void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
 
       if (update) {
         if (is_current) {
-          item->SetTemporaryMetadata(song);
-          app_->playlist_manager()->active()->InformOfCurrentSongChange(autoscroll_, true);
-          app_->playlist_manager()->active()->UpdateScrobblePoint();
+          app_->playlist_manager()->active()->UpdateItemMetadata(current_row, current_item, song, true);
         }
         else if (is_next) {
-          next_item->SetTemporaryMetadata(song);
-          app_->playlist_manager()->active()->ItemChanged(next_row);
+          app_->playlist_manager()->active()->UpdateItemMetadata(next_row, next_item, song, true);
         }
       }
 
       if (is_current) {
-        qLog(Debug) << "Playing song" << item->Metadata().title() << result.stream_url_ << "position" << play_offset_nanosec_;
+        qLog(Debug) << "Playing song" << current_item->Metadata().title() << result.stream_url_ << "position" << play_offset_nanosec_;
         engine_->Play(result.media_url_, result.stream_url_, stream_change_type_, song.has_cue(), song.beginning_nanosec(), song.end_nanosec(), play_offset_nanosec_, song.ebur128_integrated_loudness_lufs());
-        current_item_ = item;
+        current_item_ = current_item;
         play_offset_nanosec_ = 0;
       }
-      else if (is_next && !item->Metadata().is_module_music()) {
+      else if (is_next && !current_item->Metadata().is_module_music()) {
         qLog(Debug) << "Preloading next song" << next_item->Metadata().title() << result.stream_url_;
         engine_->StartPreloading(next_item->Url(), result.stream_url_, song.has_cue(), song.beginning_nanosec(), song.end_nanosec());
       }
@@ -783,7 +784,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(false);
   }
 
 }
@@ -799,24 +800,26 @@ void Player::SeekBackward() {
 void Player::EngineMetadataReceived(const EngineMetadata &engine_metadata) {
 
   if (engine_metadata.type == EngineMetadata::Type::Any || engine_metadata.type == EngineMetadata::Type::Current) {
-    PlaylistItemPtr item = app_->playlist_manager()->active()->current_item();
-    if (item && engine_metadata.media_url == item->Url()) {
-      Song song = item->Metadata();
-      bool minor = song.MergeFromEngineMetadata(engine_metadata);
-      app_->playlist_manager()->active()->SetStreamMetadata(item->Url(), song, minor);
-      return;
+    const int current_row = app_->playlist_manager()->active()->current_row();
+    if (current_row != -1) {
+      PlaylistItemPtr item = app_->playlist_manager()->active()->current_item();
+      if (item && engine_metadata.media_url == item->Url()) {
+        Song song = item->Metadata();
+        song.MergeFromEngineMetadata(engine_metadata);
+        app_->playlist_manager()->active()->UpdateItemMetadata(current_row, item, song, true);
+        return;
+      }
     }
   }
 
   if (engine_metadata.type == EngineMetadata::Type::Any || engine_metadata.type == EngineMetadata::Type::Next) {
-    int next_row = app_->playlist_manager()->active()->next_row();
+    const int next_row = app_->playlist_manager()->active()->next_row();
     if (next_row != -1) {
       PlaylistItemPtr next_item = app_->playlist_manager()->active()->item_at(next_row);
       if (engine_metadata.media_url == next_item->Url()) {
         Song song = next_item->Metadata();
         song.MergeFromEngineMetadata(engine_metadata);
-        next_item->SetTemporaryMetadata(song);
-        app_->playlist_manager()->active()->ItemChanged(next_row);
+        app_->playlist_manager()->active()->UpdateItemMetadata(next_row, next_item, song, true);
       }
     }
   }
diff --git a/src/dialogs/edittagdialog.cpp b/src/dialogs/edittagdialog.cpp
index 1f9094ad6..f84f03a4d 100644
--- a/src/dialogs/edittagdialog.cpp
+++ b/src/dialogs/edittagdialog.cpp
@@ -253,13 +253,13 @@ EditTagDialog::EditTagDialog(Application *app, QWidget *parent)
       QKeySequence(QKeySequence::Forward).toString(QKeySequence::NativeText),
       QKeySequence(QKeySequence::MoveToNextPage).toString(QKeySequence::NativeText)));
 
-  new TagCompleter(app_->collection_backend(), Playlist::Column_Artist, ui_->artist);
-  new TagCompleter(app_->collection_backend(), Playlist::Column_Album, ui_->album);
-  new TagCompleter(app_->collection_backend(), Playlist::Column_AlbumArtist, ui_->albumartist);
-  new TagCompleter(app_->collection_backend(), Playlist::Column_Genre, ui_->genre);
-  new TagCompleter(app_->collection_backend(), Playlist::Column_Composer, ui_->composer);
-  new TagCompleter(app_->collection_backend(), Playlist::Column_Performer, ui_->performer);
-  new TagCompleter(app_->collection_backend(), Playlist::Column_Grouping, ui_->grouping);
+  new TagCompleter(app_->collection_backend(), Playlist::Column::Artist, ui_->artist);
+  new TagCompleter(app_->collection_backend(), Playlist::Column::Album, ui_->album);
+  new TagCompleter(app_->collection_backend(), Playlist::Column::AlbumArtist, ui_->albumartist);
+  new TagCompleter(app_->collection_backend(), Playlist::Column::Genre, ui_->genre);
+  new TagCompleter(app_->collection_backend(), Playlist::Column::Composer, ui_->composer);
+  new TagCompleter(app_->collection_backend(), Playlist::Column::Performer, ui_->performer);
+  new TagCompleter(app_->collection_backend(), Playlist::Column::Grouping, ui_->grouping);
 
 }
 
diff --git a/src/moodbar/moodbaritemdelegate.cpp b/src/moodbar/moodbaritemdelegate.cpp
index ea1fc704f..6ddcdef30 100644
--- a/src/moodbar/moodbaritemdelegate.cpp
+++ b/src/moodbar/moodbaritemdelegate.cpp
@@ -99,8 +99,8 @@ void MoodbarItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem &o
 QPixmap MoodbarItemDelegate::PixmapForIndex(const QModelIndex &idx, const QSize size) {
 
   // Pixmaps are keyed off URL.
-  const QUrl url = idx.sibling(idx.row(), Playlist::Column_Filename).data().toUrl();
-  const bool has_cue = idx.sibling(idx.row(), Playlist::Column_HasCUE).data().toBool();
+  const QUrl url = idx.sibling(idx.row(), static_cast<int>(Playlist::Column::Filename)).data().toUrl();
+  const bool has_cue = idx.sibling(idx.row(), static_cast<int>(Playlist::Column::HasCUE)).data().toBool();
 
   Data *data = nullptr;
   if (data_.contains(url)) {
@@ -279,7 +279,7 @@ void MoodbarItemDelegate::ImageLoaded(const QUrl &url, const QImage &image) {
 
   // Update all the indices with the new pixmap.
   for (const QPersistentModelIndex &idx : std::as_const(data->indexes_)) {
-    if (idx.isValid() && idx.sibling(idx.row(), Playlist::Column_Filename).data().toUrl() == url) {
+    if (idx.isValid() && idx.sibling(idx.row(), static_cast<int>(Playlist::Column::Filename)).data().toUrl() == url) {
       QModelIndex source_index = idx;
       if (idx.model() == filter) {
         source_index = filter->mapToSource(source_index);
diff --git a/src/playlist/playlist.cpp b/src/playlist/playlist.cpp
index 362bec3a1..7c845560f 100644
--- a/src/playlist/playlist.cpp
+++ b/src/playlist/playlist.cpp
@@ -2,7 +2,7 @@
  * Strawberry Music Player
  * This file was part of Clementine.
  * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2024, Jonas Kvinge <jonas@jkvinge.net>
  *
  * Strawberry is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -97,25 +97,27 @@
 using std::make_shared;
 using namespace std::chrono_literals;
 
+const char *Playlist::kSettingsGroup = "Playlist";
 const char *Playlist::kCddaMimeType = "x-content/audio-cdda";
 const char *Playlist::kRowsMimetype = "application/x-strawberry-playlist-rows";
 const char *Playlist::kPlayNowMimetype = "application/x-strawberry-play-now";
-
-const int Playlist::kInvalidSongPriority = 200;
-const QRgb Playlist::kInvalidSongColor = qRgb(0xC0, 0xC0, 0xC0);
-
-const int Playlist::kDynamicHistoryPriority = 100;
-const QRgb Playlist::kDynamicHistoryColor = qRgb(0x80, 0x80, 0x80);
-
-const char *Playlist::kSettingsGroup = "Playlist";
-
 const int Playlist::kUndoStackSize = 20;
 const int Playlist::kUndoItemLimit = 500;
 
-const qint64 Playlist::kMinScrobblePointNsecs = 31LL * kNsecPerSec;
-const qint64 Playlist::kMaxScrobblePointNsecs = 240LL * kNsecPerSec;
+namespace {
 
-const int Playlist::kMaxPlayedIndexes = 100;
+constexpr int kInvalidSongPriority = 200;
+constexpr QRgb kInvalidSongColor = qRgb(0xC0, 0xC0, 0xC0);
+
+constexpr int kDynamicHistoryPriority = 100;
+constexpr QRgb kDynamicHistoryColor = qRgb(0x80, 0x80, 0x80);
+
+constexpr qint64 kMinScrobblePointNsecs = 31LL * kNsecPerSec;
+constexpr qint64 kMaxScrobblePointNsecs = 240LL * kNsecPerSec;
+
+constexpr int kMaxPlayedIndexes = 100;
+
+} // namespace
 
 Playlist::Playlist(SharedPtr<PlaylistBackend> backend, SharedPtr<TaskManager> task_manager, SharedPtr<CollectionBackend> collection_backend, const int id, const QString &special_type, const bool favorite, QObject *parent)
     : QAbstractListModel(parent),
@@ -137,9 +139,8 @@ Playlist::Playlist(SharedPtr<PlaylistBackend> backend, SharedPtr<TaskManager> ta
       cancel_restore_(false),
       scrobbled_(false),
       scrobble_point_(-1),
-      editing_(-1),
       auto_sort_(false),
-      sort_column_(Column_Title),
+      sort_column_(Column::Title),
       sort_order_(Qt::AscendingOrder) {
 
   undo_stack_->setUndoLimit(kUndoStackSize);
@@ -186,7 +187,7 @@ void Playlist::InsertSongItems(const SongList &songs, const int pos, const bool
 
 }
 
-QVariant Playlist::headerData(int section, Qt::Orientation, int role) const {
+QVariant Playlist::headerData(const int section, Qt::Orientation, const int role) const {
 
   if (role != Qt::DisplayRole && role != Qt::ToolTipRole) return QVariant();
 
@@ -197,68 +198,69 @@ QVariant Playlist::headerData(int section, Qt::Orientation, int role) const {
 
 }
 
-bool Playlist::column_is_editable(Playlist::Column column) {
+bool Playlist::column_is_editable(const Playlist::Column column) {
 
   switch (column) {
-    case Column_Title:
-    case Column_Artist:
-    case Column_Album:
-    case Column_AlbumArtist:
-    case Column_Composer:
-    case Column_Performer:
-    case Column_Grouping:
-    case Column_Track:
-    case Column_Disc:
-    case Column_Year:
-    case Column_Genre:
-    case Column_Comment:
+    case Column::Title:
+    case Column::Artist:
+    case Column::Album:
+    case Column::AlbumArtist:
+    case Column::Composer:
+    case Column::Performer:
+    case Column::Grouping:
+    case Column::Track:
+    case Column::Disc:
+    case Column::Year:
+    case Column::Genre:
+    case Column::Comment:
       return true;
     default:
       break;
   }
+
   return false;
 
 }
 
-bool Playlist::set_column_value(Song &song, Playlist::Column column, const QVariant &value) {
+bool Playlist::set_column_value(Song &song, const Playlist::Column column, const QVariant &value) {
 
   if (!song.IsEditable()) return false;
 
   switch (column) {
-    case Column_Title:
+    case Column::Title:
       song.set_title(value.toString());
       break;
-    case Column_Artist:
+    case Column::Artist:
       song.set_artist(value.toString());
       break;
-    case Column_Album:
+    case Column::Album:
       song.set_album(value.toString());
       break;
-    case Column_AlbumArtist:
+    case Column::AlbumArtist:
       song.set_albumartist(value.toString());
       break;
-    case Column_Composer:
+    case Column::Composer:
       song.set_composer(value.toString());
       break;
-    case Column_Performer:
+    case Column::Performer:
       song.set_performer(value.toString());
       break;
-    case Column_Grouping:
+    case Column::Grouping:
       song.set_grouping(value.toString());
       break;
-    case Column_Track:
+    case Column::Track:
       song.set_track(value.toInt());
       break;
-    case Column_Disc:
+    case Column::Disc:
       song.set_disc(value.toInt());
       break;
-    case Column_Year:
+    case Column::Year:
       song.set_year(value.toInt());
       break;
-    case Column_Genre:
+    case Column::Genre:
       song.set_genre(value.toString());
       break;
-    case Column_Comment:
+    case Column::Comment:
       song.set_comment(value.toString());
       break;
     default:
@@ -269,7 +271,7 @@ bool Playlist::set_column_value(Song &song, Playlist::Column column, const QVari
 
 }
 
-QVariant Playlist::data(const QModelIndex &idx, int role) const {
+QVariant Playlist::data(const QModelIndex &idx, const int role) const {
 
   if (!idx.isValid()) {
     return QVariant();
@@ -289,7 +291,7 @@ QVariant Playlist::data(const QModelIndex &idx, int role) const {
       return queue_->PositionOf(idx);
 
     case Role_CanSetRating:
-      return idx.column() == Column_Rating && items_[idx.row()]->IsLocalCollectionItem() && items_[idx.row()]->Metadata().id() != -1;
+      return static_cast<Column>(idx.column()) == Column::Rating && items_[idx.row()]->IsLocalCollectionItem() && items_[idx.row()]->Metadata().id() != -1;
 
     case Qt::EditRole:
     case Qt::ToolTipRole:
@@ -298,51 +300,53 @@ QVariant Playlist::data(const QModelIndex &idx, int role) const {
       Song song = item->Metadata();
 
       // Don't forget to change Playlist::CompareItems when adding new columns
-      switch (idx.column()) {
-        case Column_Title:              return song.PrettyTitle();
-        case Column_Artist:             return song.artist();
-        case Column_Album:              return song.album();
-        case Column_Length:             return song.length_nanosec();
-        case Column_Track:              return song.track();
-        case Column_Disc:               return song.disc();
-        case Column_Year:               return song.year();
-        case Column_OriginalYear:       return song.effective_originalyear();
-        case Column_Genre:              return song.genre();
-        case Column_AlbumArtist:        return song.playlist_albumartist();
-        case Column_Composer:           return song.composer();
-        case Column_Performer:          return song.performer();
-        case Column_Grouping:           return song.grouping();
+      switch (static_cast<Column>(idx.column())) {
+        case Column::Title:              return song.PrettyTitle();
+        case Column::Artist:             return song.artist();
+        case Column::Album:              return song.album();
+        case Column::Length:             return song.length_nanosec();
+        case Column::Track:              return song.track();
+        case Column::Disc:               return song.disc();
+        case Column::Year:               return song.year();
+        case Column::OriginalYear:       return song.effective_originalyear();
+        case Column::Genre:              return song.genre();
+        case Column::AlbumArtist:        return song.playlist_albumartist();
+        case Column::Composer:           return song.composer();
+        case Column::Performer:          return song.performer();
+        case Column::Grouping:           return song.grouping();
 
-        case Column_PlayCount:          return song.playcount();
-        case Column_SkipCount:          return song.skipcount();
-        case Column_LastPlayed:         return song.lastplayed();
+        case Column::PlayCount:          return song.playcount();
+        case Column::SkipCount:          return song.skipcount();
+        case Column::LastPlayed:         return song.lastplayed();
 
-        case Column_Samplerate:         return song.samplerate();
-        case Column_Bitdepth:           return song.bitdepth();
-        case Column_Bitrate:            return song.bitrate();
+        case Column::Samplerate:         return song.samplerate();
+        case Column::Bitdepth:           return song.bitdepth();
+        case Column::Bitrate:            return song.bitrate();
 
-        case Column_Filename:           return song.effective_stream_url();
-        case Column_BaseFilename:       return song.basefilename();
-        case Column_Filesize:           return song.filesize();
-        case Column_Filetype:           return QVariant::fromValue(song.filetype());
-        case Column_DateModified:       return song.mtime();
-        case Column_DateCreated:        return song.ctime();
+        case Column::Filename:           return song.effective_stream_url();
+        case Column::BaseFilename:       return song.basefilename();
+        case Column::Filesize:           return song.filesize();
+        case Column::Filetype:           return QVariant::fromValue(song.filetype());
+        case Column::DateModified:       return song.mtime();
+        case Column::DateCreated:        return song.ctime();
 
-        case Column_Comment:
+        case Column::Comment:
           if (role == Qt::DisplayRole)  return song.comment().simplified();
           return song.comment();
 
-        case Column_EBUR128IntegratedLoudness: return song.ebur128_integrated_loudness_lufs().has_value() ? song.ebur128_integrated_loudness_lufs().value() : QVariant();
+        case Column::EBUR128IntegratedLoudness: return song.ebur128_integrated_loudness_lufs().has_value() ? song.ebur128_integrated_loudness_lufs().value() : QVariant();
 
-        case Column_EBUR128LoudnessRange: return song.ebur128_loudness_range_lu().has_value() ? song.ebur128_loudness_range_lu().value() : QVariant();
+        case Column::EBUR128LoudnessRange: return song.ebur128_loudness_range_lu().has_value() ? song.ebur128_loudness_range_lu().value() : QVariant();
 
-        case Column_Source:             return QVariant::fromValue(song.source());
+        case Column::Source:             return QVariant::fromValue(song.source());
 
-        case Column_Rating:             return song.rating();
+        case Column::Rating:             return song.rating();
 
-        case Column_HasCUE:             return song.has_cue();
+        case Column::HasCUE:             return song.has_cue();
 
-        default: break;
+        case Column::Mood:
+        case Column::ColumnCount:
+          break;
 
       }
 
@@ -394,11 +398,11 @@ QVariant Playlist::data(const QModelIndex &idx, int role) const {
 
 #ifdef HAVE_MOODBAR
 void Playlist::MoodbarUpdated(const QModelIndex &idx) {
-  emit dataChanged(idx.sibling(idx.row(), Column_Mood), idx.sibling(idx.row(), Column_Mood));
+  emit dataChanged(idx.sibling(idx.row(), static_cast<int>(Column::Mood)), idx.sibling(idx.row(), static_cast<int>(Column::Mood)));
 }
 #endif
 
-bool Playlist::setData(const QModelIndex &idx, const QVariant &value, int role) {
+bool Playlist::setData(const QModelIndex &idx, const QVariant &value, const int role) {
 
   Q_UNUSED(role);
 
@@ -461,15 +465,14 @@ void Playlist::ItemReloadComplete(const QPersistentModelIndex &idx, const Song &
   if (idx.isValid()) {
     PlaylistItemPtr item = item_at(idx.row());
     if (item) {
+      ItemChanged(idx.row(), ChangedColumns(old_metadata, item->Metadata()));
       if (idx.row() == current_row()) {
-        const bool minor = old_metadata.title() == item->Metadata().title() &&
-                           old_metadata.albumartist() == item->Metadata().albumartist() &&
-                           old_metadata.artist() == item->Metadata().artist() &&
-                           old_metadata.album() == item->Metadata().album();
-        InformOfCurrentSongChange(AutoScroll::Never, minor);
-      }
-      else {
-        emit dataChanged(index(idx.row(), 0), index(idx.row(), ColumnCount - 1));
+        if (MinorMetadataChange(old_metadata, item->Metadata())) {
+          emit CurrentSongMetadataChanged(item->Metadata());
+        }
+        else {
+          emit CurrentSongChanged(item->Metadata());
+        }
       }
       if (metadata_edit) {
         emit EditingFinished(id_, idx);
@@ -701,7 +704,8 @@ void Playlist::set_current_row(const int i, const AutoScroll autoscroll, const b
   }
 
   if (current_item_index_.isValid() && !is_stopping) {
-    InformOfCurrentSongChange(autoscroll, false);
+    InformOfCurrentSongChange(false);
+    emit MaybeAutoscroll(autoscroll);
   }
 
   // The structure of a dynamic playlist is as follows:
@@ -782,7 +786,7 @@ Qt::DropActions Playlist::supportedDropActions() const {
   return Qt::MoveAction | Qt::CopyAction | Qt::LinkAction;
 }
 
-bool Playlist::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int, const QModelIndex&) {
+bool Playlist::dropMimeData(const QMimeData *data, Qt::DropAction action, const int row, int, const QModelIndex&) {
 
   if (action == Qt::IgnoreAction) return false;
 
@@ -1134,7 +1138,7 @@ void Playlist::InsertItemsWithoutUndo(const PlaylistItemPtrList &items, const in
   }
 
   if (auto_sort_) {
-    sort(sort_column_, sort_order_);
+    sort(static_cast<int>(sort_column_), sort_order_);
   }
 
   ReshuffleIndices();
@@ -1299,7 +1303,7 @@ QMimeData *Playlist::mimeData(const QModelIndexList &indexes) const {
 
 }
 
-bool Playlist::CompareItems(const int column, const Qt::SortOrder order, PlaylistItemPtr _a, PlaylistItemPtr _b) {
+bool Playlist::CompareItems(const Column column, const Qt::SortOrder order, PlaylistItemPtr _a, PlaylistItemPtr _b) {
 
   PlaylistItemPtr a = order == Qt::AscendingOrder ? _a : _b;
   PlaylistItemPtr b = order == Qt::AscendingOrder ? _b : _a;
@@ -1308,47 +1312,48 @@ bool Playlist::CompareItems(const int column, const Qt::SortOrder order, Playlis
 #define strcmp(field) return QString::localeAwareCompare(a->Metadata().field().toLower(), b->Metadata().field().toLower()) < 0;
 
   switch (column) {
+    case Column::Title:        strcmp(title_sortable);
+    case Column::Artist:       strcmp(artist_sortable);
+    case Column::Album:        strcmp(album_sortable);
+    case Column::Length:       cmp(length_nanosec);
+    case Column::Track:        cmp(track);
+    case Column::Disc:         cmp(disc);
+    case Column::Year:         cmp(year);
+    case Column::OriginalYear: cmp(effective_originalyear);
+    case Column::Genre:        strcmp(genre);
+    case Column::AlbumArtist:  strcmp(playlist_albumartist_sortable);
+    case Column::Composer:     strcmp(composer);
+    case Column::Performer:    strcmp(performer);
+    case Column::Grouping:     strcmp(grouping);
 
-    case Column_Title:        strcmp(title_sortable);
-    case Column_Artist:       strcmp(artist_sortable);
-    case Column_Album:        strcmp(album_sortable);
-    case Column_Length:       cmp(length_nanosec);
-    case Column_Track:        cmp(track);
-    case Column_Disc:         cmp(disc);
-    case Column_Year:         cmp(year);
-    case Column_OriginalYear: cmp(effective_originalyear);
-    case Column_Genre:        strcmp(genre);
-    case Column_AlbumArtist:  strcmp(playlist_albumartist_sortable);
-    case Column_Composer:     strcmp(composer);
-    case Column_Performer:    strcmp(performer);
-    case Column_Grouping:     strcmp(grouping);
+    case Column::PlayCount:    cmp(playcount);
+    case Column::SkipCount:    cmp(skipcount);
+    case Column::LastPlayed:   cmp(lastplayed);
 
-    case Column_PlayCount:    cmp(playcount);
-    case Column_SkipCount:    cmp(skipcount);
-    case Column_LastPlayed:   cmp(lastplayed);
-
-    case Column_Bitrate:      cmp(bitrate);
-    case Column_Samplerate:   cmp(samplerate);
-    case Column_Bitdepth:     cmp(bitdepth);
-    case Column_Filename:
+    case Column::Bitrate:      cmp(bitrate);
+    case Column::Samplerate:   cmp(samplerate);
+    case Column::Bitdepth:     cmp(bitdepth);
+    case Column::Filename:
       return (QString::localeAwareCompare(a->Url().path().toLower(), b->Url().path().toLower()) < 0);
-    case Column_BaseFilename: cmp(basefilename);
-    case Column_Filesize:     cmp(filesize);
-    case Column_Filetype:     cmp(filetype);
-    case Column_DateModified: cmp(mtime);
-    case Column_DateCreated:  cmp(ctime);
+    case Column::BaseFilename: cmp(basefilename);
+    case Column::Filesize:     cmp(filesize);
+    case Column::Filetype:     cmp(filetype);
+    case Column::DateModified: cmp(mtime);
+    case Column::DateCreated:  cmp(ctime);
 
-    case Column_Comment:      strcmp(comment);
-    case Column_Source:       cmp(source);
+    case Column::Comment:      strcmp(comment);
+    case Column::Source:       cmp(source);
 
-    case Column_Rating:       cmp(rating);
+    case Column::Rating:       cmp(rating);
 
-    case Column_HasCUE:       cmp(has_cue);
+    case Column::HasCUE:       cmp(has_cue);
 
-    case Column_EBUR128IntegratedLoudness: cmp(ebur128_integrated_loudness_lufs);
-    case Column_EBUR128LoudnessRange: cmp(ebur128_loudness_range_lu);
+    case Column::EBUR128IntegratedLoudness: cmp(ebur128_integrated_loudness_lufs);
+    case Column::EBUR128LoudnessRange: cmp(ebur128_loudness_range_lu);
 
-    default: qLog(Error) << "No such column" << column;
+    case Column::Mood:
+    case Column::ColumnCount:
+      break;
   }
 
 #undef cmp
@@ -1370,49 +1375,51 @@ bool Playlist::ComparePathDepths(const Qt::SortOrder order, PlaylistItemPtr _a,
 
 }
 
-QString Playlist::column_name(Column column) {
+QString Playlist::column_name(const Column column) {
 
   switch (column) {
-    case Column_Title:        return tr("Title");
-    case Column_Artist:       return tr("Artist");
-    case Column_Album:        return tr("Album");
-    case Column_Track:        return tr("Track");
-    case Column_Disc:         return tr("Disc");
-    case Column_Length:       return tr("Length");
-    case Column_Year:         return tr("Year");
-    case Column_OriginalYear: return tr("Original Year");
-    case Column_Genre:        return tr("Genre");
-    case Column_AlbumArtist:  return tr("Album Artist");
-    case Column_Composer:     return tr("Composer");
-    case Column_Performer:    return tr("Performer");
-    case Column_Grouping:     return tr("Grouping");
+    case Column::Title:        return tr("Title");
+    case Column::Artist:       return tr("Artist");
+    case Column::Album:        return tr("Album");
+    case Column::Track:        return tr("Track");
+    case Column::Disc:         return tr("Disc");
+    case Column::Length:       return tr("Length");
+    case Column::Year:         return tr("Year");
+    case Column::OriginalYear: return tr("Original Year");
+    case Column::Genre:        return tr("Genre");
+    case Column::AlbumArtist:  return tr("Album Artist");
+    case Column::Composer:     return tr("Composer");
+    case Column::Performer:    return tr("Performer");
+    case Column::Grouping:     return tr("Grouping");
 
-    case Column_PlayCount:    return tr("Play Count");
-    case Column_SkipCount:    return tr("Skip Count");
-    case Column_LastPlayed:   return tr("Last Played");
+    case Column::PlayCount:    return tr("Play Count");
+    case Column::SkipCount:    return tr("Skip Count");
+    case Column::LastPlayed:   return tr("Last Played");
 
-    case Column_Samplerate:   return tr("Sample Rate");
-    case Column_Bitdepth:     return tr("Bit Depth");
-    case Column_Bitrate:      return tr("Bitrate");
+    case Column::Samplerate:   return tr("Sample Rate");
+    case Column::Bitdepth:     return tr("Bit Depth");
+    case Column::Bitrate:      return tr("Bitrate");
 
-    case Column_Filename:     return tr("File Name");
-    case Column_BaseFilename: return tr("File Name (without path)");
-    case Column_Filesize:     return tr("File Size");
-    case Column_Filetype:     return tr("File Type");
-    case Column_DateModified: return tr("Date Modified");
-    case Column_DateCreated:  return tr("Date Created");
+    case Column::Filename:     return tr("File Name");
+    case Column::BaseFilename: return tr("File Name (without path)");
+    case Column::Filesize:     return tr("File Size");
+    case Column::Filetype:     return tr("File Type");
+    case Column::DateModified: return tr("Date Modified");
+    case Column::DateCreated:  return tr("Date Created");
 
-    case Column_Comment:      return tr("Comment");
-    case Column_Source:       return tr("Source");
-    case Column_Mood:         return tr("Mood");
-    case Column_Rating:       return tr("Rating");
-    case Column_HasCUE:       return tr("CUE");
+    case Column::Comment:      return tr("Comment");
+    case Column::Source:       return tr("Source");
+    case Column::Mood:         return tr("Mood");
+    case Column::Rating:       return tr("Rating");
+    case Column::HasCUE:       return tr("CUE");
 
-    case Column_EBUR128IntegratedLoudness: return tr("Integrated Loudness");
-    case Column_EBUR128LoudnessRange: return tr("Loudness Range");
+    case Column::EBUR128IntegratedLoudness: return tr("Integrated Loudness");
+    case Column::EBUR128LoudnessRange: return tr("Loudness Range");
 
-    default:                  qLog(Error) << "No such column" << column;;
+    case Column::ColumnCount:
+      break;
   }
+
   return QLatin1String("");
 
 }
@@ -1422,21 +1429,24 @@ QString Playlist::abbreviated_column_name(const Column column) {
   const QString &column_name = Playlist::column_name(column);
 
   switch (column) {
-    case Column_Disc:
-    case Column_PlayCount:
-    case Column_SkipCount:
-    case Column_Track:
+    case Column::Disc:
+    case Column::PlayCount:
+    case Column::SkipCount:
+    case Column::Track:
       return QStringLiteral("%1#").arg(column_name[0]);
     default:
       return column_name;
   }
+
   return QLatin1String("");
 
 }
 
-void Playlist::sort(int column, Qt::SortOrder order) {
+void Playlist::sort(const int column_number, const Qt::SortOrder order) {
 
-  sort_column_ = column;
+  const Column column = static_cast<Column>(column_number);
+
+  sort_column_ = static_cast<Column>(column);
   sort_order_ = order;
 
   if (ignore_sorting_) return;
@@ -1447,15 +1457,15 @@ void Playlist::sort(int column, Qt::SortOrder order) {
   if (dynamic_playlist_ && current_item_index_.isValid())
     begin += current_item_index_.row() + 1;
 
-  if (column == Column_Album) {
+  if (column == Column::Album) {
     // When sorting by album, also take into account discs and tracks.
-    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column_Track, order, std::placeholders::_1, std::placeholders::_2));
-    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column_Disc, order, std::placeholders::_1, std::placeholders::_2));
-    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column_Album, order, std::placeholders::_1, std::placeholders::_2));
+    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column::Track, order, std::placeholders::_1, std::placeholders::_2));
+    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column::Disc, order, std::placeholders::_1, std::placeholders::_2));
+    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column::Album, order, std::placeholders::_1, std::placeholders::_2));
   }
-  else if (column == Column_Filename) {
+  else if (column == Column::Filename) {
     // When sorting by full paths we also expect a hierarchical order. This returns a breath-first ordering of paths.
-    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column_Filename, order, std::placeholders::_1, std::placeholders::_2));
+    std::stable_sort(begin, new_items.end(), std::bind(&Playlist::CompareItems, Column::Filename, order, std::placeholders::_1, std::placeholders::_2));
     std::stable_sort(begin, new_items.end(), std::bind(&Playlist::ComparePathDepths, order, std::placeholders::_1, std::placeholders::_2));
   }
   else {
@@ -1635,7 +1645,7 @@ void Playlist::ItemsLoaded() {
 
 }
 
-static bool DescendingIntLessThan(int a, int b) { return a > b; }
+static bool DescendingIntLessThan(const int a, const int b) { return a > b; }
 
 void Playlist::RemoveItemsWithoutUndo(const QList<int> &indicesIn) {
 
@@ -1658,7 +1668,7 @@ void Playlist::RemoveItemsWithoutUndo(const QList<int> &indicesIn) {
 
 }
 
-bool Playlist::removeRows(int row, int count, const QModelIndex &parent) {
+bool Playlist::removeRows(const int row, const int count, const QModelIndex &parent) {
 
   Q_UNUSED(parent);
 
@@ -1784,25 +1794,19 @@ void Playlist::StopAfter(const int row) {
 
 }
 
-void Playlist::SetStreamMetadata(const QUrl &url, const Song &song, const bool minor) {
-
-  if (!current_item() || current_item()->Url() != url) return;
-
-  bool update_scrobble_point = song.length_nanosec() != current_item_metadata().length_nanosec();
-  current_item()->SetTemporaryMetadata(song);
-  if (update_scrobble_point) UpdateScrobblePoint();
-  InformOfCurrentSongChange(AutoScroll::Never, minor);
-
-}
-
 void Playlist::ClearStreamMetadata() {
 
-  if (!current_item()) return;
+  if (!current_item() || !current_item_index_.isValid()) return;
 
+  const Song old_metadata = current_item()->Metadata();
   current_item()->ClearTemporaryMetadata();
-  UpdateScrobblePoint();
+  const Song &new_metadata = current_item()->Metadata();
 
-  emit dataChanged(index(current_item_index_.row(), 0), index(current_item_index_.row(), ColumnCount - 1));
+  ItemChanged(current_row(), ChangedColumns(old_metadata, new_metadata));
+
+  if (old_metadata.length_nanosec() != new_metadata.length_nanosec()) {
+    UpdateScrobblePoint();
+  }
 
 }
 
@@ -2077,10 +2081,10 @@ PlaylistItemPtrList Playlist::collection_items_by_id(const int id) const {
   return collection_items_by_id_.values(id);
 }
 
-void Playlist::TracksAboutToBeDequeued(const QModelIndex&, int begin, int end) {
+void Playlist::TracksAboutToBeDequeued(const QModelIndex&, const int begin, const int end) {
 
   for (int i = begin; i <= end; ++i) {
-    temp_dequeue_change_indexes_ << queue_->mapToSource(queue_->index(i, Column_Title));
+    temp_dequeue_change_indexes_ << queue_->mapToSource(queue_->index(i, static_cast<int>(Column::Title)));
   }
 
 }
@@ -2097,8 +2101,8 @@ void Playlist::TracksDequeued() {
 
 void Playlist::TracksEnqueued(const QModelIndex&, const int begin, const int end) {
 
-  const QModelIndex &b = queue_->mapToSource(queue_->index(begin, Column_Title));
-  const QModelIndex &e = queue_->mapToSource(queue_->index(end, Column_Title));
+  const QModelIndex &b = queue_->mapToSource(queue_->index(begin, static_cast<int>(Column::Title)));
+  const QModelIndex &e = queue_->mapToSource(queue_->index(end, static_cast<int>(Column::Title)));
   emit dataChanged(b, e);
 
 }
@@ -2106,47 +2110,193 @@ void Playlist::TracksEnqueued(const QModelIndex&, const int begin, const int end
 void Playlist::QueueLayoutChanged() {
 
   for (int i = 0; i < queue_->rowCount(); ++i) {
-    const QModelIndex &idx = queue_->mapToSource(queue_->index(i, Column_Title));
+    const QModelIndex &idx = queue_->mapToSource(queue_->index(i, static_cast<int>(Column::Title)));
     emit dataChanged(idx, idx);
   }
 
 }
 
-void Playlist::ItemChanged(const int row) {
+Playlist::Columns Playlist::ChangedColumns(const Song &metadata1, const Song &metadata2) {
 
-  QModelIndex idx = index(row, ColumnCount - 1);
-  if (idx.isValid()) {
-    emit dataChanged(index(row, 0), index(row, ColumnCount - 1));
+  Columns columns;
+
+  if (metadata1.title() != metadata2.title()) {
+    columns << Column::Title;
+  }
+  if (metadata1.artist() != metadata2.artist()) {
+    columns << Column::Artist;
+  }
+  if (metadata1.album() != metadata2.album()) {
+    columns << Column::Album;
+  }
+  if (metadata1.effective_albumartist() != metadata2.effective_albumartist()) {
+    columns << Column::AlbumArtist;
+  }
+  if (metadata1.performer() != metadata2.performer()) {
+    columns << Column::Performer;
+  }
+  if (metadata1.composer() != metadata2.composer()) {
+    columns << Column::Composer;
+  }
+  if (metadata1.year() != metadata2.year()) {
+    columns << Column::Year;
+  }
+  if (metadata1.originalyear() != metadata2.originalyear()) {
+    columns << Column::OriginalYear;
+  }
+  if (metadata1.track() != metadata2.track()) {
+    columns << Column::Track;
+  }
+  if (metadata1.disc() != metadata2.disc()) {
+    columns << Column::Disc;
+  }
+  if (metadata1.length_nanosec() != metadata2.length_nanosec()) {
+    columns << Column::Length;
+  }
+  if (metadata1.genre() != metadata2.genre()) {
+    columns << Column::Genre;
+  }
+  if (metadata1.samplerate() != metadata2.samplerate()) {
+    columns << Column::Samplerate;
+  }
+  if (metadata1.bitdepth() != metadata2.bitdepth()) {
+    columns << Column::Bitdepth;
+  }
+  if (metadata1.bitrate() != metadata2.bitrate()) {
+    columns << Column::Bitrate;
+  }
+  if (metadata1.url() != metadata2.url()) {
+    columns << Column::Filename;
+    columns << Column::BaseFilename;
+  }
+  if (metadata1.filesize() != metadata2.filesize()) {
+    columns << Column::Filesize;
+  }
+  if (metadata1.filetype() != metadata2.filetype()) {
+    columns << Column::Filetype;
+  }
+  if (metadata1.ctime() != metadata2.ctime()) {
+    columns << Column::DateCreated;
+  }
+  if (metadata1.mtime() != metadata2.mtime()) {
+    columns << Column::DateModified;
+  }
+  if (metadata1.playcount() != metadata2.playcount()) {
+    columns << Column::PlayCount;
+  }
+  if (metadata1.skipcount() != metadata2.skipcount()) {
+    columns << Column::SkipCount;
+  }
+  if (metadata1.lastplayed() != metadata2.lastplayed()) {
+    columns << Column::LastPlayed;
+  }
+  if (metadata1.comment() != metadata2.comment()) {
+    columns << Column::Comment;
+  }
+  if (metadata1.grouping() != metadata2.grouping()) {
+    columns << Column::Grouping;
+  }
+  if (metadata1.source() != metadata2.source()) {
+    columns << Column::Source;
+  }
+  if (metadata1.rating() != metadata2.rating()) {
+    columns << Column::Rating;
+  }
+  if (metadata1.has_cue() != metadata2.has_cue()) {
+    columns << Column::HasCUE;
+  }
+  if (metadata1.ebur128_integrated_loudness_lufs() != metadata2.ebur128_integrated_loudness_lufs()) {
+    columns << Column::EBUR128IntegratedLoudness;
+  }
+  if (metadata1.ebur128_loudness_range_lu() != metadata2.ebur128_loudness_range_lu()) {
+    columns << Column::EBUR128LoudnessRange;
+  }
+
+  return columns;
+
+}
+
+bool Playlist::MinorMetadataChange(const Song &old_metadata, const Song &new_metadata) {
+
+  return new_metadata.title() == old_metadata.title() &&
+         new_metadata.albumartist() == old_metadata.albumartist() &&
+         new_metadata.artist() == old_metadata.artist() &&
+         new_metadata.album() == old_metadata.album();
+
+}
+
+void Playlist::UpdateItemMetadata(PlaylistItemPtr item, const Song &new_metadata, const bool temporary) {
+
+  if (!items_.contains(item)) {
+    return;
+  }
+
+  for (int row = static_cast<int>(items_.indexOf(item, 0)); row != -1; row = static_cast<int>(items_.indexOf(item, row + 1))) {
+    UpdateItemMetadata(row, item, new_metadata, temporary);
   }
 
 }
 
-void Playlist::ItemChanged(PlaylistItemPtr item) {
+void Playlist::UpdateItemMetadata(const int row, PlaylistItemPtr item, const Song &new_metadata, const bool temporary) {
 
-  for (int row = 0; row < items_.count(); ++row) {
-    if (items_[row] == item) {
-      ItemChanged(row);
+  const Song old_metadata = item->Metadata();
+
+  const Columns columns = ChangedColumns(old_metadata, new_metadata);
+  if (columns.isEmpty()) return;
+
+  if (temporary) {
+    item->SetTemporaryMetadata(new_metadata);
+  }
+  else {
+    item->SetMetadata(new_metadata);
+    if (item->HasTemporaryMetadata()) {
+      item->UpdateTemporaryMetadata(new_metadata);
+    }
+  }
+
+  ItemChanged(row, columns);
+
+  if (row == current_row()) {
+    InformOfCurrentSongChange(MinorMetadataChange(old_metadata, new_metadata));
+    if (new_metadata.length_nanosec() != old_metadata.length_nanosec()) {
+      UpdateScrobblePoint();
     }
   }
 
 }
 
-void Playlist::InformOfCurrentSongChange(const AutoScroll autoscroll, const bool minor) {
+void Playlist::ItemChanged(const int row, const Columns columns) {
 
-  // If the song is invalid, we won't play it - there's no point in informing anybody about the change
-  const Song metadata(current_item_metadata());
-  if (metadata.is_valid()) {
-    if (minor) {
-      emit SongMetadataChanged(metadata);
-      if (editing_ != current_item_index_.row()) {
-        emit dataChanged(index(current_item_index_.row(), 0), index(current_item_index_.row(), ColumnCount - 1));
+  if (columns.count() > 5) {
+    const QModelIndex idx_column_first = index(row, 0);
+    const QModelIndex idx_column_last = index(row, ColumnCount - 1);
+    if (idx_column_first.isValid() && idx_column_last.isValid()) {
+      emit dataChanged(index(row, 0), index(row, ColumnCount - 1));
+    }
+  }
+  else {
+    for (const Column &column : columns) {
+      const QModelIndex idx = index(row, static_cast<int>(column));
+      if (idx.isValid()) {
+        emit dataChanged(idx, idx);
       }
     }
-    else {
-      emit CurrentSongChanged(metadata);
-      emit MaybeAutoscroll(autoscroll);
-      emit dataChanged(index(current_item_index_.row(), 0), index(current_item_index_.row(), ColumnCount - 1));
-    }
+  }
+
+}
+
+void Playlist::InformOfCurrentSongChange(const bool minor) {
+
+  const Song &metadata = current_item_metadata();
+  if (!metadata.is_valid()) {
+    return;
+  }
+
+  if (minor) {
+    emit CurrentSongMetadataChanged(metadata);
+  }
+  else {
+    emit CurrentSongChanged(metadata);
   }
 
 }
diff --git a/src/playlist/playlist.h b/src/playlist/playlist.h
index 2b39db86f..ae21eb0d0 100644
--- a/src/playlist/playlist.h
+++ b/src/playlist/playlist.h
@@ -2,7 +2,7 @@
  * Strawberry Music Player
  * This file was part of Clementine.
  * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2024, Jonas Kvinge <jonas@jkvinge.net>
  *
  * Strawberry is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -89,41 +89,43 @@ class Playlist : public QAbstractListModel {
   void SkipTracks(const QModelIndexList &source_indexes);
 
   // Always add new columns to the end of this enum - the values are persisted
-  enum Column {
-    Column_Title = 0,
-    Column_Artist,
-    Column_Album,
-    Column_AlbumArtist,
-    Column_Performer,
-    Column_Composer,
-    Column_Year,
-    Column_OriginalYear,
-    Column_Track,
-    Column_Disc,
-    Column_Length,
-    Column_Genre,
-    Column_Samplerate,
-    Column_Bitdepth,
-    Column_Bitrate,
-    Column_Filename,
-    Column_BaseFilename,
-    Column_Filesize,
-    Column_Filetype,
-    Column_DateCreated,
-    Column_DateModified,
-    Column_PlayCount,
-    Column_SkipCount,
-    Column_LastPlayed,
-    Column_Comment,
-    Column_Grouping,
-    Column_Source,
-    Column_Mood,
-    Column_Rating,
-    Column_HasCUE,
-    Column_EBUR128IntegratedLoudness,
-    Column_EBUR128LoudnessRange,
+  enum class Column {
+    Title = 0,
+    Artist,
+    Album,
+    AlbumArtist,
+    Performer,
+    Composer,
+    Year,
+    OriginalYear,
+    Track,
+    Disc,
+    Length,
+    Genre,
+    Samplerate,
+    Bitdepth,
+    Bitrate,
+    Filename,
+    BaseFilename,
+    Filesize,
+    Filetype,
+    DateCreated,
+    DateModified,
+    PlayCount,
+    SkipCount,
+    LastPlayed,
+    Comment,
+    Grouping,
+    Source,
+    Mood,
+    Rating,
+    HasCUE,
+    EBUR128IntegratedLoudness,
+    EBUR128LoudnessRange,
     ColumnCount
   };
+  using Columns = QList<Column>;
+  static constexpr int ColumnCount = static_cast<int>(Column::ColumnCount);
 
   enum Role {
     Role_IsCurrent = Qt::UserRole + 1,
@@ -139,30 +141,19 @@ class Playlist : public QAbstractListModel {
     Always
   };
 
+  static const char *kSettingsGroup;
   static const char *kCddaMimeType;
   static const char *kRowsMimetype;
   static const char *kPlayNowMimetype;
-
-  static const int kInvalidSongPriority;
-  static const QRgb kInvalidSongColor;
-
-  static const int kDynamicHistoryPriority;
-  static const QRgb kDynamicHistoryColor;
-
-  static const char *kSettingsGroup;
-
   static const int kUndoStackSize;
   static const int kUndoItemLimit;
 
-  static const qint64 kMinScrobblePointNsecs;
-  static const qint64 kMaxScrobblePointNsecs;
+  static bool CompareItems(const Column column, const Qt::SortOrder order, PlaylistItemPtr a, PlaylistItemPtr b);
 
-  static bool CompareItems(const int column, const Qt::SortOrder order, PlaylistItemPtr a, PlaylistItemPtr b);
+  static QString column_name(const Column column);
+  static QString abbreviated_column_name(const Column column);
 
-  static QString column_name(Column column);
-  static QString abbreviated_column_name(Column column);
-
-  static bool column_is_editable(Playlist::Column column);
+  static bool column_is_editable(const Column column);
   static bool set_column_value(Song &song, Column column, const QVariant &value);
 
   // Persistence
@@ -219,7 +210,6 @@ class Playlist : public QAbstractListModel {
 
   bool scrobbled() const { return scrobbled_; }
   void set_scrobbled(const bool state) { scrobbled_ = state; }
-  void set_editing(const int row) { editing_ = row; }
   qint64 scrobble_point_nanosec() const { return scrobble_point_; }
   void UpdateScrobblePoint(const qint64 seek_point_nanosec = 0);
 
@@ -248,7 +238,7 @@ class Playlist : public QAbstractListModel {
   void StopAfter(const int row);
   void ReloadItems(const QList<int> &rows);
   void ReloadItemsBlocking(const QList<int> &rows);
-  void InformOfCurrentSongChange(const AutoScroll autoscroll, const bool minor);
+  void InformOfCurrentSongChange(const bool minor);
 
   // Just emits the dataChanged() signal so the mood column is repainted.
 #ifdef HAVE_MOODBAR
@@ -257,22 +247,25 @@ class Playlist : public QAbstractListModel {
 
   // QAbstractListModel
   int rowCount(const QModelIndex& = QModelIndex()) const override { return items_.count(); }
-  int columnCount(const QModelIndex& = QModelIndex()) const override { return ColumnCount; }
-  QVariant data(const QModelIndex &idx, int role = Qt::DisplayRole) const override;
-  bool setData(const QModelIndex &idx, const QVariant &value, int role) override;
-  QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+  int columnCount(const QModelIndex& = QModelIndex()) const override { return static_cast<int>(ColumnCount); }
+  QVariant data(const QModelIndex &idx, const int role = Qt::DisplayRole) const override;
+  bool setData(const QModelIndex &idx, const QVariant &value, const int role) override;
+  QVariant headerData(const int section, const Qt::Orientation orientation, const int role = Qt::DisplayRole) const override;
   Qt::ItemFlags flags(const QModelIndex &idx) const override;
   QStringList mimeTypes() const override;
   Qt::DropActions supportedDropActions() const override;
   QMimeData *mimeData(const QModelIndexList &indexes) const override;
-  bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
-  void sort(int column, Qt::SortOrder order) override;
-  bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override;
+  bool dropMimeData(const QMimeData *data, Qt::DropAction action, const int row, const int column, const QModelIndex &parent) override;
+  void sort(const int column_number, const Qt::SortOrder order) override;
+  bool removeRows(const int row, const int count, const QModelIndex &parent = QModelIndex()) override;
 
   static bool ComparePathDepths(Qt::SortOrder, PlaylistItemPtr, PlaylistItemPtr);
 
-  void ItemChanged(PlaylistItemPtr item);
-  void ItemChanged(const int row);
+  static Columns ChangedColumns(const Song &metadata1, const Song &metadata2);
+  static bool MinorMetadataChange(const Song &old_metadata, const Song &new_metadata);
+  void UpdateItemMetadata(PlaylistItemPtr item, const Song &new_metadata, const bool temporary);
+  void UpdateItemMetadata(const int row, PlaylistItemPtr item, const Song &new_metadata, const bool temporary);
+  void ItemChanged(const int row, const Columns columns);
 
   // Changes rating of a song to the given value asynchronously
   void RateSong(const QModelIndex &idx, const float rating);
@@ -290,7 +283,6 @@ class Playlist : public QAbstractListModel {
   void IgnoreSorting(const bool value) { ignore_sorting_ = value; }
 
   void ClearStreamMetadata();
-  void SetStreamMetadata(const QUrl &url, const Song &song, const bool minor);
   void UpdateItems(SongList songs);
 
   void Clear();
@@ -302,7 +294,7 @@ class Playlist : public QAbstractListModel {
 
   void SetColumnAlignment(const ColumnAlignmentMap &alignment);
 
-  void InsertUrls(const QList<QUrl> &urls, int pos = -1, bool play_now = false, bool enqueue = false, bool enqueue_next = false);
+  void InsertUrls(const QList<QUrl> &urls, const int pos = -1, const bool play_now = false, const bool enqueue = false, const bool enqueue_next = false);
   // Removes items with given indices from the playlist. This operation is not undoable.
   void RemoveItemsWithoutUndo(const QList<int> &indicesIn);
 
@@ -316,7 +308,7 @@ class Playlist : public QAbstractListModel {
   void RestoreFinished();
   void PlaylistLoaded();
   void CurrentSongChanged(const Song &metadata);
-  void SongMetadataChanged(const Song &metadata);
+  void CurrentSongMetadataChanged(const Song &metadata);
   void EditingFinished(const int playlist_id, const QModelIndex idx);
   void PlayRequested(const QModelIndex idx, const Playlist::AutoScroll autoscroll);
   void MaybeAutoscroll(const Playlist::AutoScroll autoscroll);
@@ -340,7 +332,7 @@ class Playlist : public QAbstractListModel {
   void InsertSongItems(const SongList &songs, const int pos, const bool play_now, const bool enqueue, const bool enqueue_next = false);
 
   // Modify the playlist without changing the undo stack.  These are used by our friends in PlaylistUndoCommands
-  void InsertItemsWithoutUndo(const PlaylistItemPtrList &items, int pos, bool enqueue = false, bool enqueue_next = false);
+  void InsertItemsWithoutUndo(const PlaylistItemPtrList &items, const int pos, const bool enqueue = false, const bool enqueue_next = false);
   PlaylistItemPtrList RemoveItemsWithoutUndo(const int row, const int count);
   void MoveItemsWithoutUndo(const QList<int> &source_rows, int pos);
   void MoveItemWithoutUndo(const int source, const int dest);
@@ -367,8 +359,6 @@ class Playlist : public QAbstractListModel {
   void Save();
 
  private:
-  static const int kMaxPlayedIndexes;
-
   bool is_loading_;
   PlaylistFilter *filter_;
   Queue *queue_;
@@ -416,12 +406,10 @@ class Playlist : public QAbstractListModel {
   bool scrobbled_;
   qint64 scrobble_point_;
 
-  int editing_;
-
   PlaylistGeneratorPtr dynamic_playlist_;
 
   bool auto_sort_;
-  int sort_column_;
+  Column sort_column_;
   Qt::SortOrder sort_order_;
 };
 
diff --git a/src/playlist/playlistdelegates.cpp b/src/playlist/playlistdelegates.cpp
index d0ce5dc22..f031a400b 100644
--- a/src/playlist/playlistdelegates.cpp
+++ b/src/playlist/playlistdelegates.cpp
@@ -81,7 +81,7 @@ const float QueuedItemDelegate::kQueueOpacityLowerBound = 0.4F;
 
 const int PlaylistDelegateBase::kMinHeight = 19;
 
-QueuedItemDelegate::QueuedItemDelegate(QObject *parent, int indicator_column)
+QueuedItemDelegate::QueuedItemDelegate(QObject *parent, const int indicator_column)
     : QStyledItemDelegate(parent),
       indicator_column_(indicator_column) {}
 
@@ -215,7 +215,7 @@ void PlaylistDelegateBase::paint(QPainter *painter, const QStyleOptionViewItem &
   QueuedItemDelegate::paint(painter, Adjusted(option, idx), idx);
 
   // Stop after indicator
-  if (idx.column() == Playlist::Column_Title) {
+  if (idx.column() == static_cast<int>(Playlist::Column::Title)) {
     if (idx.data(Playlist::Role_StopAfter).toBool()) {
       QRect rect(option.rect);
       rect.setRight(rect.right() - queue_indicator_size(idx));
@@ -258,7 +258,7 @@ bool PlaylistDelegateBase::helpEvent(QHelpEvent *event, QAbstractItemView *view,
   QString text = displayText(idx.data(), QLocale::system());
 
   // Special case: we want newlines in the comment tooltip
-  if (idx.column() == Playlist::Column_Comment) {
+  if (idx.column() == static_cast<int>(Playlist::Column::Comment)) {
     text = idx.data(Qt::ToolTipRole).toString().toHtmlEscaped();
     text.replace(QLatin1String("\\r\\n"), QLatin1String("<br />"));
     text.replace(QLatin1String("\\n"), QLatin1String("<br />"));
@@ -378,18 +378,18 @@ TagCompletionModel::TagCompletionModel(SharedPtr<CollectionBackend> backend, con
 
 }
 
-QString TagCompletionModel::database_column(Playlist::Column column) {
+QString TagCompletionModel::database_column(const Playlist::Column column) {
 
   switch (column) {
-    case Playlist::Column_Artist:       return QStringLiteral("artist");
-    case Playlist::Column_Album:        return QStringLiteral("album");
-    case Playlist::Column_AlbumArtist:  return QStringLiteral("albumartist");
-    case Playlist::Column_Composer:     return QStringLiteral("composer");
-    case Playlist::Column_Performer:    return QStringLiteral("performer");
-    case Playlist::Column_Grouping:     return QStringLiteral("grouping");
-    case Playlist::Column_Genre:        return QStringLiteral("genre");
+    case Playlist::Column::Artist:       return QStringLiteral("artist");
+    case Playlist::Column::Album:        return QStringLiteral("album");
+    case Playlist::Column::AlbumArtist:  return QStringLiteral("albumartist");
+    case Playlist::Column::Composer:     return QStringLiteral("composer");
+    case Playlist::Column::Performer:    return QStringLiteral("performer");
+    case Playlist::Column::Grouping:     return QStringLiteral("grouping");
+    case Playlist::Column::Genre:        return QStringLiteral("genre");
     default:
-      qLog(Warning) << "Unknown column" << column;
+      qLog(Warning) << "Unknown column" << static_cast<int>(column);
       return QString();
   }
 
@@ -401,7 +401,7 @@ static TagCompletionModel *InitCompletionModel(SharedPtr<CollectionBackend> back
 
 }
 
-TagCompleter::TagCompleter(SharedPtr<CollectionBackend> backend, Playlist::Column column, QLineEdit *editor) : QCompleter(editor), editor_(editor) {
+TagCompleter::TagCompleter(SharedPtr<CollectionBackend> backend, const Playlist::Column column, QLineEdit *editor) : QCompleter(editor), editor_(editor) {
 
   QFuture<TagCompletionModel*> future = QtConcurrent::run(&InitCompletionModel, backend, column);
   QFutureWatcher<TagCompletionModel*> *watcher = new QFutureWatcher<TagCompletionModel*>();
diff --git a/src/playlist/playlistdelegates.h b/src/playlist/playlistdelegates.h
index a75318b47..d58cb9995 100644
--- a/src/playlist/playlistdelegates.h
+++ b/src/playlist/playlistdelegates.h
@@ -58,7 +58,7 @@ class QueuedItemDelegate : public QStyledItemDelegate {
   Q_OBJECT
 
  public:
-  explicit QueuedItemDelegate(QObject *parent, int indicator_column = Playlist::Column_Title);
+  explicit QueuedItemDelegate(QObject *parent, const int indicator_column = static_cast<int>(Playlist::Column::Title));
 
   void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &idx) const override;
   static void DrawBox(QPainter *painter, const QRect line_rect, const QFont &font, const QString &text, int width = -1, const float opacity = 1.0);
@@ -154,14 +154,14 @@ class TagCompletionModel : public QStringListModel {
   explicit TagCompletionModel(SharedPtr<CollectionBackend> backend, const Playlist::Column column, QObject *parent = nullptr);
 
  private:
-  static QString database_column(Playlist::Column column);
+  static QString database_column(const Playlist::Column column);
 };
 
 class TagCompleter : public QCompleter {
   Q_OBJECT
 
  public:
-  explicit TagCompleter(SharedPtr<CollectionBackend> backend, Playlist::Column column, QLineEdit *editor);
+  explicit TagCompleter(SharedPtr<CollectionBackend> backend, const Playlist::Column column, QLineEdit *editor);
   ~TagCompleter() override;
 
  private slots:
diff --git a/src/playlist/playlistfilter.cpp b/src/playlist/playlistfilter.cpp
index 8f3873f1a..e1a6af3d4 100644
--- a/src/playlist/playlistfilter.cpp
+++ b/src/playlist/playlistfilter.cpp
@@ -37,39 +37,39 @@ PlaylistFilter::PlaylistFilter(QObject *parent)
 
   setDynamicSortFilter(true);
 
-  column_names_[QStringLiteral("title")] = Playlist::Column_Title;
-  column_names_[QStringLiteral("name")] = Playlist::Column_Title;
-  column_names_[QStringLiteral("artist")] = Playlist::Column_Artist;
-  column_names_[QStringLiteral("album")] = Playlist::Column_Album;
-  column_names_[QStringLiteral("albumartist")] = Playlist::Column_AlbumArtist;
-  column_names_[QStringLiteral("performer")] = Playlist::Column_Performer;
-  column_names_[QStringLiteral("composer")] = Playlist::Column_Composer;
-  column_names_[QStringLiteral("year")] = Playlist::Column_Year;
-  column_names_[QStringLiteral("originalyear")] = Playlist::Column_OriginalYear;
-  column_names_[QStringLiteral("track")] = Playlist::Column_Track;
-  column_names_[QStringLiteral("disc")] = Playlist::Column_Disc;
-  column_names_[QStringLiteral("length")] = Playlist::Column_Length;
-  column_names_[QStringLiteral("genre")] = Playlist::Column_Genre;
-  column_names_[QStringLiteral("samplerate")] = Playlist::Column_Samplerate;
-  column_names_[QStringLiteral("bitdepth")] = Playlist::Column_Bitdepth;
-  column_names_[QStringLiteral("bitrate")] = Playlist::Column_Bitrate;
-  column_names_[QStringLiteral("filename")] = Playlist::Column_Filename;
-  column_names_[QStringLiteral("grouping")] = Playlist::Column_Grouping;
-  column_names_[QStringLiteral("comment")] = Playlist::Column_Comment;
-  column_names_[QStringLiteral("rating")] = Playlist::Column_Rating;
-  column_names_[QStringLiteral("playcount")] = Playlist::Column_PlayCount;
-  column_names_[QStringLiteral("skipcount")] = Playlist::Column_SkipCount;
+  column_names_[QStringLiteral("title")] = static_cast<int>(Playlist::Column::Title);
+  column_names_[QStringLiteral("name")] = static_cast<int>(Playlist::Column::Title);
+  column_names_[QStringLiteral("artist")] = static_cast<int>(Playlist::Column::Artist);
+  column_names_[QStringLiteral("album")] = static_cast<int>(Playlist::Column::Album);
+  column_names_[QStringLiteral("albumartist")] = static_cast<int>(Playlist::Column::AlbumArtist);
+  column_names_[QStringLiteral("performer")] = static_cast<int>(Playlist::Column::Performer);
+  column_names_[QStringLiteral("composer")] = static_cast<int>(Playlist::Column::Composer);
+  column_names_[QStringLiteral("year")] = static_cast<int>(Playlist::Column::Year);
+  column_names_[QStringLiteral("originalyear")] = static_cast<int>(Playlist::Column::OriginalYear);
+  column_names_[QStringLiteral("track")] = static_cast<int>(Playlist::Column::Track);
+  column_names_[QStringLiteral("disc")] = static_cast<int>(Playlist::Column::Disc);
+  column_names_[QStringLiteral("length")] = static_cast<int>(Playlist::Column::Length);
+  column_names_[QStringLiteral("genre")] = static_cast<int>(Playlist::Column::Genre);
+  column_names_[QStringLiteral("samplerate")] = static_cast<int>(Playlist::Column::Samplerate);
+  column_names_[QStringLiteral("bitdepth")] = static_cast<int>(Playlist::Column::Bitdepth);
+  column_names_[QStringLiteral("bitrate")] = static_cast<int>(Playlist::Column::Bitrate);
+  column_names_[QStringLiteral("filename")] = static_cast<int>(Playlist::Column::Filename);
+  column_names_[QStringLiteral("grouping")] = static_cast<int>(Playlist::Column::Grouping);
+  column_names_[QStringLiteral("comment")] = static_cast<int>(Playlist::Column::Comment);
+  column_names_[QStringLiteral("rating")] = static_cast<int>(Playlist::Column::Rating);
+  column_names_[QStringLiteral("playcount")] = static_cast<int>(Playlist::Column::PlayCount);
+  column_names_[QStringLiteral("skipcount")] = static_cast<int>(Playlist::Column::SkipCount);
 
-  numerical_columns_ << Playlist::Column_Year
-                     << Playlist::Column_OriginalYear
-                     << Playlist::Column_Track
-                     << Playlist::Column_Disc
-                     << Playlist::Column_Length
-                     << Playlist::Column_Samplerate
-                     << Playlist::Column_Bitdepth
-                     << Playlist::Column_Bitrate
-                     << Playlist::Column_PlayCount
-                     << Playlist::Column_SkipCount;
+  numerical_columns_ << static_cast<int>(Playlist::Column::Year)
+                     << static_cast<int>(Playlist::Column::OriginalYear)
+                     << static_cast<int>(Playlist::Column::Track)
+                     << static_cast<int>(Playlist::Column::Disc)
+                     << static_cast<int>(Playlist::Column::Length)
+                     << static_cast<int>(Playlist::Column::Samplerate)
+                     << static_cast<int>(Playlist::Column::Bitdepth)
+                     << static_cast<int>(Playlist::Column::Bitrate)
+                     << static_cast<int>(Playlist::Column::PlayCount)
+                     << static_cast<int>(Playlist::Column::SkipCount);
 
 }
 
@@ -80,7 +80,7 @@ void PlaylistFilter::sort(int column, Qt::SortOrder order) {
   sourceModel()->sort(column, order);
 }
 
-bool PlaylistFilter::filterAcceptsRow(int row, const QModelIndex &parent) const {
+bool PlaylistFilter::filterAcceptsRow(const int row, const QModelIndex &parent) const {
 
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
   size_t hash = qHash(filter_text_);
diff --git a/src/playlist/playlistfilter.h b/src/playlist/playlistfilter.h
index 30f68e67e..bd9721021 100644
--- a/src/playlist/playlistfilter.h
+++ b/src/playlist/playlistfilter.h
@@ -42,11 +42,11 @@ class PlaylistFilter : public QSortFilterProxyModel {
   ~PlaylistFilter() override;
 
   // QAbstractItemModel
-  void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
+  void sort(const int column, const Qt::SortOrder order = Qt::AscendingOrder) override;
 
   // QSortFilterProxyModel
   // public so Playlist::NextVirtualIndex and friends can get at it
-  bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
+  bool filterAcceptsRow(const int source_row, const QModelIndex &source_parent) const override;
 
   void SetFilterText(const QString &filter_text);
 
diff --git a/src/playlist/playlistfilterparser.cpp b/src/playlist/playlistfilterparser.cpp
index 7af170377..c721b9389 100644
--- a/src/playlist/playlistfilterparser.cpp
+++ b/src/playlist/playlistfilterparser.cpp
@@ -518,7 +518,7 @@ FilterTree *FilterParser::createSearchTermTreeNode(const QString &col, const QSt
   SearchTermComparator *cmp = nullptr;
 
   // Handle the float based Rating Column
-  if (columns_[col] == Playlist::Column_Rating) {
+  if (columns_[col] == static_cast<int>(Playlist::Column::Rating)) {
     float parsed_search = Utilities::ParseSearchRating(search);
 
     if (prefix == QLatin1Char('=')) {
@@ -549,7 +549,7 @@ FilterTree *FilterParser::createSearchTermTreeNode(const QString &col, const QSt
   else if (!col.isEmpty() && columns_.contains(col) && numerical_columns_.contains(columns_[col])) {
     // the length column contains the time in seconds (nanoseconds, actually - the "nano" part is handled by the DropTailComparatorDecorator,  though).
     int search_value = 0;
-    if (columns_[col] == Playlist::Column_Length) {
+    if (columns_[col] == static_cast<int>(Playlist::Column::Length)) {
       search_value = Utilities::ParseSearchTime(search);
     }
     else {
@@ -595,7 +595,7 @@ FilterTree *FilterParser::createSearchTermTreeNode(const QString &col, const QSt
   }
 
   if (columns_.contains(col)) {
-    if (columns_[col] == Playlist::Column_Length) {
+    if (columns_[col] == static_cast<int>(Playlist::Column::Length)) {
       cmp = new DropTailComparatorDecorator(cmp);
     }
     return new FilterColumnTerm(columns_[col], cmp);
diff --git a/src/playlist/playlistheader.cpp b/src/playlist/playlistheader.cpp
index ea7d12308..d97448940 100644
--- a/src/playlist/playlistheader.cpp
+++ b/src/playlist/playlistheader.cpp
@@ -108,7 +108,7 @@ void PlaylistHeader::contextMenuEvent(QContextMenuEvent *e) {
     else if (alignment & Qt::AlignRight)   action_align_right_->setChecked(true);
 
     // Show rating lock action only for ratings section
-    action_rating_lock_->setVisible(menu_section_ == Playlist::Column_Rating);
+    action_rating_lock_->setVisible(menu_section_ == static_cast<int>(Playlist::Column::Rating));
 
   }
 
@@ -122,10 +122,10 @@ void PlaylistHeader::contextMenuEvent(QContextMenuEvent *e) {
 
 }
 
-void PlaylistHeader::AddColumnAction(int index) {
+void PlaylistHeader::AddColumnAction(const int index) {
 
 #ifndef HAVE_MOODBAR
-  if (index == Playlist::Column_Mood) {
+  if (index == Playlist::Column::Mood) {
     return;
   }
 #endif
diff --git a/src/playlist/playlistheader.h b/src/playlist/playlistheader.h
index 42e482df7..4dee37313 100644
--- a/src/playlist/playlistheader.h
+++ b/src/playlist/playlistheader.h
@@ -53,7 +53,7 @@ class PlaylistHeader : public StretchHeaderView {
 #endif
 
  signals:
-  void SectionVisibilityChanged(const int logical, const bool visible);
+  void SectionVisibilityChanged(const int logical_index, const bool visible);
   void MouseEntered();
   void SectionRatingLockStatusChanged(const bool);
 
@@ -65,7 +65,7 @@ class PlaylistHeader : public StretchHeaderView {
   void ToggleRatingEditStatus();
 
  private:
-  void AddColumnAction(int index);
+  void AddColumnAction(const int index);
 
  private:
   PlaylistView *view_;
diff --git a/src/playlist/playlistitem.cpp b/src/playlist/playlistitem.cpp
index c86d05169..ad3bfbfe0 100644
--- a/src/playlist/playlistitem.cpp
+++ b/src/playlist/playlistitem.cpp
@@ -108,7 +108,7 @@ void PlaylistItem::UpdateTemporaryMetadata(const Song &metadata) {
 
   if (!temp_metadata_.is_valid()) return;
 
-  Song old_metadata = temp_metadata_;
+  const Song old_metadata = temp_metadata_;
   temp_metadata_ = metadata;
 
   // Keep samplerate, bitdepth and bitrate from the old metadata if it's not present in the new.
diff --git a/src/playlist/playlistmanager.cpp b/src/playlist/playlistmanager.cpp
index 98ccb2d12..a32174455 100644
--- a/src/playlist/playlistmanager.cpp
+++ b/src/playlist/playlistmanager.cpp
@@ -96,9 +96,9 @@ void PlaylistManager::Init(SharedPtr<CollectionBackend> collection_backend, Shar
   parser_ = new PlaylistParser(collection_backend, this);
   playlist_container_ = playlist_container;
 
-  QObject::connect(&*collection_backend_, &CollectionBackend::SongsChanged, this, &PlaylistManager::UpdateSongs);
-  QObject::connect(&*collection_backend_, &CollectionBackend::SongsStatisticsChanged, this, &PlaylistManager::UpdateSongs);
-  QObject::connect(&*collection_backend_, &CollectionBackend::SongsRatingChanged, this, &PlaylistManager::UpdateSongs);
+  QObject::connect(&*collection_backend_, &CollectionBackend::SongsChanged, this, &PlaylistManager::UpdateCollectionSongs);
+  QObject::connect(&*collection_backend_, &CollectionBackend::SongsStatisticsChanged, this, &PlaylistManager::UpdateCollectionSongs);
+  QObject::connect(&*collection_backend_, &CollectionBackend::SongsRatingChanged, this, &PlaylistManager::UpdateCollectionSongs);
 
   for (const PlaylistBackend::Playlist &p : playlist_backend->GetAllOpenPlaylists()) {
     ++playlists_loading_;
@@ -151,7 +151,7 @@ Playlist *PlaylistManager::AddPlaylist(const int id, const QString &name, const
   ret->set_ui_path(ui_path);
 
   QObject::connect(ret, &Playlist::CurrentSongChanged, this, &PlaylistManager::CurrentSongChanged);
-  QObject::connect(ret, &Playlist::SongMetadataChanged, this, &PlaylistManager::SongMetadataChanged);
+  QObject::connect(ret, &Playlist::CurrentSongMetadataChanged, this, &PlaylistManager::CurrentSongMetadataChanged);
   QObject::connect(ret, &Playlist::PlaylistChanged, this, &PlaylistManager::OneOfPlaylistsChanged);
   QObject::connect(ret, &Playlist::PlaylistChanged, this, &PlaylistManager::UpdateSummaryText);
   QObject::connect(ret, &Playlist::EditingFinished, this, &PlaylistManager::EditingFinished);
@@ -433,7 +433,7 @@ void PlaylistManager::UpdateSummaryText() {
 
     selected += range.bottom() - range.top() + 1;
     for (int i = range.top(); i <= range.bottom(); ++i) {
-      qint64 length = range.model()->index(i, Playlist::Column_Length).data().toLongLong();
+      qint64 length = range.model()->index(i, static_cast<int>(Playlist::Column::Length)).data().toLongLong();
       if (length > 0) {
         nanoseconds += length;
       }
@@ -463,7 +463,7 @@ void PlaylistManager::SelectionChanged(const QItemSelection &selection) {
   UpdateSummaryText();
 }
 
-void PlaylistManager::UpdateSongs(const SongList &songs) {
+void PlaylistManager::UpdateCollectionSongs(const SongList &songs) {
 
   // Some songs might've changed in the collection, let's update any playlist items we have that match those songs
 
@@ -472,9 +472,7 @@ void PlaylistManager::UpdateSongs(const SongList &songs) {
       PlaylistItemPtrList items = data.p->collection_items_by_id(song.id());
       for (PlaylistItemPtr item : items) {
         if (item->Metadata().directory_id() != song.directory_id()) continue;
-        item->SetMetadata(song);
-        if (item->HasTemporaryMetadata()) item->UpdateTemporaryMetadata(song);
-        data.p->ItemChanged(item);
+        data.p->UpdateItemMetadata(item, song, false);
       }
     }
   }
diff --git a/src/playlist/playlistmanager.h b/src/playlist/playlistmanager.h
index d91a7f183..81576a152 100644
--- a/src/playlist/playlistmanager.h
+++ b/src/playlist/playlistmanager.h
@@ -131,7 +131,7 @@ class PlaylistManagerInterface : public QObject {
 
   // Forwarded from individual playlists
   void CurrentSongChanged(const Song &song);
-  void SongMetadataChanged(const Song &song);
+  void CurrentSongMetadataChanged(const Song &song);
 
   // Signals that one of manager's playlists has changed (new items, new ordering etc.) - the argument shows which.
   void PlaylistChanged(Playlist *playlist);
@@ -233,7 +233,7 @@ class PlaylistManager : public PlaylistManagerInterface {
 
   void OneOfPlaylistsChanged();
   void UpdateSummaryText();
-  void UpdateSongs(const SongList &songs);
+  void UpdateCollectionSongs(const SongList &songs);
   void ItemsLoadedForSavePlaylist(const SongList &songs, const QString &filename, const PlaylistSettingsPage::PathType path_type);
   void PlaylistLoaded();
 
diff --git a/src/playlist/playlistundocommands.cpp b/src/playlist/playlistundocommands.cpp
index 7ba20fa8e..af719bd4d 100644
--- a/src/playlist/playlistundocommands.cpp
+++ b/src/playlist/playlistundocommands.cpp
@@ -34,7 +34,7 @@ namespace PlaylistUndoCommands {
 
 Base::Base(Playlist *playlist) : QUndoCommand(nullptr), playlist_(playlist) {}
 
-InsertItems::InsertItems(Playlist *playlist, const PlaylistItemPtrList &items, int pos, bool enqueue, bool enqueue_next)
+InsertItems::InsertItems(Playlist *playlist, const PlaylistItemPtrList &items, const int pos, const bool enqueue, const bool enqueue_next)
     : Base(playlist),
       items_(items),
       pos_(pos),
@@ -55,6 +55,7 @@ void InsertItems::undo() {
 }
 
 bool InsertItems::UpdateItem(const PlaylistItemPtr &updated_item) {
+
   for (int i = 0; i < items_.size(); i++) {
     PlaylistItemPtr item = items_[i];
     if (item->Metadata().url() == updated_item->Metadata().url()) {
@@ -63,10 +64,11 @@ bool InsertItems::UpdateItem(const PlaylistItemPtr &updated_item) {
     }
   }
   return false;
+
 }
 
 
-RemoveItems::RemoveItems(Playlist *playlist, int pos, int count) : Base(playlist) {
+RemoveItems::RemoveItems(Playlist *playlist, const int pos, const int count) : Base(playlist) {
   setText(tr("remove %n songs", "", count));
 
   ranges_ << Range(pos, count);
@@ -102,7 +104,7 @@ bool RemoveItems::mergeWith(const QUndoCommand *other) {
 }
 
 
-MoveItems::MoveItems(Playlist *playlist, const QList<int> &source_rows, int pos)
+MoveItems::MoveItems(Playlist *playlist, const QList<int> &source_rows, const int pos)
     : Base(playlist),
       source_rows_(source_rows),
       pos_(pos) {
@@ -126,7 +128,7 @@ void ReOrderItems::undo() { playlist_->ReOrderWithoutUndo(old_items_); }
 
 void ReOrderItems::redo() { playlist_->ReOrderWithoutUndo(new_items_); }
 
-SortItems::SortItems(Playlist *playlist, int column, Qt::SortOrder order, const PlaylistItemPtrList &new_items)
+SortItems::SortItems(Playlist *playlist, const Playlist::Column column, const Qt::SortOrder order, const PlaylistItemPtrList &new_items)
     : ReOrderItems(playlist, new_items) {
 
   Q_UNUSED(column);
diff --git a/src/playlist/playlistundocommands.h b/src/playlist/playlistundocommands.h
index 1c885941c..d2b4957ce 100644
--- a/src/playlist/playlistundocommands.h
+++ b/src/playlist/playlistundocommands.h
@@ -27,10 +27,9 @@
 #include <QList>
 #include <QUndoStack>
 
+#include "playlist.h"
 #include "playlistitem.h"
 
-class Playlist;
-
 namespace PlaylistUndoCommands {
 
   enum Types {
@@ -49,7 +48,7 @@ namespace PlaylistUndoCommands {
 
   class InsertItems : public Base {
    public:
-    explicit InsertItems(Playlist *playlist, const PlaylistItemPtrList &items, int pos, bool enqueue = false, bool enqueue_next = false);
+    explicit InsertItems(Playlist *playlist, const PlaylistItemPtrList &items, const int pos, const bool enqueue = false, const bool enqueue_next = false);
 
     void undo() override;
     void redo() override;
@@ -67,7 +66,7 @@ namespace PlaylistUndoCommands {
 
   class RemoveItems : public Base {
    public:
-    explicit RemoveItems(Playlist *playlist, int pos, int count);
+    explicit RemoveItems(Playlist *playlist, const int pos, const int count);
 
     int id() const override { return Type_RemoveItems; }
 
@@ -77,7 +76,7 @@ namespace PlaylistUndoCommands {
 
    private:
     struct Range {
-      Range(int pos, int count) : pos_(pos), count_(count) {}
+      Range(const int pos, const int count) : pos_(pos), count_(count) {}
       int pos_;
       int count_;
       PlaylistItemPtrList items_;
@@ -88,7 +87,7 @@ namespace PlaylistUndoCommands {
 
   class MoveItems : public Base {
    public:
-    explicit MoveItems(Playlist *playlist, const QList<int> &source_rows, int pos);
+    explicit MoveItems(Playlist *playlist, const QList<int> &source_rows, const int pos);
 
     void undo() override;
     void redo() override;
@@ -112,7 +111,7 @@ namespace PlaylistUndoCommands {
 
   class SortItems : public ReOrderItems {
    public:
-    explicit SortItems(Playlist *playlist, int column, Qt::SortOrder order, const PlaylistItemPtrList &new_items);
+    explicit SortItems(Playlist *playlist, const Playlist::Column column, const Qt::SortOrder order, const PlaylistItemPtrList &new_items);
 
   };
 
diff --git a/src/playlist/playlistview.cpp b/src/playlist/playlistview.cpp
index fadba16b6..b88538070 100644
--- a/src/playlist/playlistview.cpp
+++ b/src/playlist/playlistview.cpp
@@ -2,7 +2,7 @@
  * Strawberry Music Player
  * This file was part of Clementine.
  * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2024, Jonas Kvinge <jonas@jkvinge.net>
  *
  * Strawberry is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -142,7 +142,7 @@ PlaylistView::PlaylistView(QWidget *parent)
   setHeader(header_);
   header_->setSectionsMovable(true);
   header_->setFirstSectionMovable(true);
-  header_->setSortIndicator(Playlist::Column_Title, Qt::AscendingOrder);
+  header_->setSortIndicator(static_cast<int>(Playlist::Column::Title), Qt::AscendingOrder);
 
   setStyle(style_);
   setMouseTracking(true);
@@ -206,38 +206,38 @@ void PlaylistView::SetItemDelegates() {
 
   setItemDelegate(new PlaylistDelegateBase(this));
 
-  setItemDelegateForColumn(Playlist::Column_Title, new TextItemDelegate(this));
-  setItemDelegateForColumn(Playlist::Column_Album, new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column_Album));
-  setItemDelegateForColumn(Playlist::Column_Artist, new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column_Artist));
-  setItemDelegateForColumn(Playlist::Column_AlbumArtist, new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column_AlbumArtist));
-  setItemDelegateForColumn(Playlist::Column_Genre, new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column_Genre));
-  setItemDelegateForColumn(Playlist::Column_Composer, new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column_Composer));
-  setItemDelegateForColumn(Playlist::Column_Performer, new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column_Performer));
-  setItemDelegateForColumn(Playlist::Column_Grouping, new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column_Grouping));
-  setItemDelegateForColumn(Playlist::Column_Length, new LengthItemDelegate(this));
-  setItemDelegateForColumn(Playlist::Column_Filesize, new SizeItemDelegate(this));
-  setItemDelegateForColumn(Playlist::Column_Filetype, new FileTypeItemDelegate(this));
-  setItemDelegateForColumn(Playlist::Column_DateCreated, new DateItemDelegate(this));
-  setItemDelegateForColumn(Playlist::Column_DateModified, new DateItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Title), new TextItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Album), new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column::Album));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Artist), new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column::Artist));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::AlbumArtist), new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column::AlbumArtist));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Genre), new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column::Genre));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Composer), new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column::Composer));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Performer), new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column::Performer));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Grouping), new TagCompletionItemDelegate(this, app_->collection_backend(), Playlist::Column::Grouping));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Length), new LengthItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Filesize), new SizeItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Filetype), new FileTypeItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::DateCreated), new DateItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::DateModified), new DateItemDelegate(this));
 
-  setItemDelegateForColumn(Playlist::Column_Samplerate, new PlaylistDelegateBase(this, tr("Hz")));
-  setItemDelegateForColumn(Playlist::Column_Bitdepth, new PlaylistDelegateBase(this, tr("Bit")));
-  setItemDelegateForColumn(Playlist::Column_Bitrate, new PlaylistDelegateBase(this, tr("kbps")));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Samplerate), new PlaylistDelegateBase(this, tr("Hz")));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Bitdepth), new PlaylistDelegateBase(this, tr("Bit")));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Bitrate), new PlaylistDelegateBase(this, tr("kbps")));
 
-  setItemDelegateForColumn(Playlist::Column_Filename, new NativeSeparatorsDelegate(this));
-  setItemDelegateForColumn(Playlist::Column_LastPlayed, new LastPlayedItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Filename), new NativeSeparatorsDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::LastPlayed), new LastPlayedItemDelegate(this));
 
-  setItemDelegateForColumn(Playlist::Column_Source, new SongSourceDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Source), new SongSourceDelegate(this));
 
 #ifdef HAVE_MOODBAR
-  setItemDelegateForColumn(Playlist::Column_Mood, new MoodbarItemDelegate(app_, this, this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Mood), new MoodbarItemDelegate(app_, this, this));
 #endif
 
   rating_delegate_ = new RatingItemDelegate(this);
-  setItemDelegateForColumn(Playlist::Column_Rating, rating_delegate_);
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::Rating), rating_delegate_);
 
-  setItemDelegateForColumn(Playlist::Column_EBUR128IntegratedLoudness, new Ebur128LoudnessLUFSItemDelegate(this));
-  setItemDelegateForColumn(Playlist::Column_EBUR128LoudnessRange, new Ebur128LoudnessRangeLUItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::EBUR128IntegratedLoudness), new Ebur128LoudnessLUFSItemDelegate(this));
+  setItemDelegateForColumn(static_cast<int>(Playlist::Column::EBUR128LoudnessRange), new Ebur128LoudnessRangeLUItemDelegate(this));
 }
 
 void PlaylistView::setModel(QAbstractItemModel *m) {
@@ -335,43 +335,43 @@ void PlaylistView::RestoreHeaderState() {
 
   if (set_initial_header_layout_) {
 
-    header_->HideSection(Playlist::Column_AlbumArtist);
-    header_->HideSection(Playlist::Column_Performer);
-    header_->HideSection(Playlist::Column_Composer);
-    header_->HideSection(Playlist::Column_Year);
-    header_->HideSection(Playlist::Column_OriginalYear);
-    header_->HideSection(Playlist::Column_Disc);
-    header_->HideSection(Playlist::Column_Genre);
-    header_->HideSection(Playlist::Column_Filename);
-    header_->HideSection(Playlist::Column_BaseFilename);
-    header_->HideSection(Playlist::Column_Filesize);
-    header_->HideSection(Playlist::Column_DateCreated);
-    header_->HideSection(Playlist::Column_DateModified);
-    header_->HideSection(Playlist::Column_PlayCount);
-    header_->HideSection(Playlist::Column_SkipCount);
-    header_->HideSection(Playlist::Column_LastPlayed);
-    header_->HideSection(Playlist::Column_Comment);
-    header_->HideSection(Playlist::Column_Grouping);
-    header_->HideSection(Playlist::Column_Mood);
-    header_->HideSection(Playlist::Column_Rating);
-    header_->HideSection(Playlist::Column_HasCUE);
-    header_->HideSection(Playlist::Column_EBUR128IntegratedLoudness);
-    header_->HideSection(Playlist::Column_EBUR128LoudnessRange);
+    header_->HideSection(static_cast<int>(Playlist::Column::AlbumArtist));
+    header_->HideSection(static_cast<int>(Playlist::Column::Performer));
+    header_->HideSection(static_cast<int>(Playlist::Column::Composer));
+    header_->HideSection(static_cast<int>(Playlist::Column::Year));
+    header_->HideSection(static_cast<int>(Playlist::Column::OriginalYear));
+    header_->HideSection(static_cast<int>(Playlist::Column::Disc));
+    header_->HideSection(static_cast<int>(Playlist::Column::Genre));
+    header_->HideSection(static_cast<int>(Playlist::Column::Filename));
+    header_->HideSection(static_cast<int>(Playlist::Column::BaseFilename));
+    header_->HideSection(static_cast<int>(Playlist::Column::Filesize));
+    header_->HideSection(static_cast<int>(Playlist::Column::DateCreated));
+    header_->HideSection(static_cast<int>(Playlist::Column::DateModified));
+    header_->HideSection(static_cast<int>(Playlist::Column::PlayCount));
+    header_->HideSection(static_cast<int>(Playlist::Column::SkipCount));
+    header_->HideSection(static_cast<int>(Playlist::Column::LastPlayed));
+    header_->HideSection(static_cast<int>(Playlist::Column::Comment));
+    header_->HideSection(static_cast<int>(Playlist::Column::Grouping));
+    header_->HideSection(static_cast<int>(Playlist::Column::Mood));
+    header_->HideSection(static_cast<int>(Playlist::Column::Rating));
+    header_->HideSection(static_cast<int>(Playlist::Column::HasCUE));
+    header_->HideSection(static_cast<int>(Playlist::Column::EBUR128IntegratedLoudness));
+    header_->HideSection(static_cast<int>(Playlist::Column::EBUR128LoudnessRange));
 
-    header_->moveSection(header_->visualIndex(Playlist::Column_Track), 0);
+    header_->moveSection(header_->visualIndex(static_cast<int>(Playlist::Column::Track)), 0);
 
     header_->SetStretchEnabled(true);
 
-    header_->SetColumnWidth(Playlist::Column_Track, 0.03);
-    header_->SetColumnWidth(Playlist::Column_Title, 0.24);
-    header_->SetColumnWidth(Playlist::Column_Artist, 0.24);
-    header_->SetColumnWidth(Playlist::Column_Album, 0.24);
-    header_->SetColumnWidth(Playlist::Column_Length, 0.04);
-    header_->SetColumnWidth(Playlist::Column_Samplerate, 0.05);
-    header_->SetColumnWidth(Playlist::Column_Bitdepth, 0.04);
-    header_->SetColumnWidth(Playlist::Column_Bitrate, 0.04);
-    header_->SetColumnWidth(Playlist::Column_Filetype, 0.04);
-    header_->SetColumnWidth(Playlist::Column_Source, 0.04);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Track), 0.03);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Title), 0.24);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Artist), 0.24);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Album), 0.24);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Length), 0.04);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Samplerate), 0.05);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Bitdepth), 0.04);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Bitrate), 0.04);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Filetype), 0.04);
+    header_->SetColumnWidth(static_cast<int>(Playlist::Column::Source), 0.04);
 
     header_state_ = header_->SaveState();
     header_->RestoreState(header_state_);
@@ -381,7 +381,7 @@ void PlaylistView::RestoreHeaderState() {
   }
 
   if (header_state_version_ < 1) {
-    header_->HideSection(Playlist::Column_Rating);
+    header_->HideSection(static_cast<int>(Playlist::Column::Rating));
     header_state_version_ = 1;
   }
 
@@ -394,7 +394,7 @@ void PlaylistView::RestoreHeaderState() {
     }
   }
   if (all_hidden) {
-    header_->ShowSection(Playlist::Column_Title);
+    header_->ShowSection(static_cast<int>(Playlist::Column::Title));
   }
 
   header_state_restored_ = true;
@@ -771,17 +771,7 @@ QModelIndex PlaylistView::PrevEditableIndex(const QModelIndex &current) {
 
 }
 
-bool PlaylistView::edit(const QModelIndex &idx, QAbstractItemView::EditTrigger trigger, QEvent *event) {
-
-  bool result = QAbstractItemView::edit(idx, trigger, event);
-  if (result && trigger == QAbstractItemView::AllEditTriggers && !event) {
-    playlist_->set_editing(idx.row());
-  }
-  return result;
-
-}
-
-void PlaylistView::closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint) {
+void PlaylistView::closeEditor(QWidget *editor, const QAbstractItemDelegate::EndEditHint hint) {
 
   if (hint == QAbstractItemDelegate::NoHint) {
     QTreeView::closeEditor(editor, QAbstractItemDelegate::SubmitModelCache);
@@ -809,8 +799,6 @@ void PlaylistView::closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHi
     QTreeView::closeEditor(editor, hint);
   }
 
-  playlist_->set_editing(-1);
-
 }
 
 void PlaylistView::mouseMoveEvent(QMouseEvent *event) {
@@ -894,7 +882,7 @@ void PlaylistView::mousePressEvent(QMouseEvent *event) {
 
 }
 
-void PlaylistView::scrollContentsBy(int dx, int dy) {
+void PlaylistView::scrollContentsBy(const int dx, const int dy) {
 
   if (dx != 0) {
     InvalidateCachedCurrentPixmap();
@@ -1326,7 +1314,7 @@ bool PlaylistView::eventFilter(QObject *object, QEvent *event) {
 
 }
 
-void PlaylistView::rowsInserted(const QModelIndex &parent, int start, int end) {
+void PlaylistView::rowsInserted(const QModelIndex &parent, const int start, const int end) {
 
   const bool at_end = end == model()->rowCount(parent) - 1;
 
@@ -1343,17 +1331,17 @@ ColumnAlignmentMap PlaylistView::DefaultColumnAlignment() {
 
   ColumnAlignmentMap ret;
 
-  ret[Playlist::Column_Year] =
-  ret[Playlist::Column_OriginalYear] =
-  ret[Playlist::Column_Track] =
-  ret[Playlist::Column_Disc] =
-  ret[Playlist::Column_Length] =
-  ret[Playlist::Column_Samplerate] =
-  ret[Playlist::Column_Bitdepth] =
-  ret[Playlist::Column_Bitrate] =
-  ret[Playlist::Column_Filesize] =
-  ret[Playlist::Column_PlayCount] =
-  ret[Playlist::Column_SkipCount] =
+  ret[static_cast<int>(Playlist::Column::Year)] =
+  ret[static_cast<int>(Playlist::Column::OriginalYear)] =
+  ret[static_cast<int>(Playlist::Column::Track)] =
+  ret[static_cast<int>(Playlist::Column::Disc)] =
+  ret[static_cast<int>(Playlist::Column::Length)] =
+  ret[static_cast<int>(Playlist::Column::Samplerate)] =
+  ret[static_cast<int>(Playlist::Column::Bitdepth)] =
+  ret[static_cast<int>(Playlist::Column::Bitrate)] =
+  ret[static_cast<int>(Playlist::Column::Filesize)] =
+  ret[static_cast<int>(Playlist::Column::PlayCount)] =
+  ret[static_cast<int>(Playlist::Column::SkipCount)] =
  (Qt::AlignRight | Qt::AlignVCenter);
 
   return ret;
@@ -1395,7 +1383,7 @@ void PlaylistView::CopyCurrentSongToClipboard() const {
   }
 
   // Get the song's URL
-  const QUrl url = model()->data(currentIndex().sibling(currentIndex().row(), Playlist::Column_Filename)).toUrl();
+  const QUrl url = model()->data(currentIndex().sibling(currentIndex().row(), static_cast<int>(Playlist::Column::Filename))).toUrl();
 
   QMimeData *mime_data = new QMimeData;
   mime_data->setUrls(QList<QUrl>() << url);
@@ -1411,7 +1399,7 @@ void PlaylistView::SongChanged(const Song &song) {
 
   if (select_track_ && playlist_) {
     clearSelection();
-    QItemSelection selection(playlist_->index(playlist_->current_row(), 0), playlist_->index(playlist_->current_row(), playlist_->ColumnCount - 1));
+    QItemSelection selection(playlist_->index(playlist_->current_row(), 0), playlist_->index(playlist_->current_row(), static_cast<int>(playlist_->Column::ColumnCount) - 1));
     selectionModel()->select(selection, QItemSelectionModel::Select);
   }
 
@@ -1510,7 +1498,7 @@ void PlaylistView::focusInEvent(QFocusEvent *event) {
 
 }
 
-void PlaylistView::DynamicModeChanged(bool dynamic) {
+void PlaylistView::DynamicModeChanged(const bool dynamic) {
 
   if (dynamic) {
     RepositionDynamicControls();
@@ -1551,7 +1539,7 @@ void PlaylistView::RatingHoverIn(const QModelIndex &idx, const QPoint pos) {
   update(old_index);
   const QModelIndexList indexes = selectedIndexes();
   for (const QModelIndex &i : indexes) {
-    if (i.column() == Playlist::Column_Rating) update(i);
+    if (i.column() == static_cast<int>(Playlist::Column::Rating)) update(i);
   }
 
   if (idx.data(Playlist::Role_IsCurrent).toBool() || old_index.data(Playlist::Role_IsCurrent).toBool()) {
@@ -1573,7 +1561,7 @@ void PlaylistView::RatingHoverOut() {
   update(old_index);
   const QModelIndexList indexes = selectedIndexes();
   for (const QModelIndex &i : indexes) {
-    if (i.column() == Playlist::Column_Rating) {
+    if (i.column() == static_cast<int>(Playlist::Column::Rating)) {
       update(i);
     }
   }
diff --git a/src/playlist/playlistview.h b/src/playlist/playlistview.h
index 511ec75da..f28b0a824 100644
--- a/src/playlist/playlistview.h
+++ b/src/playlist/playlistview.h
@@ -2,7 +2,7 @@
  * Strawberry Music Player
  * This file was part of Clementine.
  * Copyright 2010, David Sansome <me@davidsansome.com>
- * Copyright 2018-2021, Jonas Kvinge <jonas@jkvinge.net>
+ * Copyright 2018-2024, Jonas Kvinge <jonas@jkvinge.net>
  *
  * Strawberry is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -103,7 +103,6 @@ class PlaylistView : public QTreeView {
   void SaveSettings();
   void SetColumnAlignment(const int section, const Qt::Alignment alignment);
   void JumpToCurrentlyPlayingTrack();
-  void edit(const QModelIndex &idx) { QAbstractItemView::edit(idx); }
 
  signals:
   void PlayItem(const QModelIndex idx, const Playlist::AutoScroll autoscroll);
@@ -139,12 +138,11 @@ class PlaylistView : public QTreeView {
   void drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &idx) const override;
 
   // QAbstractScrollArea
-  void scrollContentsBy(int dx, int dy) override;
+  void scrollContentsBy(const int dx, const int dy) override;
 
   // QAbstractItemView
-  void rowsInserted(const QModelIndex &parent, int start, int end) override;
-  bool edit(const QModelIndex &idx, QAbstractItemView::EditTrigger trigger, QEvent *event) override;
-  void closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint) override;
+  void rowsInserted(const QModelIndex &parent, const int start, const int end) override;
+  void closeEditor(QWidget *editor, const QAbstractItemDelegate::EndEditHint hint) override;
 
  private slots:
   void Update() { update(); }
diff --git a/src/queue/queue.cpp b/src/queue/queue.cpp
index f44c9b80c..b346fe302 100644
--- a/src/queue/queue.cpp
+++ b/src/queue/queue.cpp
@@ -157,8 +157,8 @@ QVariant Queue::data(const QModelIndex &proxy_index, int role) const {
       return proxy_index.row();
 
     case Qt::DisplayRole:{
-      const QString artist = source_index.sibling(source_index.row(), Playlist::Column_Artist).data().toString();
-      const QString title = source_index.sibling(source_index.row(), Playlist::Column_Title).data().toString();
+      const QString artist = source_index.sibling(source_index.row(), static_cast<int>(Playlist::Column::Artist)).data().toString();
+      const QString title = source_index.sibling(source_index.row(), static_cast<int>(Playlist::Column::Title)).data().toString();
 
       if (artist.isEmpty()) return title;
       return QStringLiteral("%1 - %2").arg(artist, title);
diff --git a/src/smartplaylists/smartplaylistsearchterm.cpp b/src/smartplaylists/smartplaylistsearchterm.cpp
index 749e1a270..3d2bed11d 100644
--- a/src/smartplaylists/smartplaylistsearchterm.cpp
+++ b/src/smartplaylists/smartplaylistsearchterm.cpp
@@ -364,60 +364,61 @@ QString SmartPlaylistSearchTerm::FieldName(const Field field) {
 
   switch (field) {
     case Field::AlbumArtist:
-      return Playlist::column_name(Playlist::Column_AlbumArtist);
+      return Playlist::column_name(Playlist::Column::AlbumArtist);
     case Field::Artist:
-      return Playlist::column_name(Playlist::Column_Artist);
+      return Playlist::column_name(Playlist::Column::Artist);
     case Field::Album:
-      return Playlist::column_name(Playlist::Column_Album);
+      return Playlist::column_name(Playlist::Column::Album);
     case Field::Title:
-      return Playlist::column_name(Playlist::Column_Title);
+      return Playlist::column_name(Playlist::Column::Title);
     case Field::Track:
-      return Playlist::column_name(Playlist::Column_Track);
+      return Playlist::column_name(Playlist::Column::Track);
     case Field::Disc:
-      return Playlist::column_name(Playlist::Column_Disc);
+      return Playlist::column_name(Playlist::Column::Disc);
     case Field::Year:
-      return Playlist::column_name(Playlist::Column_Year);
+      return Playlist::column_name(Playlist::Column::Year);
     case Field::OriginalYear:
-      return Playlist::column_name(Playlist::Column_OriginalYear);
+      return Playlist::column_name(Playlist::Column::OriginalYear);
     case Field::Genre:
-      return Playlist::column_name(Playlist::Column_Genre);
+      return Playlist::column_name(Playlist::Column::Genre);
     case Field::Composer:
-      return Playlist::column_name(Playlist::Column_Composer);
+      return Playlist::column_name(Playlist::Column::Composer);
     case Field::Performer:
-      return Playlist::column_name(Playlist::Column_Performer);
+      return Playlist::column_name(Playlist::Column::Performer);
     case Field::Grouping:
-      return Playlist::column_name(Playlist::Column_Grouping);
+      return Playlist::column_name(Playlist::Column::Grouping);
     case Field::Comment:
       return QObject::tr("Comment");
     case Field::Length:
-      return Playlist::column_name(Playlist::Column_Length);
+      return Playlist::column_name(Playlist::Column::Length);
     case Field::Filepath:
-      return Playlist::column_name(Playlist::Column_Filename);
+      return Playlist::column_name(Playlist::Column::Filename);
     case Field::Filetype:
-      return Playlist::column_name(Playlist::Column_Filetype);
+      return Playlist::column_name(Playlist::Column::Filetype);
     case Field::Filesize:
-      return Playlist::column_name(Playlist::Column_Filesize);
+      return Playlist::column_name(Playlist::Column::Filesize);
     case Field::DateCreated:
-      return Playlist::column_name(Playlist::Column_DateCreated);
+      return Playlist::column_name(Playlist::Column::DateCreated);
     case Field::DateModified:
-      return Playlist::column_name(Playlist::Column_DateModified);
+      return Playlist::column_name(Playlist::Column::DateModified);
     case Field::PlayCount:
-      return Playlist::column_name(Playlist::Column_PlayCount);
+      return Playlist::column_name(Playlist::Column::PlayCount);
     case Field::SkipCount:
-      return Playlist::column_name(Playlist::Column_SkipCount);
+      return Playlist::column_name(Playlist::Column::SkipCount);
     case Field::LastPlayed:
-      return Playlist::column_name(Playlist::Column_LastPlayed);
+      return Playlist::column_name(Playlist::Column::LastPlayed);
     case Field::Rating:
-      return Playlist::column_name(Playlist::Column_Rating);
+      return Playlist::column_name(Playlist::Column::Rating);
     case Field::Samplerate:
-      return Playlist::column_name(Playlist::Column_Samplerate);
+      return Playlist::column_name(Playlist::Column::Samplerate);
     case Field::Bitdepth:
-      return Playlist::column_name(Playlist::Column_Bitdepth);
+      return Playlist::column_name(Playlist::Column::Bitdepth);
     case Field::Bitrate:
-      return Playlist::column_name(Playlist::Column_Bitrate);
+      return Playlist::column_name(Playlist::Column::Bitrate);
     case Field::FieldCount:
       Q_ASSERT(0);
   }
+
   return QString();
 
 }
@@ -437,6 +438,7 @@ QString SmartPlaylistSearchTerm::FieldSortOrderText(const Type type, const bool
     case Type::Invalid:
       return QString();
   }
+
   return QString();
 
 }
@@ -456,6 +458,7 @@ QString SmartPlaylistSearchTerm::DateName(const DateType datetype, const bool fo
     case DateType::Year:
       return (forQuery ? QStringLiteral("years") : QObject::tr("Years"));
   }
+
   return QString();
 
 }
diff --git a/src/smartplaylists/smartplaylistsearchtermwidget.cpp b/src/smartplaylists/smartplaylistsearchtermwidget.cpp
index 5f54955a9..564e00c0f 100644
--- a/src/smartplaylists/smartplaylistsearchtermwidget.cpp
+++ b/src/smartplaylists/smartplaylistsearchtermwidget.cpp
@@ -190,11 +190,11 @@ void SmartPlaylistSearchTermWidget::FieldChanged(int index) {
   // Maybe set a tag completer
   switch (field) {
     case SmartPlaylistSearchTerm::Field::Artist:
-      new TagCompleter(collection_backend_, Playlist::Column_Artist, ui_->value_text);
+      new TagCompleter(collection_backend_, Playlist::Column::Artist, ui_->value_text);
       break;
 
     case SmartPlaylistSearchTerm::Field::Album:
-      new TagCompleter(collection_backend_, Playlist::Column_Album, ui_->value_text);
+      new TagCompleter(collection_backend_, Playlist::Column::Album, ui_->value_text);
       break;
 
     default:
diff --git a/tests/src/playlist_test.cpp b/tests/src/playlist_test.cpp
index 4d62adf4d..e40ee51bb 100644
--- a/tests/src/playlist_test.cpp
+++ b/tests/src/playlist_test.cpp
@@ -85,10 +85,10 @@ TEST_F(PlaylistTest, InsertItems) {
   ASSERT_EQ(1, playlist_.rowCount(QModelIndex()));
 
   // Get the metadata
-  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
-  EXPECT_EQ(QStringLiteral("Artist"), playlist_.data(playlist_.index(0, Playlist::Column_Artist)));
-  EXPECT_EQ(QStringLiteral("Album"), playlist_.data(playlist_.index(0, Playlist::Column_Album)));
-  EXPECT_EQ(123, playlist_.data(playlist_.index(0, Playlist::Column_Length)));
+  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, static_cast<int>(Playlist::Column::Title))));
+  EXPECT_EQ(QStringLiteral("Artist"), playlist_.data(playlist_.index(0, static_cast<int>(static_cast<int>(Playlist::Column::Artist)))));
+  EXPECT_EQ(QStringLiteral("Album"), playlist_.data(playlist_.index(0, static_cast<int>(Playlist::Column::Album))));
+  EXPECT_EQ(123, playlist_.data(playlist_.index(0, static_cast<int>(Playlist::Column::Length))));
 
 }
 
@@ -242,8 +242,8 @@ TEST_F(PlaylistTest, InsertBeforeCurrent) {
   EXPECT_EQ(1, playlist_.previous_row());
   EXPECT_EQ(3, playlist_.next_row());
 
-  EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
-  EXPECT_EQ(QStringLiteral("One"), playlist_.data(playlist_.index(1, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(0, static_cast<int>(Playlist::Column::Title))));
+  EXPECT_EQ(QStringLiteral("One"), playlist_.data(playlist_.index(1, static_cast<int>(Playlist::Column::Title))));
 
 }
 
@@ -262,9 +262,9 @@ TEST_F(PlaylistTest, InsertAfterCurrent) {
   EXPECT_EQ(0, playlist_.previous_row());
   EXPECT_EQ(2, playlist_.next_row());
 
-  EXPECT_EQ(QStringLiteral("Two"), playlist_.data(playlist_.index(1, Playlist::Column_Title)));
-  EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(2, Playlist::Column_Title)));
-  EXPECT_EQ(QStringLiteral("Three"), playlist_.data(playlist_.index(3, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Two"), playlist_.data(playlist_.index(1, static_cast<int>(Playlist::Column::Title))));
+  EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(2, static_cast<int>(Playlist::Column::Title))));
+  EXPECT_EQ(QStringLiteral("Three"), playlist_.data(playlist_.index(3, static_cast<int>(Playlist::Column::Title))));
 
 }
 
@@ -305,7 +305,7 @@ TEST_F(PlaylistTest, UndoAdd) {
   EXPECT_FALSE(playlist_.undo_stack()->canRedo());
   EXPECT_TRUE(playlist_.undo_stack()->canUndo());
 
-  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, static_cast<int>(Playlist::Column::Title))));
 
 }
 
@@ -351,7 +351,7 @@ TEST_F(PlaylistTest, UndoRemove) {
   EXPECT_EQ(1, playlist_.rowCount(QModelIndex()));
   ASSERT_TRUE(playlist_.undo_stack()->canRedo());
 
-  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, static_cast<int>(Playlist::Column::Title))));
 
   playlist_.undo_stack()->redo();
   EXPECT_EQ(0, playlist_.rowCount(QModelIndex()));
@@ -454,7 +454,7 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
 
   int index = playlist_.current_row();
   EXPECT_EQ(QStringLiteral("Item 0"), playlist_.current_item()->Metadata().title());
-  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.data(playlist_.index(index, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.data(playlist_.index(index, static_cast<int>(Playlist::Column::Title))));
   EXPECT_EQ(index, playlist_.last_played_row());
   //EXPECT_EQ(index + 1, playlist_.next_row());
 
@@ -467,7 +467,7 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
 
   index = playlist_.current_row();
   EXPECT_EQ(QStringLiteral("Item 0"), playlist_.current_item()->Metadata().title());
-  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.data(playlist_.index(index, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.data(playlist_.index(index, static_cast<int>(Playlist::Column::Title))));
   EXPECT_EQ(index, playlist_.last_played_row());
   //EXPECT_EQ(-1, playlist_.next_row());
   //EXPECT_EQ(index-1, playlist_.previous_row());