dryark/strawberry
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 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
Download Patch File Download Diff File Expand all files Collapse all files

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