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

Use C++11 enum class

Browse Source
This commit is contained in:
Jonas Kvinge 2023-02-18 14:09:27 +01:00
parent e6c5f76872
commit dd72fb4ca5
237 changed files with 2915 additions and 2840 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
ext/libstrawberry-tagreader/tagreadergme.h
View File

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

4
src/analyzer/analyzerbase.cpp
View File

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

2
src/analyzer/boomanalyzer.cpp
View File

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

2
src/analyzer/sonogram.cpp
View File

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

8
src/collection/collection.cpp
View File

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

4
src/collection/collectionbackend.cpp
View File

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

2
src/collection/collectionbackend.h
View File

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

2
src/collection/collectionfilteroptions.cpp
View File

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

10
src/collection/collectionfilteroptions.h
View File

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

45
src/collection/collectionfilterwidget.cpp
View File

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

2
src/collection/collectionfilterwidget.h
View File

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

356
src/collection/collectionmodel.cpp
View File

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

50
src/collection/collectionmodel.h
View File

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

10
src/collection/collectionplaylistitem.cpp
View File

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

2
src/collection/collectionplaylistitem.h
View File

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

4
src/collection/collectionquery.cpp
View File

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

2
src/collection/collectionview.cpp
View File

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

6
src/collection/collectionwatcher.cpp
View File

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

40
src/collection/groupbydialog.cpp
View File

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

44
src/collection/savedgroupingmanager.cpp
View File

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

22
src/context/contextview.cpp
View File

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

78
src/core/commandlineoptions.cpp
View File

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

34
src/core/commandlineoptions.h
View File

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

173
src/core/mainwindow.cpp
View File

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

2
src/core/mainwindow.h
View File

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

50
src/core/metatypes.cpp
View File

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

32
src/core/mpris2.cpp
View File

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

6
src/core/musicstorage.h
View File

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

10
src/core/networkproxyfactory.cpp
View File

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

6
src/core/networkproxyfactory.h
View File

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

128
src/core/player.cpp
View File

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

4
src/core/player.h
View File

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

590
src/core/song.cpp
View File

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

96
src/core/song.h
View File

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

100
src/core/songloader.cpp
View File

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

11
src/core/songloader.h
View File

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

2
src/core/thread.cpp
View File

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

2
src/core/thread.h
View File

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

2
src/core/urlhandler.cpp
View File

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

4
src/core/urlhandler.h
View File

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

52
src/covermanager/albumcoverchoicecontroller.cpp
View File

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

2
src/covermanager/albumcoverchoicecontroller.h
View File

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

12
src/covermanager/albumcoverexport.cpp
View File

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

10
src/covermanager/albumcoverexport.h
View File

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

2
src/covermanager/albumcoverfetcher.h
View File

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

40
src/covermanager/albumcoverloader.cpp
View File

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

2
src/covermanager/albumcoverloader.h
View File

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

38
src/covermanager/albumcovermanager.cpp
View File

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

10
src/covermanager/albumcovermanager.h
View File

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

10
src/covermanager/coverexportrunnable.cpp
View File

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

8
src/covermanager/discogscoverprovider.cpp
View File

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

8
src/covermanager/discogscoverprovider.h
View File

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

2
src/covermanager/lastfmcoverprovider.h
View File

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

8
src/device/cddasongloader.cpp
View File

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

7
src/device/connecteddevice.cpp
View File

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

2
src/device/connecteddevice.h
View File

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

8
src/device/devicedatabasebackend.cpp
View File

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

8
src/device/deviceinfo.h
View File

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

4
src/device/devicemanager.cpp
View File

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

18
src/device/deviceproperties.cpp
View File

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

2
src/device/deviceview.cpp
View File

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

4
src/device/filesystemdevice.cpp
View File

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

2
src/device/filesystemdevice.h
View File

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

4
src/device/gpoddevice.cpp
View File

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

6
src/device/gpodloader.cpp
View File

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

18
src/device/mtpconnection.cpp
View File

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

20
src/device/mtpdevice.cpp
View File

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

2
src/device/mtploader.cpp
View File

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

86
src/dialogs/edittagdialog.cpp
View File

@ -341,7 +341,7 @@ bool EditTagDialog::eventFilter(QObject *o, QEvent *e) {
if (event->mimeData()->hasImage()) {
QImage image = qvariant_cast<QImage>(event->mimeData()->imageData());
if (!image.isNull()) {
UpdateCover(UpdateCoverAction_New, AlbumCoverImageResult(image));
UpdateCover(UpdateCoverAction::New, AlbumCoverImageResult(image));
}
}
break;
@ -404,7 +404,7 @@ QList<EditTagDialog::Data> EditTagDialog::LoadData(const SongList &songs) {
}
void EditTagDialog::SetSongs(const SongList &s, const PlaylistItemList &items) {
void EditTagDialog::SetSongs(const SongList &s, const PlaylistItemPtrList &items) {
// Show the loading indicator
if (!SetLoading(tr("Loading tracks") + "...")) return;
@ -438,7 +438,7 @@ void EditTagDialog::SetSongsFinished() {
ui_->tab_widget->setEnabled(false);
// Show a summary with empty information
UpdateSummaryTab(Song(), UpdateCoverAction_None);
UpdateSummaryTab(Song(), UpdateCoverAction::None);
ui_->tab_widget->setCurrentWidget(ui_->tab_summary);
SetSongListVisibility(false);
@ -614,7 +614,7 @@ void EditTagDialog::SelectionChanged() {
ui_->tab_widget->setTabEnabled(ui_->tab_widget->indexOf(ui_->tab_lyrics), !multiple);
if (multiple) {
UpdateSummaryTab(Song(), UpdateCoverAction_None);
UpdateSummaryTab(Song(), UpdateCoverAction::None);
UpdateStatisticsTab(Song());
}
else {
@ -636,11 +636,11 @@ void EditTagDialog::SelectionChanged() {
bool comment_enabled = false;
bool lyrics_enabled = false;
for (const QModelIndex &idx : indexes) {
if (data_[idx.row()].cover_action_ == UpdateCoverAction_None) {
if (data_[idx.row()].cover_action_ == UpdateCoverAction::None) {
data_[idx.row()].cover_result_ = AlbumCoverImageResult();
}
const Song &song = data_[idx.row()].original_;
if (data_[idx.row()].cover_action_ != first_cover_action || (first_cover_action != UpdateCoverAction_None && data_[idx.row()].cover_result_.image_data != data_[indexes.first().row()].cover_result_.image_data)) {
if (data_[idx.row()].cover_action_ != first_cover_action || (first_cover_action != UpdateCoverAction::None && data_[idx.row()].cover_result_.image_data != data_[indexes.first().row()].cover_result_.image_data)) {
action_different = true;
}
if (data_[idx.row()].cover_action_ != first_cover_action ||
@ -693,7 +693,7 @@ void EditTagDialog::SelectionChanged() {
const bool enable_change_art = first_song.is_collection_song();
ui_->tags_art_button->setEnabled(enable_change_art);
if ((art_different && first_cover_action != UpdateCoverAction_New) || action_different) {
if ((art_different && first_cover_action != UpdateCoverAction::New) || action_different) {
tags_cover_art_id_ = -1; // Cancels any pending art load.
ui_->tags_art->clear();
ui_->tags_art->setText(kArtDifferentHintText);
@ -717,7 +717,7 @@ void EditTagDialog::SelectionChanged() {
album_cover_choice_controller_->unset_cover_action()->setEnabled(enable_change_art && !first_song.has_manually_unset_cover());
album_cover_choice_controller_->clear_cover_action()->setEnabled(enable_change_art && !first_song.art_manual().isEmpty());
album_cover_choice_controller_->delete_cover_action()->setEnabled(enable_change_art && first_song.has_valid_art() && !first_song.has_manually_unset_cover());
if (data_[indexes.first().row()].cover_action_ == UpdateCoverAction_None) {
if (data_[indexes.first(