dryark/strawberry
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use QStringLiteral

Browse Source
This commit is contained in:
Jonas Kvinge
2024-04-09 23:20:26 +02:00
parent 3cfffa5fbb
commit 58944993b8
233 changed files with 3885 additions and 3885 deletions
Download Patch File Download Diff File Expand all files Collapse all files

380
src/collection/collectionbackend.cpp
View File

@@ -175,9 +175,9 @@ void CollectionBackend::ChangeDirPath(const int id, const QString &old_path, con
// Do the dirs table
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET path=:path WHERE ROWID=:id").arg(dirs_table_));
q.BindValue(":path", new_path);
q.BindValue(":id", id);
q.prepare(QStringLiteral("UPDATE %1 SET path=:path WHERE ROWID=:id").arg(dirs_table_));
q.BindValue(QStringLiteral(":path"), new_path);
q.BindValue(QStringLiteral(":id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -192,9 +192,9 @@ void CollectionBackend::ChangeDirPath(const int id, const QString &old_path, con
// Do the subdirs table
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET path=:path || substr(path, %2) WHERE directory=:id").arg(subdirs_table_).arg(path_len));
q.BindValue(":path", new_url);
q.BindValue(":id", id);
q.prepare(QStringLiteral("UPDATE %1 SET path=:path || substr(path, %2) WHERE directory=:id").arg(subdirs_table_).arg(path_len));
q.BindValue(QStringLiteral(":path"), new_url);
q.BindValue(QStringLiteral(":id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -204,9 +204,9 @@ void CollectionBackend::ChangeDirPath(const int id, const QString &old_path, con
// Do the songs table
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET url=:path || substr(url, %2) WHERE directory=:id").arg(songs_table_).arg(path_len));
q.BindValue(":path", new_url);
q.BindValue(":id", id);
q.prepare(QStringLiteral("UPDATE %1 SET url=:path || substr(url, %2) WHERE directory=:id").arg(songs_table_).arg(path_len));
q.BindValue(QStringLiteral(":path"), new_url);
q.BindValue(QStringLiteral(":id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -225,7 +225,7 @@ CollectionDirectoryList CollectionBackend::GetAllDirectories() {
CollectionDirectoryList ret;
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, path FROM %1").arg(dirs_table_));
q.prepare(QStringLiteral("SELECT ROWID, path FROM %1").arg(dirs_table_));
if (!q.Exec()) {
db_->ReportErrors(q);
return ret;
@@ -253,8 +253,8 @@ CollectionSubdirectoryList CollectionBackend::SubdirsInDirectory(const int id) {
CollectionSubdirectoryList CollectionBackend::SubdirsInDirectory(const int id, QSqlDatabase &db) {
SqlQuery q(db);
q.prepare(QString("SELECT path, mtime FROM %1 WHERE directory_id = :dir").arg(subdirs_table_));
q.BindValue(":dir", id);
q.prepare(QStringLiteral("SELECT path, mtime FROM %1 WHERE directory_id = :dir").arg(subdirs_table_));
q.BindValue(QStringLiteral(":dir"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return CollectionSubdirectoryList();
@@ -279,7 +279,7 @@ void CollectionBackend::UpdateTotalSongCount() {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT COUNT(*) FROM %1 WHERE unavailable = 0").arg(songs_table_));
q.prepare(QStringLiteral("SELECT COUNT(*) FROM %1 WHERE unavailable = 0").arg(songs_table_));
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -299,7 +299,7 @@ void CollectionBackend::UpdateTotalArtistCount() {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT COUNT(DISTINCT artist) FROM %1 WHERE unavailable = 0").arg(songs_table_));
q.prepare(QStringLiteral("SELECT COUNT(DISTINCT artist) FROM %1 WHERE unavailable = 0").arg(songs_table_));
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -319,7 +319,7 @@ void CollectionBackend::UpdateTotalAlbumCount() {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT COUNT(*) FROM (SELECT DISTINCT effective_albumartist, album FROM %1 WHERE unavailable = 0)").arg(songs_table_));
q.prepare(QStringLiteral("SELECT COUNT(*) FROM (SELECT DISTINCT effective_albumartist, album FROM %1 WHERE unavailable = 0)").arg(songs_table_));
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -342,8 +342,8 @@ void CollectionBackend::AddDirectory(const QString &path) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("INSERT INTO %1 (path, subdirs) VALUES (:path, 1)").arg(dirs_table_));
q.BindValue(":path", db_path);
q.prepare(QStringLiteral("INSERT INTO %1 (path, subdirs) VALUES (:path, 1)").arg(dirs_table_));
q.BindValue(QStringLiteral(":path"), db_path);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -370,8 +370,8 @@ void CollectionBackend::RemoveDirectory(const CollectionDirectory &dir) {
// Delete the subdirs that were in this directory
{
SqlQuery q(db);
q.prepare(QString("DELETE FROM %1 WHERE directory_id = :id").arg(subdirs_table_));
q.BindValue(":id", dir.id);
q.prepare(QStringLiteral("DELETE FROM %1 WHERE directory_id = :id").arg(subdirs_table_));
q.BindValue(QStringLiteral(":id"), dir.id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -381,8 +381,8 @@ void CollectionBackend::RemoveDirectory(const CollectionDirectory &dir) {
// Now remove the directory itself
{
SqlQuery q(db);
q.prepare(QString("DELETE FROM %1 WHERE ROWID = :id").arg(dirs_table_));
q.BindValue(":id", dir.id);
q.prepare(QStringLiteral("DELETE FROM %1 WHERE ROWID = :id").arg(dirs_table_));
q.BindValue(QStringLiteral(":id"), dir.id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -401,8 +401,8 @@ SongList CollectionBackend::FindSongsInDirectory(const int id) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE directory_id = :directory_id").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":directory_id", id);
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE directory_id = :directory_id").arg(Song::kColumnSpec, songs_table_));
q.BindValue(QStringLiteral(":directory_id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -424,8 +424,8 @@ SongList CollectionBackend::SongsWithMissingFingerprint(const int id) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE directory_id = :directory_id AND unavailable = 0 AND (fingerprint IS NULL OR fingerprint = '')").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":directory_id", id);
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE directory_id = :directory_id AND unavailable = 0 AND (fingerprint IS NULL OR fingerprint = '')").arg(Song::kColumnSpec, songs_table_));
q.BindValue(QStringLiteral(":directory_id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -447,8 +447,8 @@ SongList CollectionBackend::SongsWithMissingLoudnessCharacteristics(const int id
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE directory_id = :directory_id AND unavailable = 0 AND (ebur128_integrated_loudness_lufs IS NULL OR ebur128_loudness_range_lu IS NULL)").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":directory_id", id);
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE directory_id = :directory_id AND unavailable = 0 AND (ebur128_integrated_loudness_lufs IS NULL OR ebur128_loudness_range_lu IS NULL)").arg(Song::kColumnSpec, songs_table_));
q.BindValue(QStringLiteral(":directory_id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -490,9 +490,9 @@ void CollectionBackend::AddOrUpdateSubdirs(const CollectionSubdirectoryList &sub
if (subdir.mtime == 0) {
// Delete the subdirectory
SqlQuery q(db);
q.prepare(QString("DELETE FROM %1 WHERE directory_id = :id AND path = :path").arg(subdirs_table_));
q.BindValue(":id", subdir.directory_id);
q.BindValue(":path", subdir.path);
q.prepare(QStringLiteral("DELETE FROM %1 WHERE directory_id = :id AND path = :path").arg(subdirs_table_));
q.BindValue(QStringLiteral(":id"), subdir.directory_id);
q.BindValue(QStringLiteral(":path"), subdir.path);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -503,9 +503,9 @@ void CollectionBackend::AddOrUpdateSubdirs(const CollectionSubdirectoryList &sub
bool exists = false;
{
SqlQuery q(db);
q.prepare(QString("SELECT ROWID FROM %1 WHERE directory_id = :id AND path = :path").arg(subdirs_table_));
q.BindValue(":id", subdir.directory_id);
q.BindValue(":path", subdir.path);
q.prepare(QStringLiteral("SELECT ROWID FROM %1 WHERE directory_id = :id AND path = :path").arg(subdirs_table_));
q.BindValue(QStringLiteral(":id"), subdir.directory_id);
q.BindValue(QStringLiteral(":path"), subdir.path);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -515,10 +515,10 @@ void CollectionBackend::AddOrUpdateSubdirs(const CollectionSubdirectoryList &sub
if (exists) {
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET mtime = :mtime WHERE directory_id = :id AND path = :path").arg(subdirs_table_));
q.BindValue(":mtime", subdir.mtime);
q.BindValue(":id", subdir.directory_id);
q.BindValue(":path", subdir.path);
q.prepare(QStringLiteral("UPDATE %1 SET mtime = :mtime WHERE directory_id = :id AND path = :path").arg(subdirs_table_));
q.BindValue(QStringLiteral(":mtime"), subdir.mtime);
q.BindValue(QStringLiteral(":id"), subdir.directory_id);
q.BindValue(QStringLiteral(":path"), subdir.path);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -526,10 +526,10 @@ void CollectionBackend::AddOrUpdateSubdirs(const CollectionSubdirectoryList &sub
}
else {
SqlQuery q(db);
q.prepare(QString("INSERT INTO %1 (directory_id, path, mtime) VALUES (:id, :path, :mtime)").arg(subdirs_table_));
q.BindValue(":id", subdir.directory_id);
q.BindValue(":path", subdir.path);
q.BindValue(":mtime", subdir.mtime);
q.prepare(QStringLiteral("INSERT INTO %1 (directory_id, path, mtime) VALUES (:id, :path, :mtime)").arg(subdirs_table_));
q.BindValue(QStringLiteral(":id"), subdir.directory_id);
q.BindValue(QStringLiteral(":path"), subdir.path);
q.BindValue(QStringLiteral(":mtime"), subdir.mtime);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -548,7 +548,7 @@ SongList CollectionBackend::GetAllSongs() {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2").arg(Song::kColumnSpec, songs_table_));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2").arg(Song::kColumnSpec, songs_table_));
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -584,8 +584,8 @@ void CollectionBackend::AddOrUpdateSongs(const SongList &songs) {
// This is to fix a possible race condition when a directory is removed while CollectionWatcher is scanning it.
if (!dirs_table_.isEmpty()) {
SqlQuery check_dir(db);
check_dir.prepare(QString("SELECT ROWID FROM %1 WHERE ROWID = :id").arg(dirs_table_));
check_dir.BindValue(":id", song.directory_id());
check_dir.prepare(QStringLiteral("SELECT ROWID FROM %1 WHERE ROWID = :id").arg(dirs_table_));
check_dir.BindValue(QStringLiteral(":id"), song.directory_id());
if (!check_dir.Exec()) {
db_->ReportErrors(check_dir);
return;
@@ -604,9 +604,9 @@ void CollectionBackend::AddOrUpdateSongs(const SongList &songs) {
// Update
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET %2 WHERE ROWID = :id").arg(songs_table_, Song::kUpdateSpec));
q.prepare(QStringLiteral("UPDATE %1 SET %2 WHERE ROWID = :id").arg(songs_table_, Song::kUpdateSpec));
song.BindToQuery(&q);
q.BindValue(":id", song.id());
q.BindValue(QStringLiteral(":id"), song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -615,9 +615,9 @@ void CollectionBackend::AddOrUpdateSongs(const SongList &songs) {
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET %2 WHERE ROWID = :id").arg(fts_table_, Song::kFtsUpdateSpec));
q.prepare(QStringLiteral("UPDATE %1 SET %2 WHERE ROWID = :id").arg(fts_table_, Song::kFtsUpdateSpec));
song.BindToFtsQuery(&q);
q.BindValue(":id", song.id());
q.BindValue(QStringLiteral(":id"), song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -643,9 +643,9 @@ void CollectionBackend::AddOrUpdateSongs(const SongList &songs) {
// Update
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET %2 WHERE ROWID = :id").arg(songs_table_, Song::kUpdateSpec));
q.prepare(QStringLiteral("UPDATE %1 SET %2 WHERE ROWID = :id").arg(songs_table_, Song::kUpdateSpec));
new_song.BindToQuery(&q);
q.BindValue(":id", new_song.id());
q.BindValue(QStringLiteral(":id"), new_song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -654,9 +654,9 @@ void CollectionBackend::AddOrUpdateSongs(const SongList &songs) {
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET %2 WHERE ROWID = :id").arg(fts_table_, Song::kFtsUpdateSpec));
q.prepare(QStringLiteral("UPDATE %1 SET %2 WHERE ROWID = :id").arg(fts_table_, Song::kFtsUpdateSpec));
new_song.BindToFtsQuery(&q);
q.BindValue(":id", new_song.id());
q.BindValue(QStringLiteral(":id"), new_song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -675,7 +675,7 @@ void CollectionBackend::AddOrUpdateSongs(const SongList &songs) {
int id = -1;
{ // Insert the row and create a new ID
SqlQuery q(db);
q.prepare(QString("INSERT INTO %1 (%2) VALUES (%3)").arg(songs_table_, Song::kColumnSpec, Song::kBindSpec));
q.prepare(QStringLiteral("INSERT INTO %1 (%2) VALUES (%3)").arg(songs_table_, Song::kColumnSpec, Song::kBindSpec));
song.BindToQuery(&q);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -689,8 +689,8 @@ void CollectionBackend::AddOrUpdateSongs(const SongList &songs) {
{ // Add to the FTS index
SqlQuery q(db);
q.prepare(QString("INSERT INTO %1 (ROWID, %2) VALUES (:id, %3)").arg(fts_table_, Song::kFtsColumnSpec, Song::kFtsBindSpec));
q.BindValue(":id", id);
q.prepare(QStringLiteral("INSERT INTO %1 (ROWID, %2) VALUES (:id, %3)").arg(fts_table_, Song::kFtsColumnSpec, Song::kFtsBindSpec));
q.BindValue(QStringLiteral(":id"), id);
song.BindToFtsQuery(&q);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -750,9 +750,9 @@ void CollectionBackend::UpdateSongsBySongID(const SongMap &new_songs) {
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET %2 WHERE ROWID = :id").arg(songs_table_, Song::kUpdateSpec));
q.prepare(QStringLiteral("UPDATE %1 SET %2 WHERE ROWID = :id").arg(songs_table_, Song::kUpdateSpec));
new_song.BindToQuery(&q);
q.BindValue(":id", old_song.id());
q.BindValue(QStringLiteral(":id"), old_song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -760,9 +760,9 @@ void CollectionBackend::UpdateSongsBySongID(const SongMap &new_songs) {
}
{
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET %2 WHERE ROWID = :id").arg(fts_table_, Song::kFtsUpdateSpec));
q.prepare(QStringLiteral("UPDATE %1 SET %2 WHERE ROWID = :id").arg(fts_table_, Song::kFtsUpdateSpec));
new_song.BindToFtsQuery(&q);
q.BindValue(":id", old_song.id());
q.BindValue(QStringLiteral(":id"), old_song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -781,7 +781,7 @@ void CollectionBackend::UpdateSongsBySongID(const SongMap &new_songs) {
int id = -1;
{
SqlQuery q(db);
q.prepare(QString("INSERT INTO %1 (%2) VALUES (%3)").arg(songs_table_, Song::kColumnSpec, Song::kBindSpec));
q.prepare(QStringLiteral("INSERT INTO %1 (%2) VALUES (%3)").arg(songs_table_, Song::kColumnSpec, Song::kBindSpec));
new_song.BindToQuery(&q);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -795,8 +795,8 @@ void CollectionBackend::UpdateSongsBySongID(const SongMap &new_songs) {
{ // Add to the FTS index
SqlQuery q(db);
q.prepare(QString("INSERT INTO %1 (ROWID, %2) VALUES (:id, %3)").arg(fts_table_, Song::kFtsColumnSpec, Song::kFtsBindSpec));
q.BindValue(":id", id);
q.prepare(QStringLiteral("INSERT INTO %1 (ROWID, %2) VALUES (:id, %3)").arg(fts_table_, Song::kFtsColumnSpec, Song::kFtsBindSpec));
q.BindValue(QStringLiteral(":id"), id);
new_song.BindToFtsQuery(&q);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -816,8 +816,8 @@ void CollectionBackend::UpdateSongsBySongID(const SongMap &new_songs) {
if (!new_songs.contains(old_song.song_id())) {
{
SqlQuery q(db);
q.prepare(QString("DELETE FROM %1 WHERE ROWID = :id").arg(songs_table_));
q.BindValue(":id", old_song.id());
q.prepare(QStringLiteral("DELETE FROM %1 WHERE ROWID = :id").arg(songs_table_));
q.BindValue(QStringLiteral(":id"), old_song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -825,8 +825,8 @@ void CollectionBackend::UpdateSongsBySongID(const SongMap &new_songs) {
}
{
SqlQuery q(db);
q.prepare(QString("DELETE FROM %1 WHERE ROWID = :id").arg(fts_table_));
q.BindValue(":id", old_song.id());
q.prepare(QStringLiteral("DELETE FROM %1 WHERE ROWID = :id").arg(fts_table_));
q.BindValue(QStringLiteral(":id"), old_song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -853,12 +853,12 @@ void CollectionBackend::UpdateMTimesOnly(const SongList &songs) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET mtime = :mtime WHERE ROWID = :id").arg(songs_table_));
q.prepare(QStringLiteral("UPDATE %1 SET mtime = :mtime WHERE ROWID = :id").arg(songs_table_));
ScopedTransaction transaction(&db);
for (const Song &song : songs) {
q.BindValue(":mtime", song.mtime());
q.BindValue(":id", song.id());
q.BindValue(QStringLiteral(":mtime"), song.mtime());
q.BindValue(QStringLiteral(":id"), song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -874,19 +874,19 @@ void CollectionBackend::DeleteSongs(const SongList &songs) {
QSqlDatabase db(db_->Connect());
SqlQuery remove(db);
remove.prepare(QString("DELETE FROM %1 WHERE ROWID = :id").arg(songs_table_));
remove.prepare(QStringLiteral("DELETE FROM %1 WHERE ROWID = :id").arg(songs_table_));
SqlQuery remove_fts(db);
remove_fts.prepare(QString("DELETE FROM %1 WHERE ROWID = :id").arg(fts_table_));
remove_fts.prepare(QStringLiteral("DELETE FROM %1 WHERE ROWID = :id").arg(fts_table_));
ScopedTransaction transaction(&db);
for (const Song &song : songs) {
remove.BindValue(":id", song.id());
remove.BindValue(QStringLiteral(":id"), song.id());
if (!remove.Exec()) {
db_->ReportErrors(remove);
return;
}
remove_fts.BindValue(":id", song.id());
remove_fts.BindValue(QStringLiteral(":id"), song.id());
if (!remove_fts.Exec()) {
db_->ReportErrors(remove_fts);
return;
@@ -908,11 +908,11 @@ void CollectionBackend::MarkSongsUnavailable(const SongList &songs, const bool u
QSqlDatabase db(db_->Connect());
SqlQuery query(db);
query.prepare(QString("UPDATE %1 SET unavailable = %2 WHERE ROWID = :id").arg(songs_table_).arg(static_cast<int>(unavailable)));
query.prepare(QStringLiteral("UPDATE %1 SET unavailable = %2 WHERE ROWID = :id").arg(songs_table_).arg(static_cast<int>(unavailable)));
ScopedTransaction transaction(&db);
for (const Song &song : songs) {
query.BindValue(":id", song.id());
query.BindValue(QStringLiteral(":id"), song.id());
if (!query.Exec()) {
db_->ReportErrors(query);
return;
@@ -957,7 +957,7 @@ QStringList CollectionBackend::GetAll(const QString &column, const CollectionFil
QStringList CollectionBackend::GetAllArtists(const CollectionFilterOptions &opt) {
return GetAll("artist", opt);
return GetAll(QStringLiteral("artist"), opt);
}
QStringList CollectionBackend::GetAllArtistsWithAlbums(const CollectionFilterOptions &opt) {
@@ -967,16 +967,16 @@ QStringList CollectionBackend::GetAllArtistsWithAlbums(const CollectionFilterOpt
// Albums with 'albumartist' field set:
CollectionQuery query(db, songs_table_, fts_table_, opt);
query.SetColumnSpec("DISTINCT albumartist");
query.SetColumnSpec(QStringLiteral("DISTINCT albumartist"));
query.AddCompilationRequirement(false);
query.AddWhere("album", "", "!=");
query.AddWhere(QStringLiteral("album"), "", QStringLiteral("!="));
// Albums with no 'albumartist' (extract 'artist'):
CollectionQuery query2(db, songs_table_, fts_table_, opt);
query2.SetColumnSpec("DISTINCT artist");
query2.SetColumnSpec(QStringLiteral("DISTINCT artist"));
query2.AddCompilationRequirement(false);
query2.AddWhere("album", "", "!=");
query2.AddWhere("albumartist", "", "=");
query2.AddWhere(QStringLiteral("album"), "", QStringLiteral("!="));
query2.AddWhere(QStringLiteral("albumartist"), "", QStringLiteral("="));
if (!query.Exec()) {
ReportErrors(query);
@@ -1015,7 +1015,7 @@ SongList CollectionBackend::GetArtistSongs(const QString &effective_albumartist,
CollectionQuery query(db, songs_table_, fts_table_, opt);
query.AddCompilationRequirement(false);
query.AddWhere("effective_albumartist", effective_albumartist);
query.AddWhere(QStringLiteral("effective_albumartist"), effective_albumartist);
SongList songs;
if (!ExecCollectionQuery(&query, songs)) {
@@ -1033,8 +1033,8 @@ SongList CollectionBackend::GetAlbumSongs(const QString &effective_albumartist,
CollectionQuery query(db, songs_table_, fts_table_, opt);
query.AddCompilationRequirement(false);
query.AddWhere("effective_albumartist", effective_albumartist);
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("effective_albumartist"), effective_albumartist);
query.AddWhere(QStringLiteral("album"), album);
SongList songs;
if (!ExecCollectionQuery(&query, songs)) {
@@ -1052,7 +1052,7 @@ SongList CollectionBackend::GetSongsByAlbum(const QString &album, const Collecti
CollectionQuery query(db, songs_table_, fts_table_, opt);
query.AddCompilationRequirement(false);
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("album"), album);
SongList songs;
if (!ExecCollectionQuery(&query, songs)) {
@@ -1130,10 +1130,10 @@ SongList CollectionBackend::GetSongsByForeignId(const QStringList &ids, const QS
QMutexLocker l(db_->Mutex());
QSqlDatabase db(db_->Connect());
QString in = ids.join(",");
QString in = ids.join(QStringLiteral(","));
SqlQuery q(db);
q.prepare(QString("SELECT %3.ROWID, %2, %3.%4 FROM %3, %1 WHERE %3.%4 IN (in) AND %1.ROWID = %3.ROWID AND unavailable = 0").arg(songs_table_, Song::kColumnSpec, table, column, in));
q.prepare(QStringLiteral("SELECT %3.ROWID, %2, %3.%4 FROM %3, %1 WHERE %3.%4 IN (in) AND %1.ROWID = %3.ROWID AND unavailable = 0").arg(songs_table_, Song::kColumnSpec, table, column, in));
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -1161,10 +1161,10 @@ Song CollectionBackend::GetSongById(const int id, QSqlDatabase &db) {
SongList CollectionBackend::GetSongsById(const QStringList &ids, QSqlDatabase &db) {
QString in = ids.join(",");
QString in = ids.join(QStringLiteral(","));
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE ROWID IN (%3)").arg(Song::kColumnSpec, songs_table_, in));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE ROWID IN (%3)").arg(Song::kColumnSpec, songs_table_, in));
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -1186,13 +1186,13 @@ Song CollectionBackend::GetSongByUrl(const QUrl &url, const qint64 beginning) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND beginning = :beginning AND unavailable = 0").arg(Song::kColumnSpec, songs_table_));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND beginning = :beginning AND unavailable = 0").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":url1", url);
q.BindValue(":url2", url.toString());
q.BindValue(":url3", url.toString(QUrl::FullyEncoded));
q.BindValue(":url4", url.toEncoded());
q.BindValue(":beginning", beginning);
q.BindValue(QStringLiteral(":url1"), url);
q.BindValue(QStringLiteral(":url2"), url.toString());
q.BindValue(QStringLiteral(":url3"), url.toString(QUrl::FullyEncoded));
q.BindValue(QStringLiteral(":url4"), url.toEncoded());
q.BindValue(QStringLiteral(":beginning"), beginning);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -1216,13 +1216,13 @@ Song CollectionBackend::GetSongByUrlAndTrack(const QUrl &url, const int track) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND track = :track AND unavailable = 0").arg(Song::kColumnSpec, songs_table_));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND track = :track AND unavailable = 0").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":url1", url);
q.BindValue(":url2", url.toString());
q.BindValue(":url3", url.toString(QUrl::FullyEncoded));
q.BindValue(":url4", url.toEncoded());
q.BindValue(":track", track);
q.BindValue(QStringLiteral(":url1"), url);
q.BindValue(QStringLiteral(":url2"), url.toString());
q.BindValue(QStringLiteral(":url3"), url.toString(QUrl::FullyEncoded));
q.BindValue(QStringLiteral(":url4"), url.toEncoded());
q.BindValue(QStringLiteral(":track"), track);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -1246,13 +1246,13 @@ SongList CollectionBackend::GetSongsByUrl(const QUrl &url, const bool unavailabl
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND unavailable = :unavailable").arg(Song::kColumnSpec, songs_table_));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND unavailable = :unavailable").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":url1", url);
q.BindValue(":url2", url.toString());
q.BindValue(":url3", url.toString(QUrl::FullyEncoded));
q.BindValue(":url4", url.toEncoded());
q.BindValue(":unavailable", (unavailable ? 1 : 0));
q.BindValue(QStringLiteral(":url1"), url);
q.BindValue(QStringLiteral(":url2"), url.toString());
q.BindValue(QStringLiteral(":url3"), url.toString(QUrl::FullyEncoded));
q.BindValue(QStringLiteral(":url4"), url.toEncoded());
q.BindValue(QStringLiteral(":unavailable"), (unavailable ? 1 : 0));
SongList songs;
if (q.Exec()) {
@@ -1303,10 +1303,10 @@ SongList CollectionBackend::GetSongsBySongId(const QStringList &song_ids, QSqlDa
for (const QString &song_id : song_ids) {
song_ids2 << "'" + song_id + "'";
}
QString in = song_ids2.join(",");
QString in = song_ids2.join(QStringLiteral(","));
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE SONG_ID IN (%3)").arg(Song::kColumnSpec, songs_table_, in));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE SONG_ID IN (%3)").arg(Song::kColumnSpec, songs_table_, in));
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -1329,8 +1329,8 @@ SongList CollectionBackend::GetSongsByFingerprint(const QString &fingerprint) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE fingerprint = :fingerprint").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":fingerprint", fingerprint);
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE fingerprint = :fingerprint").arg(Song::kColumnSpec, songs_table_));
q.BindValue(QStringLiteral(":fingerprint"), fingerprint);
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -1360,7 +1360,7 @@ SongList CollectionBackend::GetCompilationSongs(const QString &album, const Coll
CollectionQuery query(db, songs_table_, fts_table_, opt);
query.SetColumnSpec("%songs_table.ROWID, " + Song::kColumnSpec);
query.AddCompilationRequirement(true);
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("album"), album);
if (!query.Exec()) {
ReportErrors(query);
@@ -1385,7 +1385,7 @@ void CollectionBackend::CompilationsNeedUpdating() {
// Look for albums that have songs by more than one 'effective album artist' in the same directory
SqlQuery q(db);
q.prepare(QString("SELECT effective_albumartist, album, url, compilation_detected FROM %1 WHERE unavailable = 0 ORDER BY album").arg(songs_table_));
q.prepare(QStringLiteral("SELECT effective_albumartist, album, url, compilation_detected FROM %1 WHERE unavailable = 0 ORDER BY album").arg(songs_table_));
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -1452,11 +1452,11 @@ bool CollectionBackend::UpdateCompilations(const QSqlDatabase &db, SongList &del
{ // Get song, so we can tell the model its updated
SqlQuery q(db);
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND unavailable = 0").arg(Song::kColumnSpec, songs_table_));
q.BindValue(":url1", url);
q.BindValue(":url2", url.toString());
q.BindValue(":url3", url.toString(QUrl::FullyEncoded));
q.BindValue(":url4", url.toEncoded());
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND unavailable = 0").arg(Song::kColumnSpec, songs_table_));
q.BindValue(QStringLiteral(":url1"), url);
q.BindValue(QStringLiteral(":url2"), url.toString());
q.BindValue(QStringLiteral(":url3"), url.toString(QUrl::FullyEncoded));
q.BindValue(QStringLiteral(":url4"), url.toEncoded());
if (q.Exec()) {
while (q.next()) {
Song song(source_);
@@ -1474,12 +1474,12 @@ bool CollectionBackend::UpdateCompilations(const QSqlDatabase &db, SongList &del
// Update the song
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET compilation_detected = :compilation_detected, compilation_effective = ((compilation OR :compilation_detected OR compilation_on) AND NOT compilation_off) + 0 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND unavailable = 0").arg(songs_table_));
q.BindValue(":compilation_detected", static_cast<int>(compilation_detected));
q.BindValue(":url1", url);
q.BindValue(":url2", url.toString());
q.BindValue(":url3", url.toString(QUrl::FullyEncoded));
q.BindValue(":url4", url.toEncoded());
q.prepare(QStringLiteral("UPDATE %1 SET compilation_detected = :compilation_detected, compilation_effective = ((compilation OR :compilation_detected OR compilation_on) AND NOT compilation_off) + 0 WHERE (url = :url1 OR url = :url2 OR url = :url3 OR url = :url4) AND unavailable = 0").arg(songs_table_));
q.BindValue(QStringLiteral(":compilation_detected"), static_cast<int>(compilation_detected));
q.BindValue(QStringLiteral(":url1"), url);
q.BindValue(QStringLiteral(":url2"), url.toString());
q.BindValue(QStringLiteral(":url3"), url.toString(QUrl::FullyEncoded));
q.BindValue(QStringLiteral(":url4"), url.toEncoded());
if (!q.Exec()) {
db_->ReportErrors(q);
return false;
@@ -1495,15 +1495,15 @@ CollectionBackend::AlbumList CollectionBackend::GetAlbums(const QString &artist,
QSqlDatabase db(db_->Connect());
CollectionQuery query(db, songs_table_, fts_table_, opt);
query.SetColumnSpec("url, filetype, cue_path, effective_albumartist, album, compilation_effective, art_embedded, art_automatic, art_manual, art_unset");
query.SetOrderBy("effective_albumartist, album, url");
query.SetColumnSpec(QStringLiteral("url, filetype, cue_path, effective_albumartist, album, compilation_effective, art_embedded, art_automatic, art_manual, art_unset"));
query.SetOrderBy(QStringLiteral("effective_albumartist, album, url"));
if (compilation_required) {
query.AddCompilationRequirement(true);
}
else if (!artist.isEmpty()) {
query.AddCompilationRequirement(false);
query.AddWhere("effective_albumartist", artist);
query.AddWhere(QStringLiteral("effective_albumartist"), artist);
}
if (!query.Exec()) {
@@ -1531,7 +1531,7 @@ CollectionBackend::AlbumList CollectionBackend::GetAlbums(const QString &artist,
album_info.art_embedded = query.Value(6).toBool();
const QString art_automatic = query.Value(7).toString();
if (art_automatic.contains(QRegularExpression("..+:.*"))) {
if (art_automatic.contains(QRegularExpression(QStringLiteral("..+:.*")))) {
album_info.art_automatic = QUrl::fromEncoded(art_automatic.toUtf8());
}
else {
@@ -1539,7 +1539,7 @@ CollectionBackend::AlbumList CollectionBackend::GetAlbums(const QString &artist,
}
const QString art_manual = query.Value(8).toString();
if (art_manual.contains(QRegularExpression("..+:.*"))) {
if (art_manual.contains(QRegularExpression(QStringLiteral("..+:.*")))) {
album_info.art_manual = QUrl::fromEncoded(art_manual.toUtf8());
}
else {
@@ -1586,11 +1586,11 @@ CollectionBackend::Album CollectionBackend::GetAlbumArt(const QString &effective
ret.album_artist = effective_albumartist;
CollectionQuery query(db, songs_table_, fts_table_);
query.SetColumnSpec("url, art_embedded, art_automatic, art_manual, art_unset");
query.SetColumnSpec(QStringLiteral("url, art_embedded, art_automatic, art_manual, art_unset"));
if (!effective_albumartist.isEmpty()) {
query.AddWhere("effective_albumartist", effective_albumartist);
query.AddWhere(QStringLiteral("effective_albumartist"), effective_albumartist);
}
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("album"), album);
if (!query.Exec()) {
ReportErrors(query);
@@ -1623,8 +1623,8 @@ void CollectionBackend::UpdateEmbeddedAlbumArt(const QString &effective_albumart
// Get the songs before they're updated
CollectionQuery query(db, songs_table_, fts_table_);
query.SetColumnSpec("ROWID, " + Song::kColumnSpec);
query.AddWhere("effective_albumartist", effective_albumartist);
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("effective_albumartist"), effective_albumartist);
query.AddWhere(QStringLiteral("album"), album);
if (!query.Exec()) {
ReportErrors(query);
@@ -1639,13 +1639,13 @@ void CollectionBackend::UpdateEmbeddedAlbumArt(const QString &effective_albumart
}
// Update the songs
QString sql = QString("UPDATE %1 SET art_embedded = :art_embedded, art_unset = 0 WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_);
QString sql = QStringLiteral("UPDATE %1 SET art_embedded = :art_embedded, art_unset = 0 WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_);
SqlQuery q(db);
q.prepare(sql);
q.BindValue(":art_embedded", art_embedded ? 1 : 0);
q.BindValue(":effective_albumartist", effective_albumartist);
q.BindValue(":album", album);
q.BindValue(QStringLiteral(":art_embedded"), art_embedded ? 1 : 0);
q.BindValue(QStringLiteral(":effective_albumartist"), effective_albumartist);
q.BindValue(QStringLiteral(":album"), album);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -1685,8 +1685,8 @@ void CollectionBackend::UpdateManualAlbumArt(const QString &effective_albumartis
CollectionQuery query(db, songs_table_, fts_table_);
query.SetColumnSpec("ROWID, " + Song::kColumnSpec);
query.AddWhere("effective_albumartist", effective_albumartist);
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("effective_albumartist"), effective_albumartist);
query.AddWhere(QStringLiteral("album"), album);
if (!query.Exec()) {
ReportErrors(query);
@@ -1701,10 +1701,10 @@ void CollectionBackend::UpdateManualAlbumArt(const QString &effective_albumartis
}
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET art_manual = :art_manual, art_unset = 0 WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_));
q.BindValue(":art_manual", art_manual.isValid() ? art_manual.toString(QUrl::FullyEncoded) : "");
q.BindValue(":effective_albumartist", effective_albumartist);
q.BindValue(":album", album);
q.prepare(QStringLiteral("UPDATE %1 SET art_manual = :art_manual, art_unset = 0 WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_));
q.BindValue(QStringLiteral(":art_manual"), art_manual.isValid() ? art_manual.toString(QUrl::FullyEncoded) : QLatin1String(""));
q.BindValue(QStringLiteral(":effective_albumartist"), effective_albumartist);
q.BindValue(QStringLiteral(":album"), album);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -1743,8 +1743,8 @@ void CollectionBackend::UnsetAlbumArt(const QString &effective_albumartist, cons
CollectionQuery query(db, songs_table_, fts_table_);
query.SetColumnSpec("ROWID, " + Song::kColumnSpec);
query.AddWhere("effective_albumartist", effective_albumartist);
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("effective_albumartist"), effective_albumartist);
query.AddWhere(QStringLiteral("album"), album);
if (!query.Exec()) {
ReportErrors(query);
@@ -1759,9 +1759,9 @@ void CollectionBackend::UnsetAlbumArt(const QString &effective_albumartist, cons
}
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET art_unset = 1, art_manual = '', art_automatic = '', art_embedded = '' WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_));
q.BindValue(":effective_albumartist", effective_albumartist);
q.BindValue(":album", album);
q.prepare(QStringLiteral("UPDATE %1 SET art_unset = 1, art_manual = '', art_automatic = '', art_embedded = '' WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_));
q.BindValue(QStringLiteral(":effective_albumartist"), effective_albumartist);
q.BindValue(QStringLiteral(":album"), album);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -1800,8 +1800,8 @@ void CollectionBackend::ClearAlbumArt(const QString &effective_albumartist, cons
CollectionQuery query(db, songs_table_, fts_table_);
query.SetColumnSpec("ROWID, " + Song::kColumnSpec);
query.AddWhere("effective_albumartist", effective_albumartist);
query.AddWhere("album", album);
query.AddWhere(QStringLiteral("effective_albumartist"), effective_albumartist);
query.AddWhere(QStringLiteral("album"), album);
if (!query.Exec()) {
ReportErrors(query);
@@ -1816,10 +1816,10 @@ void CollectionBackend::ClearAlbumArt(const QString &effective_albumartist, cons
}
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET art_embedded = 0, art_automatic = '', art_manual = '', art_unset = :art_unset WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_));
q.BindValue(":art_unset", art_unset ? 1 : 0);
q.BindValue(":effective_albumartist", effective_albumartist);
q.BindValue(":album", album);
q.prepare(QStringLiteral("UPDATE %1 SET art_embedded = 0, art_automatic = '', art_manual = '', art_unset = :art_unset WHERE effective_albumartist = :effective_albumartist AND album = :album AND unavailable = 0").arg(songs_table_));
q.BindValue(QStringLiteral(":art_unset"), art_unset ? 1 : 0);
q.BindValue(QStringLiteral(":effective_albumartist"), effective_albumartist);
q.BindValue(QStringLiteral(":album"), album);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -1855,8 +1855,8 @@ void CollectionBackend::ForceCompilation(const QString &album, const QList<QStri
// Get the songs before they're updated
CollectionQuery query(db, songs_table_, fts_table_);
query.SetColumnSpec("ROWID, " + Song::kColumnSpec);
query.AddWhere("album", album);
if (!artist.isEmpty()) query.AddWhere("artist", artist);
query.AddWhere(QStringLiteral("album"), album);
if (!artist.isEmpty()) query.AddWhere(QStringLiteral("artist"), artist);
if (!query.Exec()) {
ReportErrors(query);
@@ -1870,15 +1870,15 @@ void CollectionBackend::ForceCompilation(const QString &album, const QList<QStri
}
// Update the songs
QString sql(QString("UPDATE %1 SET compilation_on = :compilation_on, compilation_off = :compilation_off, compilation_effective = ((compilation OR compilation_detected OR :compilation_on) AND NOT :compilation_off) + 0 WHERE album = :album AND unavailable = 0").arg(songs_table_));
if (!artist.isEmpty()) sql += " AND artist = :artist";
QString sql(QStringLiteral("UPDATE %1 SET compilation_on = :compilation_on, compilation_off = :compilation_off, compilation_effective = ((compilation OR compilation_detected OR :compilation_on) AND NOT :compilation_off) + 0 WHERE album = :album AND unavailable = 0").arg(songs_table_));
if (!artist.isEmpty()) sql += QLatin1String(" AND artist = :artist");
SqlQuery q(db);
q.prepare(sql);
q.BindValue(":compilation_on", on ? 1 : 0);
q.BindValue(":compilation_off", on ? 0 : 1);
q.BindValue(":album", album);
if (!artist.isEmpty()) q.BindValue(":artist", artist);
q.BindValue(QStringLiteral(":compilation_on"), on ? 1 : 0);
q.BindValue(QStringLiteral(":compilation_off"), on ? 0 : 1);
q.BindValue(QStringLiteral(":album"), album);
if (!artist.isEmpty()) q.BindValue(QStringLiteral(":artist"), artist);
if (!q.Exec()) {
db_->ReportErrors(q);
@@ -1913,9 +1913,9 @@ void CollectionBackend::IncrementPlayCount(const int id) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET playcount = playcount + 1, lastplayed = :now WHERE ROWID = :id").arg(songs_table_));
q.BindValue(":now", QDateTime::currentDateTime().toSecsSinceEpoch());
q.BindValue(":id", id);
q.prepare(QStringLiteral("UPDATE %1 SET playcount = playcount + 1, lastplayed = :now WHERE ROWID = :id").arg(songs_table_));
q.BindValue(QStringLiteral(":now"), QDateTime::currentDateTime().toSecsSinceEpoch());
q.BindValue(QStringLiteral(":id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -1936,8 +1936,8 @@ void CollectionBackend::IncrementSkipCount(const int id, const float progress) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET skipcount = skipcount + 1 WHERE ROWID = :id").arg(songs_table_));
q.BindValue(":id", id);
q.prepare(QStringLiteral("UPDATE %1 SET skipcount = skipcount + 1 WHERE ROWID = :id").arg(songs_table_));
q.BindValue(QStringLiteral(":id"), id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -1982,8 +1982,8 @@ bool CollectionBackend::ResetPlayStatistics(const QStringList &id_str_list) {
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET playcount = 0, skipcount = 0, lastplayed = -1 WHERE ROWID IN (:ids)").arg(songs_table_));
q.BindValue(":ids", id_str_list.join(","));
q.prepare(QStringLiteral("UPDATE %1 SET playcount = 0, skipcount = 0, lastplayed = -1 WHERE ROWID IN (:ids)").arg(songs_table_));
q.BindValue(QStringLiteral(":ids"), id_str_list.join(QStringLiteral(",")));
if (!q.Exec()) {
db_->ReportErrors(q);
return false;
@@ -2073,14 +2073,14 @@ SongList CollectionBackend::GetSongsBy(const QString &artist, const QString &alb
SongList songs;
SqlQuery q(db);
if (album.isEmpty()) {
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE artist = :artist COLLATE NOCASE AND title = :title COLLATE NOCASE").arg(Song::kColumnSpec, songs_table_));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE artist = :artist COLLATE NOCASE AND title = :title COLLATE NOCASE").arg(Song::kColumnSpec, songs_table_));
}
else {
q.prepare(QString("SELECT ROWID, %1 FROM %2 WHERE artist = :artist COLLATE NOCASE AND album = :album COLLATE NOCASE AND title = :title COLLATE NOCASE").arg(Song::kColumnSpec, songs_table_));
q.prepare(QStringLiteral("SELECT ROWID, %1 FROM %2 WHERE artist = :artist COLLATE NOCASE AND album = :album COLLATE NOCASE AND title = :title COLLATE NOCASE").arg(Song::kColumnSpec, songs_table_));
}
q.BindValue(":artist", artist);
if (!album.isEmpty()) q.BindValue(":album", album);
q.BindValue(":title", title);
q.BindValue(QStringLiteral(":artist"), artist);
if (!album.isEmpty()) q.BindValue(QStringLiteral(":album"), album);
q.BindValue(QStringLiteral(":title"), title);
if (!q.Exec()) {
db_->ReportErrors(q);
return SongList();
@@ -2111,9 +2111,9 @@ void CollectionBackend::UpdateLastPlayed(const QString &artist, const QString &a
continue;
}
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET lastplayed = :lastplayed WHERE ROWID = :id").arg(songs_table_));
q.BindValue(":lastplayed", lastplayed);
q.BindValue(":id", song.id());
q.prepare(QStringLiteral("UPDATE %1 SET lastplayed = :lastplayed WHERE ROWID = :id").arg(songs_table_));
q.BindValue(QStringLiteral(":lastplayed"), lastplayed);
q.BindValue(QStringLiteral(":id"), song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
continue;
@@ -2137,9 +2137,9 @@ void CollectionBackend::UpdatePlayCount(const QString &artist, const QString &ti
for (const Song &song : songs) {
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET playcount = :playcount WHERE ROWID = :id").arg(songs_table_));
q.BindValue(":playcount", playcount);
q.BindValue(":id", song.id());
q.prepare(QStringLiteral("UPDATE %1 SET playcount = :playcount WHERE ROWID = :id").arg(songs_table_));
q.BindValue(QStringLiteral(":playcount"), playcount);
q.BindValue(QStringLiteral(":id"), song.id());
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -2170,10 +2170,10 @@ void CollectionBackend::UpdateSongsRating(const QList<int> &id_list, const float
for (int i : id_list) {
id_str_list << QString::number(i);
}
QString ids = id_str_list.join(",");
QString ids = id_str_list.join(QStringLiteral(","));
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET rating = :rating WHERE ROWID IN (%2)").arg(songs_table_, ids));
q.BindValue(":rating", rating);
q.prepare(QStringLiteral("UPDATE %1 SET rating = :rating WHERE ROWID IN (%2)").arg(songs_table_, ids));
q.BindValue(QStringLiteral(":rating"), rating);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -2200,9 +2200,9 @@ void CollectionBackend::UpdateLastSeen(const int directory_id, const int expire_
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("UPDATE %1 SET lastseen = :lastseen WHERE directory_id = :directory_id AND unavailable = 0").arg(songs_table_));
q.BindValue(":lastseen", QDateTime::currentDateTime().toSecsSinceEpoch());
q.BindValue(":directory_id", directory_id);
q.prepare(QStringLiteral("UPDATE %1 SET lastseen = :lastseen WHERE directory_id = :directory_id AND unavailable = 0").arg(songs_table_));
q.BindValue(QStringLiteral(":lastseen"), QDateTime::currentDateTime().toSecsSinceEpoch());
q.BindValue(QStringLiteral(":directory_id"), directory_id);
if (!q.Exec()) {
db_->ReportErrors(q);
return;
@@ -2220,9 +2220,9 @@ void CollectionBackend::ExpireSongs(const int directory_id, const int expire_una
QMutexLocker l(db_->Mutex());
QSqlDatabase db(db_->Connect());
SqlQuery q(db);
q.prepare(QString("SELECT %1.ROWID, " + Song::JoinSpec("%1") + " FROM %1 LEFT JOIN playlist_items ON %1.ROWID = playlist_items.collection_id WHERE %1.directory_id = :directory_id AND %1.unavailable = 1 AND %1.lastseen > 0 AND %1.lastseen < :time AND playlist_items.collection_id IS NULL").arg(songs_table_));
q.BindValue(":directory_id", directory_id);
q.BindValue(":time", QDateTime::currentDateTime().toSecsSinceEpoch() - (expire_unavailable_songs_days * 86400));
q.prepare(QString("SELECT %1.ROWID, " + Song::JoinSpec(QStringLiteral("%1")) + " FROM %1 LEFT JOIN playlist_items ON %1.ROWID = playlist_items.collection_id WHERE %1.directory_id = :directory_id AND %1.unavailable = 1 AND %1.lastseen > 0 AND %1.lastseen < :time AND playlist_items.collection_id IS NULL").arg(songs_table_));
q.BindValue(QStringLiteral(":directory_id"), directory_id);
q.BindValue(QStringLiteral(":time"), QDateTime::currentDateTime().toSecsSinceEpoch() - (expire_unavailable_songs_days * 86400));
if (!q.Exec()) {
db_->ReportErrors(q);
return;

2
src/collection/collectiondirectorymodel.cpp
View File

@@ -41,7 +41,7 @@ using std::make_shared;
CollectionDirectoryModel::CollectionDirectoryModel(SharedPtr<CollectionBackend> backend, QObject *parent)
: QStandardItemModel(parent),
dir_icon_(IconLoader::Load("document-open-folder")),
dir_icon_(IconLoader::Load(QStringLiteral("document-open-folder"))),
backend_(backend) {
QObject::connect(&*backend_, &CollectionBackend::DirectoryDiscovered, this, &CollectionDirectoryModel::DirectoryDiscovered);

50
src/collection/collectionfilterwidget.cpp
View File

@@ -72,34 +72,34 @@ CollectionFilterWidget::CollectionFilterWidget(QWidget *parent)
ui_->setupUi(this);
QString available_fields = Song::kFtsColumns.join(", ").replace(QRegularExpression("\\bfts"), "");
available_fields += QString(", ") + Song::kNumericalColumns.join(", ");
QString available_fields = Song::kFtsColumns.join(QStringLiteral(", ")).replace(QRegularExpression(QStringLiteral("\\bfts")), QLatin1String(""));
available_fields += QStringLiteral(", ") + Song::kNumericalColumns.join(QStringLiteral(", "));
ui_->search_field->setToolTip(
QString("<html><head/><body><p>") +
QStringLiteral("<html><head/><body><p>") +
tr("Prefix a word with a field name to limit the search to that field, e.g.:") +
QString(" ") +
QString("<span style=\"font-weight:600;\">") +
QStringLiteral(" ") +
QStringLiteral("<span style=\"font-weight:600;\">") +
tr("artist") +
QString(":</span><span style=\"font-style:italic;\">Strawbs</span> ") +
tr("searches the collection for all artists that contain the word %1. ").arg("Strawbs") +
QString("</p><p>") +
QStringLiteral(":</span><span style=\"font-style:italic;\">Strawbs</span> ") +
tr("searches the collection for all artists that contain the word %1. ").arg(QStringLiteral("Strawbs")) +
QStringLiteral("</p><p>") +
tr("Search terms for numerical fields can be prefixed with %1 or %2 to refine the search, e.g.: ")
.arg(" =, !=, &lt;, &gt;, &lt;=", "&gt;=") +
QString("<span style=\"font-weight:600;\">") +
QStringLiteral("<span style=\"font-weight:600;\">") +
tr("rating") +
QString("</span>") +
QString(":>=") +
QString("<span style=\"font-weight:italic;\">4</span>") +
QStringLiteral("</span>") +
QStringLiteral(":>=") +
QStringLiteral("<span style=\"font-weight:italic;\">4</span>") +
QString("</p><p><span style=\"font-weight:600;\">") +
QStringLiteral("</p><p><span style=\"font-weight:600;\">") +
tr("Available fields") +
QString(": ") +
QString("</span>") +
QString("<span style=\"font-style:italic;\">") +
QStringLiteral(": ") +
QStringLiteral("</span>") +
QStringLiteral("<span style=\"font-style:italic;\">") +
available_fields +
QString("</span>.") +
QString("</p></body></html>")
QStringLiteral("</span>.") +
QStringLiteral("</p></body></html>")
);
QObject::connect(ui_->search_field, &QSearchField::returnPressed, this, &CollectionFilterWidget::ReturnPressed);
@@ -109,7 +109,7 @@ CollectionFilterWidget::CollectionFilterWidget(QWidget *parent)
filter_delay_->setSingleShot(true);
// Icons
ui_->options->setIcon(IconLoader::Load("configure"));
ui_->options->setIcon(IconLoader::Load(QStringLiteral("configure")));
// Filter by age
QActionGroup *filter_age_group = new QActionGroup(this);
@@ -229,10 +229,10 @@ void CollectionFilterWidget::ReloadSettings() {
QString CollectionFilterWidget::group_by_version() const {
if (settings_prefix_.isEmpty()) {
return "group_by_version";
return QStringLiteral("group_by_version");
}
else {
return QString("%1_group_by_version").arg(settings_prefix_);
return QStringLiteral("%1_group_by_version").arg(settings_prefix_);
}
}
@@ -240,10 +240,10 @@ QString CollectionFilterWidget::group_by_version() const {
QString CollectionFilterWidget::group_by_key() const {
if (settings_prefix_.isEmpty()) {
return "group_by";
return QStringLiteral("group_by");
}
else {
return QString("%1_group_by").arg(settings_prefix_);
return QStringLiteral("%1_group_by").arg(settings_prefix_);
}
}
@@ -253,10 +253,10 @@ QString CollectionFilterWidget::group_by_key(const int number) const { return gr
QString CollectionFilterWidget::separate_albums_by_grouping_key() const {
if (settings_prefix_.isEmpty()) {
return "separate_albums_by_grouping";
return QStringLiteral("separate_albums_by_grouping");
}
else {
return QString("%1_separate_albums_by_grouping").arg(settings_prefix_);
return QStringLiteral("%1_separate_albums_by_grouping").arg(settings_prefix_);
}
}

158
src/collection/collectionmodel.cpp
View File

@@ -91,8 +91,8 @@ CollectionModel::CollectionModel(SharedPtr<CollectionBackend> backend, Applicati
total_artist_count_(0),
total_album_count_(0),
separate_albums_by_grouping_(false),
artist_icon_(IconLoader::Load("folder-sound")),
album_icon_(IconLoader::Load("cdcase")),
artist_icon_(IconLoader::Load(QStringLiteral("folder-sound"))),
album_icon_(IconLoader::Load(QStringLiteral("cdcase"))),
init_task_id_(-1),
use_pretty_covers_(true),
show_dividers_(true),
@@ -109,7 +109,7 @@ CollectionModel::CollectionModel(SharedPtr<CollectionBackend> backend, Applicati
QObject::connect(&*app_->album_cover_loader(), &AlbumCoverLoader::AlbumCoverLoaded, this, &CollectionModel::AlbumCoverLoaded);
}
QIcon nocover = IconLoader::Load("cdcase");
QIcon nocover = IconLoader::Load(QStringLiteral("cdcase"));
if (!nocover.isNull()) {
QList<QSize> nocover_sizes = nocover.availableSizes();
no_cover_icon_ = nocover.pixmap(nocover_sizes.last()).scaled(kPrettyCoverSize, kPrettyCoverSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
@@ -307,7 +307,7 @@ CollectionItem *CollectionModel::CreateCompilationArtistNode(const bool signal,
if (parent != root_ && !parent->key.isEmpty()) parent->compilation_artist_node_->key.append(parent->key);
parent->compilation_artist_node_->key.append(tr("Various artists"));
parent->compilation_artist_node_->display_text = tr("Various artists");
parent->compilation_artist_node_->sort_text = " various";
parent->compilation_artist_node_->sort_text = QStringLiteral(" various");
parent->compilation_artist_node_->container_level = parent->container_level + 1;
if (signal) endInsertRows();
@@ -396,10 +396,10 @@ QString CollectionModel::ContainerKey(const GroupBy group_by, const bool separat
}
else {
if (song.bitdepth() <= 0) {
key = QString("%1 (%2)").arg(song.TextForFiletype(), QString::number(song.samplerate() / 1000.0, 'G', 5));
key = QStringLiteral("%1 (%2)").arg(song.TextForFiletype(), QString::number(song.samplerate() / 1000.0, 'G', 5));
}
else {
key = QString("%1 (%2/%3)").arg(song.TextForFiletype(), QString::number(song.samplerate() / 1000.0, 'G', 5)).arg(song.bitdepth());
key = QStringLiteral("%1 (%2/%3)").arg(song.TextForFiletype(), QString::number(song.samplerate() / 1000.0, 'G', 5)).arg(song.bitdepth());
}
}
break;
@@ -432,7 +432,7 @@ QString CollectionModel::DividerKey(const GroupBy group_by, CollectionItem *item
case GroupBy::Format:
case GroupBy::FileType: {
QChar c = item->sort_text[0];
if (c.isDigit()) return "0";
if (c.isDigit()) return QStringLiteral("0");
if (c == ' ') return QString();
if (c.decompositionTag() != QChar::NoDecomposition) {
QString decomposition = c.decomposition();
@@ -487,7 +487,7 @@ QString CollectionModel::DividerDisplayText(const GroupBy group_by, const QStrin
case GroupBy::Genre:
case GroupBy::FileType:
case GroupBy::Format:
if (key == "0") return "0-9";
if (key == "0") return QStringLiteral("0-9");
return key.toUpper();
case GroupBy::YearAlbum:
@@ -631,7 +631,7 @@ QString CollectionModel::AlbumIconPixmapCacheKey(const QModelIndex &idx) const {
idx_copy = idx_copy.parent();
}
return Song::TextForSource(backend_->source()) + "/" + path.join("/");
return Song::TextForSource(backend_->source()) + "/" + path.join(QStringLiteral("/"));
}
@@ -1054,82 +1054,82 @@ 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:
query_options->set_column_spec("DISTINCT effective_albumartist");
query_options->set_column_spec(QStringLiteral("DISTINCT effective_albumartist"));
break;
case GroupBy::Artist:
query_options->set_column_spec("DISTINCT artist");
query_options->set_column_spec(QStringLiteral("DISTINCT artist"));
break;
case GroupBy::Album:{
QString query("DISTINCT album, album_id");
QString query(QStringLiteral("DISTINCT album, album_id"));
if (separate_albums_by_grouping) query.append(", grouping");
query_options->set_column_spec(query);
break;
}
case GroupBy::AlbumDisc:{
QString query("DISTINCT album, album_id, disc");
QString query(QStringLiteral("DISTINCT album, album_id, disc"));
if (separate_albums_by_grouping) query.append(", grouping");
query_options->set_column_spec(query);
break;
}
case GroupBy::YearAlbum:{
QString query("DISTINCT year, album, album_id");
QString query(QStringLiteral("DISTINCT year, album, album_id"));
if (separate_albums_by_grouping) query.append(", grouping");
query_options->set_column_spec(query);
break;
}
case GroupBy::YearAlbumDisc:{
QString query("DISTINCT year, album, album_id, disc");
QString query(QStringLiteral("DISTINCT year, album, album_id, disc"));
if (separate_albums_by_grouping) query.append(", grouping");
query_options->set_column_spec(query);
break;
}
case GroupBy::OriginalYearAlbum:{
QString query("DISTINCT year, originalyear, album, album_id");
QString query(QStringLiteral("DISTINCT year, originalyear, album, album_id"));
if (separate_albums_by_grouping) query.append(", grouping");
query_options->set_column_spec(query);
break;
}
case GroupBy::OriginalYearAlbumDisc:{
QString query("DISTINCT year, originalyear, album, album_id, disc");
QString query(QStringLiteral("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:
query_options->set_column_spec("DISTINCT disc");
query_options->set_column_spec(QStringLiteral("DISTINCT disc"));
break;
case GroupBy::Year:
query_options->set_column_spec("DISTINCT year");
query_options->set_column_spec(QStringLiteral("DISTINCT year"));
break;
case GroupBy::OriginalYear:
query_options->set_column_spec("DISTINCT effective_originalyear");
query_options->set_column_spec(QStringLiteral("DISTINCT effective_originalyear"));
break;
case GroupBy::Genre:
query_options->set_column_spec("DISTINCT genre");
query_options->set_column_spec(QStringLiteral("DISTINCT genre"));
break;
case GroupBy::Composer:
query_options->set_column_spec("DISTINCT composer");
query_options->set_column_spec(QStringLiteral("DISTINCT composer"));
break;
case GroupBy::Performer:
query_options->set_column_spec("DISTINCT performer");
query_options->set_column_spec(QStringLiteral("DISTINCT performer"));
break;
case GroupBy::Grouping:
query_options->set_column_spec("DISTINCT grouping");
query_options->set_column_spec(QStringLiteral("DISTINCT grouping"));
break;
case GroupBy::FileType:
query_options->set_column_spec("DISTINCT filetype");
query_options->set_column_spec(QStringLiteral("DISTINCT filetype"));
break;
case GroupBy::Format:
query_options->set_column_spec("DISTINCT filetype, samplerate, bitdepth");
query_options->set_column_spec(QStringLiteral("DISTINCT filetype, samplerate, bitdepth"));
break;
case GroupBy::Samplerate:
query_options->set_column_spec("DISTINCT samplerate");
query_options->set_column_spec(QStringLiteral("DISTINCT samplerate"));
break;
case GroupBy::Bitdepth:
query_options->set_column_spec("DISTINCT bitdepth");
query_options->set_column_spec(QStringLiteral("DISTINCT bitdepth"));
break;
case GroupBy::Bitrate:
query_options->set_column_spec("DISTINCT bitrate");
query_options->set_column_spec(QStringLiteral("DISTINCT bitrate"));
break;
case GroupBy::None:
case GroupBy::GroupByCount:
@@ -1151,7 +1151,7 @@ void CollectionModel::AddQueryWhere(const GroupBy group_by, const bool separate_
else {
// Don't duplicate compilations outside the Various artists node
query_options->set_compilation_requirement(CollectionQueryOptions::CompilationRequirement::Off);
query_options->AddWhere("effective_albumartist", item->metadata.effective_albumartist());
query_options->AddWhere(QStringLiteral("effective_albumartist"), item->metadata.effective_albumartist());
}
break;
case GroupBy::Artist:
@@ -1161,85 +1161,85 @@ void CollectionModel::AddQueryWhere(const GroupBy group_by, const bool separate_
else {
// Don't duplicate compilations outside the Various artists node
query_options->set_compilation_requirement(CollectionQueryOptions::CompilationRequirement::Off);
query_options->AddWhere("artist", item->metadata.artist());
query_options->AddWhere(QStringLiteral("artist"), item->metadata.artist());
}
break;
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());
query_options->AddWhere(QStringLiteral("album"), item->metadata.album());
query_options->AddWhere(QStringLiteral("album_id"), item->metadata.album_id());
if (separate_albums_by_grouping) query_options->AddWhere(QStringLiteral("grouping"), item->metadata.grouping());
break;
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());
query_options->AddWhere(QStringLiteral("album"), item->metadata.album());
query_options->AddWhere(QStringLiteral("album_id"), item->metadata.album_id());
query_options->AddWhere(QStringLiteral("disc"), item->metadata.disc());
if (separate_albums_by_grouping) query_options->AddWhere(QStringLiteral("grouping"), item->metadata.grouping());
break;
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());
query_options->AddWhere(QStringLiteral("year"), item->metadata.year());
query_options->AddWhere(QStringLiteral("album"), item->metadata.album());
query_options->AddWhere(QStringLiteral("album_id"), item->metadata.album_id());
if (separate_albums_by_grouping) query_options->AddWhere(QStringLiteral("grouping"), item->metadata.grouping());
break;
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());
query_options->AddWhere(QStringLiteral("year"), item->metadata.year());
query_options->AddWhere(QStringLiteral("album"), item->metadata.album());
query_options->AddWhere(QStringLiteral("album_id"), item->metadata.album_id());
query_options->AddWhere(QStringLiteral("disc"), item->metadata.disc());
if (separate_albums_by_grouping) query_options->AddWhere(QStringLiteral("grouping"), item->metadata.grouping());
break;
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());
query_options->AddWhere(QStringLiteral("year"), item->metadata.year());
query_options->AddWhere(QStringLiteral("originalyear"), item->metadata.originalyear());
query_options->AddWhere(QStringLiteral("album"), item->metadata.album());
query_options->AddWhere(QStringLiteral("album_id"), item->metadata.album_id());
if (separate_albums_by_grouping) query_options->AddWhere(QStringLiteral("grouping"), item->metadata.grouping());
break;
case GroupBy::OriginalYearAlbumDisc:
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());
query_options->AddWhere("disc", item->metadata.disc());
if (separate_albums_by_grouping) query_options->AddWhere("grouping", item->metadata.grouping());
query_options->AddWhere(QStringLiteral("year"), item->metadata.year());
query_options->AddWhere(QStringLiteral("originalyear"), item->metadata.originalyear());
query_options->AddWhere(QStringLiteral("album"), item->metadata.album());
query_options->AddWhere(QStringLiteral("album_id"), item->metadata.album_id());
query_options->AddWhere(QStringLiteral("disc"), item->metadata.disc());
if (separate_albums_by_grouping) query_options->AddWhere(QStringLiteral("grouping"), item->metadata.grouping());
break;
case GroupBy::Disc:
query_options->AddWhere("disc", item->metadata.disc());
query_options->AddWhere(QStringLiteral("disc"), item->metadata.disc());
break;
case GroupBy::Year:
query_options->AddWhere("year", item->metadata.year());
query_options->AddWhere(QStringLiteral("year"), item->metadata.year());
break;
case GroupBy::OriginalYear:
query_options->AddWhere("effective_originalyear", item->metadata.effective_originalyear());
query_options->AddWhere(QStringLiteral("effective_originalyear"), item->metadata.effective_originalyear());
break;
case GroupBy::Genre:
query_options->AddWhere("genre", item->metadata.genre());
query_options->AddWhere(QStringLiteral("genre"), item->metadata.genre());
break;
case GroupBy::Composer:
query_options->AddWhere("composer", item->metadata.composer());
query_options->AddWhere(QStringLiteral("composer"), item->metadata.composer());
break;
case GroupBy::Performer:
query_options->AddWhere("performer", item->metadata.performer());
query_options->AddWhere(QStringLiteral("performer"), item->metadata.performer());
break;
case GroupBy::Grouping:
query_options->AddWhere("grouping", item->metadata.grouping());
query_options->AddWhere(QStringLiteral("grouping"), item->metadata.grouping());
break;
case GroupBy::FileType:
query_options->AddWhere("filetype", static_cast<int>(item->metadata.filetype()));
query_options->AddWhere(QStringLiteral("filetype"), static_cast<int>(item->metadata.filetype()));
break;
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());
query_options->AddWhere(QStringLiteral("filetype"), static_cast<int>(item->metadata.filetype()));
query_options->AddWhere(QStringLiteral("samplerate"), item->metadata.samplerate());
query_options->AddWhere(QStringLiteral("bitdepth"), item->metadata.bitdepth());
break;
case GroupBy::Samplerate:
query_options->AddWhere("samplerate", item->metadata.samplerate());
query_options->AddWhere(QStringLiteral("samplerate"), item->metadata.samplerate());
break;
case GroupBy::Bitdepth:
query_options->AddWhere("bitdepth", item->metadata.bitdepth());
query_options->AddWhere(QStringLiteral("bitdepth"), item->metadata.bitdepth());
break;
case GroupBy::Bitrate:
query_options->AddWhere("bitrate", item->metadata.bitrate());
query_options->AddWhere(QStringLiteral("bitrate"), item->metadata.bitrate());
break;
case GroupBy::None:
case GroupBy::GroupByCount:
@@ -1745,12 +1745,12 @@ QString CollectionModel::PrettyDisc(const int disc) {
QString CollectionModel::SortText(QString text) {
if (text.isEmpty()) {
text = " unknown";
text = QStringLiteral(" unknown");
}
else {
text = text.toLower();
}
text = text.remove(QRegularExpression("[^\\w ]", QRegularExpression::UseUnicodePropertiesOption));
text = text.remove(QRegularExpression(QStringLiteral("[^\\w ]"), QRegularExpression::UseUnicodePropertiesOption));
return text;
@@ -1776,27 +1776,27 @@ QString CollectionModel::SortTextForArtist(QString artist, const bool skip_artic
QString CollectionModel::SortTextForNumber(const int number) {
return QString("%1").arg(number, 4, 10, QChar('0'));
return QStringLiteral("%1").arg(number, 4, 10, QChar('0'));
}
QString CollectionModel::SortTextForYear(const int year) {
QString str = QString::number(year);
return QString("0").repeated(qMax(0, 4 - str.length())) + str;
return QStringLiteral("0").repeated(qMax(0, 4 - str.length())) + str;
}
QString CollectionModel::SortTextForBitrate(const int bitrate) {
QString str = QString::number(bitrate);
return QString("0").repeated(qMax(0, 3 - str.length())) + str;
return QStringLiteral("0").repeated(qMax(0, 3 - str.length())) + str;
}
QString CollectionModel::SortTextForSong(const Song &song) {
QString ret = QString::number(std::max(0, song.disc()) * 1000 + std::max(0, song.track()));
ret.prepend(QString("0").repeated(6 - ret.length()));
ret.prepend(QStringLiteral("0").repeated(6 - ret.length()));
ret.append(song.url().toString());
return ret;
@@ -1818,7 +1818,7 @@ Qt::ItemFlags CollectionModel::flags(const QModelIndex &idx) const {
}
QStringList CollectionModel::mimeTypes() const {
return QStringList() << "text/uri-list";
return QStringList() << QStringLiteral("text/uri-list");
}
QMimeData *CollectionModel::mimeData(const QModelIndexList &indexes) const {

70
src/collection/collectionquery.cpp
View File

@@ -54,9 +54,9 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
// 3) Remove colons which don't correspond to column names.
// Split on whitespace
QString filter_text = filter_options.filter_text().replace(QRegularExpression(":\\s+"), ":");
QString filter_text = filter_options.filter_text().replace(QRegularExpression(QStringLiteral(":\\s+")), QStringLiteral(":"));
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
QStringList tokens(filter_text.split(QRegularExpression("\\s+"), Qt::SkipEmptyParts));
QStringList tokens(filter_text.split(QRegularExpression(QStringLiteral("\\s+")), Qt::SkipEmptyParts));
#else
QStringList tokens(filter_text.split(QRegularExpression("\\s+"), QString::SkipEmptyParts));
#endif
@@ -69,7 +69,7 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
if (token.contains(':')) {
const QString columntoken = token.section(':', 0, 0);
QString subtoken = token.section(':', 1, -1).replace(":", " ").trimmed();
QString subtoken = token.section(':', 1, -1).replace(QLatin1String(":"), QLatin1String(" ")).trimmed();
if (subtoken.isEmpty()) continue;
if (Song::kFtsColumns.contains("fts" + columntoken, Qt::CaseInsensitive)) {
if (!query.isEmpty()) query.append(" ");
@@ -77,10 +77,10 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
}
else if (Song::kNumericalColumns.contains(columntoken, Qt::CaseInsensitive)) {
QString comparator = RemoveSqlOperator(subtoken);
if (columntoken.compare("rating", Qt::CaseInsensitive) == 0) {
if (columntoken.compare(QLatin1String("rating"), Qt::CaseInsensitive) == 0) {
AddWhereRating(subtoken, comparator);
}
else if (columntoken.compare("length", Qt::CaseInsensitive) == 0) {
else if (columntoken.compare(QLatin1String("length"), Qt::CaseInsensitive) == 0) {
// Time is saved in nanoseconds, so add 9 0's
QString parsedTime = QString::number(Utilities::ParseSearchTime(subtoken)) + "000000000";
AddWhere(columntoken, parsedTime, comparator);
@@ -91,7 +91,7 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
}
// Not a valid filter, remove
else {
token = token.replace(":", " ").trimmed();
token = token.replace(QLatin1String(":"), QLatin1String(" ")).trimmed();
if (!token.isEmpty()) {
if (!query.isEmpty()) query.append(" ");
query += "\"" + token + "\"*";
@@ -104,7 +104,7 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
}
}
if (!query.isEmpty()) {
where_clauses_ << "fts.%fts_table_noprefix MATCH ?";
where_clauses_ << QStringLiteral("fts.%fts_table_noprefix MATCH ?");
bound_values_ << query;
join_with_fts_ = true;
}
@@ -113,7 +113,7 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
if (filter_options.max_age() != -1) {
qint64 cutoff = QDateTime::currentDateTime().toSecsSinceEpoch() - filter_options.max_age();
where_clauses_ << "ctime > ?";
where_clauses_ << QStringLiteral("ctime > ?");
bound_values_ << cutoff;
}
@@ -126,15 +126,15 @@ CollectionQuery::CollectionQuery(const QSqlDatabase &db, const QString &songs_ta
duplicates_only_ = filter_options.filter_mode() == CollectionFilterOptions::FilterMode::Duplicates;
if (filter_options.filter_mode() == CollectionFilterOptions::FilterMode::Untagged) {
where_clauses_ << "(artist = '' OR album = '' OR title ='')";
where_clauses_ << QStringLiteral("(artist = '' OR album = '' OR title ='')");
}
}
QString CollectionQuery::RemoveSqlOperator(QString &token) {
QString op = "=";
static QRegularExpression rxOp("^(=|<[>=]?|>=?|!=)");
QString op = QStringLiteral("=");
static QRegularExpression rxOp(QStringLiteral("^(=|<[>=]?|>=?|!=)"));
QRegularExpressionMatch match = rxOp.match(token);
if (match.hasMatch()) {
op = match.captured(0);
@@ -142,7 +142,7 @@ QString CollectionQuery::RemoveSqlOperator(QString &token) {
token.remove(rxOp);
if (op == "!=") {
op = "<>";
op = QStringLiteral("<>");
}
return op;
@@ -152,16 +152,16 @@ QString CollectionQuery::RemoveSqlOperator(QString &token) {
void CollectionQuery::AddWhere(const QString &column, const QVariant &value, const QString &op) {
// Ignore 'literal' for IN
if (op.compare("IN", Qt::CaseInsensitive) == 0) {
if (op.compare(QLatin1String("IN"), Qt::CaseInsensitive) == 0) {
QStringList values = value.toStringList();
QStringList final_values;
final_values.reserve(values.count());
for (const QString &single_value : values) {
final_values.append("?");
final_values.append(QStringLiteral("?"));
bound_values_ << single_value;
}
where_clauses_ << QString("%1 IN (" + final_values.join(",") + ")").arg(column);
where_clauses_ << QString("%1 IN (" + final_values.join(QStringLiteral(",")) + ")").arg(column);
}
else {
// Do integers inline - sqlite seems to get confused when you pass integers to bound parameters
@@ -170,7 +170,7 @@ void CollectionQuery::AddWhere(const QString &column, const QVariant &value, con
#else
if (value.type() == QVariant::Int) {
#endif
where_clauses_ << QString("%1 %2 %3").arg(column, op, value.toString());
where_clauses_ << QStringLiteral("%1 %2 %3").arg(column, op, value.toString());
}
else if (
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
@@ -179,11 +179,11 @@ void CollectionQuery::AddWhere(const QString &column, const QVariant &value, con
value.type() == QVariant::String
#endif
&& value.toString().isNull()) {
where_clauses_ << QString("%1 %2 ?").arg(column, op);
bound_values_ << QString("");
where_clauses_ << QStringLiteral("%1 %2 ?").arg(column, op);
bound_values_ << QLatin1String("");
}
else {
where_clauses_ << QString("%1 %2 ?").arg(column, op);
where_clauses_ << QStringLiteral("%1 %2 ?").arg(column, op);
bound_values_ << value;
}
}
@@ -192,7 +192,7 @@ void CollectionQuery::AddWhere(const QString &column, const QVariant &value, con
void CollectionQuery::AddWhereArtist(const QVariant &value) {
where_clauses_ << QString("((artist = ? AND albumartist = '') OR albumartist = ?)");
where_clauses_ << QStringLiteral("((artist = ? AND albumartist = '') OR albumartist = ?)");
bound_values_ << value;
bound_values_ << value;
@@ -206,25 +206,25 @@ void CollectionQuery::AddWhereRating(const QVariant &value, const QString &op) {
// So we have to use a certain tolerance, so that the searched value is definetly included.
const float tolerance = 0.001F;
if (op == "<") {
AddWhere("rating", parsed_rating-tolerance, "<");
AddWhere(QStringLiteral("rating"), parsed_rating-tolerance, QStringLiteral("<"));
}
else if (op == ">") {
AddWhere("rating", parsed_rating+tolerance, ">");
AddWhere(QStringLiteral("rating"), parsed_rating+tolerance, QStringLiteral(">"));
}
else if (op == "<=") {
AddWhere("rating", parsed_rating+tolerance, "<=");
AddWhere(QStringLiteral("rating"), parsed_rating+tolerance, QStringLiteral("<="));
}
else if (op == ">=") {
AddWhere("rating", parsed_rating-tolerance, ">=");
AddWhere(QStringLiteral("rating"), parsed_rating-tolerance, QStringLiteral(">="));
}
else if (op == "<>") {
where_clauses_ << QString("(rating<? OR rating>?)");
where_clauses_ << QStringLiteral("(rating<? OR rating>?)");
bound_values_ << parsed_rating - tolerance;
bound_values_ << parsed_rating + tolerance;
}
else /* (op == "=") */ {
AddWhere("rating", parsed_rating+tolerance, "<");
AddWhere("rating", parsed_rating-tolerance, ">");
AddWhere(QStringLiteral("rating"), parsed_rating+tolerance, QStringLiteral("<"));
AddWhere(QStringLiteral("rating"), parsed_rating-tolerance, QStringLiteral(">"));
}
}
@@ -233,7 +233,7 @@ void CollectionQuery::AddCompilationRequirement(const bool compilation) {
// The unary + is added to prevent sqlite from using the index idx_comp_artist.
// When joining with fts, sqlite 3.8 has a tendency to use this index and thereby nesting the tables in an order which gives very poor performance
where_clauses_ << QString("+compilation_effective = %1").arg(compilation ? 1 : 0);
where_clauses_ << QStringLiteral("+compilation_effective = %1").arg(compilation ? 1 : 0);
}
@@ -251,26 +251,26 @@ bool CollectionQuery::Exec() {
QString sql;
if (join_with_fts_) {
sql = QString("SELECT %1 FROM %2 INNER JOIN %3 AS fts ON %2.ROWID = fts.ROWID").arg(column_spec_, songs_table_, fts_table_);
sql = QStringLiteral("SELECT %1 FROM %2 INNER JOIN %3 AS fts ON %2.ROWID = fts.ROWID").arg(column_spec_, songs_table_, fts_table_);
}
else {
sql = QString("SELECT %1 FROM %2 %3").arg(column_spec_, songs_table_, GetInnerQuery());
sql = QStringLiteral("SELECT %1 FROM %2 %3").arg(column_spec_, songs_table_, GetInnerQuery());
}
QStringList where_clauses(where_clauses_);
if (!include_unavailable_) {
where_clauses << "unavailable = 0";
where_clauses << QStringLiteral("unavailable = 0");
}
if (!where_clauses.isEmpty()) sql += " WHERE " + where_clauses.join(" AND ");
if (!where_clauses.isEmpty()) sql += " WHERE " + where_clauses.join(QStringLiteral(" AND "));
if (!order_by_.isEmpty()) sql += " ORDER BY " + order_by_;
if (limit_ != -1) sql += " LIMIT " + QString::number(limit_);
sql.replace("%songs_table", songs_table_);
sql.replace("%fts_table_noprefix", fts_table_.section('.', -1, -1));
sql.replace("%fts_table", fts_table_);
sql.replace(QLatin1String("%songs_table"), songs_table_);
sql.replace(QLatin1String("%fts_table_noprefix"), fts_table_.section('.', -1, -1));
sql.replace(QLatin1String("%fts_table"), fts_table_);
if (!QSqlQuery::prepare(sql)) return false;

4
src/collection/collectionquery.h
View File

@@ -67,9 +67,9 @@ class CollectionQuery : public QSqlQuery {
QString RemoveSqlOperator(QString &token);
// Adds a fragment of WHERE clause. When executed, this Query will connect all the fragments with AND operator.
// Please note that IN operator expects a QStringList as value.
void AddWhere(const QString &column, const QVariant &value, const QString &op = "=");
void AddWhere(const QString &column, const QVariant &value, const QString &op = QStringLiteral("="));
void AddWhereArtist(const QVariant &value);
void AddWhereRating(const QVariant &value, const QString &op = "=");
void AddWhereRating(const QVariant &value, const QString &op = QStringLiteral("="));
void SetBoundValues(const QVariantList &bound_values) { bound_values_ = bound_values; }
void SetDuplicatesOnly(const bool duplicates_only) { duplicates_only_ = duplicates_only; }

2
src/collection/collectionqueryoptions.h
View File

@@ -51,7 +51,7 @@ class CollectionQueryOptions {
void set_query_have_compilations(const bool query_have_compilations) { query_have_compilations_ = query_have_compilations; }
QList<Where> where_clauses() const { return where_clauses_; }
void AddWhere(const QString &column, const QVariant &value, const QString &op = "=");
void AddWhere(const QString &column, const QVariant &value, const QString &op = QStringLiteral("="));
private:
QString column_spec_;

60
src/collection/collectionview.cpp
View File

@@ -80,7 +80,7 @@ CollectionView::CollectionView(QWidget *parent)
total_song_count_(-1),
total_artist_count_(-1),
total_album_count_(-1),
nomusic_(":/pictures/nomusic.png"),
nomusic_(QStringLiteral(":/pictures/nomusic.png")),
context_menu_(nullptr),
action_load_(nullptr),
action_add_to_playlist_(nullptr),
@@ -109,7 +109,7 @@ CollectionView::CollectionView(QWidget *parent)
setDragDropMode(QAbstractItemView::DragOnly);
setSelectionMode(QAbstractItemView::ExtendedSelection);
setStyleSheet("QTreeView::item{padding-top:1px;}");
setStyleSheet(QStringLiteral("QTreeView::item{padding-top:1px;}"));
}
@@ -364,29 +364,29 @@ void CollectionView::contextMenuEvent(QContextMenuEvent *e) {
if (!context_menu_) {
context_menu_ = new QMenu(this);
action_add_to_playlist_ = context_menu_->addAction(IconLoader::Load("media-playback-start"), tr("Append to current playlist"), this, &CollectionView::AddToPlaylist);
action_load_ = context_menu_->addAction(IconLoader::Load("media-playback-start"), tr("Replace current playlist"), this, &CollectionView::Load);
action_open_in_new_playlist_ = context_menu_->addAction(IconLoader::Load("document-new"), tr("Open in new playlist"), this, &CollectionView::OpenInNewPlaylist);
action_add_to_playlist_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("media-playback-start")), tr("Append to current playlist"), this, &CollectionView::AddToPlaylist);
action_load_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("media-playback-start")), tr("Replace current playlist"), this, &CollectionView::Load);
action_open_in_new_playlist_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("document-new")), tr("Open in new playlist"), this, &CollectionView::OpenInNewPlaylist);
context_menu_->addSeparator();
action_add_to_playlist_enqueue_ = context_menu_->addAction(IconLoader::Load("go-next"), tr("Queue track"), this, &CollectionView::AddToPlaylistEnqueue);
action_add_to_playlist_enqueue_next_ = context_menu_->addAction(IconLoader::Load("go-next"), tr("Queue to play next"), this, &CollectionView::AddToPlaylistEnqueueNext);
action_add_to_playlist_enqueue_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("go-next")), tr("Queue track"), this, &CollectionView::AddToPlaylistEnqueue);
action_add_to_playlist_enqueue_next_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("go-next")), tr("Queue to play next"), this, &CollectionView::AddToPlaylistEnqueueNext);
context_menu_->addSeparator();
action_search_for_this_ = context_menu_->addAction(IconLoader::Load("edit-find"), tr("Search for this"), this, &CollectionView::SearchForThis);
action_search_for_this_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("edit-find")), tr("Search for this"), this, &CollectionView::SearchForThis);
context_menu_->addSeparator();
action_organize_ = context_menu_->addAction(IconLoader::Load("edit-copy"), tr("Organize files..."), this, &CollectionView::Organize);
action_organize_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("edit-copy")), tr("Organize files..."), this, &CollectionView::Organize);
#ifndef Q_OS_WIN
action_copy_to_device_ = context_menu_->addAction(IconLoader::Load("device"), tr("Copy to device..."), this, &CollectionView::CopyToDevice);
action_copy_to_device_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("device")), tr("Copy to device..."), this, &CollectionView::CopyToDevice);
#endif
action_delete_files_ = context_menu_->addAction(IconLoader::Load("edit-delete"), tr("Delete from disk..."), this, &CollectionView::Delete);
action_delete_files_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("edit-delete")), tr("Delete from disk..."), this, &CollectionView::Delete);
context_menu_->addSeparator();
action_edit_track_ = context_menu_->addAction(IconLoader::Load("edit-rename"), tr("Edit track information..."), this, &CollectionView::EditTracks);
action_edit_tracks_ = context_menu_->addAction(IconLoader::Load("edit-rename"), tr("Edit tracks information..."), this, &CollectionView::EditTracks);
action_show_in_browser_ = context_menu_->addAction(IconLoader::Load("document-open-folder"), tr("Show in file browser..."), this, &CollectionView::ShowInBrowser);
action_edit_track_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("edit-rename")), tr("Edit track information..."), this, &CollectionView::EditTracks);
action_edit_tracks_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("edit-rename")), tr("Edit tracks information..."), this, &CollectionView::EditTracks);
action_show_in_browser_ = context_menu_->addAction(IconLoader::Load(QStringLiteral("document-open-folder")), tr("Show in file browser..."), this, &CollectionView::ShowInBrowser);
context_menu_->addSeparator();
@@ -582,7 +582,7 @@ void CollectionView::SearchForThis() {
if (!songs.isEmpty()) {
last_selected_song_ = songs.last();
}
search = QString("title:%1").arg(last_selected_song_.title());
search = QStringLiteral("title:%1").arg(last_selected_song_.title());
break;
}
@@ -598,53 +598,53 @@ void CollectionView::SearchForThis() {
switch (container_group_by) {
case CollectionModel::GroupBy::AlbumArtist:
search = QString("albumartist:%1").arg(item->metadata.effective_albumartist());
search = QStringLiteral("albumartist:%1").arg(item->metadata.effective_albumartist());
break;
case CollectionModel::GroupBy::Artist:
search = QString("artist:%1").arg(item->metadata.artist());
search = QStringLiteral("artist:%1").arg(item->metadata.artist());
break;
case CollectionModel::GroupBy::Album:
search = QString("album:%1").arg(item->metadata.album());
search = QStringLiteral("album:%1").arg(item->metadata.album());
break;
case CollectionModel::GroupBy::AlbumDisc:
search = QString("album:%1").arg(item->metadata.album());
search = QStringLiteral("album:%1").arg(item->metadata.album());
break;
case CollectionModel::GroupBy::YearAlbum:
case CollectionModel::GroupBy::YearAlbumDisc:{
search = QString("year:%1 album:%2").arg(item->metadata.year()).arg(item->metadata.album());
search = QStringLiteral("year:%1 album:%2").arg(item->metadata.year()).arg(item->metadata.album());
break;
}
case CollectionModel::GroupBy::OriginalYearAlbum:
case CollectionModel::GroupBy::OriginalYearAlbumDisc:{
search = QString("year:%1 album:%2").arg(item->metadata.effective_originalyear()).arg(item->metadata.album());
search = QStringLiteral("year:%1 album:%2").arg(item->metadata.effective_originalyear()).arg(item->metadata.album());
break;
}
case CollectionModel::GroupBy::Year:
search = QString("year:%1").arg(item->metadata.year());
search = QStringLiteral("year:%1").arg(item->metadata.year());
break;
case CollectionModel::GroupBy::OriginalYear:
search = QString("year:%1").arg(item->metadata.effective_originalyear());
search = QStringLiteral("year:%1").arg(item->metadata.effective_originalyear());
break;
case CollectionModel::GroupBy::Genre:
search = QString("genre:%1").arg(item->metadata.genre());
search = QStringLiteral("genre:%1").arg(item->metadata.genre());
break;
case CollectionModel::GroupBy::Composer:
search = QString("composer:%1").arg(item->metadata.composer());
search = QStringLiteral("composer:%1").arg(item->metadata.composer());
break;
case CollectionModel::GroupBy::Performer:
search = QString("performer:%1").arg(item->metadata.performer());
search = QStringLiteral("performer:%1").arg(item->metadata.performer());
break;
case CollectionModel::GroupBy::Grouping:
search = QString("grouping:%1").arg(item->metadata.grouping());
search = QStringLiteral("grouping:%1").arg(item->metadata.grouping());
break;
case CollectionModel::GroupBy::Samplerate:
search = QString("samplerate:%1").arg(item->metadata.samplerate());
search = QStringLiteral("samplerate:%1").arg(item->metadata.samplerate());
break;
case CollectionModel::GroupBy::Bitdepth:
search = QString("bitdepth:%1").arg(item->metadata.bitdepth());
search = QStringLiteral("bitdepth:%1").arg(item->metadata.bitdepth());
break;
case CollectionModel::GroupBy::Bitrate:
search = QString("bitrate:%1").arg(item->metadata.bitrate());
search = QStringLiteral("bitrate:%1").arg(item->metadata.bitrate());
break;
default:
search = model()->data(current, Qt::DisplayRole).toString();

32
src/collection/collectionwatcher.cpp
View File

@@ -70,8 +70,8 @@
using namespace std::chrono_literals;
QStringList CollectionWatcher::sValidImages = QStringList() << "jpg" << "png" << "gif" << "jpeg";
QStringList CollectionWatcher::kIgnoredExtensions = QStringList() << "tmp" << "tar" << "gz" << "bz2" << "xz" << "tbz" << "tgz" << "z" << "zip" << "rar";
QStringList CollectionWatcher::sValidImages = QStringList() << QStringLiteral("jpg") << QStringLiteral("png") << QStringLiteral("gif") << QStringLiteral("jpeg");
QStringList CollectionWatcher::kIgnoredExtensions = QStringList() << QStringLiteral("tmp") << QStringLiteral("tar") << QStringLiteral("gz") << QStringLiteral("bz2") << QStringLiteral("xz") << QStringLiteral("tbz") << QStringLiteral("tgz") << QStringLiteral("z") << QStringLiteral("zip") << QStringLiteral("rar");
CollectionWatcher::CollectionWatcher(Song::Source source, QObject *parent)
: QObject(parent),
@@ -154,7 +154,7 @@ void CollectionWatcher::ReloadSettings() {
s.beginGroup(CollectionSettingsPage::kSettingsGroup);
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();
QStringList filters = s.value("cover_art_patterns", QStringList() << QStringLiteral("front") << QStringLiteral("cover")).toStringList();
if (source_ == Song::Source::Collection) {
song_tracking_ = s.value("song_tracking", false).toBool();
song_ebur128_loudness_analysis_ = s.value("song_ebur128_loudness_analysis", false).toBool();
@@ -612,7 +612,7 @@ void CollectionWatcher::ScanSubdirectory(const QString &path, const CollectionSu
Chromaprinter chromaprinter(file);
fingerprint = chromaprinter.CreateFingerprint();
if (fingerprint.isEmpty()) {
fingerprint = "NONE";
fingerprint = QStringLiteral("NONE");
}
}
#endif
@@ -639,7 +639,7 @@ void CollectionWatcher::ScanSubdirectory(const QString &path, const CollectionSu
Chromaprinter chromaprinter(file);
fingerprint = chromaprinter.CreateFingerprint();
if (fingerprint.isEmpty()) {
fingerprint = "NONE";
fingerprint = QStringLiteral("NONE");
}
}
#endif
@@ -892,50 +892,50 @@ void CollectionWatcher::AddChangedSong(const QString &file, const Song &matching
}
else {
if (matching_song.url() != new_song.url()) {
changes << "file path";
changes << QStringLiteral("file path");
notify_new = true;
}
if (matching_song.fingerprint() != new_song.fingerprint()) {
changes << "fingerprint";
changes << QStringLiteral("fingerprint");
notify_new = true;
}
if (!matching_song.IsMetadataEqual(new_song)) {
changes << "metadata";
changes << QStringLiteral("metadata");
notify_new = true;
}
if (!matching_song.IsPlayStatisticsEqual(new_song)) {
changes << "play statistics";
changes << QStringLiteral("play statistics");
notify_new = true;
}
if (!matching_song.IsRatingEqual(new_song)) {
changes << "rating";
changes << QStringLiteral("rating");
notify_new = true;
}
if (!matching_song.IsArtEqual(new_song)) {
changes << "album art";
changes << QStringLiteral("album art");
notify_new = true;
}
if (!matching_song.IsAcoustIdEqual(new_song)) {
changes << "acoustid";
changes << QStringLiteral("acoustid");
notify_new = true;
}
if (!matching_song.IsMusicBrainzEqual(new_song)) {
changes << "musicbrainz";
changes << QStringLiteral("musicbrainz");
notify_new = true;
}
if (!matching_song.IsEBUR128Equal(new_song)) {
changes << "ebur128 loudness characteristics";
changes << QStringLiteral("ebur128 loudness characteristics");
notify_new = true;
}
if (matching_song.mtime() != new_song.mtime()) {
changes << "mtime";
changes << QStringLiteral("mtime");
}
if (changes.isEmpty()) {
qLog(Debug) << "Song" << file << "unchanged.";
}
else {
qLog(Debug) << "Song" << file << changes.join(", ") << "changed.";
qLog(Debug) << "Song" << file << changes.join(QStringLiteral(", ")) << "changed.";
}
}

4
src/collection/collectionwatcher.h
View File

@@ -252,11 +252,11 @@ class CollectionWatcher : public QObject {
};
inline QString CollectionWatcher::NoExtensionPart(const QString &fileName) {
return fileName.contains('.') ? fileName.section('.', 0, -2) : "";
return fileName.contains('.') ? fileName.section('.', 0, -2) : QLatin1String("");
}
// Thanks Amarok
inline QString CollectionWatcher::ExtensionPart(const QString &fileName) {
return fileName.contains( '.' ) ? fileName.mid( fileName.lastIndexOf('.') + 1 ).toLower() : "";
return fileName.contains( '.' ) ? fileName.mid( fileName.lastIndexOf('.') + 1 ).toLower() : QLatin1String("");
}
inline QString CollectionWatcher::DirectoryPart(const QString &fileName) {
return fileName.section('/', 0, -2);

2
src/collection/savedgroupingmanager.cpp
View File

@@ -56,7 +56,7 @@ SavedGroupingManager::SavedGroupingManager(const QString &saved_groupings_settin
model_->setHorizontalHeaderItem(2, new QStandardItem(tr("Second Level")));
model_->setHorizontalHeaderItem(3, new QStandardItem(tr("Third Level")));
ui_->list->setModel(model_);
ui_->remove->setIcon(IconLoader::Load("edit-delete"));
ui_->remove->setIcon(IconLoader::Load(QStringLiteral("edit-delete")));
ui_->remove->setEnabled(false);
ui_->remove->setShortcut(QKeySequence::Delete);