diff --git a/src/databaseinterface.h b/src/databaseinterface.h index f9a49247..e755d422 100644 --- a/src/databaseinterface.h +++ b/src/databaseinterface.h @@ -1,447 +1,448 @@ /* * Copyright 2016-2017 Matthieu Gallien * * This program is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see . */ #ifndef DATABASEINTERFACE_H #define DATABASEINTERFACE_H #include "elisaLib_export.h" #include "datatype.h" #include "elisautils.h" #include "musicalbum.h" #include "musicaudiotrack.h" #include "musicaudiogenre.h" #include #include #include #include #include #include #include #include #include class DatabaseInterfacePrivate; class QMutex; class QSqlRecord; class QSqlQuery; class ELISALIB_EXPORT DatabaseInterface : public QObject { Q_OBJECT public: enum ColumnsRoles { TitleRole = Qt::UserRole + 1, SecondaryTextRole, ImageUrlRole, ShadowForImageRole, ChildModelRole, DurationRole, + StringDurationRole, MilliSecondsDurationRole, ArtistRole, AllArtistsRole, HighestTrackRating, AlbumRole, AlbumArtistRole, TrackNumberRole, DiscNumberRole, RatingRole, GenreRole, LyricistRole, ComposerRole, CommentRole, YearRole, ChannelsRole, BitRateRole, SampleRateRole, ResourceRole, IdRole, DatabaseIdRole, IsSingleDiscAlbumRole, ContainerDataRole, IsPartialDataRole, AlbumIdRole, }; Q_ENUM(ColumnsRoles) private: using DataType = QMap; public: class TrackDataType : public DataType { public: using DataType::DataType; qulonglong databaseId() const { return operator[](key_type::DatabaseIdRole).toULongLong(); } QString title() const { return operator[](key_type::TitleRole).toString(); } QString artist() const { return operator[](key_type::ArtistRole).toString(); } QString album() const { return operator[](key_type::AlbumRole).toString(); } QString albumArtist() const { return operator[](key_type::AlbumArtistRole).toString(); } int trackNumber() const { return operator[](key_type::TrackNumberRole).toInt(); } int discNumber() const { return operator[](key_type::DiscNumberRole).toInt(); } int duration() const { return operator[](key_type::DurationRole).toInt(); } QUrl resourceURI() const { return operator[](key_type::ResourceRole).toUrl(); } }; using ListTrackDataType = QList; class AlbumDataType : public DataType { public: using DataType::DataType; qulonglong databaseId() const { return operator[](key_type::DatabaseIdRole).toULongLong(); } }; using ListAlbumDataType = QList; class ArtistDataType : public DataType { public: using DataType::DataType; qulonglong databaseId() const { return operator[](key_type::DatabaseIdRole).toULongLong(); } }; using ListArtistDataType = QList; class GenreDataType : public DataType { public: using DataType::DataType; qulonglong databaseId() const { return operator[](key_type::DatabaseIdRole).toULongLong(); } }; using ListGenreDataType = QList; enum PropertyType { DatabaseId, DisplayRole, SecondaryRole, }; Q_ENUM(PropertyType) enum AlbumDiscsCount { SingleDiscAlbum, MultipleDiscsAlbum, }; Q_ENUM(AlbumDiscsCount) explicit DatabaseInterface(QObject *parent = nullptr); ~DatabaseInterface() override; Q_INVOKABLE void init(const QString &dbName, const QString &databaseFileName = {}); MusicAlbum albumFromTitleAndArtist(const QString &title, const QString &artist); ListTrackDataType allTracksData(); ListAlbumDataType allAlbumsData(); ListTrackDataType albumData(qulonglong databaseId); ListArtistDataType allArtistsData(); ListGenreDataType allGenresData(); DataType oneData(ElisaUtils::PlayListEntryType aType, qulonglong databaseId); QList allTracks(); QList allTracksFromSource(const QString &musicSource); QList allAlbums(); QList allGenres(); ListTrackDataType tracksDataFromAuthor(const QString &artistName); TrackDataType trackDataFromDatabaseId(qulonglong id); MusicAudioTrack trackFromDatabaseId(qulonglong id); qulonglong trackIdFromTitleAlbumTrackDiscNumber(const QString &title, const QString &artist, const QString &album, int trackNumber, int discNumber); qulonglong trackIdFromFileName(const QUrl &fileName); void applicationAboutToQuit(); Q_SIGNALS: void artistsAdded(const ListArtistDataType &newArtists); void composersAdded(const ListArtistDataType &newComposers); void lyricistsAdded(const ListArtistDataType &newLyricists); void albumsAdded(const ListAlbumDataType &newAlbums); void tracksAdded(const ListTrackDataType &allTracks); void genresAdded(const ListGenreDataType &allGenres); void artistRemoved(qulonglong removedArtistId); void albumRemoved(qulonglong removedAlbumId); void trackRemoved(qulonglong id); void albumModified(const AlbumDataType &modifiedAlbum, qulonglong modifiedAlbumId); void trackModified(const TrackDataType &modifiedTrack); void sentAlbumData(const MusicAlbum albumData); void requestsInitDone(); void databaseError(); void restoredTracks(const QString &musicSource, QHash allFiles); public Q_SLOTS: void insertTracksList(const QList &tracks, const QHash &covers, const QString &musicSource); void removeTracksList(const QList &removedTracks); void modifyTracksList(const QList &modifiedTracks, const QHash &covers, const QString &musicSource); void removeAllTracksFromSource(const QString &sourceName); void getAlbumFromAlbumId(qulonglong id); void askRestoredTracks(const QString &musicSource); private: enum class TrackFileInsertType { NewTrackFileInsert, ModifiedTrackFileInsert, }; void initChangesTrackers(); void recordModifiedTrack(qulonglong trackId); void recordModifiedAlbum(qulonglong albumId); bool startTransaction() const; bool finishTransaction() const; bool rollBackTransaction() const; QList fetchTracks(qulonglong albumId); QList fetchTrackIds(qulonglong albumId); MusicAlbum internalAlbumFromId(qulonglong albumId); MusicAlbum internalAlbumFromTitleAndArtist(const QString &title, const QString &artist); qulonglong internalAlbumIdFromTitleAndArtist(const QString &title, const QString &artist); MusicAudioTrack internalTrackFromDatabaseId(qulonglong id); qulonglong internalTrackIdFromTitleAlbumTracDiscNumber(const QString &title, const QString &artist, const QString &album, int trackNumber, int discNumber); qulonglong getDuplicateTrackIdFromTitleAlbumTrackDiscNumber(const QString &title, const QString &album, const QString &albumArtist, const QString &trackPath, int trackNumber, int discNumber); qulonglong internalTrackIdFromFileName(const QUrl &fileName); ListTrackDataType internalTracksFromAuthor(const QString &artistName); QList internalAlbumIdsFromAuthor(const QString &artistName); void initDatabase(); void initRequest(); qulonglong insertAlbum(const QString &title, const QString &albumArtist, const QString &trackArtist, const QString &trackPath, const QUrl &albumArtURI); bool updateAlbumFromId(qulonglong albumId, const QUrl &albumArtUri, const MusicAudioTrack ¤tTrack, const QString &albumPath); qulonglong insertArtist(const QString &name); qulonglong internalArtistIdFromName(const QString &name); qulonglong insertGenre(const QString &name); MusicAudioGenre internalGenreFromId(qulonglong genreId); void removeTrackInDatabase(qulonglong trackId); void updateTrackInDatabase(const MusicAudioTrack &oneTrack, const QString &albumPath); void removeAlbumInDatabase(qulonglong albumId); void removeArtistInDatabase(qulonglong artistId); void reloadExistingDatabase(); qulonglong initialId(DataUtils::DataType aType); qulonglong genericInitialId(QSqlQuery &request); qulonglong insertMusicSource(const QString &name); void insertTrackOrigin(const QUrl &fileNameURI, const QDateTime &fileModifiedTime, qulonglong discoverId); void updateTrackOrigin(qulonglong trackId, const QUrl &fileName, const QDateTime &fileModifiedTime); int computeTrackPriority(qulonglong trackId, const QUrl &fileName); qulonglong internalInsertTrack(const MusicAudioTrack &oneModifiedTrack, const QHash &covers, qulonglong originTrackId, TrackFileInsertType insertType); MusicAudioTrack buildTrackFromDatabaseRecord(const QSqlRecord &trackRecord) const; TrackDataType buildTrackDataFromDatabaseRecord(const QSqlRecord &trackRecord) const; void internalRemoveTracksList(const QList &removedTracks); void internalRemoveTracksList(const QHash &removedTracks, qulonglong sourceId); void internalRemoveTracksWithoutMapping(); QUrl internalAlbumArtUriFromAlbumId(qulonglong albumId); bool isValidArtist(qulonglong albumId); qulonglong insertComposer(const QString &name); qulonglong insertLyricist(const QString &name); qulonglong internalSourceIdFromName(const QString &sourceName); QHash internalAllFileNameFromSource(qulonglong sourceId); bool internalGenericPartialData(QSqlQuery &query); ListArtistDataType internalAllArtistsPartialData(); ArtistDataType internalOneArtistPartialData(qulonglong databaseId); ListAlbumDataType internalAllAlbumsPartialData(); AlbumDataType internalOneAlbumPartialData(qulonglong databaseId); ListTrackDataType internalAllTracksPartialData(); TrackDataType internalOneTrackPartialData(qulonglong databaseId); ListGenreDataType internalAllGenresPartialData(); GenreDataType internalOneGenrePartialData(qulonglong databaseId); ListArtistDataType internalAllComposersPartialData(); ArtistDataType internalOneComposerPartialData(qulonglong databaseId); ListArtistDataType internalAllLyricistsPartialData(); ArtistDataType internalOneLyricistPartialData(qulonglong databaseId); bool prepareQuery(QSqlQuery &query, const QString &queryText) const; void updateAlbumArtist(qulonglong albumId, const QString &title, const QString &albumPath, const QString &artistName); std::unique_ptr d; }; Q_DECLARE_METATYPE(DatabaseInterface::TrackDataType) Q_DECLARE_METATYPE(DatabaseInterface::AlbumDataType) Q_DECLARE_METATYPE(DatabaseInterface::ArtistDataType) Q_DECLARE_METATYPE(DatabaseInterface::GenreDataType) Q_DECLARE_METATYPE(DatabaseInterface::ListTrackDataType) Q_DECLARE_METATYPE(DatabaseInterface::ListAlbumDataType) Q_DECLARE_METATYPE(DatabaseInterface::ListArtistDataType) Q_DECLARE_METATYPE(DatabaseInterface::ListGenreDataType) #endif // DATABASEINTERFACE_H diff --git a/src/mediaplaylist.cpp b/src/mediaplaylist.cpp index 419e4177..b46ca72c 100644 --- a/src/mediaplaylist.cpp +++ b/src/mediaplaylist.cpp @@ -1,1297 +1,1307 @@ /* * Copyright 2015-2017 Matthieu Gallien * * This program is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see . */ #include "mediaplaylist.h" #include "databaseinterface.h" #include "musicaudiotrack.h" #include "musiclistenersmanager.h" #include #include #include #include #include #include #include class MediaPlayListPrivate { public: QList mData; QList mTrackData; MusicListenersManager* mMusicListenersManager = nullptr; QPersistentModelIndex mCurrentTrack; QVariantMap mPersistentState; QMediaPlaylist mLoadPlaylist; int mCurrentPlayListPosition = 0; bool mRandomPlay = false; bool mRepeatPlay = false; }; MediaPlayList::MediaPlayList(QObject *parent) : QAbstractListModel(parent), d(new MediaPlayListPrivate) { connect(&d->mLoadPlaylist, &QMediaPlaylist::loaded, this, &MediaPlayList::loadPlayListLoaded); connect(&d->mLoadPlaylist, &QMediaPlaylist::loadFailed, this, &MediaPlayList::loadPlayListLoadFailed); auto currentMsecTime = QTime::currentTime().msec(); if (currentMsecTime != -1) { seedRandomGenerator(static_cast(currentMsecTime)); } } MediaPlayList::~MediaPlayList() = default; int MediaPlayList::rowCount(const QModelIndex &parent) const { if (parent.isValid()) { return 0; } return d->mData.size(); } QHash MediaPlayList::roleNames() const { auto roles = QAbstractItemModel::roleNames(); roles[static_cast(ColumnsRoles::IsValidRole)] = "isValid"; roles[static_cast(ColumnsRoles::TitleRole)] = "title"; - roles[static_cast(ColumnsRoles::DurationRole)] = "duration"; + roles[static_cast(ColumnsRoles::StringDurationRole)] = "duration"; roles[static_cast(ColumnsRoles::ArtistRole)] = "artist"; roles[static_cast(ColumnsRoles::AlbumArtistRole)] = "albumArtist"; roles[static_cast(ColumnsRoles::AlbumRole)] = "album"; roles[static_cast(ColumnsRoles::TrackNumberRole)] = "trackNumber"; roles[static_cast(ColumnsRoles::DiscNumberRole)] = "discNumber"; roles[static_cast(ColumnsRoles::RatingRole)] = "rating"; roles[static_cast(ColumnsRoles::GenreRole)] = "genre"; roles[static_cast(ColumnsRoles::LyricistRole)] = "lyricist"; roles[static_cast(ColumnsRoles::ComposerRole)] = "composer"; roles[static_cast(ColumnsRoles::CommentRole)] = "comment"; roles[static_cast(ColumnsRoles::YearRole)] = "year"; roles[static_cast(ColumnsRoles::ChannelsRole)] = "channels"; roles[static_cast(ColumnsRoles::BitRateRole)] = "bitRate"; roles[static_cast(ColumnsRoles::SampleRateRole)] = "sampleRate"; roles[static_cast(ColumnsRoles::CountRole)] = "count"; roles[static_cast(ColumnsRoles::IsPlayingRole)] = "isPlaying"; roles[static_cast(ColumnsRoles::HasAlbumHeader)] = "hasAlbumHeader"; roles[static_cast(ColumnsRoles::IsSingleDiscAlbumRole)] = "isSingleDiscAlbum"; roles[static_cast(ColumnsRoles::SecondaryTextRole)] = "secondaryText"; roles[static_cast(ColumnsRoles::ImageUrlRole)] = "imageUrl"; roles[static_cast(ColumnsRoles::ShadowForImageRole)] = "shadowForImage"; roles[static_cast(ColumnsRoles::ResourceRole)] = "trackResource"; roles[static_cast(ColumnsRoles::TrackDataRole)] = "trackData"; roles[static_cast(ColumnsRoles::AlbumIdRole)] = "albumId"; return roles; } QVariant MediaPlayList::data(const QModelIndex &index, int role) const { auto result = QVariant(); if (!index.isValid()) { return result; } if (index.row() < 0 || index.row() >= d->mData.size()) { return result; } if (d->mData[index.row()].mIsValid) { switch(role) { case ColumnsRoles::IsValidRole: result = d->mData[index.row()].mIsValid; break; case ColumnsRoles::HasAlbumHeader: result = rowHasHeader(index.row()); break; case ColumnsRoles::IsPlayingRole: result = d->mData[index.row()].mIsPlaying; break; + case ColumnsRoles::StringDurationRole: + { + QTime trackDuration = d->mTrackData[index.row()][static_cast(role)].toTime(); + if (trackDuration.hour() == 0) { + result = trackDuration.toString(QStringLiteral("mm:ss")); + } else { + result = trackDuration.toString(); + } + break; + } default: result = d->mTrackData[index.row()][static_cast(role)]; } } else { switch(role) { case ColumnsRoles::IsValidRole: result = d->mData[index.row()].mIsValid; break; case ColumnsRoles::TitleRole: result = d->mData[index.row()].mTitle; break; case ColumnsRoles::IsPlayingRole: result = d->mData[index.row()].mIsPlaying; break; case ColumnsRoles::ArtistRole: result = d->mData[index.row()].mArtist; break; case ColumnsRoles::AlbumArtistRole: result = d->mData[index.row()].mArtist; break; case ColumnsRoles::AlbumRole: result = d->mData[index.row()].mAlbum; break; case ColumnsRoles::TrackNumberRole: result = -1; break; case ColumnsRoles::HasAlbumHeader: result = rowHasHeader(index.row()); break; case ColumnsRoles::IsSingleDiscAlbumRole: result = false; break; case Qt::DisplayRole: result = d->mData[index.row()].mTitle; break; case ColumnsRoles::ImageUrlRole: result = QUrl(QStringLiteral("image://icon/error")); break; case ColumnsRoles::ShadowForImageRole: result = false; break; default: result = {}; } } return result; } bool MediaPlayList::setData(const QModelIndex &index, const QVariant &value, int role) { bool modelModified = false; if (!index.isValid()) { return modelModified; } if (index.row() < 0 || index.row() >= d->mData.size()) { return modelModified; } if (role < ColumnsRoles::IsValidRole || role > ColumnsRoles::HasAlbumHeader) { return modelModified; } auto convertedRole = static_cast(role); switch(convertedRole) { case ColumnsRoles::IsPlayingRole: { modelModified = true; auto newState = static_cast(value.toInt()); d->mData[index.row()].mIsPlaying = newState; Q_EMIT dataChanged(index, index, {role}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } break; } default: modelModified = false; } return modelModified; } bool MediaPlayList::removeRows(int row, int count, const QModelIndex &parent) { beginRemoveRows(parent, row, row + count - 1); bool hadAlbumHeader = false; if (rowCount() > row + count) { hadAlbumHeader = rowHasHeader(row + count); } for (int i = row, cpt = 0; cpt < count; ++i, ++cpt) { d->mData.removeAt(i); d->mTrackData.removeAt(i); } endRemoveRows(); if (!d->mCurrentTrack.isValid()) { d->mCurrentTrack = index(d->mCurrentPlayListPosition, 0); if (d->mCurrentTrack.isValid()) { notifyCurrentTrackChanged(); } if (!d->mCurrentTrack.isValid()) { Q_EMIT playListFinished(); resetCurrentTrack(); if (!d->mCurrentTrack.isValid()) { notifyCurrentTrackChanged(); } } } if (!d->mCurrentTrack.isValid() && rowCount(parent) <= row) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); if (hadAlbumHeader != rowHasHeader(row)) { Q_EMIT dataChanged(index(row, 0), index(row, 0), {ColumnsRoles::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } Q_EMIT persistentStateChanged(); return false; } bool MediaPlayList::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild) { if (sourceParent != destinationParent) { return false; } if (!beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1, destinationParent, destinationChild)) { return false; } auto firstMovedTrackHasHeader = rowHasHeader(sourceRow); auto nextTrackHasHeader = rowHasHeader(sourceRow + count); auto futureNextTrackHasHeader = rowHasHeader(destinationChild); if (sourceRow < destinationChild) { nextTrackHasHeader = rowHasHeader(sourceRow + count); } for (auto cptItem = 0; cptItem < count; ++cptItem) { if (sourceRow < destinationChild) { d->mData.move(sourceRow, destinationChild - 1); d->mTrackData.move(sourceRow, destinationChild - 1); } else { d->mData.move(sourceRow, destinationChild); d->mTrackData.move(sourceRow, destinationChild); } } endMoveRows(); if (sourceRow < destinationChild) { if (firstMovedTrackHasHeader != rowHasHeader(destinationChild - count)) { Q_EMIT dataChanged(index(destinationChild - count, 0), index(destinationChild - count, 0), {ColumnsRoles::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } else { if (firstMovedTrackHasHeader != rowHasHeader(destinationChild)) { Q_EMIT dataChanged(index(destinationChild, 0), index(destinationChild, 0), {ColumnsRoles::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } if (sourceRow < destinationChild) { if (nextTrackHasHeader != rowHasHeader(sourceRow)) { Q_EMIT dataChanged(index(sourceRow, 0), index(sourceRow, 0), {ColumnsRoles::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } else { if (nextTrackHasHeader != rowHasHeader(sourceRow + count)) { Q_EMIT dataChanged(index(sourceRow + count, 0), index(sourceRow + count, 0), {ColumnsRoles::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } if (sourceRow < destinationChild) { if (futureNextTrackHasHeader != rowHasHeader(destinationChild + count - 1)) { Q_EMIT dataChanged(index(destinationChild + count - 1, 0), index(destinationChild + count - 1, 0), {ColumnsRoles::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } else { if (futureNextTrackHasHeader != rowHasHeader(destinationChild + count)) { Q_EMIT dataChanged(index(destinationChild + count, 0), index(destinationChild + count, 0), {ColumnsRoles::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } Q_EMIT persistentStateChanged(); return true; } void MediaPlayList::move(int from, int to, int n) { if (from < to) { moveRows({}, from, n, {}, to + 1); } else { moveRows({}, from, n, {}, to); } } void MediaPlayList::enqueue(const TrackDataType &newTrack) { enqueue(MediaPlayListEntry(newTrack), newTrack); } void MediaPlayList::enqueue(const MediaPlayListEntry &newEntry, const TrackDataType &audioTrack) { beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size()); d->mData.push_back(newEntry); if (!audioTrack.isEmpty()) { d->mTrackData.push_back(audioTrack); } else { d->mTrackData.push_back({}); } endInsertRows(); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); Q_EMIT persistentStateChanged(); if (!newEntry.mIsValid) { if (newEntry.mTrackUrl.isValid()) { qDebug() << "MediaPlayList::enqueue" << "newTrackByFileNameInList" << newEntry.mTrackUrl; auto entryURL = newEntry.mTrackUrl.toUrl(); if (entryURL.isLocalFile()) { auto entryString = entryURL.toLocalFile(); QFileInfo newTrackFile(entryString); if (newTrackFile.exists()) { d->mData.last().mIsValid = true; } Q_EMIT newEntryInList(0, entryString, ElisaUtils::FileName); } } else { Q_EMIT newTrackByNameInList(newEntry.mTitle.toString(), newEntry.mArtist.toString(), newEntry.mAlbum.toString(), newEntry.mTrackNumber.toInt(), newEntry.mDiscNumber.toInt()); } } else { Q_EMIT newEntryInList(newEntry.mId, {}, ElisaUtils::Track); } if (!newEntry.mIsValid) { Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } void MediaPlayList::enqueue(const MusicAlbum &album) { enqueue(album.tracksList(), ElisaUtils::AppendPlayList, ElisaUtils::DoNotTriggerPlay); } void MediaPlayList::enqueueArtist(const QString &artistName) { beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size()); d->mData.push_back(MediaPlayListEntry{artistName}); d->mTrackData.push_back({}); endInsertRows(); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); Q_EMIT newEntryInList(0, artistName, ElisaUtils::Artist); Q_EMIT persistentStateChanged(); } void MediaPlayList::enqueueFilesList(const ElisaUtils::EntryDataList &newEntries) { beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + newEntries.size() - 1); for (const auto &oneTrackUrl : newEntries) { auto newEntry = MediaPlayListEntry(QUrl::fromLocalFile(std::get<1>(oneTrackUrl))); d->mData.push_back(newEntry); d->mTrackData.push_back({}); if (newEntry.mTrackUrl.isValid()) { qDebug() << "MediaPlayList::enqueue" << "newTrackByFileNameInList" << std::get<1>(oneTrackUrl); auto entryURL = newEntry.mTrackUrl.toUrl(); if (entryURL.isLocalFile()) { auto entryString = entryURL.toLocalFile(); QFileInfo newTrackFile(entryString); if (newTrackFile.exists()) { d->mData.last().mIsValid = true; } Q_EMIT newEntryInList(0, entryString, ElisaUtils::FileName); } } } endInsertRows(); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); Q_EMIT persistentStateChanged(); Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader}); } void MediaPlayList::enqueueTracksListById(const ElisaUtils::EntryDataList &newEntries) { beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + newEntries.size() - 1); for (const auto &newTrack : newEntries) { d->mData.push_back(MediaPlayListEntry{std::get<0>(newTrack)}); d->mTrackData.push_back({}); Q_EMIT newEntryInList(std::get<0>(newTrack), std::get<1>(newTrack), ElisaUtils::Track); } endInsertRows(); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); Q_EMIT persistentStateChanged(); Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader}); } void MediaPlayList::enqueueOneEntry(const ElisaUtils::EntryData &entryData, ElisaUtils::PlayListEntryType type) { beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size()); d->mData.push_back(MediaPlayListEntry{std::get<0>(entryData), std::get<1>(entryData), type}); d->mTrackData.push_back({}); Q_EMIT newEntryInList(std::get<0>(entryData), std::get<1>(entryData), type); endInsertRows(); Q_EMIT tracksCountChanged(); Q_EMIT persistentStateChanged(); } void MediaPlayList::enqueueMultipleEntries(const ElisaUtils::EntryDataList &entriesData, ElisaUtils::PlayListEntryType type) { beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + entriesData.size() - 1); for (const auto &entryData : entriesData) { d->mData.push_back(MediaPlayListEntry{std::get<0>(entryData), std::get<1>(entryData), type}); d->mTrackData.push_back({}); Q_EMIT newEntryInList(std::get<0>(entryData), std::get<1>(entryData), type); } endInsertRows(); Q_EMIT tracksCountChanged(); Q_EMIT persistentStateChanged(); } void MediaPlayList::replaceAndPlay(const ElisaUtils::EntryData &newEntry, ElisaUtils::PlayListEntryType databaseIdType) { enqueue(newEntry, databaseIdType, ElisaUtils::PlayListEnqueueMode::ReplacePlayList, ElisaUtils::PlayListEnqueueTriggerPlay::TriggerPlay); } void MediaPlayList::enqueue(const QList &albums, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay) { if (albums.isEmpty()) { return; } auto tracksCount = 0; for (const auto &oneAlbum : albums) { for (auto oneTrackIndex = 0; oneTrackIndex < oneAlbum.tracksCount(); ++oneTrackIndex) { ++tracksCount; } } if (enqueueMode == ElisaUtils::ReplacePlayList) { clearPlayList(); } beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + tracksCount - 1); for (const auto &oneAlbum : albums) { for (auto oneTrackIndex = 0; oneTrackIndex < oneAlbum.tracksCount(); ++oneTrackIndex) { const auto &oneTrack = oneAlbum.trackFromIndex(oneTrackIndex); d->mData.push_back(MediaPlayListEntry{oneTrack.databaseId()}); auto oneData = DatabaseInterface::TrackDataType{}; oneData[DatabaseInterface::TrackDataType::key_type::TitleRole] = oneTrack.title(); oneData[DatabaseInterface::TrackDataType::key_type::ArtistRole] = oneTrack.artist(); oneData[DatabaseInterface::TrackDataType::key_type::AlbumRole] = oneTrack.albumName(); oneData[DatabaseInterface::TrackDataType::key_type::AlbumIdRole] = oneTrack.albumId(); oneData[DatabaseInterface::TrackDataType::key_type::TrackNumberRole] = oneTrack.trackNumber(); oneData[DatabaseInterface::TrackDataType::key_type::DiscNumberRole] = oneTrack.discNumber(); oneData[DatabaseInterface::TrackDataType::key_type::DurationRole] = oneTrack.duration(); oneData[DatabaseInterface::TrackDataType::key_type::MilliSecondsDurationRole] = oneTrack.duration().msecsSinceStartOfDay(); oneData[DatabaseInterface::TrackDataType::key_type::ResourceRole] = oneTrack.resourceURI(); oneData[DatabaseInterface::TrackDataType::key_type::ImageUrlRole] = oneTrack.albumCover(); d->mTrackData.push_back(oneData); } } endInsertRows(); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); Q_EMIT persistentStateChanged(); Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader}); if (triggerPlay == ElisaUtils::TriggerPlay) { Q_EMIT ensurePlay(); } } void MediaPlayList::enqueue(const QList &tracks, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay) { if (tracks.isEmpty()) { return; } if (enqueueMode == ElisaUtils::ReplacePlayList) { clearPlayList(); } beginInsertRows(QModelIndex(), d->mData.size(), d->mData.size() + tracks.size() - 1); for (const auto &oneTrack : tracks) { d->mData.push_back(MediaPlayListEntry{oneTrack.databaseId()}); auto oneData = DatabaseInterface::TrackDataType{}; oneData[DatabaseInterface::TrackDataType::key_type::TitleRole] = oneTrack.title(); oneData[DatabaseInterface::TrackDataType::key_type::ArtistRole] = oneTrack.artist(); oneData[DatabaseInterface::TrackDataType::key_type::AlbumRole] = oneTrack.albumName(); oneData[DatabaseInterface::TrackDataType::key_type::AlbumIdRole] = oneTrack.albumId(); oneData[DatabaseInterface::TrackDataType::key_type::TrackNumberRole] = oneTrack.trackNumber(); oneData[DatabaseInterface::TrackDataType::key_type::DiscNumberRole] = oneTrack.discNumber(); oneData[DatabaseInterface::TrackDataType::key_type::DurationRole] = oneTrack.duration(); oneData[DatabaseInterface::TrackDataType::key_type::MilliSecondsDurationRole] = oneTrack.duration().msecsSinceStartOfDay(); oneData[DatabaseInterface::TrackDataType::key_type::ResourceRole] = oneTrack.resourceURI(); oneData[DatabaseInterface::TrackDataType::key_type::ImageUrlRole] = oneTrack.albumCover(); d->mTrackData.push_back(oneData); } endInsertRows(); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); Q_EMIT persistentStateChanged(); Q_EMIT dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, 0), {MediaPlayList::HasAlbumHeader}); if (triggerPlay == ElisaUtils::TriggerPlay) { Q_EMIT ensurePlay(); } } void MediaPlayList::replaceAndPlay(const TrackDataType &newTrack) { clearPlayList(); enqueue(newTrack); Q_EMIT ensurePlay(); } void MediaPlayList::replaceAndPlay(const MusicAlbum &album) { clearPlayList(); enqueue(album); Q_EMIT ensurePlay(); } void MediaPlayList::clearPlayList() { if (d->mData.isEmpty()) { return; } beginRemoveRows({}, 0, d->mData.count() - 1); d->mData.clear(); d->mTrackData.clear(); endRemoveRows(); d->mCurrentPlayListPosition = 0; d->mCurrentTrack = QPersistentModelIndex{}; notifyCurrentTrackChanged(); Q_EMIT tracksCountChanged(); } void MediaPlayList::loadPlaylist(const QUrl &fileName) { d->mLoadPlaylist.clear(); d->mLoadPlaylist.load(fileName, "m3u"); } void MediaPlayList::enqueue(const ElisaUtils::EntryData &newEntry, ElisaUtils::PlayListEntryType databaseIdType) { enqueue(newEntry, databaseIdType, ElisaUtils::PlayListEnqueueMode::AppendPlayList, ElisaUtils::PlayListEnqueueTriggerPlay::DoNotTriggerPlay); } void MediaPlayList::enqueue(const ElisaUtils::EntryDataList &newEntries, ElisaUtils::PlayListEntryType databaseIdType) { enqueue(newEntries, databaseIdType, ElisaUtils::PlayListEnqueueMode::AppendPlayList, ElisaUtils::PlayListEnqueueTriggerPlay::DoNotTriggerPlay); } void MediaPlayList::enqueue(qulonglong newEntryDatabaseId, const QString &newEntryTitle, ElisaUtils::PlayListEntryType databaseIdType, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay) { enqueue({newEntryDatabaseId, newEntryTitle}, databaseIdType, enqueueMode, triggerPlay); } void MediaPlayList::enqueue(ElisaUtils::EntryData newEntry, ElisaUtils::PlayListEntryType databaseIdType, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay) { if (enqueueMode == ElisaUtils::ReplacePlayList) { clearPlayList(); } switch (databaseIdType) { case ElisaUtils::Album: case ElisaUtils::Artist: case ElisaUtils::Genre: enqueueOneEntry(newEntry, databaseIdType); break; case ElisaUtils::Track: enqueue(MediaPlayListEntry{std::get<0>(newEntry)}); break; case ElisaUtils::FileName: enqueueFilesList({newEntry}); break; case ElisaUtils::Unknown: break; } if (triggerPlay == ElisaUtils::TriggerPlay) { Q_EMIT ensurePlay(); } } void MediaPlayList::enqueue(const ElisaUtils::EntryDataList &newEntries, ElisaUtils::PlayListEntryType databaseIdType, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay) { if (newEntries.isEmpty()) { return; } if (enqueueMode == ElisaUtils::ReplacePlayList) { clearPlayList(); } switch (databaseIdType) { case ElisaUtils::Track: enqueueTracksListById(newEntries); break; case ElisaUtils::FileName: enqueueFilesList(newEntries); break; case ElisaUtils::Album: case ElisaUtils::Artist: case ElisaUtils::Genre: enqueueMultipleEntries(newEntries, databaseIdType); break; case ElisaUtils::Unknown: break; } if (triggerPlay == ElisaUtils::TriggerPlay) { Q_EMIT ensurePlay(); } } bool MediaPlayList::savePlaylist(const QUrl &fileName) { QMediaPlaylist savePlaylist; for (int i = 0; i < d->mData.size(); ++i) { const auto &oneTrack = d->mData.at(i); const auto &oneTrackData = d->mTrackData.at(i); if (oneTrack.mIsValid) { savePlaylist.addMedia(oneTrackData.resourceURI()); } } return savePlaylist.save(fileName, "m3u"); } QVariantMap MediaPlayList::persistentState() const { auto currentState = QVariantMap(); auto result = QList(); for (int trackIndex = 0; trackIndex < d->mData.size(); ++trackIndex) { auto oneData = QList(); const auto &oneEntry = d->mData[trackIndex]; if (oneEntry.mIsValid) { const auto &oneTrack = d->mTrackData[trackIndex]; oneData.push_back(oneTrack.title()); oneData.push_back(oneTrack.artist()); oneData.push_back(oneTrack.album()); oneData.push_back(QString::number(oneTrack.trackNumber())); oneData.push_back(QString::number(oneTrack.discNumber())); result.push_back(QVariant(oneData)); } } currentState[QStringLiteral("playList")] = result; currentState[QStringLiteral("currentTrack")] = d->mCurrentPlayListPosition; currentState[QStringLiteral("randomPlay")] = d->mRandomPlay; currentState[QStringLiteral("repeatPlay")] = d->mRepeatPlay; return currentState; } MusicListenersManager *MediaPlayList::musicListenersManager() const { return d->mMusicListenersManager; } int MediaPlayList::tracksCount() const { return rowCount(); } QPersistentModelIndex MediaPlayList::currentTrack() const { return d->mCurrentTrack; } int MediaPlayList::currentTrackRow() const { return d->mCurrentTrack.row(); } bool MediaPlayList::randomPlay() const { return d->mRandomPlay; } bool MediaPlayList::repeatPlay() const { return d->mRepeatPlay; } void MediaPlayList::setPersistentState(const QVariantMap &persistentStateValue) { if (d->mPersistentState == persistentStateValue) { return; } qDebug() << "MediaPlayList::setPersistentState" << persistentStateValue; d->mPersistentState = persistentStateValue; auto persistentState = d->mPersistentState[QStringLiteral("playList")].toList(); for (auto &oneData : persistentState) { auto trackData = oneData.toStringList(); if (trackData.size() != 5) { continue; } auto restoredTitle = trackData[0]; auto restoredArtist = trackData[1]; auto restoredAlbum = trackData[2]; auto restoredTrackNumber = trackData[3].toInt(); auto restoredDiscNumber = trackData[4].toInt(); enqueue({restoredTitle, restoredArtist, restoredAlbum, restoredTrackNumber, restoredDiscNumber}); } restorePlayListPosition(); restoreRandomPlay(); restoreRepeatPlay(); Q_EMIT persistentStateChanged(); } void MediaPlayList::removeSelection(QList selection) { std::sort(selection.begin(), selection.end()); std::reverse(selection.begin(), selection.end()); for (auto oneItem : selection) { removeRow(oneItem); } } void MediaPlayList::tracksListAdded(qulonglong newDatabaseId, const QString &entryTitle, ElisaUtils::PlayListEntryType databaseIdType, const ListTrackDataType &tracks) { for (int playListIndex = 0; playListIndex < d->mData.size(); ++playListIndex) { auto &oneEntry = d->mData[playListIndex]; if (oneEntry.mEntryType != databaseIdType) { continue; } if (oneEntry.mTitle != entryTitle) { continue; } if (newDatabaseId != 0 && oneEntry.mId != newDatabaseId) { continue; } d->mTrackData[playListIndex] = tracks.first(); oneEntry.mId = tracks.first().databaseId(); oneEntry.mIsValid = true; oneEntry.mEntryType = ElisaUtils::Track; Q_EMIT dataChanged(index(playListIndex, 0), index(playListIndex, 0), {}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } if (tracks.size() > 1) { beginInsertRows(QModelIndex(), playListIndex + 1, playListIndex - 1 + tracks.size()); for (int trackIndex = 1; trackIndex < tracks.size(); ++trackIndex) { d->mData.push_back(MediaPlayListEntry{tracks[trackIndex].databaseId()}); d->mTrackData.push_back(tracks[trackIndex]); } endInsertRows(); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } Q_EMIT tracksCountChanged(); } Q_EMIT persistentStateChanged(); } } void MediaPlayList::trackChanged(const TrackDataType &track) { for (int i = 0; i < d->mData.size(); ++i) { auto &oneEntry = d->mData[i]; if (oneEntry.mEntryType != ElisaUtils::Artist && oneEntry.mIsValid) { if (oneEntry.mTrackUrl.toUrl().isValid() && track.resourceURI() != oneEntry.mTrackUrl.toUrl()) { continue; } if (!oneEntry.mTrackUrl.toUrl().isValid() && (oneEntry.mId == 0 || track.databaseId() != oneEntry.mId)) { continue; } const auto &trackData = d->mTrackData[i]; if (!trackData.empty()) { bool sameData = true; for (const auto &oneKey : track.keys()) { if (trackData[oneKey] != track[oneKey]) { sameData = false; break; } } if (sameData) { continue; } } d->mTrackData[i] = track; Q_EMIT dataChanged(index(i, 0), index(i, 0), {}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } continue; } else if (oneEntry.mEntryType != ElisaUtils::Artist && !oneEntry.mIsValid && !oneEntry.mTrackUrl.isValid()) { if (track.title() != oneEntry.mTitle) { continue; } if (track.album() != oneEntry.mAlbum) { continue; } if (track.trackNumber() != oneEntry.mTrackNumber) { continue; } if (track.discNumber() != oneEntry.mDiscNumber) { continue; } d->mTrackData[i] = track; oneEntry.mId = track.databaseId(); oneEntry.mIsValid = true; Q_EMIT dataChanged(index(i, 0), index(i, 0), {}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } break; } else if (oneEntry.mEntryType != ElisaUtils::Artist && !oneEntry.mIsValid && oneEntry.mTrackUrl.isValid()) { qDebug() << "MediaPlayList::trackChanged" << oneEntry << track; qDebug() << "MediaPlayList::trackChanged" << track.resourceURI() << oneEntry.mTrackUrl; if (track.resourceURI() != oneEntry.mTrackUrl) { continue; } d->mTrackData[i] = track; oneEntry.mId = track.databaseId(); oneEntry.mIsValid = true; Q_EMIT dataChanged(index(i, 0), index(i, 0), {}); restorePlayListPosition(); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } break; } } } void MediaPlayList::trackRemoved(qulonglong trackId) { for (int i = 0; i < d->mData.size(); ++i) { auto &oneEntry = d->mData[i]; if (oneEntry.mIsValid) { if (oneEntry.mId == trackId) { oneEntry.mIsValid = false; oneEntry.mTitle = d->mTrackData[i].title(); oneEntry.mArtist = d->mTrackData[i].artist(); oneEntry.mAlbum = d->mTrackData[i].album(); oneEntry.mTrackNumber = d->mTrackData[i].trackNumber(); oneEntry.mDiscNumber = d->mTrackData[i].discNumber(); Q_EMIT dataChanged(index(i, 0), index(i, 0), {}); if (!d->mCurrentTrack.isValid()) { resetCurrentTrack(); } } } } } void MediaPlayList::setMusicListenersManager(MusicListenersManager *musicListenersManager) { if (d->mMusicListenersManager == musicListenersManager) { return; } d->mMusicListenersManager = musicListenersManager; if (d->mMusicListenersManager) { d->mMusicListenersManager->subscribeForTracks(this); } Q_EMIT musicListenersManagerChanged(); } void MediaPlayList::setRandomPlay(bool value) { d->mRandomPlay = value; Q_EMIT randomPlayChanged(); } void MediaPlayList::setRepeatPlay(bool value) { d->mRepeatPlay = value; Q_EMIT repeatPlayChanged(); } void MediaPlayList::skipNextTrack() { if (!d->mCurrentTrack.isValid()) { return; } if (!d->mRandomPlay && (d->mCurrentTrack.row() >= (rowCount() - 1))) { if (!d->mRepeatPlay) { Q_EMIT playListFinished(); } if (rowCount() == 1) { d->mCurrentTrack = QPersistentModelIndex{}; notifyCurrentTrackChanged(); } resetCurrentTrack(); return; } if (d->mRandomPlay) { int randomValue = qrand(); randomValue = randomValue % (rowCount()); d->mCurrentTrack = index(randomValue, 0); } else { d->mCurrentTrack = index(d->mCurrentTrack.row() + 1, 0); } notifyCurrentTrackChanged(); } void MediaPlayList::skipPreviousTrack() { if (!d->mCurrentTrack.isValid()) { return; } if (!d->mRandomPlay && !d->mRepeatPlay && d->mCurrentTrack.row() <= 0) { return; } if (d->mRandomPlay) { int randomValue = qrand(); randomValue = randomValue % (rowCount()); d->mCurrentTrack = index(randomValue, 0); } else { if (d->mRepeatPlay) { if (d->mCurrentTrack.row() == 0) { d->mCurrentTrack = index(rowCount() - 1, 0); } else { d->mCurrentTrack = index(d->mCurrentTrack.row() - 1, 0); } } else { d->mCurrentTrack = index(d->mCurrentTrack.row() - 1, d->mCurrentTrack.column(), d->mCurrentTrack.parent()); } } notifyCurrentTrackChanged(); } void MediaPlayList::seedRandomGenerator(uint seed) { qsrand(seed); } void MediaPlayList::switchTo(int row) { if (!d->mCurrentTrack.isValid()) { return; } d->mCurrentTrack = index(row, 0); notifyCurrentTrackChanged(); } void MediaPlayList::trackInError(const QUrl &sourceInError, QMediaPlayer::Error playerError) { Q_UNUSED(playerError) for (int i = 0; i < d->mData.size(); ++i) { auto &oneTrack = d->mData[i]; if (oneTrack.mIsValid) { const auto &oneTrackData = d->mTrackData.at(i); if (oneTrackData.resourceURI() == sourceInError) { oneTrack.mIsValid = false; Q_EMIT dataChanged(index(i, 0), index(i, 0), {ColumnsRoles::IsValidRole}); } } } } bool MediaPlayList::rowHasHeader(int row) const { if (row >= rowCount()) { return false; } if (row < 0) { return false; } if (row - 1 < 0) { return true; } auto currentAlbumTitle = QString(); auto currentAlbumArtist = QString(); if (d->mData[row].mIsValid) { currentAlbumTitle = d->mTrackData[row].album(); currentAlbumArtist = d->mTrackData[row].albumArtist(); } else { currentAlbumTitle = d->mData[row].mAlbum.toString(); currentAlbumArtist = d->mData[row].mArtist.toString(); } auto previousAlbumTitle = QString(); auto previousAlbumArtist = QString(); if (d->mData[row - 1].mIsValid) { previousAlbumTitle = d->mTrackData[row - 1].album(); previousAlbumArtist = d->mTrackData[row - 1].albumArtist(); } else { previousAlbumTitle = d->mData[row - 1].mAlbum.toString(); previousAlbumArtist = d->mData[row - 1].mArtist.toString(); } if (currentAlbumTitle == previousAlbumTitle && currentAlbumArtist == previousAlbumArtist) { return false; } return true; } void MediaPlayList::loadPlayListLoaded() { clearPlayList(); for (int i = 0; i < d->mLoadPlaylist.mediaCount(); ++i) { enqueue(MediaPlayListEntry{d->mLoadPlaylist.media(i).canonicalUrl()}); } restorePlayListPosition(); restoreRandomPlay(); restoreRepeatPlay(); Q_EMIT persistentStateChanged(); d->mLoadPlaylist.clear(); Q_EMIT playListLoaded(); } void MediaPlayList::loadPlayListLoadFailed() { d->mLoadPlaylist.clear(); Q_EMIT playListLoadFailed(); } void MediaPlayList::resetCurrentTrack() { for(int row = 0; row < rowCount(); ++row) { auto candidateTrack = index(row, 0); if (candidateTrack.isValid() && candidateTrack.data(ColumnsRoles::IsValidRole).toBool()) { d->mCurrentTrack = candidateTrack; notifyCurrentTrackChanged(); break; } } } void MediaPlayList::notifyCurrentTrackChanged() { Q_EMIT currentTrackChanged(d->mCurrentTrack); Q_EMIT currentTrackRowChanged(); bool currentTrackIsValid = d->mCurrentTrack.isValid(); if (currentTrackIsValid) { d->mCurrentPlayListPosition = d->mCurrentTrack.row(); } } void MediaPlayList::restorePlayListPosition() { auto playerCurrentTrack = d->mPersistentState.find(QStringLiteral("currentTrack")); if (playerCurrentTrack != d->mPersistentState.end()) { auto newIndex = index(playerCurrentTrack->toInt(), 0); if (newIndex.isValid() && (newIndex != d->mCurrentTrack)) { d->mCurrentTrack = newIndex; notifyCurrentTrackChanged(); if (d->mCurrentTrack.isValid()) { d->mPersistentState.erase(playerCurrentTrack); } } } } void MediaPlayList::restoreRandomPlay() { auto randomPlayStoredValue = d->mPersistentState.find(QStringLiteral("randomPlay")); if (randomPlayStoredValue != d->mPersistentState.end()) { setRandomPlay(randomPlayStoredValue->toBool()); d->mPersistentState.erase(randomPlayStoredValue); } } void MediaPlayList::restoreRepeatPlay() { auto repeatPlayStoredValue = d->mPersistentState.find(QStringLiteral("repeatPlay")); if (repeatPlayStoredValue != d->mPersistentState.end()) { setRepeatPlay(repeatPlayStoredValue->toBool()); d->mPersistentState.erase(repeatPlayStoredValue); } } QDebug operator<<(const QDebug &stream, const MediaPlayListEntry &data) { stream << data.mTitle << data.mAlbum << data.mArtist << data.mTrackUrl << data.mTrackNumber << data.mDiscNumber << data.mId << data.mIsValid; return stream; } #include "moc_mediaplaylist.cpp" diff --git a/src/mediaplaylist.h b/src/mediaplaylist.h index 57182acc..f4d87861 100644 --- a/src/mediaplaylist.h +++ b/src/mediaplaylist.h @@ -1,368 +1,369 @@ /* * Copyright 2015-2017 Matthieu Gallien * * This program is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see . */ #ifndef MEDIAPLAYLIST_H #define MEDIAPLAYLIST_H #include "elisaLib_export.h" #include "musicaudiotrack.h" #include "musicalbum.h" #include "elisautils.h" #include "databaseinterface.h" #include #include #include #include #include class MediaPlayListPrivate; class MusicListenersManager; class MediaPlayListEntry; class QDebug; class ELISALIB_EXPORT MediaPlayList : public QAbstractListModel { Q_OBJECT Q_PROPERTY(QVariantMap persistentState READ persistentState WRITE setPersistentState NOTIFY persistentStateChanged) Q_PROPERTY(MusicListenersManager* musicListenersManager READ musicListenersManager WRITE setMusicListenersManager NOTIFY musicListenersManagerChanged) Q_PROPERTY(int tracksCount READ tracksCount NOTIFY tracksCountChanged) Q_PROPERTY(QPersistentModelIndex currentTrack READ currentTrack NOTIFY currentTrackChanged) Q_PROPERTY(int currentTrackRow READ currentTrackRow NOTIFY currentTrackRowChanged) Q_PROPERTY(bool randomPlay READ randomPlay WRITE setRandomPlay NOTIFY randomPlayChanged) Q_PROPERTY(bool repeatPlay READ repeatPlay WRITE setRepeatPlay NOTIFY repeatPlayChanged) public: enum ColumnsRoles { TitleRole = DatabaseInterface::TitleRole, SecondaryTextRole, ImageUrlRole, ShadowForImageRole, ChildModelRole, DurationRole, + StringDurationRole, MilliSecondsDurationRole, ArtistRole, AllArtistsRole, HighestTrackRating, AlbumRole, AlbumArtistRole, TrackNumberRole, DiscNumberRole, RatingRole, GenreRole, LyricistRole, ComposerRole, CommentRole, YearRole, ChannelsRole, BitRateRole, SampleRateRole, ResourceRole, IdRole, DatabaseIdRole, IsSingleDiscAlbumRole, ContainerDataRole, IsPartialDataRole, AlbumIdRole, IsValidRole, TrackDataRole, CountRole, IsPlayingRole, HasAlbumHeader, }; Q_ENUM(ColumnsRoles) enum PlayState { NotPlaying, IsPlaying, IsPaused, }; Q_ENUM(PlayState) using ListTrackDataType = DatabaseInterface::ListTrackDataType; using TrackDataType = DatabaseInterface::TrackDataType; explicit MediaPlayList(QObject *parent = nullptr); ~MediaPlayList() override; int rowCount(const QModelIndex &parent = QModelIndex()) const override; QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override; bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override; QHash roleNames() const override; Q_INVOKABLE bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override; Q_INVOKABLE bool moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild) override; Q_INVOKABLE void move(int from, int to, int n); Q_INVOKABLE void clearPlayList(); Q_INVOKABLE bool savePlaylist(const QUrl &fileName); QVariantMap persistentState() const; MusicListenersManager* musicListenersManager() const; int tracksCount() const; QPersistentModelIndex currentTrack() const; int currentTrackRow() const; bool randomPlay() const; bool repeatPlay() const; Q_SIGNALS: void newTrackByNameInList(const QString &title, const QString &artist, const QString &album, int trackNumber, int discNumber); void newEntryInList(qulonglong newDatabaseId, const QString &entryTitle, ElisaUtils::PlayListEntryType databaseIdType); void persistentStateChanged(); void musicListenersManagerChanged(); void tracksCountChanged(); void currentTrackChanged(QPersistentModelIndex currentTrack); void currentTrackRowChanged(); void randomPlayChanged(); void repeatPlayChanged(); void playListFinished(); void playListLoaded(); void playListLoadFailed(); void ensurePlay(); public Q_SLOTS: void setPersistentState(const QVariantMap &persistentState); void removeSelection(QList selection); void tracksListAdded(qulonglong newDatabaseId, const QString &entryTitle, ElisaUtils::PlayListEntryType databaseIdType, const ListTrackDataType &tracks); void trackChanged(const TrackDataType &track); void trackRemoved(qulonglong trackId); void setMusicListenersManager(MusicListenersManager* musicListenersManager); void setRandomPlay(bool value); void setRepeatPlay(bool value); void skipNextTrack(); void skipPreviousTrack(); void seedRandomGenerator(uint seed); void switchTo(int row); void loadPlaylist(const QUrl &fileName); void enqueue(const ElisaUtils::EntryData &newEntry, ElisaUtils::PlayListEntryType databaseIdType); void enqueue(const ElisaUtils::EntryDataList &newEntries, ElisaUtils::PlayListEntryType databaseIdType); void enqueue(qulonglong newEntryDatabaseId, const QString &newEntryTitle, ElisaUtils::PlayListEntryType databaseIdType, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay); void enqueue(ElisaUtils::EntryData newEntry, ElisaUtils::PlayListEntryType databaseIdType, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay); void enqueue(const ElisaUtils::EntryDataList &newEntries, ElisaUtils::PlayListEntryType databaseIdType, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay); void enqueue(const TrackDataType &newTrack); void enqueue(const MediaPlayListEntry &newEntry, const TrackDataType &audioTrack = {}); void enqueue(const MusicAlbum &album); void enqueue(const QList &albums, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay); void enqueue(const QList &tracks, ElisaUtils::PlayListEnqueueMode enqueueMode, ElisaUtils::PlayListEnqueueTriggerPlay triggerPlay); void replaceAndPlay(const ElisaUtils::EntryData &newEntry, ElisaUtils::PlayListEntryType databaseIdType); void replaceAndPlay(const TrackDataType &newTrack); void replaceAndPlay(const MusicAlbum &album); void trackInError(const QUrl &sourceInError, QMediaPlayer::Error playerError); private Q_SLOTS: void loadPlayListLoaded(); void loadPlayListLoadFailed(); private: bool rowHasHeader(int row) const; void resetCurrentTrack(); void notifyCurrentTrackChanged(); void restorePlayListPosition(); void restoreRandomPlay(); void restoreRepeatPlay(); void enqueueArtist(const QString &artistName); void enqueueFilesList(const ElisaUtils::EntryDataList &newEntries); void enqueueTracksListById(const ElisaUtils::EntryDataList &newEntries); void enqueueOneEntry(const ElisaUtils::EntryData &entryData, ElisaUtils::PlayListEntryType type); void enqueueMultipleEntries(const ElisaUtils::EntryDataList &entriesData, ElisaUtils::PlayListEntryType type); std::unique_ptr d; }; class MediaPlayListEntry { public: MediaPlayListEntry() = default; explicit MediaPlayListEntry(qulonglong id) : mId(id), mIsValid(true) { } MediaPlayListEntry(QString title, QString artist, QString album, int trackNumber, int discNumber) : mTitle(std::move(title)), mAlbum(std::move(album)), mArtist(std::move(artist)), mTrackNumber(trackNumber), mDiscNumber(discNumber) { } explicit MediaPlayListEntry(const MusicAudioTrack &track) : mTitle(track.title()), mAlbum(track.albumName()), mTrackNumber(track.trackNumber()), mDiscNumber(track.discNumber()), mId(track.databaseId()), mIsValid(true) { } explicit MediaPlayListEntry(const MediaPlayList::TrackDataType &track) : mTitle(track[DatabaseInterface::TitleRole]), mAlbum(track[DatabaseInterface::AlbumRole]), mTrackNumber(track[DatabaseInterface::TrackNumberRole]), mDiscNumber(track[DatabaseInterface::DiscNumberRole]), mId(track[DatabaseInterface::DatabaseIdRole].toULongLong()), mIsValid(true) { } explicit MediaPlayListEntry(QString artist) : mArtist(std::move(artist)), mEntryType(ElisaUtils::Artist) { } explicit MediaPlayListEntry(QUrl fileName) : mTrackUrl(std::move(fileName)) { } explicit MediaPlayListEntry(qulonglong id, const QString &entryTitle, ElisaUtils::PlayListEntryType type) : mTitle(entryTitle), mId(id), mIsValid(type == ElisaUtils::Track), mEntryType(type) { } QVariant mTitle; QVariant mAlbum; QVariant mArtist; QVariant mTrackUrl; QVariant mTrackNumber = -1; QVariant mDiscNumber = -1; qulonglong mId = 0; bool mIsValid = false; ElisaUtils::PlayListEntryType mEntryType = ElisaUtils::PlayListEntryType::Unknown; MediaPlayList::PlayState mIsPlaying = MediaPlayList::NotPlaying; }; QDebug operator<<(const QDebug &stream, const MediaPlayListEntry &data); #endif // MEDIAPLAYLIST_H diff --git a/src/models/albummodel.cpp b/src/models/albummodel.cpp index 863b7b77..b5bfe9d7 100644 --- a/src/models/albummodel.cpp +++ b/src/models/albummodel.cpp @@ -1,450 +1,453 @@ /* * Copyright 2015-2017 Matthieu Gallien * * This program is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see . */ #include "albummodel.h" #include "databaseinterface.h" #include #include #include #include class AlbumModelPrivate { public: MusicAlbum mCurrentAlbum; }; AlbumModel::AlbumModel(QObject *parent) : QAbstractItemModel(parent), d(std::make_unique()) { } AlbumModel::~AlbumModel() = default; int AlbumModel::rowCount(const QModelIndex &parent) const { if (parent.isValid()) { return 0; } return d->mCurrentAlbum.tracksCount(); } QHash AlbumModel::roleNames() const { auto roles = QAbstractItemModel::roleNames(); roles[static_cast(ColumnsRoles::TitleRole)] = "title"; roles[static_cast(ColumnsRoles::DurationRole)] = "duration"; roles[static_cast(ColumnsRoles::ArtistRole)] = "artist"; roles[static_cast(ColumnsRoles::AlbumRole)] = "album"; roles[static_cast(ColumnsRoles::AlbumArtistRole)] = "albumArtist"; roles[static_cast(ColumnsRoles::TrackNumberRole)] = "trackNumber"; roles[static_cast(ColumnsRoles::DiscNumberRole)] = "discNumber"; roles[static_cast(ColumnsRoles::RatingRole)] = "rating"; roles[static_cast(ColumnsRoles::GenreRole)] = "genre"; roles[static_cast(ColumnsRoles::LyricistRole)] = "lyricist"; roles[static_cast(ColumnsRoles::ComposerRole)] = "composer"; roles[static_cast(ColumnsRoles::CommentRole)] = "comment"; roles[static_cast(ColumnsRoles::YearRole)] = "year"; roles[static_cast(ColumnsRoles::ChannelsRole)] = "channels"; roles[static_cast(ColumnsRoles::BitRateRole)] = "bitRate"; roles[static_cast(ColumnsRoles::SampleRateRole)] = "sampleRate"; roles[static_cast(ColumnsRoles::ImageRole)] = "image"; roles[static_cast(ColumnsRoles::DatabaseIdRole)] = "databaseId"; roles[static_cast(ColumnsRoles::DiscFirstTrackRole)] = "isFirstTrackOfDisc"; roles[static_cast(ColumnsRoles::IsSingleDiscAlbumRole)] = "isSingleDiscAlbum"; roles[static_cast(ColumnsRoles::ContainerDataRole)] = "containerData"; roles[static_cast(ColumnsRoles::ResourceRole)] = "trackResource"; roles[static_cast(ColumnsRoles::SecondaryTextRole)] = "secondaryText"; roles[static_cast(ColumnsRoles::ImageUrlRole)] = "imageUrl"; roles[static_cast(ColumnsRoles::ShadowForImageRole)] = "shadowForImage"; return roles; } Qt::ItemFlags AlbumModel::flags(const QModelIndex &index) const { if (!index.isValid()) { return Qt::NoItemFlags; } return Qt::ItemIsSelectable | Qt::ItemIsEnabled; } QVariant AlbumModel::data(const QModelIndex &index, int role) const { auto result = QVariant(); Q_ASSERT(index.isValid()); Q_ASSERT(index.column() == 0); Q_ASSERT(index.row() >= 0 && index.row() < d->mCurrentAlbum.tracksCount()); Q_ASSERT(!index.parent().isValid()); Q_ASSERT(index.model() == this); const auto ¤tTrack = d->mCurrentAlbum.trackFromIndex(index.row()); if (!currentTrack.isValid()) { return result; } result = internalDataTrack(currentTrack, role, index.row()); return result; } QVariant AlbumModel::internalDataTrack(const MusicAudioTrack &track, int role, int rowIndex) const { auto result = QVariant(); switch(role) { case ColumnsRoles::TitleRole: if (track.title().isEmpty()) { track.resourceURI().fileName(); } else { result = track.title(); } break; case ColumnsRoles::MilliSecondsDurationRole: result = track.duration().msecsSinceStartOfDay(); break; - case ColumnsRoles::DurationRole: + case ColumnsRoles::StringDurationRole: { QTime trackDuration = track.duration(); if (trackDuration.hour() == 0) { result = trackDuration.toString(QStringLiteral("mm:ss")); } else { result = trackDuration.toString(); } break; } + case ColumnsRoles::DurationRole: + result = track.duration(); + break; case ColumnsRoles::ArtistRole: result = track.artist(); break; case ColumnsRoles::AlbumRole: result = track.albumName(); break; case ColumnsRoles::AlbumArtistRole: result = track.albumArtist(); break; case ColumnsRoles::TrackNumberRole: result = track.trackNumber(); break; case ColumnsRoles::DiscNumberRole: result = track.discNumber(); break; case ColumnsRoles::DiscFirstTrackRole: if (rowIndex == 0) { result = true; } else { auto previousTrack = d->mCurrentAlbum.trackFromIndex(rowIndex - 1); result = (previousTrack.discNumber() != track.discNumber()); } break; case ColumnsRoles::IsSingleDiscAlbumRole: result = track.isSingleDiscAlbum(); break; case ColumnsRoles::RatingRole: result = track.rating(); break; case ColumnsRoles::GenreRole: result = track.genre(); break; case ColumnsRoles::LyricistRole: result = track.lyricist(); break; case ColumnsRoles::ComposerRole: result = track.composer(); break; case ColumnsRoles::YearRole: result = track.year(); break; case ColumnsRoles::ChannelsRole: result = track.channels(); break; case ColumnsRoles::BitRateRole: result = track.bitRate(); break; case ColumnsRoles::ImageRole: { if (d->mCurrentAlbum.albumArtURI().isValid()) { result = d->mCurrentAlbum.albumArtURI(); } break; } case ColumnsRoles::ResourceRole: result = track.resourceURI(); break; case ColumnsRoles::IdRole: result = track.title(); break; case ColumnsRoles::DatabaseIdRole: result = track.databaseId(); break; case ColumnsRoles::ContainerDataRole: result = QVariant::fromValue(track); break; case Qt::DisplayRole: result = track.title(); break; case ColumnsRoles::SecondaryTextRole: { auto secondaryText = QString(); secondaryText = QStringLiteral("%1 - %2%3"); secondaryText = secondaryText.arg(track.trackNumber()); secondaryText = secondaryText.arg(track.title()); if (track.artist() == track.albumArtist()) { secondaryText = secondaryText.arg(QString()); } else { auto artistText = QString(); artistText = QStringLiteral(" - %1"); artistText = artistText.arg(track.artist()); secondaryText = secondaryText.arg(artistText); } result = secondaryText; break; } case ColumnsRoles::ImageUrlRole: { const auto &albumArtUri = d->mCurrentAlbum.albumArtURI(); if (albumArtUri.isValid()) { result = albumArtUri; } else { result = QUrl(QStringLiteral("image://icon/media-optical-audio")); } break; } case ColumnsRoles::ShadowForImageRole: result = d->mCurrentAlbum.albumArtURI().isValid(); break; } return result; } QModelIndex AlbumModel::index(int row, int column, const QModelIndex &parent) const { auto result = QModelIndex(); if (column != 0) { return result; } if (parent.isValid()) { return result; } if (row >= d->mCurrentAlbum.tracksCount()) { return result; } return createIndex(row, column); } QModelIndex AlbumModel::parent(const QModelIndex &child) const { Q_UNUSED(child) return {}; } int AlbumModel::columnCount(const QModelIndex &parent) const { Q_UNUSED(parent); return 1; } MusicAlbum AlbumModel::albumData() const { return d->mCurrentAlbum; } QString AlbumModel::title() const { return d->mCurrentAlbum.title(); } QString AlbumModel::author() const { return d->mCurrentAlbum.artist(); } int AlbumModel::tracksCount() const { return d->mCurrentAlbum.tracksCount(); } void AlbumModel::setAlbumData(const MusicAlbum &album) { if (d->mCurrentAlbum == album) { return; } if (d->mCurrentAlbum.tracksCount() > 0) { beginRemoveRows({}, 0, d->mCurrentAlbum.tracksCount() - 1); d->mCurrentAlbum = {}; endRemoveRows(); } beginInsertRows({}, 0, album.tracksCount() - 1); d->mCurrentAlbum = album; endInsertRows(); Q_EMIT albumDataChanged(); Q_EMIT tracksCountChanged(); Q_EMIT authorChanged(); Q_EMIT titleChanged(); } void AlbumModel::albumModified(const AlbumDataType &modifiedAlbum) { #if 0 if (modifiedAlbum.databaseId() != d->mCurrentAlbum.databaseId()) { return; } auto removedTracks = QList(); for (auto i = 0; i < d->mCurrentAlbum.tracksCount(); ++i) { bool trackExist = false; for (auto j = 0; j < modifiedAlbum.tracksCount() && !trackExist; ++j) { trackExist = (d->mCurrentAlbum.trackIdFromIndex(i) == modifiedAlbum.trackIdFromIndex(j)); if (trackExist) { const auto &oldTrack = d->mCurrentAlbum.trackFromIndex(i); const auto &newTrack = modifiedAlbum.trackFromIndex(j); if (oldTrack != newTrack) { trackModified(newTrack); } } } if (!trackExist) { const auto &oldTrack = d->mCurrentAlbum.trackFromIndex(i); removedTracks.push_back(oldTrack); } } for (const auto &removedTrack : removedTracks) { trackRemoved(removedTrack); } for (auto j = 0; j < modifiedAlbum.tracksCount(); ++j) { bool trackExist = false; for (auto i = 0; i < d->mCurrentAlbum.tracksCount() && !trackExist; ++i) { trackExist = (d->mCurrentAlbum.trackIdFromIndex(i) == modifiedAlbum.trackIdFromIndex(j)); } if (!trackExist) { const auto &newTrack = modifiedAlbum.trackFromIndex(j); trackAdded(newTrack); } } #endif } void AlbumModel::albumRemoved(qulonglong modifiedAlbumId) { if (modifiedAlbumId != d->mCurrentAlbum.databaseId()) { return; } for (int trackIndex = d->mCurrentAlbum.tracksCount() - 1; trackIndex >= 0 ; --trackIndex) { trackRemoved(d->mCurrentAlbum.trackFromIndex(trackIndex)); } } void AlbumModel::trackAdded(const MusicAudioTrack &newTrack) { if (newTrack.albumName() != d->mCurrentAlbum.title()) { return; } auto trackIndex = d->mCurrentAlbum.trackIndexFromId(newTrack.databaseId()); if (trackIndex != -1) { return; } bool trackInserted = false; for (int trackIndex = 0; trackIndex < d->mCurrentAlbum.tracksCount(); ++trackIndex) { const auto &oneTrack = d->mCurrentAlbum.trackFromIndex(trackIndex); if (oneTrack.discNumber() == newTrack.discNumber() && oneTrack.trackNumber() > newTrack.trackNumber()) { beginInsertRows({}, trackIndex, trackIndex); d->mCurrentAlbum.insertTrack(newTrack, trackIndex); endInsertRows(); trackInserted = true; break; } } if (!trackInserted) { beginInsertRows({}, d->mCurrentAlbum.tracksCount(), d->mCurrentAlbum.tracksCount()); d->mCurrentAlbum.insertTrack(newTrack, d->mCurrentAlbum.tracksCount()); endInsertRows(); } } void AlbumModel::trackModified(const MusicAudioTrack &modifiedTrack) { if (modifiedTrack.albumName() != d->mCurrentAlbum.title()) { return; } auto trackIndex = d->mCurrentAlbum.trackIndexFromId(modifiedTrack.databaseId()); if (trackIndex == -1) { return; } d->mCurrentAlbum.updateTrack(modifiedTrack, trackIndex); Q_EMIT dataChanged(index(trackIndex, 0), index(trackIndex, 0)); } void AlbumModel::trackRemoved(const MusicAudioTrack &removedTrack) { if (removedTrack.albumName() != d->mCurrentAlbum.title()) { return; } auto trackIndex = d->mCurrentAlbum.trackIndexFromId(removedTrack.databaseId()); if (trackIndex == -1) { return; } beginRemoveRows({}, trackIndex, trackIndex); d->mCurrentAlbum.removeTrackFromIndex(trackIndex); endRemoveRows(); } void AlbumModel::loadAlbumData(qulonglong id) { Q_EMIT requestAlbumData(id); } #include "moc_albummodel.cpp" diff --git a/src/models/albummodel.h b/src/models/albummodel.h index ebac70dc..d1fed8f3 100644 --- a/src/models/albummodel.h +++ b/src/models/albummodel.h @@ -1,172 +1,173 @@ /* * Copyright 2015-2017 Matthieu Gallien * * This program is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program. If not, see . */ #ifndef ALBUMMODEL_H #define ALBUMMODEL_H #include "elisaLib_export.h" #include "databaseinterface.h" #include "musicalbum.h" #include #include #include #include #include class MusicAudioTrack; class DatabaseInterface; class AlbumModelPrivate; class QMutex; class ELISALIB_EXPORT AlbumModel : public QAbstractItemModel { Q_OBJECT Q_PROPERTY(MusicAlbum albumData READ albumData WRITE setAlbumData NOTIFY albumDataChanged) Q_PROPERTY(QString title READ title NOTIFY titleChanged) Q_PROPERTY(QString author READ author NOTIFY authorChanged) Q_PROPERTY(int tracksCount READ tracksCount NOTIFY tracksCountChanged) public: enum ItemClass { Container = 0, Album = 1, Artist = 2, AudioTrack = 3, }; enum ColumnsRoles { TitleRole = Qt::UserRole + 1, DurationRole, + StringDurationRole, MilliSecondsDurationRole, ArtistRole, AlbumRole, AlbumArtistRole, TrackNumberRole, DiscNumberRole, RatingRole, GenreRole, LyricistRole, ComposerRole, CommentRole, YearRole, ChannelsRole, BitRateRole, SampleRateRole, ImageRole, ResourceRole, IdRole, DatabaseIdRole, DiscFirstTrackRole, IsSingleDiscAlbumRole, ContainerDataRole, SecondaryTextRole, ImageUrlRole, ShadowForImageRole, }; Q_ENUM(ColumnsRoles) using ListTrackDataType = DatabaseInterface::ListTrackDataType; using TrackDataType = DatabaseInterface::TrackDataType; using ListAlbumDataType = DatabaseInterface::ListAlbumDataType; using AlbumDataType = DatabaseInterface::AlbumDataType; explicit AlbumModel(QObject *parent = nullptr); ~AlbumModel() override; int rowCount(const QModelIndex &parent = QModelIndex()) const override; QHash roleNames() const override; Qt::ItemFlags flags(const QModelIndex &index) const override; QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override; QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override; QModelIndex parent(const QModelIndex &child) const override; int columnCount(const QModelIndex &parent = QModelIndex()) const override; MusicAlbum albumData() const; QString title() const; QString author() const; int tracksCount() const; Q_INVOKABLE void loadAlbumData(qulonglong id); Q_SIGNALS: void albumDataChanged(); void titleChanged(); void authorChanged(); void tracksCountChanged(); void requestAlbumData(qulonglong id); public Q_SLOTS: void setAlbumData(const MusicAlbum &album); void albumModified(const AlbumDataType &modifiedAlbum); void albumRemoved(qulonglong modifiedAlbumId); private: void trackAdded(const MusicAudioTrack &newTrack); void trackModified(const MusicAudioTrack &modifiedTrack); void trackRemoved(const MusicAudioTrack &removedTrack); QVariant internalDataTrack(const MusicAudioTrack &track, int role, int rowIndex) const; std::unique_ptr d; }; Q_DECLARE_METATYPE(AlbumModel::ItemClass) #endif // ALBUMMODEL_H