Merge branch '2.5' into '2.6'

Author: mixxxbot

src/effects/backends/builtin/echoeffect.cpp

@@ -167,13 +167,13 @@ void EchoEffect::processChannel(
     int read_position = pGroupState->write_position;
     decrementRing(&read_position, delay_samples, pGroupState->delay_buf.size());
 
-    RampingValue<CSAMPLE_GAIN> send(send_current,
-            pGroupState->prev_send,
+    RampingValue<CSAMPLE_GAIN> send(pGroupState->prev_send,
+            send_current,
             engineParameters.framesPerBuffer());
     // Feedback the delay buffer and then add the new input.
 
-    RampingValue<CSAMPLE_GAIN> feedback(feedback_current,
-            pGroupState->prev_feedback,
+    RampingValue<CSAMPLE_GAIN> feedback(pGroupState->prev_feedback,
+            feedback_current,
             engineParameters.framesPerBuffer());
 
     int rampIndex = 0;

src/library/dao/playlistdao.cpp

@@ -13,7 +13,8 @@
 #include "util/math.h"
 
 PlaylistDAO::PlaylistDAO()
-        : m_pAutoDJProcessor(nullptr) {
+        : m_currentHistoryPlaylist(kInvalidPlaylistId),
+          m_pAutoDJProcessor(nullptr) {
 }
 
 void PlaylistDAO::initialize(const QSqlDatabase& database) {
@@ -330,19 +331,35 @@ bool PlaylistDAO::deleteUnlockedPlaylists(QStringList&& idStringList) {
 }
 
 bool PlaylistDAO::deleteAllUnlockedPlaylistsWithFewerTracks(
-        PlaylistDAO::HiddenType type, int minNumberOfTracks) {
+        PlaylistDAO::HiddenType type,
+        int minNumberOfTracks,
+        bool skipCurrHistory) {
+    // Note: this slot is also called after purging tracks in order to delete
+    // now empty history playlists.
+    // Though, if the current History is now also empty, we must not delete that!
+    // Else the following session log is lost -- or rather not recorded in the
+    // first place since the id passed to appendTrackToPlaylist() does not exist
+    // anymore.
+    // skipCurrHistory prevents that.
     VERIFY_OR_DEBUG_ASSERT(minNumberOfTracks > 0) {
         return false; // nothing to do, probably unintended invocation
     }
 
     QSqlQuery query(m_database);
-    query.prepare(QStringLiteral(
+    QString queryString = QStringLiteral(
             "SELECT id FROM Playlists  "
             "WHERE (SELECT count(playlist_id) FROM PlaylistTracks WHERE "
             "Playlists.ID = PlaylistTracks.playlist_id) < :length AND "
-            "Playlists.hidden = :hidden AND Playlists.locked = 0"));
+            "Playlists.hidden = :hidden AND Playlists.locked = 0");
+    if (skipCurrHistory) {
+        queryString.append(QStringLiteral(" AND Playlists.ID != :currHistoryId"));
+    }
+    query.prepare(queryString);
     query.bindValue(":hidden", static_cast<int>(type));
     query.bindValue(":length", minNumberOfTracks);
+    if (skipCurrHistory) {
+        query.bindValue(":currHistoryId", m_currentHistoryPlaylist);
+    }
     if (!query.exec()) {
         LOG_FAILED_QUERY(query);
         return false;
@@ -352,6 +369,11 @@ bool PlaylistDAO::deleteAllUnlockedPlaylistsWithFewerTracks(
     while (query.next()) {
         idStringList.append(query.value(0).toString());
     }
+
+    if (idStringList.isEmpty()) {
+        return false;
+    }
+
     qInfo() << "Prepared deletion of" << idStringList.size() << "playlists of type" << type
             << "that contain fewer than" << minNumberOfTracks << "tracks";
 
@@ -481,9 +503,29 @@ bool PlaylistDAO::removeTracksFromPlaylist(int playlistId, int startIndex) {
     return true;
 }
 
+bool PlaylistDAO::playlistExists(const int playlistId) const {
+    ScopedTransaction transaction(m_database);
+    QSqlQuery query(m_database);
+    query.prepare(QStringLiteral("SELECT id FROM Playlists WHERE id = :id"));
+    query.bindValue(":id", playlistId);
+
+    if (!query.exec()) {
+        LOG_FAILED_QUERY(query);
+        return false;
+    }
+
+    if (query.next()) {
+        // id is guaranteed to be unique, so we can return here
+        return true;
+    }
+    // not found
+    return false;
+}
+
 bool PlaylistDAO::appendTracksToPlaylist(const QList<TrackId>& trackIds, const int playlistId) {
     // qDebug() << "PlaylistDAO::appendTracksToPlaylist"
     //          << QThread::currentThread() << m_database.connectionName();
+    DEBUG_ASSERT(playlistExists(playlistId));
 
     // Start the transaction
     ScopedTransaction transaction(m_database);
@@ -1094,7 +1136,8 @@ void PlaylistDAO::removeTracksFromPlaylists(const QList<TrackId>& trackIds, bool
     transaction.commit();
 
     // We may now have empty history playlists. Remove them.
-    deleteAllUnlockedPlaylistsWithFewerTracks(PlaylistDAO::PLHT_SET_LOG, 1);
+    // Note: does not delete current History playlist.
+    deleteAllUnlockedPlaylistsWithFewerTracks(PlaylistDAO::PLHT_SET_LOG, 1, true);
 
     // update the sidebar
     emit playlistContentChanged(playlistIds);

src/library/dao/playlistdao.h

@@ -48,7 +48,8 @@ class PlaylistDAO : public QObject, public virtual DAO {
     /// Needs to be called inside a transaction.
     /// @return true on success, false on error
     bool deleteAllUnlockedPlaylistsWithFewerTracks(const PlaylistDAO::HiddenType type,
-            int minNumberOfTracks);
+            int minNumberOfTracks,
+            bool skipCurrHistory = false);
     // Rename a playlist
     void renamePlaylist(const int playlistId, const QString& newName);
     // Lock or unlock a playlist
@@ -57,6 +58,8 @@ class PlaylistDAO : public QObject, public virtual DAO {
     int setPlaylistsLocked(const QSet<int>& playlistIds, const bool lock);
     // Find out the state of a playlist lock
     bool isPlaylistLocked(const int playlistId) const;
+    // Check if a playlist exists
+    bool playlistExists(const int playlistId) const;
     // Append a list of tracks to a playlist
     bool appendTracksToPlaylist(const QList<TrackId>& trackIds, const int playlistId);
     // Append a track to a playlist
@@ -120,6 +123,10 @@ class PlaylistDAO : public QObject, public virtual DAO {
 
     void getPlaylistsTrackIsIn(TrackId trackId, QSet<int>* playlistSet) const;
 
+    void setCurrentHistoryPlaylistId(int id) {
+        m_currentHistoryPlaylist = id;
+    }
+
     void setAutoDJProcessor(AutoDJProcessor* pAutoDJProcessor);
 
   signals:
@@ -151,6 +158,7 @@ class PlaylistDAO : public QObject, public virtual DAO {
     void populatePlaylistMembershipCache();
 
     QMultiHash<TrackId, int> m_playlistsTrackIsIn;
+    int m_currentHistoryPlaylist;
     AutoDJProcessor* m_pAutoDJProcessor;
     DISALLOW_COPY_AND_ASSIGN(PlaylistDAO);
 };

src/library/trackset/setlogfeature.cpp

@@ -383,6 +383,7 @@ void SetlogFeature::slotGetNewPlaylist() {
                  << set_log_name;
     } else {
         m_recentTracks.clear();
+        m_playlistDao.setCurrentHistoryPlaylistId(m_currentPlaylistId);
     }
 
     // reload child model again because the 'added' signal fired by PlaylistDAO
@@ -447,6 +448,7 @@ void SetlogFeature::slotJoinWithPrevious() {
 
         // Change current setlog
         m_currentPlaylistId = previousPlaylistId;
+        m_playlistDao.setCurrentHistoryPlaylistId(m_currentPlaylistId);
     }
     qDebug() << "slotJoinWithPrevious() current:"
              << clickedPlaylistId

src/widget/wlibrarytableview.cpp

@@ -111,15 +111,45 @@ bool WLibraryTableView::restoreTrackModelState(
     verticalScrollBar()->setValue(state->verticalScrollPosition);
     horizontalScrollBar()->setValue(state->horizontalScrollPosition);
 
-    auto* pSelection = selectionModel();
-    pSelection->clearSelection();
+    // Build a selection range rather than selecting each track individually,
+    // which can lag the GUI by spamming selectionChanged() handlers.
+    QItemSelectionModel* pSelectionModel = selectionModel();
+    pSelectionModel->clearSelection();
+    QItemSelection newSelection;
     QModelIndexList selectedRows = state->selectedRows;
+    QModelIndex topLeft;
+    QModelIndex bottomRight;
     if (!selectedRows.isEmpty()) {
-        for (auto index : std::as_const(selectedRows)) {
-            pSelection->select(index,
-                    QItemSelectionModel::Select | QItemSelectionModel::Rows);
+        // In saveTrackModelState() we fill state->selectedRows with the sorted
+        // rows, hence no need to sort here.
+        for (const QModelIndex& index : std::as_const(selectedRows)) {
+            if (!topLeft.isValid()) {
+                // start new range. only done once for first row
+                topLeft = index;
+                bottomRight = index;
+                continue;
+            }
+
+            if (index.row() == bottomRight.row() + 1) {
+                // continuous range
+                bottomRight = index;
+                continue;
+            } else {
+                // prev index was end of range, add current range to selection
+                // and start a new one
+                newSelection.select(topLeft, bottomRight);
+                topLeft = index;
+                bottomRight = index;
+            }
+        }
+
+        // If we reached end, submit the last selection
+        if (bottomRight == selectedRows.last()) {
+            newSelection.select(topLeft, bottomRight);
         }
     }
+    pSelectionModel->select(newSelection,
+            QItemSelectionModel::Select | QItemSelectionModel::Rows);
 
     QModelIndex currIndex = state->currentIndex;
     restoreCurrentIndex(currIndex);