Merge lp:~daschuer/mixxx/1.10-autodj into lp:mixxx/1.10

[Daniel Schürmann]

Back port of the auto DJ patches, without the new controls.

[RJ Skerry-Ryan (rryan)]

Looks good -- please merge!

review: Approve

[Daniel Schürmann (daschuer)]

Merged to #3107

=== modified file 'mixxx/src/dlgautodj.cpp'
--- mixxx/src/dlgautodj.cpp	2011-11-30 06:19:47 +0000
+++ mixxx/src/dlgautodj.cpp	2012-05-31 20:47:26 +0000
@@ -1,28 +1,35 @@
 #include <QSqlTableModel>
-#include "widget/wwidget.h"
-#include "widget/wskincolor.h"
-#include "widget/wtracktableview.h"
+
+#include "dlgautodj.h"
+
 #include "controlobject.h"
 #include "controlobjectthreadmain.h"
+#include "library/playlisttablemodel.h"
 #include "library/trackcollection.h"
-#include "library/playlisttablemodel.h"
-#include "dlgautodj.h"
+#include "playerinfo.h"
+#include "widget/wskincolor.h"
+#include "widget/wtracktableview.h"
+#include "widget/wwidget.h"
 
+#define CONFIG_KEY "[Auto DJ]"
 
 DlgAutoDJ::DlgAutoDJ(QWidget* parent, ConfigObject<ConfigValue>* pConfig,
-                     TrackCollection* pTrackCollection, MixxxKeyboard* pKeyboard)
-     : QWidget(parent), Ui::DlgAutoDJ(), m_playlistDao(pTrackCollection->getPlaylistDAO())
-{
+                     TrackCollection* pTrackCollection,
+                     MixxxKeyboard* pKeyboard)
+        : QWidget(parent),
+          Ui::DlgAutoDJ(),
+          m_pConfig(pConfig),
+          m_pTrackCollection(pTrackCollection),
+          m_pTrackTableView(
+              new WTrackTableView(this, pConfig, m_pTrackCollection)),
+          m_playlistDao(pTrackCollection->getPlaylistDAO()),
+          m_bFadeNow(false),
+          m_eState(ADJ_DISABLED),
+          m_posThreshold1(1.0f),
+          m_posThreshold2(1.0f) {
     setupUi(this);
 
-    m_pConfig = pConfig;
-    m_pTrackCollection = pTrackCollection;
-    m_bAutoDJEnabled = false;
-    m_bPlayer1Primed = false;
-    m_bPlayer2Primed = false;
-    m_pTrackTableView = new WTrackTableView(this, pConfig, m_pTrackCollection);
     m_pTrackTableView->installEventFilter(pKeyboard);
-
     connect(m_pTrackTableView, SIGNAL(loadTrack(TrackPointer)),
             this, SIGNAL(loadTrack(TrackPointer)));
     connect(m_pTrackTableView, SIGNAL(loadTrackToPlayer(TrackPointer, QString)),
@@ -34,8 +41,8 @@
     m_pTrackTablePlaceholder->hide();
     box->insertWidget(1, m_pTrackTableView);
 
-    m_pAutoDJTableModel =  new PlaylistTableModel(this, pTrackCollection,
-                                                  "mixxx.db.model.autodj");
+    m_pAutoDJTableModel = new PlaylistTableModel(this, pTrackCollection,
+                                                 "mixxx.db.model.autodj");
     int playlistId = m_playlistDao.getPlaylistIdFromName(AUTODJ_TABLE);
     if (playlistId < 0) {
         m_playlistDao.createPlaylist(AUTODJ_TABLE, true);
@@ -44,7 +51,7 @@
     m_pAutoDJTableModel->setPlaylist(playlistId);
     m_pTrackTableView->loadTrackModel(m_pAutoDJTableModel);
 
-    //Override some playlist-view properties:
+    // Override some playlist-view properties:
 
     // Do not set this because it disables auto-scrolling
     //m_pTrackTableView->setDragDropMode(QAbstractItemView::InternalMove);
@@ -58,40 +65,49 @@
     connect(pushButtonAutoDJ, SIGNAL(toggled(bool)),
             this,  SLOT(toggleAutoDJ(bool))); _blah;
 
+    // playposition is from -0.14 to + 1.14
     m_pCOPlayPos1 = new ControlObjectThreadMain(
-                            ControlObject::getControl(ConfigKey("[Channel1]", "playposition")));
+        ControlObject::getControl(ConfigKey("[Channel1]", "playposition")));
     m_pCOPlayPos2 = new ControlObjectThreadMain(
-                            ControlObject::getControl(ConfigKey("[Channel2]", "playposition")));
+        ControlObject::getControl(ConfigKey("[Channel2]", "playposition")));
     m_pCOPlay1 = new ControlObjectThreadMain(
-                            ControlObject::getControl(ConfigKey("[Channel1]", "play")));
+        ControlObject::getControl(ConfigKey("[Channel1]", "play")));
     m_pCOPlay2 = new ControlObjectThreadMain(
-                            ControlObject::getControl(ConfigKey("[Channel2]", "play")));
+        ControlObject::getControl(ConfigKey("[Channel2]", "play")));
+    m_pCOPlay1Fb = new ControlObjectThreadMain(
+        ControlObject::getControl(ConfigKey("[Channel1]", "play")));
+    m_pCOPlay2Fb = new ControlObjectThreadMain(
+        ControlObject::getControl(ConfigKey("[Channel2]", "play")));
     m_pCORepeat1 = new ControlObjectThreadMain(
-                            ControlObject::getControl(ConfigKey("[Channel1]", "repeat")));
+        ControlObject::getControl(ConfigKey("[Channel1]", "repeat")));
     m_pCORepeat2 = new ControlObjectThreadMain(
-                            ControlObject::getControl(ConfigKey("[Channel2]", "repeat")));
+        ControlObject::getControl(ConfigKey("[Channel2]", "repeat")));
     m_pCOCrossfader = new ControlObjectThreadMain(
-                            ControlObject::getControl(ConfigKey("[Master]", "crossfader")));
+        ControlObject::getControl(ConfigKey("[Master]", "crossfader")));
 }
 
-DlgAutoDJ::~DlgAutoDJ()
-{
+DlgAutoDJ::~DlgAutoDJ() {
+    qDebug() << "~DlgAutoDJ()";
     delete m_pCOPlayPos1;
     delete m_pCOPlayPos2;
     delete m_pCOPlay1;
     delete m_pCOPlay2;
+    delete m_pCOPlay1Fb;
+    delete m_pCOPlay2Fb;
+    delete m_pCORepeat1;
     delete m_pCORepeat2;
     delete m_pCOCrossfader;
+    // Delete m_pTrackTableView before the table model. This is because the
+    // table view saves the header state using the model.
+    delete m_pTrackTableView;
+    delete m_pAutoDJTableModel;
 }
 
-void DlgAutoDJ::onShow()
-{
+void DlgAutoDJ::onShow() {
     m_pAutoDJTableModel->select();
 }
 
-void DlgAutoDJ::setup(QDomNode node)
-{
-
+void DlgAutoDJ::setup(QDomNode node) {
     QPalette pal = palette();
 
     // Row colors
@@ -108,9 +124,6 @@
         // the future this should be configurable from the skin with this as the
         // fallback option
         QColor text(255 - r1.red(), 255 - r1.green(), 255 - r1.blue());
-
-        //setAlternatingRowColors ( true );
-
         QColor fgColor;
         fgColor.setNamedColor(WWidget::selectNodeQString(node, "FgColor"));
         fgColor = WSkinColor::getCorrectColor(fgColor);
@@ -119,26 +132,24 @@
         pal.setColor(QPalette::AlternateBase, r2);
         pal.setColor(QPalette::Text, text);
         pal.setColor(QPalette::WindowText, fgColor);
-
     }
 
     setPalette(pal);
 
     pushButtonAutoDJ->setPalette(pal);
-    //m_pTrackTableView->setPalette(pal); //Since we're getting this passed into us already created,
-                                          //shouldn't need to set the palette.
-}
-
-void DlgAutoDJ::onSearchStarting()
-{
-}
-
-void DlgAutoDJ::onSearchCleared()
-{
-}
-
-void DlgAutoDJ::onSearch(const QString& text)
-{
+
+    // Since we're getting this passed into us already created, shouldn't need
+    // to set the palette.
+    //m_pTrackTableView->setPalette(pal);
+}
+
+void DlgAutoDJ::onSearchStarting() {
+}
+
+void DlgAutoDJ::onSearchCleared() {
+}
+
+void DlgAutoDJ::onSearch(const QString& text) {
     m_pAutoDJTableModel->search(text);
 }
 
@@ -154,204 +165,427 @@
     m_pTrackTableView->moveSelection(delta);
 }
 
-void DlgAutoDJ::shufflePlaylist(bool buttonChecked)
-{
+void DlgAutoDJ::shufflePlaylist(bool buttonChecked) {
     Q_UNUSED(buttonChecked);
     qDebug() << "Shuffling AutoDJ playlist";
-    m_pAutoDJTableModel->shuffleTracks(m_pAutoDJTableModel->index(0, 0));
+    int row;
+    if(m_eState == ADJ_DISABLED) {
+        row = 0;
+    } else {
+        row = 1;
+    }
+    m_pAutoDJTableModel->shuffleTracks(m_pAutoDJTableModel->index(row, 0));
     qDebug() << "Shuffling done";
 }
 
-void DlgAutoDJ::toggleAutoDJ(bool toggle)
-{
-    if (toggle) //Enable Auto DJ
-    {
-        if (m_pCOPlay1->get() == 1.0f && m_pCOPlay2->get() == 1.0f) {
-            qDebug() << "One player must be stopped before enabling Auto DJ mode";
-            pushButtonAutoDJ->setChecked(false);
-            return;
-        }
-
+void DlgAutoDJ::skipNext(bool buttonChecked) {
+    Q_UNUSED(buttonChecked);
+    qDebug() << "Skip Next";
+    // Load the next song from the queue.
+    if (m_pCOPlay1Fb->get() == 0.0f) {
+        removePlayingTrackFromQueue("[Channel1]");
+        loadNextTrackFromQueue();
+    } else if (m_pCOPlay2Fb->get() == 0.0f) {
+        removePlayingTrackFromQueue("[Channel2]");
+        loadNextTrackFromQueue();
+    }
+}
+
+void DlgAutoDJ::fadeNow(bool buttonChecked) {
+    Q_UNUSED(buttonChecked);
+    qDebug() << "Fade Now";
+    if (m_eState == ADJ_IDLE) {
+        m_bFadeNow = true;
+        double crossfader = m_pCOCrossfader->get();
+        if (crossfader <= 0.3f && m_pCOPlay1Fb->get() == 1.0f) {
+            m_posThreshold1 = m_pCOPlayPos1->get() -
+                    ((crossfader + 1.0f) / 2 * (m_fadeDuration1));
+            // Repeat is disabled by FadeNow but disables auto Fade
+            m_pCORepeat1->slotSet(0.0f);
+        } else if (crossfader >= -0.3f && m_pCOPlay2Fb->get() == 1.0f) {
+            m_posThreshold2 = m_pCOPlayPos2->get() -
+                    ((1.0f - crossfader) / 2 * (m_fadeDuration2));
+            // Repeat is disabled by FadeNow but disables auto Fade
+            m_pCORepeat2->slotSet(0.0f);
+        }
+    }
+}
+
+void DlgAutoDJ::toggleAutoDJ(bool toggle) {
+    bool deck1Playing = m_pCOPlay1Fb->get() == 1.0f;
+    bool deck2Playing = m_pCOPlay2Fb->get() == 1.0f;
+
+    if (toggle) {  // Enable Auto DJ
+        if (deck1Playing && deck2Playing) {
+            QMessageBox::warning(
+                NULL, tr("Auto-DJ"),
+                tr("One deck must be stopped to enable Auto-DJ mode."),
+                QMessageBox::Ok);
+            qDebug() << "One deck must be stopped before enabling Auto DJ mode";
+            pushButtonAutoDJ->setChecked(false);
+            return;
+        }
+
+        // Never load the same track if it is already playing
+        if (deck1Playing) {
+            removePlayingTrackFromQueue("[Channel1]");
+        }
+        if (deck2Playing) {
+            removePlayingTrackFromQueue("[Channel2]");
+        }
+
+        TrackPointer nextTrack = getNextTrackFromQueue();
+        if (!nextTrack) {
+            qDebug() << "Queue is empty now";
+            pushButtonAutoDJ->setChecked(false);
+            return;
+        }
+
+        // Track is available so GO
+        pushButtonAutoDJ->setToolTip(tr("Disable Auto DJ"));
         pushButtonAutoDJ->setText(tr("Disable Auto DJ"));
-        m_bAutoDJEnabled = true;
+        qDebug() << "Auto DJ enabled";
+
         connect(m_pCOPlayPos1, SIGNAL(valueChanged(double)),
-        this, SLOT(player1PositionChanged(double)));
+                this, SLOT(player1PositionChanged(double)));
         connect(m_pCOPlayPos2, SIGNAL(valueChanged(double)),
-        this, SLOT(player2PositionChanged(double)));
-
-
-        //Manually override the "next track is already loaded" flag
-        //because we've already primed a player with the first track.
-        //We do this so that you don't lose the first song in your
-        //Auto DJ queue if you enable Auto DJ then change your mind
-        //and disable it right away. This just makes it a little bit
-        //more user friendly. :)
-        //m_bNextTrackAlreadyLoaded = true;
-        m_bPlayer1Primed = false;
-        m_bPlayer2Primed = false;
-
-        //If there are no tracks in the Auto DJ queue, disable Auto DJ mode.
-       /* if (m_pAutoDJTableModel->rowCount() == 0)
-        {
-            //Queue was empty. Disable and return.
-            pushButtonAutoDJ->setChecked(false);
-            return;
-        }*/ //don't need this code, above block takes care of this case.
-
-        //If only one of the players is playing...
-        if ((m_pCOPlay1->get() == 1.0f && m_pCOPlay2->get() == 0.0f) ||
-            (m_pCOPlay1->get() == 0.0f && m_pCOPlay2->get() == 1.0f))
-        {
-            //Load the first song from the queue.
-            if (!loadNextTrackFromQueue(false)) {
-                //Queue was empty. Disable and return.
-                pushButtonAutoDJ->setChecked(false);
-                return;
-            }
-            //Set the primed flags so the crossfading algorithm knows
-            //that it doesn't need to load a track into whatever player.
-            if (m_pCOPlay1->get() == 1.0f)
-            {
-                m_bPlayer1Primed = true;
-            }
-            if (m_pCOPlay2->get() == 1.0f)
-            {
-                m_bPlayer2Primed = true;
-            }
-        }
-        //If both players are stopped, start the first one (which should have just had a track loaded into it)
-        else if (m_pCOPlay1->get() == 0.0f && m_pCOPlay2->get() == 0.0f) {
-            //Load the first song from the queue.
-            if (!loadNextTrackFromQueue(false)) {
-                //Queue was empty. Disable and return.
-                pushButtonAutoDJ->setChecked(false);
-                return;
-            }
-            m_pCOCrossfader->slotSet(-1.0f); //Move crossfader to the left!
-            m_pCORepeat1->slotSet(1.0f); //Turn on repeat mode to avoid race condition between async load
-                                               //and "play" command.
-            m_pCOPlay1->slotSet(1.0f); //Play the track in player 1
-        }
-    }
-    else //Disable Auto DJ
-    {
+                this, SLOT(player2PositionChanged(double)));
+
+        connect(m_pCOPlay1Fb, SIGNAL(valueChanged(double)),
+                this, SLOT(player1PlayChanged(double)));
+        connect(m_pCOPlay2Fb, SIGNAL(valueChanged(double)),
+                this, SLOT(player2PlayChanged(double)));
+
+        if (!deck1Playing && !deck2Playing) {
+            // both decks are stopped
+            m_eState = ADJ_ENABLE_P1LOADED;
+            // Force Update on load Track
+            m_pCOPlayPos1->slotSet(-0.001f);
+        } else {
+            m_eState = ADJ_IDLE;
+            if (deck1Playing) {
+                // deck 1 is already playing
+                player1PlayChanged(1.0f);
+            } else {
+                // deck 2 is already playing
+                player2PlayChanged(1.0f);
+            }
+        }
+        // Loads into first deck If stopped else into second else not
+        emit(loadTrack(nextTrack));
+    } else {  // Disable Auto DJ
+        pushButtonAutoDJ->setToolTip(tr("Enable Auto DJ"));
         pushButtonAutoDJ->setText(tr("Enable Auto DJ"));
         qDebug() << "Auto DJ disabled";
-        m_bAutoDJEnabled = false;
+        m_eState = ADJ_DISABLED;
+        m_bFadeNow = false;
         m_pCOPlayPos1->disconnect(this);
         m_pCOPlayPos2->disconnect(this);
-        m_pCORepeat1->slotSet(0.0f); //Turn off repeat mode
-        m_pCORepeat2->slotSet(0.0f); //Turn off repeat mode
-    }
-}
-
-void DlgAutoDJ::player1PositionChanged(double value)
-{
-    const float posThreshold = 0.95; //95% playback is when we crossfade and do stuff
-    if (value > posThreshold)
-    {
-        //Crossfade!
-        float crossfadeValue = -1.0f + 2*(value-posThreshold)/(1.0f-posThreshold);
-        m_pCOCrossfader->slotSet(crossfadeValue); //Move crossfader to the right!
-        //If the second player doesn't have a new track loaded in it...
-        if (!m_bPlayer2Primed)
-        {
-            qDebug() << "pp1c loading";
-
-            //Load the next track into Player 2
-            //if (!m_bNextTrackAlreadyLoaded) //Fudge to make us not skip the first track
-            {
-                if (!loadNextTrackFromQueue(true))
-                    return;
-            }
-            //m_bNextTrackAlreadyLoaded = false; //Reset fudge
-            m_bPlayer2Primed = true;
-        }
-        //If the second player is stopped...
-        if (m_pCOPlay2->get() == 0.0f)
-        {
-            //Turn off repeat mode to tell Player 1 to stop at the end
-            m_pCORepeat1->slotSet(0.0f);
-
-            //Turn on repeat mode to tell Player 2 to start playing when the new track is loaded.
-            //This helps us get around the fact that it takes time for the track to be loaded
-            //and that is executed asynchronously (so we get around the race condition).
-            m_pCORepeat2->slotSet(1.0f);
-            //Play!
-            m_pCOPlay2->slotSet(1.0f);
-        }
-
-        if (value == 1.0f)
-        {
-            m_pCOPlay1->slotSet(0.0f); //Stop the player
-            m_bPlayer1Primed = false;
-        }
-    }
-}
-
-void DlgAutoDJ::player2PositionChanged(double value)
-{
-    const float posThreshold = 0.95; //95% playback is when we crossfade and do stuff
-    if (value > posThreshold)
-    {
-        //Crossfade!
-        float crossfadeValue = 1.0f - 2*(value-posThreshold)/(1.0f-posThreshold);
-        m_pCOCrossfader->slotSet(crossfadeValue); //Move crossfader to the right!
-
-        //If the first player doesn't have the next track loaded, load a track into
-        //it and start playing it!
-        if (!m_bPlayer1Primed)
-        {
-            //Load the next track into player 1
-            //if (!m_bNextTrackAlreadyLoaded) //Fudge to make us not skip the first track
-            {
-                if (!loadNextTrackFromQueue(true))
-                    return;
-            }
-            //m_bNextTrackAlreadyLoaded = false; //Reset fudge
-            m_bPlayer1Primed = true;
-        }
-        if (m_pCOPlay1->get() == 0.0f)
-        {
-            //Turn off repeat mode to tell Player 2 to stop at the end
-            m_pCORepeat2->slotSet(0.0f);
-
-            //Turn on repeat mode to tell Player 1 to start playing when the new track is loaded.
-            //This helps us get around the fact that it takes time for the track to be loaded
-            //and that is executed asynchronously (so we get around the race condition).
-            m_pCORepeat1->slotSet(1.0f);
-            m_pCOPlay1->slotSet(1.0f);
-        }
-
-        if (value == 1.0f)
-        {
-            m_pCOPlay2->slotSet(0.0f); //Stop the player
-            m_bPlayer2Primed = false;
-        }
-    }
-}
-
-
-bool DlgAutoDJ::loadNextTrackFromQueue(bool removeTopMostBeforeLoading)
-{
-    if (removeTopMostBeforeLoading) {
-        //Only remove the top track if this isn't the start of Auto DJ mode.
-        m_pAutoDJTableModel->removeTrack(m_pAutoDJTableModel->index(0, 0));
-    }
-
-    //Get the track at the top of the playlist...
-    TrackPointer nextTrack = m_pAutoDJTableModel->getTrack(m_pAutoDJTableModel->index(0, 0));
-
-    if (!nextTrack) //We ran out of tracks in the queue...
-    {
-        //Disable auto DJ and return...
+        m_pCOPlay1->disconnect(this);
+        m_pCOPlay2->disconnect(this);
+    }
+}
+
+void DlgAutoDJ::player1PositionChanged(double value) {
+    // 95% playback is when we crossfade and do stuff
+    // const float posThreshold = 0.95;
+
+    // 0.05; // 5% playback is crossfade duration
+    const float fadeDuration = m_fadeDuration1;
+
+    // qDebug() << "player1PositionChanged(" << value << ")";
+    if (m_eState == ADJ_DISABLED) {
+        //nothing to do
+        return;
+    }
+
+    bool deck1Playing = m_pCOPlay1Fb->get() == 1.0f;
+    bool deck2Playing = m_pCOPlay2Fb->get() == 1.0f;
+
+    if (m_eState == ADJ_ENABLE_P1LOADED) {
+        // Auto DJ Start
+        if (!deck1Playing && !deck2Playing) {
+            m_pCOCrossfader->slotSet(-1.0f);  // Move crossfader to the left!
+            m_pCOPlay1->slotSet(1.0f);  // Play the track in player 1
+            removePlayingTrackFromQueue("[Channel1]");
+        } else {
+            m_eState = ADJ_IDLE;
+            if (deck1Playing && !deck2Playing) {
+                // Here we are, if first deck was playing before starting Auto DJ
+                // or if it was started just before
+                loadNextTrackFromQueue();
+                // if we start the deck from code we don`t get a signal
+                player1PlayChanged(1.0f);
+                // call function manually
+            } else {
+                player2PlayChanged(1.0f);
+            }
+        }
+        return;
+    }
+
+    if (m_eState == ADJ_P2FADING) {
+        if (deck1Playing && !deck2Playing) {
+            // End State
+            m_pCOCrossfader->slotSet(-1.0f);  // Move crossfader to the left!
+            // qDebug() << "1: m_pCOCrossfader->slotSet(_-1.0f_);";
+            m_eState = ADJ_IDLE;
+            loadNextTrackFromQueue();
+        }
+        return;
+    }
+
+    if (m_eState == ADJ_IDLE) {
+        if (m_pCORepeat1->get() == 1.0f) {
+            // repeat disables auto DJ
+            return;
+        }
+    }
+
+    if (value >= m_posThreshold1) {
+        if (m_eState == ADJ_IDLE &&
+            (deck1Playing || m_posThreshold1 >= 1.0f)) {
+            if (!deck2Playing) {
+                // Start Deck 2
+                player2PlayChanged(1.0f);
+                m_pCOPlay2->slotSet(1.0f);
+                if (fadeDuration < 0.0f) {
+                    // Scroll back for pause between tracks
+                    m_pCOPlayPos2->slotSet(m_fadeDuration2);
+                }
+            }
+            removePlayingTrackFromQueue("[Channel2]");
+            m_eState = ADJ_P1FADING;
+        }
+
+        float posFadeEnd = math_min(1.0, m_posThreshold1 + fadeDuration);
+
+        if (value >= posFadeEnd) {
+            // Pre-EndState
+            // m_pCOCrossfader->slotSet(1.0f); //Move crossfader to the right!
+
+            m_pCOPlay1->slotSet(0.0f);  // Stop the player
+            //m_posThreshold = 1.0f - fadeDuration; // back to default
+
+            // does not work always immediately after stop
+            // loadNextTrackFromQueue();
+            // m_eState = ADJ_IDLE; // Fading ready
+        } else {
+            // Crossfade!
+            float crossfadeValue = -1.0f +
+                    2*(value-m_posThreshold1)/(posFadeEnd-m_posThreshold1);
+            // crossfadeValue = -1.0f -> + 1.0f
+            // Move crossfader to the right!
+            m_pCOCrossfader->slotSet(crossfadeValue);
+            // qDebug() << "1: m_pCOCrossfader->slotSet " << crossfadeValue;
+        }
+    }
+}
+
+void DlgAutoDJ::player2PositionChanged(double value) {
+    // 95% playback is when we crossfade and do stuff
+    // const float posThreshold = 0.95;
+
+    // 0.05; // 5% playback is crossfade duration
+    float fadeDuration = m_fadeDuration2;
+
+    //qDebug() << "player2PositionChanged(" << value << ")";
+    if (m_eState == ADJ_DISABLED) {
+        //nothing to do
+        return;
+    }
+
+    bool deck1Playing = m_pCOPlay1Fb->get() == 1.0f;
+    bool deck2Playing = m_pCOPlay2Fb->get() == 1.0f;
+
+    if (m_eState == ADJ_P1FADING) {
+        if (!deck1Playing && deck2Playing) {
+            // End State
+            // Move crossfader to the right!
+            m_pCOCrossfader->slotSet(1.0f);
+            // qDebug() << "1: m_pCOCrossfader->slotSet(_1.0f_);";
+            m_eState = ADJ_IDLE;
+            loadNextTrackFromQueue();
+        }
+        return;
+    }
+
+    if (m_eState == ADJ_IDLE) {
+        if (m_pCORepeat2->get() == 1.0f) {
+            //repeat disables auto DJ
+            return;
+        }
+    }
+
+    if (value >= m_posThreshold2) {
+        if (m_eState == ADJ_IDLE &&
+            (deck2Playing || m_posThreshold2 >= 1.0f)) {
+            if (!deck1Playing) {
+                player1PlayChanged(1.0f);
+                m_pCOPlay1->slotSet(1.0f);
+                if (fadeDuration < 0) {
+                    // Scroll back for pause between tracks
+                    m_pCOPlayPos1->slotSet(m_fadeDuration1);
+                }
+            }
+            removePlayingTrackFromQueue("[Channel1]");
+            m_eState = ADJ_P2FADING;
+        }
+
+        float posFadeEnd = math_min(1.0, m_posThreshold2 + fadeDuration);
+
+        if (value >= posFadeEnd) {
+            // Pre-End State
+            //m_pCOCrossfader->slotSet(-1.0f); //Move crossfader to the left!
+
+            m_pCOPlay2->slotSet(0.0f);  // Stop the player
+
+            //m_posThreshold = 1.0f - fadeDuration; // back to default
+
+            // does not work always immediately after stop
+            // loadNextTrackFromQueue();
+            // m_eState = ADJ_IDLE; // Fading ready
+        } else {
+            //Crossfade!
+            float crossfadeValue = 1.0f -
+                    2*(value-m_posThreshold2)/(posFadeEnd-m_posThreshold2);
+            // crossfadeValue = 1.0f -> + -1.0f
+            m_pCOCrossfader->slotSet(crossfadeValue); //Move crossfader to the right!
+            // qDebug() << "2: m_pCOCrossfader->slotSet " << crossfadeValue;
+        }
+    }
+}
+
+TrackPointer DlgAutoDJ::getNextTrackFromQueue() {
+    // Get the track at the top of the playlist...
+    TrackPointer nextTrack;
+
+    while (true) {
+        nextTrack = m_pAutoDJTableModel->getTrack(
+            m_pAutoDJTableModel->index(0, 0));
+
+        if (nextTrack) {
+            if (nextTrack->exists()) {
+                // found a valid Track
+                return nextTrack;
+            } else {
+                // Remove missing song from auto DJ playlist
+                m_pAutoDJTableModel->removeTrack(
+                    m_pAutoDJTableModel->index(0, 0));
+            }
+        } else {
+            // we are running out of tracks
+            break;
+        }
+    }
+    return nextTrack;
+}
+
+bool DlgAutoDJ::loadNextTrackFromQueue() {
+    TrackPointer nextTrack = getNextTrackFromQueue();
+
+    // We ran out of tracks in the queue...
+    if (!nextTrack) {
+        // Disable auto DJ and return...
         pushButtonAutoDJ->setChecked(false);
+        // And eject track as "End of auto DJ warning"
+        emit(loadTrack(nextTrack));
         return false;
     }
 
-    //m_bNextTrackAlreadyLoaded = false;
-
     emit(loadTrack(nextTrack));
-
-    return true;
+    return true;
+}
+
+bool DlgAutoDJ::removePlayingTrackFromQueue(QString group) {
+    TrackPointer nextTrack, loadedTrack;
+    int nextId = 0, loadedId = 0;
+
+    // Get the track at the top of the playlist...
+    nextTrack = m_pAutoDJTableModel->getTrack(m_pAutoDJTableModel->index(0, 0));
+    if (nextTrack) {
+        nextId = nextTrack->getId();
+    }
+
+    // Get loaded track
+    loadedTrack = PlayerInfo::Instance().getTrackInfo(group);
+    if (loadedTrack) {
+        loadedId = loadedTrack->getId();
+    }
+
+    // When enable auto DJ and Topmost Song is already on second deck, nothing to do
+    //BaseTrackPlayer::getLoadedTrack()
+    //pTrack = PlayerInfo::Instance().getCurrentPlayingTrack();
+
+    if (loadedId != nextId) {
+        // Do not remove when the user has loaded a track manually
+        return false;
+    }
+
+    // remove the top track
+    m_pAutoDJTableModel->removeTrack(m_pAutoDJTableModel->index(0, 0));
+
+    return true;
+}
+
+void DlgAutoDJ::player1PlayChanged(double value) {
+    //qDebug() << "player1PlayChanged(" << value << ")";
+    if (value == 1.0f && m_eState == ADJ_IDLE) {
+        TrackPointer loadedTrack =
+                PlayerInfo::Instance().getTrackInfo("[Channel1]");
+        if (loadedTrack) {
+            int TrackDuration = loadedTrack->getDuration();
+            qDebug() << "TrackDuration = " << TrackDuration;
+
+			int autoDjTransition = 5;
+
+            if (TrackDuration > autoDjTransition) {
+                m_fadeDuration1 = static_cast<float>(autoDjTransition) /
+                        static_cast<float>(TrackDuration);
+            } else {
+                m_fadeDuration1 = 0;
+            }
+
+            if (autoDjTransition > 0) {
+                m_posThreshold1 = 1.0f - m_fadeDuration1;
+            } else {
+                // in case of pause
+                m_posThreshold1 = 1.0f;
+            }
+            qDebug() << "m_fadeDuration1 = " << m_fadeDuration1;
+        }
+    }
+}
+
+void DlgAutoDJ::player2PlayChanged(double value) {
+    //qDebug() << "player2PlayChanged(" << value << ")";
+    if (value == 1.0f && m_eState == ADJ_IDLE) {
+        TrackPointer loadedTrack =
+                PlayerInfo::Instance().getTrackInfo("[Channel2]");
+        if (loadedTrack) {
+            int TrackDuration = loadedTrack->getDuration();
+            qDebug() << "TrackDuration = " << TrackDuration;
+
+			int autoDjTransition = 5;
+
+            if (TrackDuration > autoDjTransition) {
+                m_fadeDuration2 = static_cast<float>(autoDjTransition) /
+                        static_cast<float>(TrackDuration);
+            } else {
+                m_fadeDuration2 = 0;
+            }
+
+            if (autoDjTransition > 0) {
+                m_posThreshold2 = 1.0f - m_fadeDuration2;
+            } else {
+                // in case of pause
+                m_posThreshold2 = 1.0f;
+            }
+            qDebug() << "m_fadeDuration2 = " << m_fadeDuration2;
+        }
+    }
+}
+
+bool DlgAutoDJ::appendTrack(int trackId) {
+    return m_pAutoDJTableModel->appendTrack(trackId);
 }
 
=== modified file 'mixxx/src/dlgautodj.h'
--- mixxx/src/dlgautodj.h	2011-04-24 06:00:11 +0000
+++ mixxx/src/dlgautodj.h	2012-05-31 20:47:26 +0000
@@ -31,37 +31,59 @@
     virtual void loadSelectedTrack();
     virtual void loadSelectedTrackToGroup(QString group);
     virtual void moveSelection(int delta);
+    virtual bool appendTrack(int trackId);
 
   public slots:
     void shufflePlaylist(bool buttonChecked);
+    void skipNext(bool buttonChecked);
+    void fadeNow(bool buttonChecked);
     void toggleAutoDJ(bool toggle);
     void player1PositionChanged(double value);
     void player2PositionChanged(double value);
+    void player1PlayChanged(double value);
+    void player2PlayChanged(double value);
 
   signals:
     void loadTrack(TrackPointer tio);
     void loadTrackToPlayer(TrackPointer tio, QString group);
 
   private:
-    bool loadNextTrackFromQueue(bool removeTopMostBeforeLoading);
+    enum ADJstates {
+        ADJ_IDLE = 0,
+        ADJ_P1FADING,
+        ADJ_P2FADING,
+        ADJ_ENABLE_P1LOADED,
+        ADJ_ENABLE_P1PLAYING,
+        ADJ_DISABLED
+    };
+
+    TrackPointer getNextTrackFromQueue();
+    bool loadNextTrackFromQueue();
+    bool removePlayingTrackFromQueue(QString group);
 
     ConfigObject<ConfigValue>* m_pConfig;
     TrackCollection* m_pTrackCollection;
     WTrackTableView* m_pTrackTableView;
     PlaylistTableModel* m_pAutoDJTableModel;
     PlaylistDAO& m_playlistDao;
-    bool m_bAutoDJEnabled;
-    bool m_bNextTrackAlreadyLoaded; /** Makes our Auto DJ logic assume the
-                                        next track that should be played is
-                                        already loaded. We need this flag to
-                                        make our first-track-gets-loaded-but-
-                                        not-removed-from-the-queue behaviour
-                                        work. */
-    bool m_bPlayer1Primed, m_bPlayer2Primed;
+
+    // Makes our Auto DJ logic assume the next track that should be played is
+    // already loaded. We need this flag to make our
+    // first-track-gets-loaded-but- not-removed-from-the-queue behaviour work.
+    bool m_bNextTrackAlreadyLoaded;
+
+    bool m_bFadeNow;
+    enum ADJstates m_eState;
+    float m_posThreshold1;
+    float m_posThreshold2;
+    float m_fadeDuration1;
+    float m_fadeDuration2;
     ControlObjectThreadMain* m_pCOPlayPos1;
     ControlObjectThreadMain* m_pCOPlayPos2;
     ControlObjectThreadMain* m_pCOPlay1;
     ControlObjectThreadMain* m_pCOPlay2;
+    ControlObjectThreadMain* m_pCOPlay1Fb;
+    ControlObjectThreadMain* m_pCOPlay2Fb;
     ControlObjectThreadMain* m_pCORepeat1;
     ControlObjectThreadMain* m_pCORepeat2;
     ControlObjectThreadMain* m_pCOCrossfader;
@@ -82,7 +104,7 @@
 
 
 #define _blah if ((QDate::currentDate().day() == 1) && (QDate::currentDate().month() == 4)) \
-             pushButtonAutoDJ->setText("\x45\x6e\x61\x62\x6c\x65\x20\x50\x65\x65" \
+        pushButtonAutoDJ->setText("\x45\x6e\x61\x62\x6c\x65\x20\x50\x65\x65" \
                                   "\x20\x42\x72\x65\x61\x6b\x20\x4d\x6f\x64\x65")
 
 
 
=== modified file 'mixxx/src/dlgprepare.h'
--- mixxx/src/dlgprepare.h	2011-03-26 12:29:21 +0000
+++ mixxx/src/dlgprepare.h	2012-05-31 20:47:26 +0000
@@ -6,6 +6,7 @@
 #include "configobject.h"
 #include "library/libraryview.h"
 #include "library/trackcollection.h"
+#include "library/preparelibrarytablemodel.h"
 
 class PrepareLibraryTableModel;
 class WPrepareCratesTableView;
@@ -29,6 +30,7 @@
     virtual void loadSelectedTrack();
     virtual void loadSelectedTrackToGroup(QString group);
     virtual void moveSelection(int delta);
+    inline const QString currentSearch() { return m_pPrepareLibraryTableModel->currentSearch(); };
 
   public slots:
     void tableSelectionChanged(const QItemSelection& selected,
 
=== modified file 'mixxx/src/dlgrecording.cpp'
--- mixxx/src/dlgrecording.cpp	2011-11-04 23:15:03 +0000
+++ mixxx/src/dlgrecording.cpp	2012-05-31 20:47:26 +0000
@@ -119,6 +119,7 @@
 void DlgRecording::onSearchCleared()
 {
 }
+
 void DlgRecording::refreshBrowseModel(){
      m_browseModel.setPath(m_recordingDir);
 }
 
=== modified file 'mixxx/src/dlgrecording.h'
--- mixxx/src/dlgrecording.h	2011-03-31 18:47:04 +0000
+++ mixxx/src/dlgrecording.h	2012-05-31 20:47:26 +0000
@@ -35,6 +35,7 @@
     virtual void loadSelectedTrackToGroup(QString group);
     virtual void moveSelection(int delta);
     void refreshBrowseModel();
+    inline const QString currentSearch() { return m_proxyModel.currentSearch(); }
 
   public slots:
     void toggleRecording(bool toggle);
 
=== modified file 'mixxx/src/library/autodjfeature.cpp'
--- mixxx/src/library/autodjfeature.cpp	2011-10-12 17:29:43 +0000
+++ mixxx/src/library/autodjfeature.cpp	2012-05-31 20:47:26 +0000
@@ -23,6 +23,7 @@
           m_pConfig(pConfig),
           m_pTrackCollection(pTrackCollection),
           m_playlistDao(pTrackCollection->getPlaylistDAO()) {
+	m_pAutoDJView = NULL;
 }
 
 AutoDJFeature::~AutoDJFeature() {
@@ -36,19 +37,19 @@
     return QIcon(":/images/library/ic_library_autodj.png");
 }
 
-void AutoDJFeature::bindWidget(WLibrarySidebar* sidebarWidget,
+void AutoDJFeature::bindWidget(WLibrarySidebar* /*sidebarWidget*/,
                                WLibrary* libraryWidget,
                                MixxxKeyboard* keyboard) {
 
-    DlgAutoDJ* pAutoDJView = new DlgAutoDJ(libraryWidget,
+    m_pAutoDJView = new DlgAutoDJ(libraryWidget,
                                            m_pConfig,
                                            m_pTrackCollection,
                                            keyboard);
-    pAutoDJView->installEventFilter(keyboard);
-    libraryWidget->registerView(m_sAutoDJViewName, pAutoDJView);
-    connect(pAutoDJView, SIGNAL(loadTrack(TrackPointer)),
+    m_pAutoDJView->installEventFilter(keyboard);
+    libraryWidget->registerView(m_sAutoDJViewName, m_pAutoDJView);
+    connect(m_pAutoDJView, SIGNAL(loadTrack(TrackPointer)),
             this, SIGNAL(loadTrack(TrackPointer)));
-    connect(pAutoDJView, SIGNAL(loadTrackToPlayer(TrackPointer, QString)),
+    connect(m_pAutoDJView, SIGNAL(loadTrackToPlayer(TrackPointer, QString)),
             this, SIGNAL(loadTrackToPlayer(TrackPointer, QString)));
 }
 
@@ -58,19 +59,18 @@
 
 void AutoDJFeature::activate() {
     //qDebug() << "AutoDJFeature::activate()";
-    //emit(showTrackModel(m_pAutoDJTableModelProxy));
-    emit(switchToView("Auto DJ"));
-}
-
-void AutoDJFeature::activateChild(const QModelIndex& index) {
-
-}
-
-void AutoDJFeature::onRightClick(const QPoint& globalPos) {
-}
-
-void AutoDJFeature::onRightClickChild(const QPoint& globalPos,
-                                            QModelIndex index) {
+    emit(switchToView(m_sAutoDJViewName));
+    emit(restoreSearch(QString())); //Null String disables search box
+}
+
+void AutoDJFeature::activateChild(const QModelIndex& /*index*/) {
+}
+
+void AutoDJFeature::onRightClick(const QPoint& /*globalPos*/) {
+}
+
+void AutoDJFeature::onRightClickChild(const QPoint& /*globalPos*/,
+                                            QModelIndex /*index*/) {
 }
 
 bool AutoDJFeature::dropAccept(QUrl url) {
@@ -98,12 +98,18 @@
     }
 
     // TODO(XXX) No feedback on whether this worked.
-    int playlistId = m_playlistDao.getPlaylistIdFromName(AUTODJ_TABLE);
-    m_playlistDao.appendTrackToPlaylist(trackId, playlistId);
+    if( m_pAutoDJView ){
+    	m_pAutoDJView->appendTrack(trackId);
+    }
+    else{
+    	int playlistId = m_playlistDao.getPlaylistIdFromName(AUTODJ_TABLE);
+    	m_playlistDao.appendTrackToPlaylist(trackId, playlistId);
+    }
+
     return true;
 }
 
-bool AutoDJFeature::dropAcceptChild(const QModelIndex& index, QUrl url) {
+bool AutoDJFeature::dropAcceptChild(const QModelIndex& /*index*/, QUrl /*url*/) {
     return false;
 }
 
@@ -112,10 +118,10 @@
     return SoundSourceProxy::isFilenameSupported(file.fileName());
 }
 
-bool AutoDJFeature::dragMoveAcceptChild(const QModelIndex& index,
-                                              QUrl url) {
+bool AutoDJFeature::dragMoveAcceptChild(const QModelIndex& /*index*/,
+                                              QUrl /*url*/) {
     return false;
 }
-void AutoDJFeature::onLazyChildExpandation(const QModelIndex &index){
+void AutoDJFeature::onLazyChildExpandation(const QModelIndex& /*index*/){
     //Nothing to do because the childmodel is not of lazy nature.
 }
 
=== modified file 'mixxx/src/library/autodjfeature.h'
--- mixxx/src/library/autodjfeature.h	2011-03-10 13:37:21 +0000
+++ mixxx/src/library/autodjfeature.h	2012-05-31 20:47:26 +0000
@@ -11,6 +11,7 @@
 #include "library/dao/playlistdao.h"
 #include "configobject.h"
 #include "treeitemmodel.h"
+#include "dlgautodj.h"
 
 class PlaylistTableModel;
 class TrackCollection;
@@ -50,6 +51,7 @@
     PlaylistDAO& m_playlistDao;
     const static QString m_sAutoDJViewName;
     TreeItemModel m_childModel;
+    DlgAutoDJ* m_pAutoDJView;
 };
 
 
 
=== modified file 'mixxx/src/library/basesqltablemodel.cpp'
--- mixxx/src/library/basesqltablemodel.cpp	2011-12-18 18:50:40 +0000
+++ mixxx/src/library/basesqltablemodel.cpp	2012-05-31 20:47:26 +0000
@@ -18,6 +18,7 @@
                                      QString settingsNamespace)
         :  QAbstractTableModel(pParent),
            TrackModel(db, settingsNamespace),
+           m_currentSearch(""),
            m_pTrackCollection(pTrackCollection),
            m_trackDAO(m_pTrackCollection->getTrackDAO()),
            m_database(db) {
@@ -528,7 +529,7 @@
     // waveform widget to load a track into a Player).
     defaultFlags |= Qt::ItemIsDragEnabled;
 
-    int row = index.row();
+    //int row = index.row(); // not used
     int column = index.column();
 
     if ( column == fieldIndex(LIBRARYTABLE_FILETYPE)
 
=== modified file 'mixxx/src/library/browse/browsefeature.cpp'
--- mixxx/src/library/browse/browsefeature.cpp	2012-03-13 04:36:19 +0000
+++ mixxx/src/library/browse/browsefeature.cpp	2012-05-31 20:47:26 +0000
@@ -141,8 +141,9 @@
 }
 
 void BrowseFeature::activate() {
-    emit(restoreSearch(m_currentSearch));
+    emit(restoreSearch(QString()));
 }
+
 /*
  * Note: This is executed whenever you single click on an child item
  * Single clicks will not populate sub folders
 
=== modified file 'mixxx/src/library/browse/browsefeature.h'
--- mixxx/src/library/browse/browsefeature.h	2011-03-30 21:53:33 +0000
+++ mixxx/src/library/browse/browsefeature.h	2012-05-31 20:47:26 +0000
@@ -54,7 +54,6 @@
     ProxyTrackModel m_proxyModel;
     TrackCollection* m_pTrackCollection;
     FolderTreeModel m_childModel;
-    QString m_currentSearch;
 };
 
 #endif /* BROWSEFEATURE_H */
 
=== modified file 'mixxx/src/library/browse/browsetablemodel.cpp'
--- mixxx/src/library/browse/browsetablemodel.cpp	2011-12-22 10:56:03 +0000
+++ mixxx/src/library/browse/browsetablemodel.cpp	2012-05-31 20:47:26 +0000
@@ -112,23 +112,23 @@
 }
 
 int BrowseTableModel::getTrackId(const QModelIndex& index) const {
-   Q_UNUSED(index);
-   // We can't implement this as it stands.
+    Q_UNUSED(index);
+    // We can't implement this as it stands.
     return -1;
 }
 
 const QLinkedList<int> BrowseTableModel::getTrackRows(int trackId) const {
-   Q_UNUSED(trackId);
-   // We can't implement this as it stands.
-   return QLinkedList<int>();
+    Q_UNUSED(trackId);
+    // We can't implement this as it stands.
+    return QLinkedList<int>();
 }
 
 void BrowseTableModel::search(const QString& searchText) {
-   Q_UNUSED(searchText);
+    Q_UNUSED(searchText);
 }
 
 const QString BrowseTableModel::currentSearch() const {
-    return QString();
+    return QString(""); 
 }
 
 bool BrowseTableModel::isColumnInternal(int) {
@@ -215,7 +215,7 @@
 {
     Q_UNUSED(index);
     Q_UNUSED(location);
-   return false;
+    return false;
 }
 
 QMimeData* BrowseTableModel::mimeData(const QModelIndexList &indexes) const {
@@ -318,7 +318,7 @@
 {
     Q_UNUSED(role);
 
-   if(!index.isValid())
+    if(!index.isValid())
         return false;
     qDebug() << "BrowseTableModel::setData(" << index.data() << ")";
     int row = index.row();
 
=== modified file 'mixxx/src/library/cratefeature.cpp'
--- mixxx/src/library/cratefeature.cpp	2011-12-09 02:49:02 +0000
+++ mixxx/src/library/cratefeature.cpp	2012-05-31 20:47:26 +0000
@@ -137,6 +137,7 @@
 void CrateFeature::activate() {
     emit(showPage(QUrl("qrc:/html/crates.html")));
     emit(switchToView("CRATEHOME"));
+    emit(restoreSearch(QString())); //disable search on crate home
 }
 
 void CrateFeature::activateChild(const QModelIndex& index) {
 
=== modified file 'mixxx/src/library/dao/cratedao.h'
--- mixxx/src/library/dao/cratedao.h	2012-05-04 05:38:59 +0000
+++ mixxx/src/library/dao/cratedao.h	2012-05-31 20:47:26 +0000
@@ -50,6 +50,8 @@
     void changed(int crateId);
     void trackAdded(int crateId, int trackId);
     void trackRemoved(int crateId, int trackId);
+    void renamed(int crateId);
+    void lockChanged(int crateId);
 
   private:
     QSqlDatabase& m_database;
 
=== modified file 'mixxx/src/library/dao/playlistdao.cpp'
--- mixxx/src/library/dao/playlistdao.cpp	2012-05-04 05:38:59 +0000
+++ mixxx/src/library/dao/playlistdao.cpp	2012-05-31 20:47:26 +0000
@@ -505,7 +505,7 @@
     return tracksAdded;
 }
 
-void PlaylistDAO::addToAutoDJQueue(int playlistId) {
+void PlaylistDAO::addToAutoDJQueue(int playlistId, bool bTop) {
     //qDebug() << "Adding tracks from playlist " << playlistId << " to the Auto-DJ Queue";
 
     // Query the PlaylistTracks database to locate tracks in the selected playlist
@@ -520,7 +520,15 @@
     // Get the ID of the Auto-DJ playlist
     int autoDJId = getPlaylistIdFromName(AUTODJ_TABLE);
     // Loop through the tracks, adding them to the Auto-DJ Queue
-    while(query.next()) {
-        appendTrackToPlaylist(query.value(0).toInt(), autoDJId);
+
+    int i = 2; // Start at position 2 because position 1 was already loaded to the deck
+
+    while (query.next()) {
+    	if (bTop) {
+    		insertTrackIntoPlaylist(query.value(0).toInt(), autoDJId, i++);
+    	}
+    	else {
+    		appendTrackToPlaylist(query.value(0).toInt(), autoDJId);
+    	}
     }
 }
 
=== modified file 'mixxx/src/library/dao/playlistdao.h'
--- mixxx/src/library/dao/playlistdao.h	2012-05-04 05:38:59 +0000
+++ mixxx/src/library/dao/playlistdao.h	2012-05-31 20:47:26 +0000
@@ -57,13 +57,15 @@
     /** Inserts a list of tracks into playlist*/
     int insertTracksIntoPlaylist(QList<int> trackIds, int playlistId, int position);
     /** Add a playlist to the Auto-DJ Queue */
-    void addToAutoDJQueue(int playlistId);
+    void addToAutoDJQueue(int playlistId, bool bTop);
   signals:
     void added(int playlistId);
     void deleted(int playlistId);
     void changed(int playlistId);
     void trackAdded(int playlistId, int trackId, int position);
     void trackRemoved(int playlistId, int trackId, int position);
+    void renamed(int playlistId);
+    void lockChanged(int playlistId);
   private:
     QSqlDatabase& m_database;
     DISALLOW_COPY_AND_ASSIGN(PlaylistDAO);
 
=== modified file 'mixxx/src/library/itunes/itunesfeature.cpp'
--- mixxx/src/library/itunes/itunesfeature.cpp	2011-10-16 03:12:52 +0000
+++ mixxx/src/library/itunes/itunesfeature.cpp	2012-05-31 20:47:26 +0000
@@ -116,6 +116,7 @@
                 tr("Select your iTunes library"),
                 QDir::homePath(), "*.xml");
             if (m_dbfile.isEmpty() || !QFile::exists(m_dbfile)) {
+                emit(showTrackModel(m_pITunesTrackModel));
                 return;
             }
             settings.setValue(ITDB_PATH_KEY, m_dbfile);
@@ -138,10 +139,8 @@
         //calls a slot in the sidebar model such that 'iTunes (isLoading)' is displayed.
         emit (featureIsLoading(this));
     }
-    else{
-        emit(showTrackModel(m_pITunesTrackModel));
-    }
 
+    emit(showTrackModel(m_pITunesTrackModel));
 }
 
 void ITunesFeature::activateChild(const QModelIndex& index) {
 
=== modified file 'mixxx/src/library/playlistfeature.cpp'
--- mixxx/src/library/playlistfeature.cpp	2012-03-27 18:17:26 +0000
+++ mixxx/src/library/playlistfeature.cpp	2012-05-31 20:47:26 +0000
@@ -102,6 +102,7 @@
 void PlaylistFeature::activate() {
     emit(showPage(QUrl("qrc:/html/playlists.html")));
     emit(switchToView("PLAYLISTHOME"));
+    emit(restoreSearch(QString())); // Null String disables search box
 }
 
 void PlaylistFeature::activateChild(const QModelIndex& index) {
@@ -448,7 +449,7 @@
         new PlaylistTableModel(this, m_pTrackCollection,
                                "mixxx.db.model.playlist_export"));
 
-    pPlaylistTableModel->setPlaylist(m_pPlaylistTableModel->getPlaylist());
+    pPlaylistTableModel->setPlaylist(m_pPlaylistTableModel->getPlaylistId());
     pPlaylistTableModel->setSort(pPlaylistTableModel->fieldIndex(PLAYLISTTRACKSTABLE_POSITION), Qt::AscendingOrder);
     pPlaylistTableModel->select();
     int rows = pPlaylistTableModel->rowCount();
@@ -481,12 +482,18 @@
 
 void PlaylistFeature::slotAddToAutoDJ() {
     //qDebug() << "slotAddToAutoDJ() row:" << m_lastRightClickedIndex.data();
+	addToAutoDJ(false); // Top = True
+}
+
+void PlaylistFeature::addToAutoDJ(bool bTop) {
+    //qDebug() << "slotAddToAutoDJ() row:" << m_lastRightClickedIndex.data();
 
     if (m_lastRightClickedIndex.isValid()) {
         int playlistId = m_playlistDao.getPlaylistIdFromName(
             m_lastRightClickedIndex.data().toString());
         if (playlistId >= 0) {
-            m_playlistDao.addToAutoDJQueue(playlistId);
+       		// Insert this playlist
+        	m_playlistDao.addToAutoDJQueue(playlistId, bTop);
         }
     }
     emit(featureUpdated());
 
=== modified file 'mixxx/src/library/playlistfeature.h'
--- mixxx/src/library/playlistfeature.h	2011-11-27 06:59:02 +0000
+++ mixxx/src/library/playlistfeature.h	2012-05-31 20:47:26 +0000
@@ -59,6 +59,7 @@
  private:
     void constructChildModel();
     void clearChildModel();
+    void addToAutoDJ(bool bTop);
 
     TrackCollection* m_pTrackCollection;
     PlaylistTableModel* m_pPlaylistTableModel;
 
=== modified file 'mixxx/src/library/playlisttablemodel.cpp'
--- mixxx/src/library/playlisttablemodel.cpp	2012-05-04 05:38:59 +0000
+++ mixxx/src/library/playlisttablemodel.cpp	2012-05-31 20:47:26 +0000
@@ -5,7 +5,6 @@
 #include "library/trackcollection.h"
 #include "library/playlisttablemodel.h"
 #include "library/queryutil.h"
-
 #include "mixxxutils.cpp"
 
 PlaylistTableModel::PlaylistTableModel(QObject* parent,
@@ -64,6 +63,12 @@
     initHeaderData();
     setSearch("");
     setDefaultSort(fieldIndex("position"), Qt::AscendingOrder);
+    setSort(defaultSortColumn(),defaultSortOrder());
+}
+
+int PlaylistTableModel::getPlaylistId()
+{
+    return m_iPlaylistId;
 }
 
 bool PlaylistTableModel::addTrack(const QModelIndex& index, QString location) {
@@ -94,6 +99,16 @@
     return true;
 }
 
+bool PlaylistTableModel::appendTrack(int trackId) {
+    if (trackId < 0) {
+        return false;
+    }
+
+    m_playlistDao.appendTrackToPlaylist(trackId, m_iPlaylistId);
+
+    select(); //Repopulate the data model.
+    return true;
+}
 
 int PlaylistTableModel::addTracks(const QModelIndex& index, QList<QString> locations) {
     const int positionColumn = fieldIndex(PLAYLISTTRACKSTABLE_POSITION);
@@ -272,32 +287,38 @@
 
     //Print out any SQL error, if there was one.
     if (query.lastError().isValid()) {
-     	qDebug() << query.lastError();
+        qDebug() << query.lastError();
     }
 
     select();
 }
 
-void PlaylistTableModel::shuffleTracks(const QModelIndex& currentIndex) {
+void PlaylistTableModel::shuffleTracks(const QModelIndex& shuffleStartIndex) {
     int numOfTracks = rowCount();
     int seed = QDateTime::currentDateTime().toTime_t();
     qsrand(seed);
     QSqlQuery query(m_pTrackCollection->getDatabase());
     const int positionColumnIndex = fieldIndex(PLAYLISTTRACKSTABLE_POSITION);
-    int currentPosition = currentIndex.sibling(currentIndex.row(), positionColumnIndex).data().toInt();
-    int shuffleStartIndex = currentPosition + 1;
+    int shuffleStartRow = shuffleStartIndex.row();
 
     m_pTrackCollection->getDatabase().transaction();
 
     // This is a simple Fisher-Yates shuffling algorithm
-    for (int i=numOfTracks-1; i >= shuffleStartIndex; i--)
+    for (int i=numOfTracks-1; i >= shuffleStartRow; i--)
     {
-        int random = int(qrand() / (RAND_MAX + 1.0) * (numOfTracks + 1 - shuffleStartIndex) + shuffleStartIndex);
-        qDebug() << "Swapping tracks " << i << " and " << random;
+        int oldPosition = index(i, positionColumnIndex).data().toInt();
+        int random = int(qrand() / (RAND_MAX + 1.0) * (numOfTracks - shuffleStartRow) + shuffleStartRow + 1);
+        qDebug() << "Swapping tracks " << oldPosition << " and " << random;
         QString swapQuery = "UPDATE PlaylistTracks SET position=%1 WHERE position=%2 AND playlist_id=%3";
-        query.exec(swapQuery.arg(-1).arg(i).arg(m_iPlaylistId));
-        query.exec(swapQuery.arg(i).arg(random).arg(m_iPlaylistId));
-        query.exec(swapQuery.arg(random).arg(-1).arg(m_iPlaylistId));
+        query.exec(swapQuery.arg(QString::number(-1),
+                                 QString::number(oldPosition),
+                                 QString::number(m_iPlaylistId)));
+        query.exec(swapQuery.arg(QString::number(oldPosition),
+                                 QString::number(random),
+                                 QString::number(m_iPlaylistId)));
+        query.exec(swapQuery.arg(QString::number(random),
+                                 QString::number(-1),
+                                 QString::number(m_iPlaylistId)));
 
         if (query.lastError().isValid())
             qDebug() << query.lastError();
@@ -336,6 +357,7 @@
 }
 
 QItemDelegate* PlaylistTableModel::delegateForColumn(const int i) {
+	Q_UNUSED(i);
     return NULL;
 }
 
 
=== modified file 'mixxx/src/library/playlisttablemodel.h'
--- mixxx/src/library/playlisttablemodel.h	2012-05-04 05:38:59 +0000
+++ mixxx/src/library/playlisttablemodel.h	2012-05-31 20:47:26 +0000
@@ -19,9 +19,7 @@
                        QString settingsNamespace);
     virtual ~PlaylistTableModel();
     void setPlaylist(int playlistId);
-    int getPlaylist() const {
-        return m_iPlaylistId;
-    }
+    int getPlaylistId(void);
     virtual TrackPointer getTrack(const QModelIndex& index) const;
 
     virtual void search(const QString& searchText);
@@ -30,6 +28,7 @@
     virtual void removeTrack(const QModelIndex& index);
     virtual void removeTracks(const QModelIndexList& indices);
     virtual bool addTrack(const QModelIndex& index, QString location);
+    virtual bool appendTrack(int trackId);
     // Adding multiple tracks at one to a playlist. Returns the number of
     // successful additions.
     virtual int addTracks(const QModelIndex& index, QList<QString> locations);
 
=== modified file 'mixxx/src/library/preparefeature.cpp'
--- mixxx/src/library/preparefeature.cpp	2011-03-26 12:29:21 +0000
+++ mixxx/src/library/preparefeature.cpp	2012-05-31 20:47:26 +0000
@@ -41,31 +41,35 @@
 void PrepareFeature::bindWidget(WLibrarySidebar* sidebarWidget,
                                 WLibrary* libraryWidget,
                                 MixxxKeyboard* keyboard) {
-    DlgPrepare* pPrepareView = new DlgPrepare(libraryWidget,
+    m_pPrepareView = new DlgPrepare(libraryWidget,
                                               m_pConfig,
                                               m_pTrackCollection);
-    connect(pPrepareView, SIGNAL(loadTrack(TrackPointer)),
+    connect(m_pPrepareView, SIGNAL(loadTrack(TrackPointer)),
             this, SIGNAL(loadTrack(TrackPointer)));
-    connect(pPrepareView, SIGNAL(loadTrackToPlayer(TrackPointer, QString)),
+    connect(m_pPrepareView, SIGNAL(loadTrackToPlayer(TrackPointer, QString)),
             this, SIGNAL(loadTrackToPlayer(TrackPointer, QString)));
-    connect(pPrepareView, SIGNAL(analyzeTracks(QList<int>)),
+    connect(m_pPrepareView, SIGNAL(analyzeTracks(QList<int>)),
             this, SLOT(analyzeTracks(QList<int>)));
-    connect(pPrepareView, SIGNAL(stopAnalysis()),
+    connect(m_pPrepareView, SIGNAL(stopAnalysis()),
             this, SLOT(stopAnalysis()));
 
     connect(this, SIGNAL(analysisActive(bool)),
-            pPrepareView, SLOT(analysisActive(bool)));
+            m_pPrepareView, SLOT(analysisActive(bool)));
     connect(this, SIGNAL(trackAnalysisProgress(TrackPointer, int)),
-            pPrepareView, SLOT(trackAnalysisProgress(TrackPointer, int)));
-    connect(this, SIGNAL(trackAnalysisFinished(TrackPointer)),
-            pPrepareView, SLOT(trackAnalysisFinished(TrackPointer)));
-    pPrepareView->installEventFilter(keyboard);
+            m_pPrepareView, SLOT(trackAnalysisProgress(TrackPointer, int)));
+    connect(this, SIGNAL(trackAnalysisFinished(TrackPointer)),
+            m_pPrepareView, SLOT(trackAnalysisFinished(TrackPointer)));
+
+    connect(this, SIGNAL(trackAnalysisFinished(TrackPointer)),
+            m_pPrepareView, SLOT(trackAnalysisFinished(TrackPointer)));
+
+    m_pPrepareView->installEventFilter(keyboard);
 
     // Let the DlgPrepare know whether or not analysis is active.
     bool bAnalysisActive = m_pAnalyserQueue != NULL;
     emit(analysisActive(bAnalysisActive));
 
-    libraryWidget->registerView(m_sPrepareViewName, pPrepareView);
+    libraryWidget->registerView(m_sPrepareViewName, m_pPrepareView);
 }
 
 TreeItemModel* PrepareFeature::getChildModel() {
@@ -75,6 +79,7 @@
 void PrepareFeature::activate() {
     //qDebug() << "PrepareFeature::activate()";
     emit(switchToView(m_sPrepareViewName));
+    emit(restoreSearch(m_pPrepareView->currentSearch()));
 }
 
 void PrepareFeature::activateChild(const QModelIndex& index) {
 
=== modified file 'mixxx/src/library/preparefeature.h'
--- mixxx/src/library/preparefeature.h	2011-03-26 12:29:21 +0000
+++ mixxx/src/library/preparefeature.h	2012-05-31 20:47:26 +0000
@@ -9,6 +9,7 @@
 #include "library/libraryfeature.h"
 #include "configobject.h"
 #include "treeitemmodel.h"
+#include "dlgprepare.h"
 
 class AnalyserQueue;
 class LibraryTableModel;
@@ -63,6 +64,7 @@
     int m_iOldBpmEnabled;
     TreeItemModel m_childModel;
     const static QString m_sPrepareViewName;
+    DlgPrepare* m_pPrepareView;
 };
 
 
 
=== modified file 'mixxx/src/library/proxytrackmodel.cpp'
--- mixxx/src/library/proxytrackmodel.cpp	2011-09-25 08:08:35 +0000
+++ mixxx/src/library/proxytrackmodel.cpp	2012-05-31 20:47:26 +0000
@@ -11,7 +11,8 @@
         // ProxyTrackModel proxies settings requests to the composed TrackModel,
         // don't initialize its TrackModel with valid parameters.
         : TrackModel(QSqlDatabase(), ""),
-          m_bHandleSearches(bHandleSearches) {
+          m_bHandleSearches(bHandleSearches),
+          m_currentSearch("") {
     m_pTrackModel = dynamic_cast<TrackModel*>(pTrackModel);
     Q_ASSERT(m_pTrackModel && pTrackModel);
     setSourceModel(pTrackModel);
 
=== modified file 'mixxx/src/library/recording/recordingfeature.cpp'
--- mixxx/src/library/recording/recordingfeature.cpp	2011-04-10 18:23:52 +0000
+++ mixxx/src/library/recording/recordingfeature.cpp	2012-05-31 20:47:26 +0000
@@ -23,8 +23,9 @@
                                    TrackCollection* pTrackCollection,
                                    RecordingManager* pRecordingManager)
         : LibraryFeature(parent),
-          m_pConfig(pConfig), m_pRecordingView(0),
-          m_pTrackCollection(pTrackCollection),
+          m_pConfig(pConfig),
+          m_pTrackCollection(pTrackCollection), 
+          m_pRecordingView(0),
           m_pRecordingManager(pRecordingManager){
 
 }
@@ -48,6 +49,8 @@
                              WLibrary *libraryWidget,
                              MixxxKeyboard *keyboard)
 {
+    Q_UNUSED(sidebarWidget);
+
     //The view will be deleted by LibraryWidget
     m_pRecordingView = new DlgRecording(libraryWidget,
                                            m_pConfig,
@@ -64,35 +67,47 @@
 }
 
 bool RecordingFeature::dropAccept(QUrl url) {
+    Q_UNUSED(url);
     return false;
 }
 
 bool RecordingFeature::dropAcceptChild(const QModelIndex& index, QUrl url) {
+    Q_UNUSED(index);
+    Q_UNUSED(url);
     return false;
 }
 
 bool RecordingFeature::dragMoveAccept(QUrl url) {
+    Q_UNUSED(url);
     return false;
 }
 
 bool RecordingFeature::dragMoveAcceptChild(const QModelIndex& index, QUrl url) {
+    Q_UNUSED(index);
+    Q_UNUSED(url);
     return false;
 }
 
 void RecordingFeature::activate() {
     m_pRecordingView->refreshBrowseModel();
-    emit(switchToView("Recording"));
+    emit(switchToView(m_sRecordingViewName));
+    emit(restoreSearch(m_pRecordingView->currentSearch()));
 }
 
 void RecordingFeature::activateChild(const QModelIndex& index) {
-
+    Q_UNUSED(index);
 }
 
 void RecordingFeature::onRightClick(const QPoint& globalPos) {
+    Q_UNUSED(globalPos);
 }
 
 void RecordingFeature::onRightClickChild(const QPoint& globalPos, QModelIndex index) {
+    Q_UNUSED(globalPos);
+	Q_UNUSED(index);
 }
+
 void RecordingFeature::onLazyChildExpandation(const QModelIndex &index){
-    //Nothing to do here since we have no child models
+	Q_UNUSED(index);    
+	// Nothing to do here since we have no child models
 }
 
=== modified file 'mixxx/src/library/recording/recordingfeature.h'
--- mixxx/src/library/recording/recordingfeature.h	2011-04-10 18:23:52 +0000
+++ mixxx/src/library/recording/recordingfeature.h	2012-05-31 20:47:26 +0000
@@ -53,7 +53,6 @@
     ConfigObject<ConfigValue>* m_pConfig;
     TrackCollection* m_pTrackCollection;
     FolderTreeModel m_childModel;
-    QString m_currentSearch;
     const static QString m_sRecordingViewName;
     DlgRecording* m_pRecordingView;
     RecordingManager* m_pRecordingManager;
 
=== modified file 'mixxx/src/library/rhythmbox/rhythmboxfeature.cpp'
--- mixxx/src/library/rhythmbox/rhythmboxfeature.cpp	2012-05-14 20:28:12 +0000
+++ mixxx/src/library/rhythmbox/rhythmboxfeature.cpp	2012-05-31 20:47:26 +0000
@@ -100,9 +100,8 @@
         //calls a slot in the sidebar model such that 'Rhythmbox (isLoading)' is displayed.
         emit (featureIsLoading(this));
     }
-    else
-        emit(showTrackModel(m_pRhythmboxTrackModel));
 
+    emit(showTrackModel(m_pRhythmboxTrackModel));
 }
 
 void RhythmboxFeature::activateChild(const QModelIndex& index) {
 
=== modified file 'mixxx/src/library/traktor/traktorfeature.cpp'
--- mixxx/src/library/traktor/traktorfeature.cpp	2011-10-18 05:12:35 +0000
+++ mixxx/src/library/traktor/traktorfeature.cpp	2012-05-31 20:47:26 +0000
@@ -109,9 +109,9 @@
         m_title = tr("(loading) Traktor");
         //calls a slot in the sidebar model such that 'iTunes (isLoading)' is displayed.
         emit (featureIsLoading(this));
-    } else {
-        emit(showTrackModel(m_pTraktorTableModel));
     }
+
+    emit(showTrackModel(m_pTraktorTableModel));
 }
 
 void TraktorFeature::activateChild(const QModelIndex& index) {
 
=== modified file 'mixxx/src/soundmanager.h'
--- mixxx/src/soundmanager.h	2011-10-16 02:09:36 +0000
+++ mixxx/src/soundmanager.h	2012-05-31 20:47:26 +0000
@@ -92,7 +92,7 @@
 #ifdef __PORTAUDIO__
     bool m_paInitialized;
     unsigned int m_jackSampleRate;
-#endif
+#endif    
     QHash<AudioOutput, const AudioSource*> m_registeredSources;
     QHash<AudioInput, AudioDestination*> m_registeredDestinations;
 
 
=== modified file 'mixxx/src/widget/wsearchlineedit.cpp'
--- mixxx/src/widget/wsearchlineedit.cpp	2012-03-13 03:40:29 +0000
+++ mixxx/src/widget/wsearchlineedit.cpp	2012-05-31 20:47:26 +0000
@@ -117,7 +117,17 @@
     }
 }
 
+// slot
 void WSearchLineEdit::restoreSearch(const QString& text) {
+    if(text.isNull()) {
+        // disable
+        setEnabled(false);
+        blockSignals(true);
+        setText("- - -");
+        blockSignals(false);
+        return;
+    }
+    setEnabled(true);
     qDebug() << "WSearchLineEdit::restoreSearch(" << text << ")";
     blockSignals(true);
     setText(text);
@@ -136,6 +146,7 @@
 
 void WSearchLineEdit::slotSetupTimer(const QString& text)
 {
+    Q_UNUSED(text);
     m_searchTimer.stop();
     //300 milliseconds timeout
     m_searchTimer.start(300);
 
=== modified file 'mixxx/src/widget/wtracktableview.cpp'
--- mixxx/src/widget/wtracktableview.cpp	2012-05-04 05:38:59 +0000
+++ mixxx/src/widget/wtracktableview.cpp	2012-05-31 20:47:26 +0000
@@ -816,6 +816,15 @@
 }
 
 void WTrackTableView::slotSendToAutoDJ() {
+	// append to auto DJ
+	sendToAutoDJ(false); // bTop = false
+}
+
+void WTrackTableView::slotSendToAutoDJTop() {
+	sendToAutoDJ(true); // bTop = true
+}
+
+void WTrackTableView::sendToAutoDJ(bool bTop) {
     if (!modelHasCapabilities(TrackModel::TRACKMODELCAPS_ADDTOAUTODJ)) {
         return;
     }
 
=== modified file 'mixxx/src/widget/wtracktableview.h'
--- mixxx/src/widget/wtracktableview.h	2012-05-04 03:00:08 +0000
+++ mixxx/src/widget/wtracktableview.h	2012-05-31 20:47:26 +0000
@@ -46,6 +46,7 @@
     void slotNextTrackInfo();
     void slotPrevTrackInfo();
     void slotSendToAutoDJ();
+    void slotSendToAutoDJTop();
     void slotReloadTrackMetadata();
     void slotResetPlayed();
     void addSelectionToPlaylist(int iPlaylistId);
@@ -54,6 +55,7 @@
     void doSortByColumn(int headerSection);
 
   private:
+    void sendToAutoDJ(bool bTop);
     void showTrackInfo(QModelIndex index);
     void createActions();
     void dragMoveEvent(QDragMoveEvent * event);
@@ -90,6 +92,7 @@
 
     // Send to Auto-DJ Action
     QAction *m_pAutoDJAct;
+    QAction *m_pAutoDJTopAct;
 
     // Remove from table
     QAction *m_pRemoveAct;