Merge lp:~daschuer/mixxx/features_ipod into lp:~mixxxdevelopers/mixxx/trunk

[Daniel Schürmann]

Features:
* New library item "iPod"
* Sorting and Filtering
* new icon for Rhythmbox
* iPod auto detection
* disable iPod feature in preferences

[RAFFI TEA (raffitea)]

Hey Daniel,

Can you just say a word about your ipod auto detection?
What library have you used for that? Do we have dependencies to GTK now?
Have you tested on Windows, too?

[Daniel Schürmann (daschuer)]

I have tested it only with Ubuntu Lucid, Natty and Oneiric.

---

On Ubuntu the Ipod mounted automatically in /media/IPOD[x]
The ipod feature is looking there for default. "Auto detection" is just pushing it a bit :-).
It is based on code, which I have already found in Mixxx Sources and which also has untested parts for Mac and Windows.

---

The ipod feature drew dependencies to the Glib, not to whole GTK.
The libgpod is based on Glib, which implements the object model for GTK.
On Gnome based systems, Mixxx has GTK dependencies anyway.

[lp:~daschuer/mixxx/features_ipod]

2925. By Daniel Schürmann on 2011-10-31

merged with lp:mixxx

2926. By Daniel Schürmann on 2011-11-06

merged with lp:mixxx

2927. By Daniel Schürmann on 2011-12-10

merged with lp:mixxx

2928. By Daniel Schürmann on 2012-11-18

merged with lp:mixxx

Unmerged revisions

2928. By Daniel Schürmann on 2012-11-18

merged with lp:mixxx

2927. By Daniel Schürmann on 2011-12-10

merged with lp:mixxx

2926. By Daniel Schürmann on 2011-11-06

merged with lp:mixxx

2925. By Daniel Schürmann on 2011-10-31

merged with lp:mixxx

2924. By Daniel Schürmann on 2011-10-29

merged with lp:mixxx

2923. By Daniel Schürmann on 2011-10-29

brach now working

2922. By Daniel Schürmann on 2011-10-29

added ipod files

2921. By Daniel Schürmann on 2011-10-28

merged from daschuers_trunk

=== modified file 'mixxx/build/features.py'
--- mixxx/build/features.py	2012-09-26 05:07:07 +0000
+++ mixxx/build/features.py	2012-11-18 17:09:22 +0000
@@ -276,7 +276,7 @@
 
 class IPod(Feature):
     def description(self):
-        return "NOT-WORKING iPod Support"
+        return "Guest's iPod Support"
 
     def enabled(self, build):
         build.flags['ipod'] = util.get_flags(build.env, 'ipod', 0)
@@ -291,7 +291,12 @@
         if not self.enabled(build):
             return
 
+        gpod_found = conf.CheckLib(['libgpod','gpod'])
         build.env.Append(CPPDEFINES = '__IPOD__')
+
+        if not gpod_found:
+            raise Exception('Could not find libgpod or its development headers. Please install it or compile Mixxx without iPod support using the ipod=0 flag.')
+
         if build.platform_is_windows:
             build.env.Append(LIBS = 'gpod');
             # You must check v-this-v directory out from http://publicsvn.songbirdnest.com/vendor-binaries/trunk/windows-i686-msvc8/libgpod/
@@ -309,7 +314,9 @@
             build.env.ParseConfig('pkg-config glib-2.0 --silence-errors --cflags --libs')
 
     def sources(self, build):
-        return ['wipodtracksmodel.cpp']
+        return ['library/ipod/ipodfeature.cpp',
+                'library/ipod/ipodplaylistmodel.cpp',
+                'library/ipod/gpoditdb.cpp']
 
 class MSVCDebug(Feature):
     # FIXME: this flag is also detected in mixxx.py at line 100 because it's needed sooner than this is processed

=== added file 'mixxx/res/images/library/ic_library_ipod.png'
Binary files mixxx/res/images/library/ic_library_ipod.png	1970-01-01 00:00:00 +0000 and mixxx/res/images/library/ic_library_ipod.png	2012-11-18 17:09:22 +0000 differ
=== removed file 'mixxx/res/images/library/ic_library_rhythmbox.png'
Binary files mixxx/res/images/library/ic_library_rhythmbox.png	2012-07-06 08:24:39 +0000 and mixxx/res/images/library/ic_library_rhythmbox.png	1970-01-01 00:00:00 +0000 differ
=== modified file 'mixxx/res/mixxx.qrc'
--- mixxx/res/mixxx.qrc	2012-09-06 05:11:40 +0000
+++ mixxx/res/mixxx.qrc	2012-11-18 17:09:22 +0000
@@ -34,6 +34,7 @@
         <file>images/library/ic_library_recordings.png</file>
         <file>images/library/ic_library_rhythmbox.png</file>
         <file>images/library/ic_library_traktor.png</file>
+        <file>images/library/ic_library_ipod.png</file>
         <file>shaders/computemaxsignal.frag</file>
         <file>shaders/filteredsignal.frag</file>
         <file>shaders/passthrough.vert</file>

=== modified file 'mixxx/src/dlgprefplaylist.cpp'
--- mixxx/src/dlgprefplaylist.cpp	2012-07-09 21:38:03 +0000
+++ mixxx/src/dlgprefplaylist.cpp	2012-11-18 17:09:22 +0000
@@ -51,6 +51,10 @@
     //connect(pushButtonM4A, SIGNAL(clicked()), this, SLOT(slotM4ACheck()));
     connect(pushButtonExtraPlugins, SIGNAL(clicked()), this, SLOT(slotExtraPlugins()));
 
+#ifndef __IPOD__
+    checkBox_show_ipod->hide();
+#endif // __IPOD__
+
     if (!PromoTracksFeature::isSupported(config))
     {
         groupBoxBundledSongs->hide();
@@ -146,6 +150,9 @@
     checkBox_use_relative_path->setChecked((bool)config->getValueString(ConfigKey("[Library]","UseRelativePathOnExport")).toInt());
     checkBox_show_rhythmbox->setChecked((bool)config->getValueString(ConfigKey("[Library]","ShowRhythmboxLibrary"),"1").toInt());
     checkBox_show_itunes->setChecked((bool)config->getValueString(ConfigKey("[Library]","ShowITunesLibrary"),"1").toInt());
+    #ifdef __IPOD__
+    checkBox_show_ipod->setChecked((bool)config->getValueString(ConfigKey("[Library]","ShowIpod"),"1").toInt());
+    #endif // __IPOD__
     checkBox_show_traktor->setChecked((bool)config->getValueString(ConfigKey("[Library]","ShowTraktorLibrary"),"1").toInt());
 }
 
@@ -180,6 +187,11 @@
     config->set(ConfigKey("[Library]","ShowITunesLibrary"),
                 ConfigValue((int)checkBox_show_itunes->isChecked()));
 
+#ifdef __IPOD__
+    config->set(ConfigKey("[Library]","ShowIpod"),
+                ConfigValue((int)checkBox_show_ipod->isChecked()));
+#endif // __IPOD__
+
     config->set(ConfigKey("[Library]","ShowTraktorLibrary"),
                 ConfigValue((int)checkBox_show_traktor->isChecked()));
 

=== modified file 'mixxx/src/dlgprefplaylistdlg.ui'
--- mixxx/src/dlgprefplaylistdlg.ui	2012-06-09 22:03:56 +0000
+++ mixxx/src/dlgprefplaylistdlg.ui	2012-11-18 17:09:22 +0000
@@ -181,6 +181,16 @@
         </property>
        </widget>
       </item>
+      <item row="4" column="0">
+       <widget class="QCheckBox" name="checkBox_show_ipod">
+        <property name="text">
+         <string>Show iPod</string>
+        </property>
+        <property name="checked">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>

=== added directory 'mixxx/src/library/ipod'
=== added file 'mixxx/src/library/ipod/gpoditdb.cpp'
--- mixxx/src/library/ipod/gpoditdb.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/library/ipod/gpoditdb.cpp	2012-11-18 17:09:22 +0000
@@ -0,0 +1,64 @@
+/*
+ * GPodItdb.cpp
+ *
+ *  Created on: 01.02.2012
+ *      Author: Daniel Schürmann
+ */
+
+#include <QLibrary>
+#include <QtDebug>
+#include <QDir>
+#include <QMessageBox>
+
+#include "gpoditdb.h"
+
+
+GPodItdb::GPodItdb() :
+        m_itdb(NULL),
+        m_libGPodLoaded(true) {
+
+    // Load shared library
+    QLibrary libGPod("libgpod");
+
+    fp_itdb_free = (itdb_free__)libGPod.resolve("itdb_free");
+    if(!fp_itdb_free) m_libGPodLoaded = false;
+
+    fp_itdb_playlist_mpl = (itdb_playlist_mpl__)libGPod.resolve("itdb_playlist_mpl");
+    if(!fp_itdb_playlist_mpl) m_libGPodLoaded = false;
+
+    fp_itdb_parse = (itdb_parse__)libGPod.resolve("itdb_parse");
+    if(!fp_itdb_parse) m_libGPodLoaded = false;
+
+    qDebug() << "GPodItdb: try to resolve libgpod functions: " << (m_libGPodLoaded?"success":"failed");
+}
+
+GPodItdb::~GPodItdb() {
+    if (m_itdb) {
+        fp_itdb_free(m_itdb);
+    }
+}
+
+void GPodItdb::parse(const QString& mount, GError **error) {
+
+    if (m_itdb) {
+        fp_itdb_free(m_itdb);
+        m_itdb = NULL;
+    }
+    m_itdb = fp_itdb_parse(QDir::toNativeSeparators(mount).toLocal8Bit(), error);
+}
+
+Itdb_Playlist* GPodItdb::getFirstPlaylist() {
+    m_playlistNode = g_list_first(m_itdb->playlists);
+    if (m_playlistNode) {
+        return (Itdb_Playlist*)m_playlistNode->data;
+    }
+    return NULL;
+}
+
+Itdb_Playlist* GPodItdb::getNextPlaylist() {
+    m_playlistNode = g_list_next(m_playlistNode);
+    if (m_playlistNode) {
+        return (Itdb_Playlist*)m_playlistNode->data;
+    }
+    return NULL;
+}

=== added file 'mixxx/src/library/ipod/gpoditdb.h'
--- mixxx/src/library/ipod/gpoditdb.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/library/ipod/gpoditdb.h	2012-11-18 17:09:22 +0000
@@ -0,0 +1,49 @@
+/*
+ * gpoditdb.h
+ *
+ *  Created on: 01.02.2012
+ *      Author: daniel
+ */
+
+#include <QObject>
+
+extern "C"
+{
+#include <gpod/itdb.h>
+}
+
+#ifndef GPODITDB_H_
+#define GPODITDB_H_
+
+class GPodItdb {
+public:
+    GPodItdb();
+    virtual ~GPodItdb();
+    bool isSupported() { return m_libGPodLoaded; };
+    void parse(const QString& mount, GError **error);
+    Itdb_Playlist* getFirstPlaylist();
+    Itdb_Playlist* getNextPlaylist();
+    Itdb_Playlist* getMasterPlaylist() { return fp_itdb_playlist_mpl(m_itdb); };
+    Itdb_Playlist* getCurrentPlaylist() { return m_pCurrentPlaylist; };
+    void setCurrentPlaylist(Itdb_Playlist* pl) { m_pCurrentPlaylist = pl; };
+
+    typedef int (*itdb_free__)(Itdb_iTunesDB *itdb);
+    itdb_free__ fp_itdb_free;
+
+    typedef Itdb_Playlist* (*itdb_playlist_mpl__)(Itdb_iTunesDB *itdb);
+    itdb_playlist_mpl__ fp_itdb_playlist_mpl;
+
+    typedef Itdb_iTunesDB* (*itdb_parse__)(const gchar *mp, GError **error);
+    itdb_parse__ fp_itdb_parse;
+
+    typedef gboolean (*itdb_playlist_is_mpl__)(Itdb_Playlist *pl);
+    itdb_playlist_is_mpl__ fp_itdb_playlist_is_mpl;
+
+private:
+    Itdb_iTunesDB* m_itdb;
+    bool m_libGPodLoaded;
+    GList* m_playlistNode;
+    Itdb_Playlist *m_pCurrentPlaylist;
+};
+
+#endif /* GPODITDB_H_ */

=== added file 'mixxx/src/library/ipod/ipodfeature.cpp'
--- mixxx/src/library/ipod/ipodfeature.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/library/ipod/ipodfeature.cpp	2012-11-18 17:09:22 +0000
@@ -0,0 +1,405 @@
+#include <QMessageBox>
+#include <QtDebug>
+#include <QXmlStreamReader>
+#include <QDesktopServices>
+#include <QFileDialog>
+#include <QMenu>
+#include <QAction>
+
+#include "library/ipod/ipodfeature.h"
+#include "library/ipod/gpoditdb.h"
+
+#include "library/itunes/itunestrackmodel.h"
+#include "library/ipod/ipodplaylistmodel.h"
+#include "library/dao/settingsdao.h"
+
+extern "C" {
+#include <glib-object.h> // g_type_init
+}
+
+const QString IPodFeature::IPOD_MOUNT_KEY = "mixxx.IPodFeature.mount";
+
+
+IPodFeature::IPodFeature(QObject* parent, TrackCollection* pTrackCollection)
+        : LibraryFeature(parent),
+          m_pTrackCollection(pTrackCollection),
+          m_isActivated(false),
+          m_cancelImport(false),
+          m_itdb(NULL)
+{
+    m_title = tr("iPod");
+    m_pIPodPlaylistModel = new IPodPlaylistModel(this, m_pTrackCollection);
+
+    m_gPodItdb = new GPodItdb();
+
+    connect(&m_future_watcher, SIGNAL(finished()), this, SLOT(onTrackCollectionLoaded()));
+
+    m_pAddToAutoDJAction = new QAction(tr("Add to Auto DJ bottom"),this);
+    connect(m_pAddToAutoDJAction, SIGNAL(triggered()),
+            this, SLOT(slotAddToAutoDJ()));
+
+    m_pAddToAutoDJTopAction = new QAction(tr("Add to Auto DJ top 2"),this);
+    connect(m_pAddToAutoDJTopAction, SIGNAL(triggered()),
+            this, SLOT(slotAddToAutoDJTop()));
+
+    m_pImportAsMixxxPlaylistAction = new QAction(tr("Import as Mixxx Playlist"), this);
+    connect(m_pImportAsMixxxPlaylistAction, SIGNAL(triggered()),
+            this, SLOT(slotImportAsMixxxPlaylist()));
+}
+
+IPodFeature::~IPodFeature() {
+    qDebug() << "~IPodFeature()";
+    // stop import thread, if still running
+    m_cancelImport = true;
+    if (m_future.isRunning()) {
+        qDebug() << "m_future still running";
+        m_future.waitForFinished();
+        qDebug() << "m_future finished";
+    }
+    if (m_itdb) {
+        itdb_free(m_itdb);
+    }
+    delete m_pIPodPlaylistModel;
+    delete m_pAddToAutoDJAction;
+    delete m_pAddToAutoDJTopAction;
+    delete m_pImportAsMixxxPlaylistAction;
+    delete m_gPodItdb;
+}
+
+// static
+bool IPodFeature::isSupported() {
+    // The iPod might be mount at any time at any location
+    return true; //m_gPodItdb->isSupported();
+}
+
+
+QVariant IPodFeature::title() {
+    return m_title;
+}
+
+QIcon IPodFeature::getIcon() {
+    return QIcon(":/images/library/ic_library_ipod.png");
+}
+
+void IPodFeature::activate() {
+    activate(false);
+}
+
+void IPodFeature::activate(bool forceReload) {
+    //qDebug("IPodFeature::activate()");
+
+    if (!m_isActivated || forceReload) {
+
+        SettingsDAO settings(m_pTrackCollection->getDatabase());
+
+        QString dbSetting(settings.getValue(IPOD_MOUNT_KEY));
+        // if a path exists in the database, use it
+        if (!dbSetting.isEmpty() && QFile::exists(dbSetting)) {
+            m_dbfile = dbSetting;
+        } else {
+            // No Path in settings
+            m_dbfile = "";
+        }
+
+        m_dbfile = detectMountPoint(m_dbfile);
+
+        if (!QFile::exists(m_dbfile)) {
+            m_dbfile = QFileDialog::getExistingDirectory(
+                NULL,
+                tr("Select your iPod mount"));
+            if (m_dbfile.isEmpty()) {
+                emit(showTrackModel(m_pIPodPlaylistModel));
+                return;
+            }
+        }
+
+        m_isActivated =  true;
+
+        QThreadPool::globalInstance()->setMaxThreadCount(4); //Tobias decided to use 4
+        // Let a worker thread do the iPod parsing
+        m_future = QtConcurrent::run(this, &IPodFeature::importLibrary);
+        m_future_watcher.setFuture(m_future);
+        m_title = tr("(loading) iPod"); // (loading) at start in respect to small displays
+        //calls a slot in the sidebar model such that '(loading)iPod' is displayed.
+        emit (featureIsLoading(this));
+    }
+    else{
+        m_pIPodPlaylistModel->setPlaylist(itdb_playlist_mpl(m_itdb)); // Gets the master playlist
+    }
+    emit(showTrackModel(m_pIPodPlaylistModel));
+}
+
+QString IPodFeature::detectMountPoint( QString iPodMountPoint) {
+    QFileInfoList mountpoints;
+    #ifdef __WINDOWS__
+      // Windows iPod Detection
+      mountpoints = QDir::drives();
+    #elif __LINUX__
+      // Linux
+      mountpoints = QDir("/media").entryInfoList();
+      mountpoints += QDir("/mnt").entryInfoList();
+    #elif __APPLE__
+      // Mac OSX
+      mountpoints = QDir("/Volumes").entryInfoList();
+    #endif
+
+    QListIterator<QFileInfo> i(mountpoints);
+    QFileInfo mp;
+    while (i.hasNext()) {
+        mp = (QFileInfo) i.next();
+        qDebug() << "mp:" << mp.filePath();
+        if( mp.filePath() != iPodMountPoint ) {
+            if (QDir( QString(mp.filePath() + "/iPod_Control") ).exists() ) {
+                qDebug() << "iPod found at" << mp.filePath();
+
+                // Multiple iPods
+                if (!iPodMountPoint.isEmpty()) {
+                    int ret = QMessageBox::warning(NULL, tr("Multiple iPods Detected"),
+                           tr("Mixxx has detected another iPod. \n\n")+
+                           tr("Choose Yes to use the newly found iPod @ ")+ mp.filePath()+
+                           tr(" or to continue to search for other iPods. \n")+
+                           tr("Choose No to use the existing iPod @ ")+ iPodMountPoint+
+                           tr( " and end detection. \n"),
+                           QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
+                    if (ret == QMessageBox::No) {
+                    break;
+                    }
+                }
+                iPodMountPoint = mp.filePath();
+            }
+        }
+    }
+    return iPodMountPoint;
+}
+
+void IPodFeature::activateChild(const QModelIndex& index) {
+    TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
+    qDebug() << "IPodFeature::activateChild " << item->data() << " " << item->dataPath();
+    QString playlist = item->dataPath().toString();
+    Itdb_Playlist* pPlaylist = (Itdb_Playlist*)playlist.toUInt();
+
+    if (pPlaylist) {
+        qDebug() << "Activating " << QString::fromUtf8(pPlaylist->name);
+    }
+    m_pIPodPlaylistModel->setPlaylist(pPlaylist);
+    emit(showTrackModel(m_pIPodPlaylistModel));
+}
+
+TreeItemModel* IPodFeature::getChildModel() {
+    return &m_childModel;
+}
+
+void IPodFeature::onRightClick(const QPoint& globalPos) {
+    Q_UNUSED(globalPos);
+}
+
+void IPodFeature::onRightClickChild(const QPoint& globalPos, QModelIndex index) {
+    //Save the model index so we can get it in the action slots...
+    m_lastRightClickedIndex = index;
+
+    //Create the right-click menu
+    QMenu menu(NULL);
+    menu.addAction(m_pAddToAutoDJAction);
+    menu.addAction(m_pAddToAutoDJTopAction);
+    menu.addSeparator();
+    menu.addAction(m_pImportAsMixxxPlaylistAction);
+    menu.exec(globalPos);
+}
+
+bool IPodFeature::dropAccept(QList<QUrl> urls) {
+    Q_UNUSED(urls);
+    return false;
+}
+
+bool IPodFeature::dropAcceptChild(const QModelIndex& index, QList<QUrl> urls) {
+    Q_UNUSED(index);
+    Q_UNUSED(urls);
+    return false;
+}
+
+bool IPodFeature::dragMoveAccept(QUrl url) {
+    Q_UNUSED(url);
+    return false;
+}
+
+bool IPodFeature::dragMoveAcceptChild(const QModelIndex& index, QUrl url) {
+    Q_UNUSED(index);
+    Q_UNUSED(url);
+    return false;
+}
+
+/*
+ * This method is executed in a separate thread
+ * via QtConcurrent::run
+ */
+TreeItem* IPodFeature::importLibrary() {
+    // Give thread a low priority
+    QThread* thisThread = QThread::currentThread();
+    thisThread->setPriority(QThread::LowestPriority);
+
+    qDebug() << "IPodFeature::importLibrary() ";
+
+    TreeItem* playlist_root = new TreeItem();
+
+    GError* err = 0;
+    qDebug() << "Calling the libgpod db parser for:" << m_dbfile;
+    if (m_itdb) {
+        itdb_free(m_itdb);
+        m_itdb = NULL;
+    }
+    m_itdb = itdb_parse(QDir::toNativeSeparators(m_dbfile).toLocal8Bit(), &err);
+
+    if (err) {
+        qDebug() << "There was an error, attempting to free db: "
+                 << err->message;
+        QMessageBox::warning(NULL, tr("Error Loading iPod database"),
+                err->message);
+        g_error_free(err);
+        if (m_itdb) {
+            itdb_free(m_itdb);
+            m_itdb = 0;
+        }
+    } else if (m_itdb) {
+        GList* playlist_node;
+
+        for (playlist_node = g_list_first(m_itdb->playlists);
+             playlist_node != NULL;
+             playlist_node = g_list_next(playlist_node))
+        {
+            Itdb_Playlist* pPlaylist;
+            pPlaylist = (Itdb_Playlist*)playlist_node->data;
+            if (!itdb_playlist_is_mpl(pPlaylist)) {
+                QString playlistname = QString::fromUtf8(pPlaylist->name);
+                qDebug() << playlistname;
+                // append the playlist to the child model
+                TreeItem *item = new TreeItem(playlistname, QString::number((uint)pPlaylist), this, playlist_root);
+                playlist_root->appendChild(item);
+            }
+        }
+    }
+    return playlist_root;
+}
+
+void IPodFeature::onTrackCollectionLoaded(){
+    TreeItem* root = m_future.result();
+    if(root){
+        m_childModel.setRootItem(root);
+        if (m_isActivated) {
+            activate();
+        }
+        qDebug() << "iPod library loaded: success";
+        SettingsDAO settings(m_pTrackCollection->getDatabase());
+        settings.setValue(IPOD_MOUNT_KEY, m_dbfile);
+    }
+    else{
+        QMessageBox::warning(
+            NULL,
+            tr("Error Loading iPod database"),
+            tr("There was an error loading your iPod database. Some of "
+               "your iPod tracks or playlists may not have loaded."));
+    }
+    //calls a slot in the sidebarmodel such that 'isLoading' is removed from the feature title.
+    m_title = tr("iPod");
+    emit(featureLoadingFinished(this));
+    activate();
+}
+
+void IPodFeature::onLazyChildExpandation(const QModelIndex &index){
+    Q_UNUSED(index);
+    //Nothing to do because the childmodel is not of lazy nature.
+}
+
+void IPodFeature::slotAddToAutoDJ() {
+    //qDebug() << "slotAddToAutoDJ() row:" << m_lastRightClickedIndex.data();
+    addToAutoDJ(false); // Top = True
+}
+
+
+void IPodFeature::slotAddToAutoDJTop() {
+    //qDebug() << "slotAddToAutoDJTop() row:" << m_lastRightClickedIndex.data();
+    addToAutoDJ(true); // bTop = True
+}
+
+void IPodFeature::addToAutoDJ(bool bTop) {
+    // qDebug() << "slotAddToAutoDJ() row:" << m_lastRightClickedIndex.data();
+
+    if (m_lastRightClickedIndex.isValid()) {
+        TreeItem *item = static_cast<TreeItem*>(m_lastRightClickedIndex.internalPointer());
+        qDebug() << "IPodFeature::addToAutoDJ " << item->data() << " " << item->dataPath();
+        QString playlist = item->dataPath().toString();
+        Itdb_Playlist* pPlaylist = (Itdb_Playlist*)playlist.toUInt();
+        if (pPlaylist) {
+            IPodPlaylistModel* pPlaylistModelToAdd = new IPodPlaylistModel(this, m_pTrackCollection);
+            pPlaylistModelToAdd->setPlaylist(pPlaylist);
+            PlaylistDAO &playlistDao = m_pTrackCollection->getPlaylistDAO();
+            int autoDJId = playlistDao.getPlaylistIdFromName(AUTODJ_TABLE);
+
+            int rows = pPlaylistModelToAdd->rowCount();
+            for(int i = 0; i < rows; ++i){
+                QModelIndex index = pPlaylistModelToAdd->index(i,0);
+                if (index.isValid()) {
+                    TrackPointer track = pPlaylistModelToAdd->getTrack(index);
+                    if (bTop) {
+                        // Start at position 2 because position 1 was already loaded to the deck
+                        playlistDao.insertTrackIntoPlaylist(track->getId(), autoDJId, i+2);
+                    } else {
+                        playlistDao.appendTrackToPlaylist(track->getId(), autoDJId);
+                    }
+                }
+            }
+            delete pPlaylistModelToAdd;
+        }
+    }
+}
+
+void IPodFeature::slotImportAsMixxxPlaylist() {
+    // qDebug() << "slotAddToAutoDJ() row:" << m_lastRightClickedIndex.data();
+
+    if (m_lastRightClickedIndex.isValid()) {
+        TreeItem *item = static_cast<TreeItem*>(m_lastRightClickedIndex.internalPointer());
+        qDebug() << "IPodFeature::slotImportAsMixxxPlaylist " << item->data() << " " << item->dataPath();
+        QString playlist = item->dataPath().toString();
+        Itdb_Playlist* pPlaylist = (Itdb_Playlist*)playlist.toUInt();
+        playlist = QString::fromUtf8(pPlaylist->name);
+        if (pPlaylist) {
+            IPodPlaylistModel* pPlaylistModelToAdd = new IPodPlaylistModel(this, m_pTrackCollection);
+            pPlaylistModelToAdd->setPlaylist(pPlaylist);
+            PlaylistDAO &playlistDao = m_pTrackCollection->getPlaylistDAO();
+
+            int playlistId = playlistDao.getPlaylistIdFromName(playlist);
+            int i = 1;
+
+            if (playlistId != -1) {
+                // Calculate a unique name
+                playlist += "(%1)";
+                while (playlistId != -1) {
+                    i++;
+                    playlistId = playlistDao.getPlaylistIdFromName(playlist.arg(i));
+                }
+                playlist = playlist.arg(i);
+            }
+            playlistId = playlistDao.createPlaylist(playlist);
+
+            if (playlistId != -1) {
+                // Copy Tracks
+                int rows = pPlaylistModelToAdd->rowCount();
+                for (int i = 0; i < rows; ++i) {
+                    QModelIndex index = pPlaylistModelToAdd->index(i,0);
+                    if (index.isValid()) {
+                        //qDebug() << pPlaylistModelToAdd->getTrackLocation(index);
+                        TrackPointer track = pPlaylistModelToAdd->getTrack(index);
+                        playlistDao.appendTrackToPlaylist(track->getId(), playlistId);
+                    }
+                }
+            }
+            else {
+                QMessageBox::warning(NULL,
+                                     tr("Playlist Creation Failed"),
+                                     tr("An unknown error occurred while creating playlist: ")
+                                      + playlist);
+            }
+
+            delete pPlaylistModelToAdd;
+        }
+    }
+}

=== added file 'mixxx/src/library/ipod/ipodfeature.h'
--- mixxx/src/library/ipod/ipodfeature.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/library/ipod/ipodfeature.h	2012-11-18 17:09:22 +0000
@@ -0,0 +1,90 @@
+
+#ifndef IPODFEATURE_H
+#define IPODFEATURE_H
+
+#include <QStringListModel>
+#include <QtSql>
+#include <QFuture>
+#include <QtConcurrentRun>
+#include <QFutureWatcher>
+
+#include "library/libraryfeature.h"
+#include "library/trackcollection.h"
+#include "library/treeitemmodel.h"
+#include "library/treeitem.h"
+
+extern "C"
+{
+#include <gpod/itdb.h>
+}
+
+class IPodPlaylistModel;
+class GPodItdb;
+
+class IPodFeature : public LibraryFeature {
+ Q_OBJECT
+ public:
+    IPodFeature(QObject* parent, TrackCollection* pTrackCollection);
+    virtual ~IPodFeature();
+    static bool isSupported();
+
+    QVariant title();
+    QIcon getIcon();
+
+    bool dropAccept(QList<QUrl> urls);
+    bool dropAcceptChild(const QModelIndex& index, QList<QUrl> urls);
+    bool dragMoveAccept(QUrl url);
+    bool dragMoveAcceptChild(const QModelIndex& index, QUrl url);
+
+    TreeItemModel* getChildModel();
+
+  public slots:
+    void activate();
+    void activate(bool forceReload);
+    void activateChild(const QModelIndex& index);
+    void onRightClick(const QPoint& globalPos);
+    void onRightClickChild(const QPoint& globalPos, QModelIndex index);
+    void onLazyChildExpandation(const QModelIndex& index);
+    void onTrackCollectionLoaded();
+    void slotAddToAutoDJ();
+    void slotAddToAutoDJTop();
+    void slotImportAsMixxxPlaylist();
+
+  private:
+    static QString getiTunesMusicPath();
+    //returns the invisible rootItem for the sidebar model
+    TreeItem* importLibrary();
+    void addToAutoDJ(bool bTop);
+    QString detectMountPoint(QString iPodMountPoint);
+
+    QAction* m_pAddToAutoDJAction;
+    QAction* m_pAddToAutoDJTopAction;
+    QAction* m_pImportAsMixxxPlaylistAction;
+
+    QModelIndex m_lastRightClickedIndex;
+
+    IPodPlaylistModel* m_pIPodPlaylistModel;
+    TreeItemModel m_childModel;
+    QStringList m_playlists;
+    TrackCollection* m_pTrackCollection;
+    //a new DB connection for the worker thread
+    QSqlDatabase m_database;
+    bool m_isActivated;
+    QString m_dbfile;
+
+    QFutureWatcher<TreeItem*> m_future_watcher;
+    QFuture<TreeItem*> m_future;
+    QString m_title;
+    bool m_cancelImport;
+
+    QString m_dbItunesRoot;
+    QString m_mixxxItunesRoot;
+
+    GPodItdb* m_gPodItdb;
+
+    Itdb_iTunesDB* m_itdb;
+
+    static const QString IPOD_MOUNT_KEY;
+};
+
+#endif /* IPODFEATURE_H */

=== added file 'mixxx/src/library/ipod/ipodplaylistmodel.cpp'
--- mixxx/src/library/ipod/ipodplaylistmodel.cpp	1970-01-01 00:00:00 +0000
+++ mixxx/src/library/ipod/ipodplaylistmodel.cpp	2012-11-18 17:09:22 +0000
@@ -0,0 +1,901 @@
+#include <QtAlgorithms>
+#include <QtDebug>
+#include <QTime>
+
+#include "library/ipod/ipodplaylistmodel.h"
+#include "mixxxutils.cpp"
+#include "library/starrating.h"
+#include "track/beatfactory.h"
+#include "track/beats.h"
+
+extern "C" {
+#include <glib-object.h> // g_type_init
+}
+
+const bool sDebug = false;
+
+IPodPlaylistModel::IPodPlaylistModel(QObject* pParent, TrackCollection* pTrackCollection)
+        :  TrackModel(pTrackCollection->getDatabase(),
+                "mixxx.db.model.ipod_playlist"),
+           QAbstractTableModel(pParent),
+           m_iSortColumn(0),
+           m_eSortOrder(Qt::AscendingOrder),
+           m_currentSearch(""),
+           m_pTrackCollection(pTrackCollection),
+           m_trackDAO(m_pTrackCollection->getTrackDAO()),
+           m_pPlaylist(NULL)
+{
+    initHeaderData();
+}
+
+IPodPlaylistModel::~IPodPlaylistModel() {
+
+}
+
+void IPodPlaylistModel::initHeaderData() {
+    // Set the column heading labels, rename them for translations and have
+    // proper capitalization
+
+    m_headerList.append(qMakePair(QString(tr("#")),          (size_t)0xffff));
+    m_headerList.append(qMakePair(QString(tr("Artist")),     offsetof(Itdb_Track, artist)));
+    m_headerList.append(qMakePair(QString(tr("Title")),      offsetof(Itdb_Track, title)));
+    m_headerList.append(qMakePair(QString(tr("Album")),      offsetof(Itdb_Track, album)));
+    m_headerList.append(qMakePair(QString(tr("Year")),       offsetof(Itdb_Track, year)));
+    m_headerList.append(qMakePair(QString(tr("Duration")),   offsetof(Itdb_Track, tracklen)));
+    m_headerList.append(qMakePair(QString(tr("Rating")),     offsetof(Itdb_Track, rating)));
+    m_headerList.append(qMakePair(QString(tr("Genre")),      offsetof(Itdb_Track, genre)));
+    m_headerList.append(qMakePair(QString(tr("Type")),       offsetof(Itdb_Track, filetype)));
+    m_headerList.append(qMakePair(QString(tr("Track #")),    offsetof(Itdb_Track, track_nr)));
+    m_headerList.append(qMakePair(QString(tr("Date Added")), offsetof(Itdb_Track, time_added)));
+    m_headerList.append(qMakePair(QString(tr("BPM")),        offsetof(Itdb_Track, BPM)));
+    m_headerList.append(qMakePair(QString(tr("Bitrate")),    offsetof(Itdb_Track, bitrate)));
+    m_headerList.append(qMakePair(QString(tr("Location")),   offsetof(Itdb_Track, ipod_path)));
+    m_headerList.append(qMakePair(QString(tr("Comment")),    offsetof(Itdb_Track, comment)));
+
+}
+
+void IPodPlaylistModel::initDefaultSearchColumns() {
+    QStringList searchColumns;
+    searchColumns << "artist"
+                  << "album"
+                  << "location"
+                  << "comment"
+                  << "title";
+    setSearchColumns(searchColumns);
+}
+
+void IPodPlaylistModel::setSearchColumns(const QStringList& searchColumns) {
+    m_searchColumns = searchColumns;
+
+    // Convert all the search column names to their field indexes because we use
+    // them a bunch.
+    m_searchColumnIndices.resize(m_searchColumns.size());
+    for (int i = 0; i < m_searchColumns.size(); ++i) {
+        m_searchColumnIndices[i] = fieldIndex(m_searchColumns[i]);
+    }
+}
+
+QVariant IPodPlaylistModel::headerData(int section, Qt::Orientation orientation, int role) const {
+    if (role != Qt::DisplayRole)
+        return QAbstractTableModel::headerData(section, orientation, role);
+
+    if (   orientation == Qt::Horizontal
+        && role == Qt::DisplayRole
+        && section < m_headerList.size()
+    ) {
+        return QVariant(m_headerList.at(section).first);
+    }
+    return QAbstractTableModel::headerData(section, orientation, role);
+}
+
+
+int IPodPlaylistModel::findSortInsertionPoint(int trackId, TrackPointer pTrack,
+                                              const QVector<QPair<int, QHash<int, QVariant> > >& rowInfo) {
+    QVariant trackValue = getTrackValueForColumn(trackId, m_iSortColumn, pTrack);
+
+    int min = 0;
+    int max = rowInfo.size()-1;
+
+    if (sDebug) {
+        qDebug() << this << "Trying to insertion sort:"
+                 << trackValue << "min" << min << "max" << max;
+    }
+
+    while (min <= max) {
+        int mid = min + (max - min) / 2;
+        const QPair<int, QHash<int, QVariant> >& otherRowInfo = rowInfo[mid];
+        int otherTrackId = otherRowInfo.first;
+        // const QHash<int, QVariant>& otherRowCache = otherRowInfo.second; // not used
+
+
+        // This should not happen, but it's a recoverable error so we should only log it.
+        if (!m_recordCache.contains(otherTrackId)) {
+            qDebug() << "WARNING: track" << otherTrackId << "was not in index";
+//           updateTrackInIndex(otherTrackId);
+        }
+
+        QVariant tableValue = getTrackValueForColumn(otherTrackId, m_iSortColumn);
+        int compare = compareColumnValues(m_iSortColumn, m_eSortOrder, trackValue, tableValue);
+
+        if (sDebug) {
+            qDebug() << this << "Comparing" << trackValue
+                     << "to" << tableValue << ":" << compare;
+        }
+
+        if (compare == 0) {
+            // Alright, if we're here then we can insert it here and be
+            // "correct"
+            min = mid;
+            break;
+        } else if (compare > 0) {
+            min = mid + 1;
+        } else {
+            max = mid - 1;
+        }
+    }
+    return min;
+}
+
+
+const QString IPodPlaylistModel::currentSearch() const {
+    return m_currentSearch;
+}
+
+void IPodPlaylistModel::setSort(int column, Qt::SortOrder order) {
+    if (sDebug) {
+        qDebug() << this << "setSort()";
+    }
+
+    m_iSortColumn = column;
+    m_eSortOrder = order;
+}
+
+void IPodPlaylistModel::sort(int column, Qt::SortOrder order) {
+    if (sDebug) {
+        qDebug() << this << "sort()" << column << order;
+    }
+
+    m_iSortColumn = column;
+    m_eSortOrder = order;
+
+    emit layoutAboutToBeChanged();
+    qSort(m_sortedPlaylist.begin(), m_sortedPlaylist.end(), columnLessThan);
+    emit layoutChanged();
+}
+
+int IPodPlaylistModel::rowCount(const QModelIndex& parent) const {
+    if (m_pPlaylist && !parent.isValid()) {
+        return m_sortedPlaylist.size();
+    }
+    return 0;
+}
+
+int IPodPlaylistModel::columnCount(const QModelIndex& parent) const {
+    return parent.isValid() ? 0 : m_headerList.size();
+}
+
+int IPodPlaylistModel::fieldIndex(const QString& fieldName) const {
+    // Usually a small list, so O(n) is small
+    //return m_queryRecord.indexOf(fieldName);
+    //return m_columnNames.indexOf(fieldName);
+    QHash<QString, int>::const_iterator it = m_columnIndex.constFind(fieldName);
+    if (it != m_columnIndex.end()) {
+        return it.value();
+    }
+    return -1;
+}
+
+QVariant IPodPlaylistModel::data(const QModelIndex& index, int role) const {
+    //qDebug() << this << "data()";
+    QVariant value = QVariant();
+
+    if (    role != Qt::DisplayRole
+         && role != Qt::EditRole
+         && role != Qt::CheckStateRole
+         && role != Qt::ToolTipRole
+    ) {
+        return value;
+    }
+
+
+    Itdb_Track* pTrack = getPTrackFromModelIndex(index);
+    if (!pTrack) {
+        return value;
+    }
+
+    size_t structOffset = m_headerList.at(index.column()).second;
+
+
+    if (structOffset == 0xffff) { // "#"
+        value = m_sortedPlaylist.at(index.row()).pos;
+    } else if (structOffset == offsetof(Itdb_Track, year)) {
+        if (pTrack->year) {
+            value = QVariant(pTrack->year);
+        }
+    } else if (structOffset == offsetof(Itdb_Track, tracklen)) {
+        if (pTrack->tracklen) {
+            value = MixxxUtils::millisecondsToMinutes(pTrack->tracklen, true);
+        }
+    } else if (structOffset == offsetof(Itdb_Track, rating)) {
+        value = qVariantFromValue(StarRating(pTrack->rating));
+    } else if (structOffset == offsetof(Itdb_Track, track_nr)) {
+        if (pTrack->track_nr) {
+            value = QVariant(pTrack->track_nr);
+        }
+    } else if (structOffset == offsetof(Itdb_Track, BPM)) {
+        if (pTrack->BPM) {
+            value = QVariant(pTrack->BPM);
+        }
+    } else if (structOffset == offsetof(Itdb_Track, bitrate)) {
+        if (pTrack->bitrate) {
+            value = QVariant(pTrack->bitrate);
+        }
+    } else if (structOffset == offsetof(Itdb_Track, time_added)) {
+        if (pTrack->time_added) {
+            QDateTime timeAdded;
+            timeAdded.setTime_t(pTrack->time_added);
+            timeAdded.toString(Qt::ISODate);
+            value = QVariant(timeAdded.toString(Qt::ISODate));
+        }
+    } else {
+        // for the gchar* elements
+        //qDebug() << *(gchar**)((char*)(pTrack) + structOffset);
+        QString ret = QString::fromUtf8(*(gchar**)((char*)(pTrack) + structOffset));
+
+        value = QVariant(ret);
+    }
+
+
+/*
+    // This value is the value in its most raw form. It was looked up either
+    // from the SQL table or from the cached track layer.
+    QVariant value = getBaseValue(index, role);
+*/
+
+
+    // Format the value based on whether we are in a tooltip, display, or edit
+    // role
+    switch (role) {
+        case Qt::ToolTipRole:
+        case Qt::DisplayRole:
+            /*
+            if (column == fieldIndex(LIBRARYTABLE_DURATION)) {
+                if (qVariantCanConvert<int>(value))
+                    value = MixxxUtils::secondsToMinutes(qVariantValue<int>(value));
+            } else if (column == fieldIndex(LIBRARYTABLE_RATING)) {
+                if (qVariantCanConvert<int>(value))
+                    value = qVariantFromValue(StarRating(value.toInt()));
+            } else if (column == fieldIndex(LIBRARYTABLE_TIMESPLAYED)) {
+                if (qVariantCanConvert<int>(value))
+                    value =  QString("(%1)").arg(value.toInt());
+            } else if (column == fieldIndex(LIBRARYTABLE_PLAYED)) {
+                // Convert to a bool. Not really that useful since it gets converted
+                // right back to a QVariant
+                value = (value == "true") ? true : false;
+            }
+            */
+            break;
+        case Qt::EditRole:
+            /*
+            if (column == fieldIndex(LIBRARYTABLE_BPM)) {
+                return value.toDouble();
+            } else if (column == fieldIndex(LIBRARYTABLE_TIMESPLAYED)) {
+                return index.sibling(row, fieldIndex(LIBRARYTABLE_PLAYED)).data().toBool();
+            } else if (column == fieldIndex(LIBRARYTABLE_RATING)) {
+                if (qVariantCanConvert<int>(value))
+                    value = qVariantFromValue(StarRating(value.toInt()));
+            }
+            */
+            break;
+        case Qt::CheckStateRole:
+            /*
+            if (column == fieldIndex(LIBRARYTABLE_TIMESPLAYED)) {
+                bool played = index.sibling(row, fieldIndex(LIBRARYTABLE_PLAYED)).data().toBool();
+                value = played ? Qt::Checked : Qt::Unchecked;
+            } else {
+            */
+            value = QVariant();
+            //}
+            break;
+        default:
+            break;
+    }
+    return value;
+}
+
+bool IPodPlaylistModel::setData(const QModelIndex& index, const QVariant& value, int role) {
+
+    if (!index.isValid())
+        return false;
+
+    int row = index.row();
+    int column = index.column();
+
+    if (sDebug) {
+        qDebug() << this << "setData() column:" << column << "value:" << value << "role:" << role;
+    }
+
+    // Over-ride sets to TIMESPLAYED and re-direct them to PLAYED
+    if (role == Qt::CheckStateRole) {
+        if (column == fieldIndex(LIBRARYTABLE_TIMESPLAYED)) {
+            QString val = value.toInt() > 0 ? QString("true") : QString("false");
+            QModelIndex playedIndex = index.sibling(index.row(), fieldIndex(LIBRARYTABLE_PLAYED));
+            return setData(playedIndex, val, Qt::EditRole);
+        }
+        return false;
+    }
+
+    if (row < 0 || row >= m_rowInfo.size()) {
+        return false;
+    }
+
+    const QPair<int, QHash<int, QVariant> >& rowInfo = m_rowInfo[row];
+    int trackId = rowInfo.first;
+
+    // You can't set something in the table columns because we have no way of
+    // persisting it.
+    const QHash<int, QVariant>& columns = rowInfo.second;
+    if (columns.contains(column)) {
+        return false;
+    }
+
+    TrackPointer pTrack = m_trackDAO.getTrack(trackId);
+    setTrackValueForColumn(pTrack, column, value);
+
+    // Do not save the track here. Changing the track dirties it and the caching
+    // system will automatically save the track once it is unloaded from
+    // memory. rryan 10/2010
+    //m_trackDAO.saveTrack(pTrack);
+
+    return true;
+}
+
+TrackModel::CapabilitiesFlags IPodPlaylistModel::getCapabilities() const {
+    return TRACKMODELCAPS_NONE
+            | TRACKMODELCAPS_ADDTOPLAYLIST
+            | TRACKMODELCAPS_ADDTOCRATE
+            | TRACKMODELCAPS_ADDTOAUTODJ
+            | TRACKMODELCAPS_LOADTODECK
+            | TRACKMODELCAPS_LOADTOSAMPLER;
+}
+
+Qt::ItemFlags IPodPlaylistModel::flags(const QModelIndex &index) const {
+    return readWriteFlags(index);
+}
+
+Qt::ItemFlags IPodPlaylistModel::readWriteFlags(const QModelIndex &index) const {
+    if (!index.isValid())
+        return Qt::ItemIsEnabled;
+
+    Qt::ItemFlags defaultFlags = QAbstractItemModel::flags(index);
+
+    //Enable dragging songs from this data model to elsewhere (like the waveform
+    //widget to load a track into a Player).
+    defaultFlags |= Qt::ItemIsDragEnabled;
+
+    //int row = index.row(); // not used
+    int column = index.column();
+
+    if ( column == fieldIndex(LIBRARYTABLE_FILETYPE)
+         || column == fieldIndex(LIBRARYTABLE_LOCATION)
+         || column == fieldIndex(LIBRARYTABLE_DURATION)
+         || column == fieldIndex(LIBRARYTABLE_BITRATE)
+         || column == fieldIndex(LIBRARYTABLE_DATETIMEADDED)) {
+        return defaultFlags;
+    } else if (column == fieldIndex(LIBRARYTABLE_TIMESPLAYED)) {
+        return defaultFlags | Qt::ItemIsUserCheckable;
+    } else {
+        return defaultFlags | Qt::ItemIsEditable;
+    }
+}
+
+Qt::ItemFlags IPodPlaylistModel::readOnlyFlags(const QModelIndex &index) const
+{
+    Qt::ItemFlags defaultFlags = QAbstractItemModel::flags(index);
+    if (!index.isValid())
+        return Qt::ItemIsEnabled;
+
+    //Enable dragging songs from this data model to elsewhere (like the waveform widget to
+    //load a track into a Player).
+    defaultFlags |= Qt::ItemIsDragEnabled;
+
+    return defaultFlags;
+}
+
+void IPodPlaylistModel::trackChanged(int trackId) {
+    if (sDebug) {
+        qDebug() << this << "trackChanged" << trackId;
+    }
+    // TODO(daschuer): eg. use that for played column
+    //m_trackOverrides.insert(trackId);
+    //QLinkedList<int> rows = getTrackRows(trackId);
+/*
+    foreach (int row, rows) {
+        //qDebug() << "Row in this result set was updated. Signalling update. track:" << trackId << "row:" << row;
+        QModelIndex left = index(row, 0);
+        QModelIndex right = index(row, columnCount());
+        emit(dataChanged(left, right));
+    }
+*/
+}
+
+//static
+bool IPodPlaylistModel::columnLessThan(const playlist_member &s1, const playlist_member &s2) {
+    bool ret;
+
+    size_t structOffset = s1.pClass->m_headerList.at(s1.pClass->m_iSortColumn).second;
+
+    if (structOffset == 0xffff) { // "#"
+        ret = s1.pos < s2.pos;
+    } else if (structOffset == offsetof(Itdb_Track, year)) {
+        ret = s1.pTrack->year < s2.pTrack->year;
+    } else if (structOffset == offsetof(Itdb_Track, tracklen)) {
+        ret = s1.pTrack->tracklen < s2.pTrack->tracklen;
+    } else if (structOffset == offsetof(Itdb_Track, rating)) {
+        ret = s1.pTrack->rating < s2.pTrack->rating;
+    } else if (structOffset == offsetof(Itdb_Track, track_nr)) {
+        ret = s1.pTrack->track_nr < s2.pTrack->track_nr;
+    } else if (structOffset == offsetof(Itdb_Track, BPM)) {
+        ret = s1.pTrack->BPM < s2.pTrack->BPM;
+    } else if (structOffset == offsetof(Itdb_Track, bitrate)) {
+        ret = s1.pTrack->bitrate < s2.pTrack->bitrate;
+    } else if (structOffset == offsetof(Itdb_Track, time_added)) {
+        ret = s1.pTrack->time_added < s2.pTrack->time_added;
+    } else {
+        // for the gchar* elements
+        QString string1 = QString::fromUtf8(*(gchar**)((char*)(s1.pTrack) + structOffset));
+        QString string2 = QString::fromUtf8(*(gchar**)((char*)(s2.pTrack) + structOffset));
+        ret = string1.toLower() < string2.toLower();
+    }
+
+    if (s1.pClass->m_eSortOrder != Qt::AscendingOrder) {
+        return !ret;
+    }
+    return ret;
+}
+
+int IPodPlaylistModel::compareColumnValues(int iColumnNumber, Qt::SortOrder eSortOrder,
+                                           QVariant val1, QVariant val2) {
+    int result = 0;
+
+    if (iColumnNumber == fieldIndex(PLAYLISTTRACKSTABLE_POSITION) ||
+        iColumnNumber == fieldIndex(LIBRARYTABLE_BITRATE) ||
+        iColumnNumber == fieldIndex(LIBRARYTABLE_BPM) ||
+        iColumnNumber == fieldIndex(LIBRARYTABLE_DURATION) ||
+        iColumnNumber == fieldIndex(LIBRARYTABLE_TIMESPLAYED) ||
+        iColumnNumber == fieldIndex(LIBRARYTABLE_RATING)) {
+        // Sort as floats.
+        double delta = val1.toDouble() - val2.toDouble();
+
+        if (fabs(delta) < .00001)
+            result = 0;
+        else if (delta > 0.0)
+            result = 1;
+        else
+            result = -1;
+    } else {
+        // Default to case-insensitive string comparison
+        result = val1.toString().compare(val2.toString(), Qt::CaseInsensitive);
+    }
+
+    // If we're in descending order, flip the comparison.
+    if (eSortOrder == Qt::DescendingOrder) {
+        result = -result;
+    }
+
+    return result;
+}
+
+
+QVariant IPodPlaylistModel::getTrackValueForColumn(int trackId, int column, TrackPointer pTrack) const {
+    QVariant result;
+
+    // The caller can optionally provide a pTrack if they already looked it
+    // up. This is just an optimization to help reduce the # of calls to
+    // lookupCachedTrack. If they didn't provide it, look it up.
+    if (pTrack) {
+        result = getTrackValueForColumn(pTrack, column);
+    }
+
+    // If the track lookup failed (could happen for track properties we dont
+    // keep track of in Track, like playlist position) look up the value in
+    // their SQL record.
+
+    // TODO(rryan) this code is flawed for columns that contains row-specific
+    // metadata. Currently the upper-levels will not delegate row-specific
+    // columns to this method, but there should still be a check here I think.
+    if (!result.isValid()) {
+        QHash<int, QVector<QVariant> >::const_iterator it =
+                m_recordCache.find(trackId);
+        if (it != m_recordCache.end()) {
+            const QVector<QVariant>& fields = it.value();
+            result = fields.value(column, result);
+        }
+    }
+    return result;
+}
+
+QVariant IPodPlaylistModel::getTrackValueForColumn(TrackPointer pTrack, int column) const {
+    if (!pTrack)
+        return QVariant();
+
+    // TODO(XXX) Qt properties could really help here.
+    if (fieldIndex(LIBRARYTABLE_ARTIST) == column) {
+        return QVariant(pTrack->getArtist());
+    } else if (fieldIndex(LIBRARYTABLE_TITLE) == column) {
+        return QVariant(pTrack->getTitle());
+    } else if (fieldIndex(LIBRARYTABLE_ALBUM) == column) {
+        return QVariant(pTrack->getAlbum());
+    } else if (fieldIndex(LIBRARYTABLE_YEAR) == column) {
+        return QVariant(pTrack->getYear());
+    } else if (fieldIndex(LIBRARYTABLE_GENRE) == column) {
+        return QVariant(pTrack->getGenre());
+    } else if (fieldIndex(LIBRARYTABLE_FILETYPE) == column) {
+        return QVariant(pTrack->getType());
+    } else if (fieldIndex(LIBRARYTABLE_TRACKNUMBER) == column) {
+        return QVariant(pTrack->getTrackNumber());
+    } else if (fieldIndex(LIBRARYTABLE_LOCATION) == column) {
+        return QVariant(pTrack->getLocation());
+    } else if (fieldIndex(LIBRARYTABLE_COMMENT) == column) {
+        return QVariant(pTrack->getComment());
+    } else if (fieldIndex(LIBRARYTABLE_DURATION) == column) {
+        return pTrack->getDuration();
+    } else if (fieldIndex(LIBRARYTABLE_BITRATE) == column) {
+        return QVariant(pTrack->getBitrate());
+    } else if (fieldIndex(LIBRARYTABLE_BPM) == column) {
+        return QVariant(pTrack->getBpm());
+    } else if (fieldIndex(LIBRARYTABLE_PLAYED) == column) {
+        return QVariant(pTrack->getPlayed());
+    } else if (fieldIndex(LIBRARYTABLE_TIMESPLAYED) == column) {
+        return QVariant(pTrack->getTimesPlayed());
+    } else if (fieldIndex(LIBRARYTABLE_RATING) == column) {
+        return pTrack->getRating();
+    } else if (fieldIndex(LIBRARYTABLE_KEY) == column) {
+        return pTrack->getKey();
+    }
+    return QVariant();
+}
+
+void IPodPlaylistModel::setTrackValueForColumn(TrackPointer pTrack, int column, QVariant value) {
+    // TODO(XXX) Qt properties could really help here.
+    if (fieldIndex(LIBRARYTABLE_ARTIST) == column) {
+        pTrack->setArtist(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_TITLE) == column) {
+        pTrack->setTitle(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_ALBUM) == column) {
+        pTrack->setAlbum(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_YEAR) == column) {
+        pTrack->setYear(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_GENRE) == column) {
+        pTrack->setGenre(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_FILETYPE) == column) {
+        pTrack->setType(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_TRACKNUMBER) == column) {
+        pTrack->setTrackNumber(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_LOCATION) == column) {
+        pTrack->setLocation(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_COMMENT) == column) {
+        pTrack->setComment(value.toString());
+    } else if (fieldIndex(LIBRARYTABLE_DURATION) == column) {
+        pTrack->setDuration(value.toInt());
+    } else if (fieldIndex(LIBRARYTABLE_BITRATE) == column) {
+        pTrack->setBitrate(value.toInt());
+    } else if (fieldIndex(LIBRARYTABLE_BPM) == column) {
+        //QVariant::toFloat needs >= QT 4.6.x
+        pTrack->setBpm((float) value.toDouble());
+    } else if (fieldIndex(LIBRARYTABLE_PLAYED) == column) {
+        pTrack->setPlayed(value.toBool());
+    } else if (fieldIndex(LIBRARYTABLE_TIMESPLAYED) == column) {
+        pTrack->setTimesPlayed(value.toInt());
+    } else if (fieldIndex(LIBRARYTABLE_RATING) == column) {
+        StarRating starRating = qVariantValue<StarRating>(value);
+        pTrack->setRating(starRating.starCount());
+    } else if (fieldIndex(LIBRARYTABLE_KEY) == column) {
+        pTrack->setKey(value.toString());
+    }
+}
+
+QVariant IPodPlaylistModel::getBaseValue(const QModelIndex& index, int role) const {
+    if (role != Qt::DisplayRole &&
+        role != Qt::ToolTipRole &&
+        role != Qt::EditRole) {
+        return QVariant();
+    }
+
+    int row = index.row();
+    int column = index.column();
+
+    if (row < 0 || row >= m_rowInfo.size()) {
+        return QVariant();
+    }
+
+    const QPair<int, QHash<int, QVariant> >& rowInfo = m_rowInfo[row];
+    int trackId = rowInfo.first;
+
+    // If the row info has the row-specific column, return that.
+    const QHash<int, QVariant>& columns = rowInfo.second;
+    if (columns.contains(column)) {
+        if (sDebug) {
+            qDebug() << "Returning table-column value" << columns[column] << "for column" << column;
+        }
+        return columns[column];
+    }
+
+    // Otherwise, return the information from the track record cache for the
+    // given track ID
+    return getTrackValueForColumn(trackId, column);
+}
+
+void IPodPlaylistModel::setPlaylist(Itdb_Playlist* pPlaylist) {
+    if (m_pPlaylist) {
+        beginRemoveRows(QModelIndex(), 0, m_sortedPlaylist.size()-1);
+        m_pPlaylist = NULL;
+        m_sortedPlaylist.clear();
+        endRemoveRows();
+    }
+
+    if (pPlaylist) {
+        beginInsertRows(QModelIndex(), 0, pPlaylist->num-1);
+        m_pPlaylist = pPlaylist;
+        // walk thought linked list and collect playlist position
+
+        GList* track_node;
+        uint pl_position = 0;
+
+        QByteArray search = m_currentSearch.toUtf8();
+
+        for (track_node = g_list_first(pPlaylist->members);
+             track_node != NULL;
+             track_node = g_list_next(track_node))
+        {
+            struct playlist_member plMember;
+            plMember.pClass = this;
+            plMember.pTrack = (Itdb_Track*)track_node->data;
+            plMember.pos = ++pl_position;
+
+            // Filter
+            bool add = false;
+            if( itdb_playlist_is_mpl(pPlaylist) && search.size()){
+                // Apply filter only for the master playlist "IPOD"
+                gchar* haystack = g_strconcat(
+                        plMember.pTrack->artist,
+                        plMember.pTrack->title,
+                        plMember.pTrack->album,
+                        plMember.pTrack->comment,
+                        plMember.pTrack->genre,
+                        NULL);
+
+                if( findInUtf8Case(haystack, search.data())) {
+                    add = true;
+                }
+                g_free(haystack);
+            } else {
+                add = true;
+            }
+
+            if (add) {
+                m_sortedPlaylist.append(plMember);
+            }
+
+        }
+        qSort(m_sortedPlaylist.begin(), m_sortedPlaylist.end(), columnLessThan);
+
+        endInsertRows();
+    }
+}
+
+//static
+bool IPodPlaylistModel::findInUtf8Case(gchar* heystack, gchar* needles) {
+    bool ret = true;
+    if (heystack == NULL) {
+        return false;
+    }
+    if (needles == NULL) {
+        return true;
+    }
+
+    gchar* heystack_casefold = g_utf8_casefold(heystack, -1);
+    gchar* needles_casefold = g_utf8_casefold(needles, -1);
+    gchar** needle = g_strsplit_set(needles_casefold, " ", 0);
+
+    qDebug() << "find" << heystack_casefold;
+
+    // all needles must be found, implicit AND
+    for (int i = 0; needle[i]; i++) {
+        if (needle[i][0] != 0) {
+            if (!g_strrstr(heystack_casefold, needle[i])) {
+                ret = false;
+                break;
+            }
+        }
+    }
+    g_free(heystack_casefold);
+    g_free(needles_casefold);
+    g_strfreev(needle);
+    return ret;
+}
+
+TrackPointer IPodPlaylistModel::getTrack(const QModelIndex& index) const {
+
+    Itdb_Track* pTrack = getPTrackFromModelIndex(index);
+    if (!pTrack) {
+        return TrackPointer();
+    }
+
+    QString location = itdb_get_mountpoint(m_pPlaylist->itdb);
+    QString ipod_path = pTrack->ipod_path;
+    ipod_path.replace(QString(":"), QString("/"));
+    location += ipod_path;
+
+    qDebug() << location;
+
+    TrackDAO& track_dao = m_pTrackCollection->getTrackDAO();
+    int track_id = track_dao.getTrackId(location);
+    if (track_id < 0) {
+        // Add Track to library
+        track_id = track_dao.addTrack(location, true);
+    }
+
+    TrackPointer pTrackP;
+
+    if (track_id < 0) {
+        // Add Track to library failed
+        // Create own TrackInfoObject
+        pTrackP = TrackPointer(new TrackInfoObject(location), &QObject::deleteLater);
+    }
+    else {
+        pTrackP = track_dao.getTrack(track_id);
+    }
+
+    // Overwrite metadata from Ipod
+    // Note: This will be written to the mixxx library as well
+    // This is OK here because the location ist still pointing to the iPod device
+    pTrackP->setArtist(QString::fromUtf8(pTrack->artist));
+    pTrackP->setTitle(QString::fromUtf8(pTrack->title));
+    pTrackP->setAlbum(QString::fromUtf8(pTrack->album));
+    pTrackP->setYear(QString::number(pTrack->year));
+    pTrackP->setGenre(QString::fromUtf8(pTrack->genre));
+    double bpm = (double)pTrack->BPM;
+    pTrackP->setBpm(bpm);
+    pTrackP->setComment(QString::fromUtf8(pTrack->comment));
+
+    // If the track has a BPM, then give it a static beatgrid.
+    if (bpm) {
+        BeatsPointer pBeats = BeatFactory::makeBeatGrid(pTrackP.data(), bpm, 0.0f);
+        pTrackP->setBeats(pBeats);
+    }
+
+    return pTrackP;
+}
+// Gets the on-disk location of the track at the given location.
+QString IPodPlaylistModel::getTrackLocation(const QModelIndex& index) const {
+
+    Itdb_Track* pTrack = getPTrackFromModelIndex(index);
+    if (!pTrack) {
+        return QString();
+    }
+
+    QString location = itdb_get_mountpoint(m_pPlaylist->itdb);
+    QString ipod_path = pTrack->ipod_path;
+    ipod_path.replace(QString(":"), QString("/"));
+    location += ipod_path;
+
+    return location;
+}
+
+// Gets a significant hint of the track at the given QModelIndex
+// This is used to restore the selection after WTrackTableView::doSortByColumn
+int IPodPlaylistModel::getTrackId(const QModelIndex& index) const {
+    // in our case the position in the playlist is as significant hint  
+    int row = index.row();
+    if (row < m_sortedPlaylist.size()) {
+        return m_sortedPlaylist.at(row).pos;
+    }
+    else {
+        return 0;
+    }
+}
+
+const QLinkedList<int> IPodPlaylistModel::getTrackRows(int trackId) const {
+    // In this case we get the position as trackId, returned from getTrackId above.
+    QLinkedList<int> ret;
+    for (int i = 0; i < m_sortedPlaylist.size(); ++i) {
+        if (m_sortedPlaylist.at(i).pos == trackId ){
+            ret.push_back(i);
+            break;
+        }
+    }
+    return ret;
+}
+
+void IPodPlaylistModel::search(const QString& searchText) {
+    if (sDebug)
+        qDebug() << this << "search" << searchText;
+
+    if (m_currentSearch != searchText) {
+        m_currentSearch = searchText;
+        if (itdb_playlist_is_mpl(m_pPlaylist)) {
+            setPlaylist(m_pPlaylist);
+        }
+    }
+}
+
+const QString IPodPlaylistModel::currentSearch() {
+    return m_currentSearch;
+}
+
+bool IPodPlaylistModel::isColumnInternal(int column) {
+    Q_UNUSED(column);
+    return false;
+}
+
+QMimeData* IPodPlaylistModel::mimeData(const QModelIndexList &indexes) const {
+    QMimeData *mimeData = new QMimeData();
+    QList<QUrl> urls;
+
+    //Ok, so the list of indexes we're given contains separates indexes for
+    //each column, so even if only one row is selected, we'll have like 7 indexes.
+    //We need to only count each row once:
+    QList<int> rows;
+
+    foreach (QModelIndex index, indexes) {
+        if (index.isValid()) {
+            if (!rows.contains(index.row())) {
+                rows.push_back(index.row());
+                QUrl url = QUrl::fromLocalFile(getTrackLocation(index));
+                if (!url.isValid())
+                    qDebug() << "ERROR invalid url\n";
+                else
+                    urls.append(url);
+            }
+        }
+    }
+    mimeData->setUrls(urls);
+    return mimeData;
+}
+    /** if no header state exists, we may hide some columns so that the user can reactivate them **/
+bool IPodPlaylistModel::isColumnHiddenByDefault(int column) {
+    Q_UNUSED(column);
+    return false;
+}
+
+void IPodPlaylistModel::removeTrack(const QModelIndex& index) {
+    Q_UNUSED(index);
+}
+
+void IPodPlaylistModel::removeTracks(const QModelIndexList& indices) {
+    Q_UNUSED(indices);
+}
+
+bool IPodPlaylistModel::addTrack(const QModelIndex& index, QString location) {
+    Q_UNUSED(index);
+    Q_UNUSED(location);
+    return false;
+}
+
+void IPodPlaylistModel::moveTrack(const QModelIndex& sourceIndex, const QModelIndex& destIndex) {
+    Q_UNUSED(destIndex);
+    Q_UNUSED(sourceIndex);
+}
+
+QItemDelegate* IPodPlaylistModel::delegateForColumn(const int i) {
+    Q_UNUSED(i);
+    return NULL;
+}
+
+Itdb_Track* IPodPlaylistModel::getPTrackFromModelIndex(const QModelIndex& index) const {
+    if (   !index.isValid()
+        || m_pPlaylist == NULL
+    ) {
+        return NULL;
+    }
+
+    int row = index.row();
+    int column = index.column();
+
+    if (row >= m_sortedPlaylist.size() || column >= m_headerList.size()) {
+        // index is outside the valid range
+        return NULL;
+    }
+    return m_sortedPlaylist.at(row).pTrack;
+}

=== added file 'mixxx/src/library/ipod/ipodplaylistmodel.h'
--- mixxx/src/library/ipod/ipodplaylistmodel.h	1970-01-01 00:00:00 +0000
+++ mixxx/src/library/ipod/ipodplaylistmodel.h	2012-11-18 17:09:22 +0000
@@ -0,0 +1,146 @@
+#ifndef IPODPLAYLISTMODEL_H
+#define IPODPLAYLISTMODEL_H
+
+#include <QtCore>
+#include <QHash>
+#include <QtGui>
+#include <QtSql>
+
+#include "library/trackmodel.h"
+#include "library/trackcollection.h"
+#include "library/dao/trackdao.h"
+
+extern "C"
+{
+#include <gpod/itdb.h>
+}
+
+// BaseSqlTableModel is a custom-written SQL-backed table which aggressively
+// caches the contents of the table and supports lightweight updates.
+class IPodPlaylistModel : public QAbstractTableModel , public virtual TrackModel
+{
+    Q_OBJECT
+  public:
+
+    struct playlist_member {
+        IPodPlaylistModel* pClass;
+        int pos;
+        Itdb_Track* pTrack;
+    };
+
+    IPodPlaylistModel(QObject* pParent, TrackCollection* pTrackCollection);
+    virtual ~IPodPlaylistModel();
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Methods implemented from QAbstractItemModel
+    ////////////////////////////////////////////////////////////////////////////
+
+    virtual TrackPointer getTrack(const QModelIndex& index) const;
+    virtual QString getTrackLocation(const QModelIndex& index) const;
+    virtual int getTrackId(const QModelIndex& index) const;
+    virtual const QLinkedList<int> getTrackRows(int trackId) const;
+    virtual void search(const QString& searchText);
+    virtual const QString currentSearch();
+    virtual bool isColumnInternal(int column);
+    virtual bool isColumnHiddenByDefault(int column);
+    virtual void removeTrack(const QModelIndex& index);
+    virtual void removeTracks(const QModelIndexList& indices);
+    virtual bool addTrack(const QModelIndex& index, QString location);
+    virtual void moveTrack(const QModelIndex& sourceIndex, const QModelIndex& destIndex);
+
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const;
+    QMimeData* mimeData(const QModelIndexList &indexes) const;
+
+    QItemDelegate* delegateForColumn(const int i);
+    TrackModel::CapabilitiesFlags getCapabilities() const;
+
+    virtual void sort(int column, Qt::SortOrder order);
+    virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
+    virtual bool setData(const QModelIndex& index, const QVariant& value, int role=Qt::EditRole);
+    virtual int columnCount(const QModelIndex& parent=QModelIndex()) const;
+    virtual int rowCount(const QModelIndex& parent=QModelIndex()) const;
+    virtual QVariant headerData(int section, Qt::Orientation orientation,
+                                int role=Qt::DisplayRole) const;
+
+    void setPlaylist(Itdb_Playlist* pPlaylist);
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Other public methods
+    ////////////////////////////////////////////////////////////////////////////
+
+    virtual const QString currentSearch() const;
+    virtual void setSort(int column, Qt::SortOrder order);
+    virtual int fieldIndex(const QString& fieldName) const;
+
+  protected:
+    /** Use this if you want a model that is read-only. */
+    virtual Qt::ItemFlags readOnlyFlags(const QModelIndex &index) const;
+    /** Use this if you want a model that can be changed  */
+    virtual Qt::ItemFlags readWriteFlags(const QModelIndex &index) const;
+
+    // Set the columns used for searching. Names must correspond to the column
+    // names in the table provided to setTable. Must be called after setTable is
+    // called.
+    virtual void setSearchColumns(const QStringList& searchColumns);
+    // virtual QString orderByClause() const;
+    virtual void initHeaderData();
+    virtual void initDefaultSearchColumns();
+
+  private slots:
+    void trackChanged(int trackId);
+
+  private:
+    inline TrackPointer lookupCachedTrack(int trackId) const;
+    inline QVariant getTrackValueForColumn(TrackPointer pTrack, int column) const;
+    inline QVariant getTrackValueForColumn(int trackId, int column,
+                                           TrackPointer pTrack=TrackPointer()) const;
+    inline void setTrackValueForColumn(TrackPointer pTrack, int column, QVariant value);
+    QVariant getBaseValue(const QModelIndex& index, int role = Qt::DisplayRole) const;
+
+    static bool columnLessThan(const playlist_member &s1, const playlist_member &s2);
+
+
+    virtual int compareColumnValues(int iColumnNumber, Qt::SortOrder eSortOrder, QVariant val1, QVariant val2);
+    virtual int findSortInsertionPoint(int trackId, TrackPointer pTrack,
+                                       const QVector<QPair<int, QHash<int, QVariant> > >& rowInfo);
+
+    Itdb_Track* getPTrackFromModelIndex(const QModelIndex& index) const;
+
+    static bool findInUtf8Case(gchar* heystack, gchar* needles);
+
+    QString m_tableName;
+    QStringList m_columnNames;
+    QString m_columnNamesJoined;
+    QHash<QString, int> m_columnIndex;
+    QSet<QString> m_tableColumns;
+    QString m_tableColumnsJoined;
+    QSet<int> m_tableColumnIndices;
+
+    QStringList m_searchColumns;
+    QVector<int> m_searchColumnIndices;
+    QString m_idColumn;
+
+    int m_iSortColumn;
+    Qt::SortOrder m_eSortOrder;
+
+    bool m_bIndexBuilt;
+    QSqlRecord m_queryRecord;
+    QHash<int, QVector<QVariant> > m_recordCache;
+    QVector<QPair<int, QHash<int, QVariant> > > m_rowInfo;
+    QHash<int, QLinkedList<int> > m_trackIdToRows;
+    QSet<int> m_trackOverrides;
+
+    QString m_currentSearch;
+    QString m_currentSearchFilter;
+
+    QList<QPair<QString, size_t> > m_headerList;
+
+    QList<IPodPlaylistModel::playlist_member> m_sortedPlaylist;
+
+    TrackCollection* m_pTrackCollection;
+    TrackDAO& m_trackDAO;
+
+    Itdb_Playlist* m_pPlaylist;
+};
+
+#endif /* IPODPLAYLISTMODEL_H */

=== modified file 'mixxx/src/library/library.cpp'
--- mixxx/src/library/library.cpp	2012-10-04 16:19:07 +0000
+++ mixxx/src/library/library.cpp	2012-11-18 17:09:22 +0000
@@ -14,6 +14,9 @@
 #include "library/rhythmbox/rhythmboxfeature.h"
 #include "library/recording/recordingfeature.h"
 #include "library/itunes/itunesfeature.h"
+#ifdef __IPOD__
+#include "library/ipod/ipodfeature.h"
+#endif // __IPOD__
 #include "library/mixxxlibraryfeature.h"
 #include "library/autodjfeature.h"
 #include "library/playlistfeature.h"
@@ -75,6 +78,12 @@
         pConfig->getValueString(ConfigKey("[Library]","ShowITunesLibrary"),"1").toInt()) {
         addFeature(new ITunesFeature(this, m_pTrackCollection));
     }
+#ifdef __IPOD__
+    if (IPodFeature::isSupported() && 
+        pConfig->getValueString(ConfigKey("[Library]","ShowIpod"),"1").toInt()) {
+        addFeature(new IPodFeature(this, m_pTrackCollection));
+    }
+#endif // __IPOD__
     if (TraktorFeature::isSupported() &&
         pConfig->getValueString(ConfigKey("[Library]","ShowTraktorLibrary"),"1").toInt()) {
         addFeature(new TraktorFeature(this, m_pTrackCollection));

=== modified file 'mixxx/src/widget/wlibrarysidebar.cpp'
--- mixxx/src/widget/wlibrarysidebar.cpp	2012-07-25 17:20:41 +0000
+++ mixxx/src/widget/wlibrarysidebar.cpp	2012-11-18 17:09:22 +0000
@@ -59,7 +59,8 @@
     if (event->mimeData()->hasUrls()) {
         QList<QUrl> urls(event->mimeData()->urls());
         //Drag and drop within this widget
-        if (event->source() == this && event->possibleActions() & Qt::MoveAction) {
+        if (   (event->source() == this)
+            && (event->possibleActions() & Qt::MoveAction)) {
             //Do nothing.
              event->ignore();
         } else {
@@ -77,13 +78,15 @@
                     }
                 }
             }
-            if (accepted)
+            if (accepted) {
                 event->acceptProposedAction();
-            else
+            } else {
                 event->ignore();
+            }
         }
-    } else
+    } else {
         event->ignore();
+    }
 }
 
 void WLibrarySidebar::timerEvent(QTimerEvent *event) {
@@ -106,8 +109,10 @@
     if (event->mimeData()->hasUrls()) {
         QList<QUrl> urls(event->mimeData()->urls());
         //Drag and drop within this widget
-        if (event->source() == this && event->possibleActions() & Qt::MoveAction) {
-            event->ignore();
+        if (    (event->source() == this)
+             && (event->possibleActions() & Qt::MoveAction)) {
+            //Do nothing.
+             event->ignore();
         } else {
             //Reset the selected items (if you had anything highlighted, it clears it)
             //this->selectionModel()->clear();

=== modified file 'mixxx/src/widget/wtracktableview.cpp'
--- mixxx/src/widget/wtracktableview.cpp	2012-11-16 04:38:16 +0000
+++ mixxx/src/widget/wtracktableview.cpp	2012-11-18 17:09:22 +0000
@@ -959,11 +959,11 @@
 
 void WTrackTableView::slotSendToAutoDJ() {
     // append to auto DJ
-    sendToAutoDJ(false);  // bTop = false
+    sendToAutoDJ(false); // bTop = false
 }
 
 void WTrackTableView::slotSendToAutoDJTop() {
-    sendToAutoDJ(true);  // bTop = true
+    sendToAutoDJ(true); // bTop = true
 }
 
 void WTrackTableView::sendToAutoDJ(bool bTop) {