Funkwhale/strawberry-audio-player-windows-mac-linux
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update individual playlist columns, use enum class

Browse Source
This commit is contained in:
Jonas Kvinge 2024-06-20 22:52:27 +02:00
parent 5816d0bb12
commit 9f9c46e370
24 changed files with 670 additions and 541 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/core/mainwindow.cpp
View File

@ -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);

53
src/core/player.cpp
View File

@ -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);
}
}
}

14
src/dialogs/edittagdialog.cpp
View File

@ -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);
}

6
src/moodbar/moodbaritemdelegate.cpp
View File

@ -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);

574
src/playlist/playlist.cpp
View File

@ -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);
}
}

128
src/playlist/playlist.h
View File

@ -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_;
};

26
src/playlist/playlistdelegates.cpp
View File

@ -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*>();

6
src/playlist/playlistdelegates.h
View File

@ -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:

66
src/playlist/playlistfilter.cpp
View File

@ -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_);

4
src/playlist/playlistfilter.h
View File

@ -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);

6
src/playlist/playlistfilterparser.cpp
View File

@ -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);

6
src/playlist/playlistheader.cpp
View File

@ -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

4
src/playlist/playlistheader.h
View File

@ -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_;

2
src/playlist/playlistitem.cpp
View File

@ -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.

16
src/playlist/playlistmanager.cpp
View File

@ -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);
}
}
}

4
src/playlist/playlistmanager.h
View File

@ -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();

10
src/playlist/playlistundocommands.cpp
View File

@ -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);

13
src/playlist/playlistundocommands.h
View File

@ -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);
};

170
src/playlist/playlistview.cpp
View File

@ -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);
}
}

10
src/playlist/playlistview.h
View File

@ -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(); }

4
src/queue/queue.cpp
View File

@ -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);

53
src/smartplaylists/smartplaylistsearchterm.cpp
View File

@ -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();
}

4
src/smartplaylists/smartplaylistsearchtermwidget.cpp
View File

@ -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:

26
tests/src/playlist_test.cpp
View File

@ -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());