Playlists: allow to adopt current order (sorted) as playlist order

Author: ronso0

src/library/dao/playlistdao.cpp

@@ -1116,6 +1116,48 @@ int PlaylistDAO::tracksInPlaylist(const int playlistId) const {
     return count;
 }
 
+void PlaylistDAO::orderTracksByCurrPos(const int playlistId,
+        QList<std::pair<TrackId, int>>& newOrder) {
+    if (newOrder.isEmpty() || playlistId == kInvalidPlaylistId) {
+        return;
+    }
+    ScopedTransaction transaction(m_database);
+    QSqlQuery query(m_database);
+    query.prepare(QStringLiteral(
+            "UPDATE PlaylistTracks "
+            "SET position=:new_pos "
+            "WHERE position=:old_pos AND "
+            "track_id=:track_id AND "
+            "playlist_id=:pl_id"));
+    int newPos = 1;
+    for (auto oldIdAndPos : newOrder) {
+        int oldPos = oldIdAndPos.second;
+        const TrackId trackId = oldIdAndPos.first;
+        VERIFY_OR_DEBUG_ASSERT(trackId.isValid()) {
+            return;
+        }
+        query.bindValue(":new_pos", newPos++);
+        query.bindValue(":old_pos", oldPos);
+        query.bindValue(":track_id", trackId.toVariant());
+        query.bindValue(":pl_id", playlistId);
+        if (!query.exec()) {
+            // We temporarily have duplicate positions, so abort the entire operation
+            // to not leave the playlist with an invalid state.
+            LOG_FAILED_QUERY(query);
+            return;
+        }
+    }
+
+    transaction.commit();
+
+    // Print out any SQL error, if there was one.
+    if (query.lastError().isValid()) {
+        qDebug() << query.lastError();
+    }
+
+    emit tracksMoved(QSet<int>{playlistId});
+}
+
 void PlaylistDAO::moveTrack(const int playlistId, const int oldPosition, const int newPosition) {
     ScopedTransaction transaction(m_database);
     QSqlQuery query(m_database);
@@ -1341,9 +1383,7 @@ void PlaylistDAO::shuffleTracks(const int playlistId,
             }
         }
 
-        //qDebug() << "Swapping tracks " << trackAPosition << " and " << trackBPosition;
-        trackPositionIds.insert(trackAPosition, trackBId);
-        trackPositionIds.insert(trackBPosition, trackAId);
+        // qDebug() << "Swapping tracks " << trackAPosition << " and " << trackBPosition;
 
 // TODO: The following use of QList<T>::swap(int, int) is deprecated
 // and should be replaced with QList<T>::swapItemsAt(int, int)

src/library/dao/playlistdao.h

@@ -110,6 +110,9 @@ class PlaylistDAO : public QObject, public virtual DAO {
     bool copyPlaylistTracks(const int sourcePlaylistID, const int targetPlaylistID);
     // Returns the number of tracks in the given playlist.
     int tracksInPlaylist(const int playlistId) const;
+    // This receives a track list that represents the current order (sorted by BPM for example)
+    // and adopts this order for `position` in the playlist
+    void orderTracksByCurrPos(const int playlistId, QList<std::pair<TrackId, int>>& newOrder);
     // moved Track to a new position
     void moveTrack(const int playlistId,
             const int oldPosition, const int newPosition);

src/library/playlisttablemodel.cpp

@@ -339,6 +339,22 @@ void PlaylistTableModel::shuffleTracks(const QModelIndexList& shuffle, const QMo
     m_pTrackCollectionManager->internalCollection()->getPlaylistDAO().shuffleTracks(m_iPlaylistId, positions, allIds);
 }
 
+void PlaylistTableModel::orderTracksByCurrPos() {
+    QList<std::pair<TrackId, int>> idPosList;
+    int numOfTracks = rowCount();
+    const int positionColumn = fieldIndex(ColumnCache::COLUMN_PLAYLISTTRACKSTABLE_POSITION);
+    const int idColumn = fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_ID);
+    // Set up list of all IDs
+    for (int i = 0; i < numOfTracks; i++) {
+        TrackId trackId(index(i, idColumn).data());
+        int oldPosition = index(i, positionColumn).data().toInt();
+        idPosList.append(std::make_pair(trackId, oldPosition));
+    }
+    m_pTrackCollectionManager->internalCollection()
+            ->getPlaylistDAO()
+            .orderTracksByCurrPos(m_iPlaylistId, idPosList);
+}
+
 const QList<int> PlaylistTableModel::getSelectedPositions(const QModelIndexList& indices) const {
     if (indices.isEmpty()) {
         return {};

src/library/playlisttablemodel.h

@@ -22,6 +22,7 @@ class PlaylistTableModel final : public TrackSetTableModel {
     void moveTrack(const QModelIndex& sourceIndex, const QModelIndex& destIndex) override;
     void removeTrack(const QModelIndex& index);
     void shuffleTracks(const QModelIndexList& shuffle, const QModelIndex& exclude);
+    void orderTracksByCurrPos() override;
 
     bool isColumnInternal(int column) final;
     bool isColumnHiddenByDefault(int column) final;

src/library/trackmodel.h

@@ -187,6 +187,7 @@ class TrackModel {
         Q_UNUSED(sourceIndex);
         Q_UNUSED(destIndex);
     }
+    virtual void orderTracksByCurrPos() {};
     virtual bool isLocked() {
         return false;
     }

src/widget/wtracktableview.cpp

@@ -307,6 +307,10 @@ void WTrackTableView::loadTrackModel(QAbstractItemModel* model, bool restoreStat
                 &WTrackTableViewHeader::shuffle,
                 this,
                 &WTrackTableView::slotRandomSorting);
+        connect(pHeader,
+                &WTrackTableViewHeader::adoptSortOrder,
+                this,
+                &WTrackTableView::slotAdoptSortOrderForPlaylist);
 
         Qt::SortOrder sortOrder;
         TrackModel::SortColumnId sortColumn =
@@ -1838,6 +1842,24 @@ void WTrackTableView::slotSortingChanged(int headerSection, Qt::SortOrder order)
     }
 }
 
+void WTrackTableView::slotAdoptSortOrderForPlaylist() {
+    TrackModel* pTrackModel = getTrackModel();
+    if (!pTrackModel) {
+        return;
+    }
+    if (!pTrackModel->hasCapabilities(TrackModel::Capability::Reorder)) {
+        return;
+    }
+
+    int sortColumnId = static_cast<int>(m_pSortColumn->get());
+    if (sortColumnId == static_cast<int>(TrackModel::SortColumnId::Position)) {
+        // If already sorted by number there's noting to do
+        return;
+    }
+    pTrackModel->orderTracksByCurrPos();
+    // TODO should we resort by # ??
+}
+
 void WTrackTableView::slotRandomSorting() {
     // There's no need to remove the shuffle feature of the Preview column
     // (and replace it with a dedicated randomize slot to BaseSqltableModel),

src/widget/wtracktableview.h

@@ -146,6 +146,7 @@ class WTrackTableView : public WLibraryTableView {
 
     void slotSortingChanged(int headerSection, Qt::SortOrder order);
     void slotRandomSorting();
+    void slotAdoptSortOrderForPlaylist();
     void keyNotationChanged();
 
   protected:

src/widget/wtracktableviewheader.cpp

@@ -218,6 +218,17 @@ void WTrackTableViewHeader::setModel(QAbstractItemModel* model) {
                 /*signal-to-signal*/ Qt::DirectConnection);
         m_menu.addAction(pShuffleAction);
     }
+    // Only show the "adopt order" action in models that support reordering
+    if (pTrackModel->hasCapabilities(TrackModel::Capability::Sorting) &&
+            pTrackModel->hasCapabilities(TrackModel::Capability::Reorder)) {
+        auto pAdoptSortorderAction = make_parented<QAction>(tr("Adopt sort order"), &m_menu);
+        connect(pAdoptSortorderAction,
+                &QAction::triggered,
+                this,
+                &WTrackTableViewHeader::adoptSortOrder,
+                /*signal-to-signal*/ Qt::DirectConnection);
+        m_menu.addAction(pAdoptSortorderAction);
+    }
 
     // Safety check against someone getting stuck with all columns hidden
     // (produces an empty library table). Just re-show them all.

src/widget/wtracktableviewheader.h

@@ -68,6 +68,7 @@ class WTrackTableViewHeader : public QHeaderView {
 
   signals:
     void shuffle();
+    void adoptSortOrder();
 
   private slots:
     void showOrHideColumn(int);