Merge lp:~mixxxdevelopers/mixxx/iTunes2 into lp:~mixxxdevelopers/mixxx/trunk

[RAFFI TEA]

NOTE: SINCE TRUNK HAS CHANGED, I HAVE CREATED THIS BRANCH WHICH RESOLVES MERGING CONFLICTS.

This is are rewrite of the itunes feature.
It is now sql-based. A Sax parser is used to put all tracks
into database tables.

The branch has been tested with itunes music collections from IRC user theresajayne and me.
A collection of over 70000 files will now consume no main memory anymore. Before it took ~2GB.

PLEASE REVIEW....

[RJ Skerry-Ryan (rryan)]

Since features_library has merged to trunk revision 7 is live and should not be modified. In my local copy I added a revision 8 that only creates the itunes table.

Also, the indentation in a lot of these files seems to be 2-space indent, which doesn't match the rest of the files' 4-space indent.

After loading an iTunes XML sent to me by Tobias a long time ago, Mixxx hard-locked up after I clicked iTunes and said 'Ok' to the question of whether or not to load my library. Not sure what the problem is, looking at it now.

[RJ Skerry-Ryan (rryan)]

Turns out the while(1) loops were infinite looping. I changed them to while (!xml.atEnd()) and that seemed to fix it. For what it's worth, my XML file causes a "Premature end of document." error. There isn't any UI feedback when that happens, which would be nice.

I'll push my edits to this branch. (that updates the merge request automatically)

[lp:~mixxxdevelopers/mixxx/iTunes2]

2563. By RJ Skerry-Ryan on 2010-11-21

Adding updates. Split itunes SQL revision into revision 8 from 7 since 7 is now permanent. Add safety from infinite loops in parsing. Fix indentation to be 4-space indents.

[RJ Skerry-Ryan (rryan)]

OK I fixed what I mentioned and added a GUI warning when the file fails to parse. It looks good to me.

review: Approve

[lp:~mixxxdevelopers/mixxx/iTunes2]

2564. By RJ Skerry-Ryan on 2010-11-21

Adding a warning message when the iTunes library fails to load. Make failed parses of iTunes still select in the track model because it might have gotten partially through the file and showing some is better than showing none.

2565. By RJ Skerry-Ryan on 2010-11-21

Switch iTunes trackmodel and playlits model to use custom header states instead of the mixxx playlist one.

2566. By RJ Skerry-Ryan on 2010-11-21

Remove Traktor references.

[RAFFI TEA (raffitea)]

Tanks RJ for your review.

[lp:~mixxxdevelopers/mixxx/iTunes2]

2567. By RJ Skerry-Ryan on 2010-11-21

Oops, fix multi-line string.

[RJ Skerry-Ryan (rryan)]

I'll let you do the honors -- go ahead and merge it into trunk :)

[RAFFI TEA (raffitea)]

Before I merge I have another question:

Both itunestrackmodel and itunesplaylistmodel are subclassed from BaseSqlTableModel. In BaseSqlTableModel we handle 'trackChanged' signals. Now assume we've an iTunes track that has incorrect playtime information. If BaseSqlTableModel captures 'trackChanged' signals for iTunes playlistsmodels I'm sure we run into problems? Will this ever happen?

[RJ Skerry-Ryan (rryan)]

Hm, this is a good point. They shouldn't be inherited from BaseSQLTableModel
because BaseSqlTableModel assumes the track is in the Mixxx library. Maybe
we can split the Mixxx db specific stuff into a MixxxSqlTableModel that
inherits from BaseSqlTableModel ? Ugh, that seems like an ugly solution.
What do you think, Tobias?

RJ

On Sun, Nov 21, 2010 at 3:23 PM, RAFFI TEA <email address hidden>wrote:

> Before I merge I have another question:
>
> Both itunestrackmodel and itunesplaylistmodel are subclassed from
> BaseSqlTableModel. In BaseSqlTableModel we handle 'trackChanged' signals.
> Now assume we've an iTunes track that has incorrect playtime information. If
> BaseSqlTableModel captures 'trackChanged' signals for iTunes playlistsmodels
> I'm sure we run into problems? Will this ever happen?
> --
> https://code.launchpad.net/~mixxxdevelopers/mixxx/iTunes2/+merge/41225
> You are reviewing the proposed merge of lp:~mixxxdevelopers/mixxx/iTunes2
> into lp:mixxx.
>

[RAFFI TEA (raffitea)]

I think there are two options. (1) We follow RJ's proposal. However, we get a deeper class hierarchy, which is really not my favor. (2) We refactor BaseSqlTableModel. In particular, we move the connect statement in a separate method (e.g., setTrackChangeAwareness(bool) ). If the parameter is true, we connect the signal. This is probably the quickest way to realize.

Both suggestions are not the 'cleanest'. But I am more towards solution (2) because there's no real difference between native and non-native library features unless the latter are read-only models and trackChanged signals are unintended. This brings me to another idea: (3) We could disconnect the signal in BaseSqlTableModel::readOnlyFlags(QModelIndex ind). Basically, all non-native Mixxx library features return read-only model flags, e.g., iTunes models return BaseSqlTableModel::readOnlyFlags() in their flags() method.

What do you think RJ or Albert?

=== modified file 'mixxx/res/schema.xml'
--- mixxx/res/schema.xml	2010-11-17 21:02:24 +0000
+++ mixxx/res/schema.xml	2010-11-21 15:57:13 +0000
@@ -172,4 +172,31 @@
       DELETE FROM settings WHERE name="mixxx.db.model.missing.header_state";
     </sql>
   </revision>
+  <revision version="8">
+    <description>
+      Added iTunes tables
+    </description>
+    <sql>
+      CREATE TABLE IF NOT EXISTS itunes_library (
+        id INTEGER primary key,
+        artist varchar(48), title varchar(48),
+        album varchar(48), year varchar(16),
+        genre varchar(32), tracknumber varchar(3),
+        location varchar(512),
+        comment varchar(60),
+        duration integer,
+        bitrate integer,
+        bpm integer,
+        rating integer);
+
+       CREATE TABLE IF NOT EXISTS itunes_playlists (
+        id INTEGER primary key,
+        name varchar(100) UNIQUE);
+
+      CREATE TABLE IF NOT EXISTS itunes_playlist_tracks (
+        id INTEGER primary key AUTOINCREMENT,
+        playlist_id INTEGER REFERENCES itunes_playlist(id),
+        track_id INTEGER REFERENCES itunes_library(id));
+    </sql>
+  </revision>
 </schema>
 
=== modified file 'mixxx/src/library/itunesfeature.cpp'
--- mixxx/src/library/itunesfeature.cpp	2010-08-01 12:55:15 +0000
+++ mixxx/src/library/itunesfeature.cpp	2010-11-21 15:57:13 +0000
@@ -1,27 +1,29 @@
 #include <QMessageBox>
 #include <QtDebug>
-
+#include <QXmlStreamReader>
+#include <QDesktopServices>
 #include "library/itunesfeature.h"
 
 #include "library/itunestrackmodel.h"
 #include "library/itunesplaylistmodel.h"
-#include "library/proxytrackmodel.h"
-
-ITunesFeature::ITunesFeature(QObject* parent)
-    : LibraryFeature(parent) {
-    //Don't actually initialize these until the iTunes item in the sidebar is clicked.
-    m_pITunesTrackModel = NULL;
-    m_pITunesPlaylistModel = NULL;
-    m_pTrackModelProxy = NULL;
-    m_pPlaylistModelProxy = NULL;
+
+
+ITunesFeature::ITunesFeature(QObject* parent, TrackCollection* pTrackCollection)
+        : LibraryFeature(parent),
+          m_pTrackCollection(pTrackCollection),
+          m_database(pTrackCollection->getDatabase()) {
+    m_pITunesTrackModel = new ITunesTrackModel(this, m_pTrackCollection);
+    m_pITunesPlaylistModel = new ITunesPlaylistModel(this, m_pTrackCollection);
+    m_isActivated = false;
 }
 
 ITunesFeature::~ITunesFeature() {
-
+    delete m_pITunesTrackModel;
+    delete m_pITunesPlaylistModel;
 }
 
 bool ITunesFeature::isSupported() {
-    return (QFile::exists(ITunesTrackModel::getiTunesMusicPath()));
+    return QFile::exists(getiTunesMusicPath());
 }
 
 
@@ -36,7 +38,7 @@
 void ITunesFeature::activate() {
     //qDebug("ITunesFeature::activate()");
 
-    if (!m_pITunesTrackModel) {
+    if (!m_isActivated) {
         if (QMessageBox::question(
             NULL,
             tr("Load iTunes Library?"),
@@ -46,31 +48,24 @@
             == QMessageBox::Cancel) {
             return;
         }
-        m_pITunesTrackModel = new ITunesTrackModel();
-        m_pITunesPlaylistModel = new ITunesPlaylistModel(m_pITunesTrackModel);
-
-        // Use a ProxyTrackModel for search/sorting of iTunes tracks
-        m_pTrackModelProxy = new ProxyTrackModel(m_pITunesTrackModel);
-        m_pTrackModelProxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
-        m_pTrackModelProxy->setSortCaseSensitivity(Qt::CaseInsensitive);
-
-        // Use a ProxyTrackModel for search/sorting of iTunes playlists
-        m_pPlaylistModelProxy = new ProxyTrackModel(m_pITunesPlaylistModel);
-        m_pPlaylistModelProxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
-        m_pPlaylistModelProxy->setSortCaseSensitivity(Qt::CaseInsensitive);
-
-        QStringList list;
-        for (int i = 0; i < m_pITunesPlaylistModel->numPlaylists(); ++i) {
-            list << m_pITunesPlaylistModel->playlistTitle(i);
+
+        if (importLibrary(getiTunesMusicPath())) {
+            m_isActivated =  true;
+        } else {
+            QMessageBox::warning(
+                NULL,
+                tr("Error Loading iTunes Library"),
+                tr("There was an error loading your iTunes library. Some of "
+                   "your iTunes tracks or playlists may not have loaded."));
         }
 
         //Sort the playlists since in iTunes they are sorted, too.
-        list.sort();
+        //list.sort();
 
-        m_childModel.setStringList(list);
+        m_childModel.setStringList(m_playlists);
     }
 
-    emit(showTrackModel(m_pTrackModelProxy));
+    emit(showTrackModel(m_pITunesTrackModel));
 }
 
 void ITunesFeature::activateChild(const QModelIndex& index) {
@@ -78,7 +73,7 @@
     QString playlist = index.data().toString();
     qDebug() << "Activating " << playlist;
     m_pITunesPlaylistModel->setPlaylist(playlist);
-    emit(showTrackModel(m_pPlaylistModelProxy));
+    emit(showTrackModel(m_pITunesPlaylistModel));
 }
 
 QAbstractItemModel* ITunesFeature::getChildModel() {
@@ -106,3 +101,373 @@
 bool ITunesFeature::dragMoveAcceptChild(const QModelIndex& index, QUrl url) {
     return false;
 }
+
+QString ITunesFeature::getiTunesMusicPath() {
+    QString musicFolder;
+#if defined(__APPLE__)
+    musicFolder = QDesktopServices::storageLocation(QDesktopServices::MusicLocation) + "/iTunes/iTunes Music Library.xml";
+#elif defined(__WINDOWS__)
+    musicFolder = QDesktopServices::storageLocation(QDesktopServices::MusicLocation) + "\\iTunes\\iTunes Music Library.xml";
+#elif defined(__LINUX__)
+		musicFolder = QDir::homePath() + "/iTunes Music Library.xml";
+#else
+		musicFolder = "";
+#endif
+    qDebug() << "ITunesLibrary=[" << musicFolder << "]";
+    return musicFolder;
+}
+bool ITunesFeature::importLibrary(QString file) {
+    //Delete all table entries of iTunes feature
+    m_database.transaction();
+    clearTable("itunes_playlist_tracks");
+    clearTable("itunes_library");
+    clearTable("itunes_playlists");
+    m_database.commit();
+
+    qDebug() << "Import iTunes library";
+
+    m_database.transaction();
+
+    //Parse iTunes XML file using SAX (for performance)
+    QFile itunes_file(file);
+    if (!itunes_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qDebug() << "Cannot open iTunes music collection";
+        return false;
+    }
+    QXmlStreamReader xml(&itunes_file);
+
+    while (!xml.atEnd()) {
+        xml.readNext();
+        if (xml.isStartElement()) {
+            if (xml.name() == "key") {
+                if (xml.readElementText() == "Tracks") {
+                    parseTracks(xml);
+                    qDebug() << "Finished Parsing TrackList";
+                } else if (xml.readElementText() == "Playlists") {
+                    //parse all the playlists here and exit the loop afterwards
+                    parsePlaylists(xml);
+                    qDebug() << "Finished Parsing Playlists";
+                }
+            }
+        }
+    }
+
+    itunes_file.close();
+
+    // Even if an error occured, commit the transaction. The file may have been
+    // half-parsed.
+    m_database.commit();
+    m_pITunesTrackModel->select();
+
+    if (xml.hasError()) {
+        // do error handling
+        qDebug() << "Cannot process iTunes music collection";
+        qDebug() << "XML ERROR: " << xml.errorString();
+        return false;
+    }
+    return true;
+}
+
+void ITunesFeature::parseTracks(QXmlStreamReader &xml) {
+    QSqlQuery query(m_database);
+    query.prepare("INSERT INTO itunes_library (id, artist, title, album, year, genre, comment, tracknumber,"
+                  "bpm, bitrate,"
+                  "duration, location,"
+                  "rating ) "
+                  "VALUES (:id, :artist, :title, :album, :year, :genre, :comment, :tracknumber,"
+                  ":bpm, :bitrate,"
+                  ":duration, :location," ":rating )");
+
+
+    bool in_container_dictionary = false;
+    bool in_track_dictionary = false;
+
+    qDebug() << "Parse Tracks";
+
+    //read all sunsequent <dict> until we reach the closing ENTRY tag
+    while (!xml.atEnd()) {
+        xml.readNext();
+
+        if (xml.isStartElement()) {
+            if (xml.name() == "dict") {
+                if (!in_track_dictionary && !in_container_dictionary) {
+                    in_container_dictionary = true;
+                    continue;
+                } else if (in_container_dictionary && !in_track_dictionary) {
+                    //We are in a <dict> tag that holds track information
+                    in_track_dictionary = true;
+                    //Parse track here
+                    parseTrack(xml, query);
+                }
+            }
+        }
+
+        if (xml.isEndElement() && xml.name() == "dict") {
+            if (in_track_dictionary && in_container_dictionary) {
+                in_track_dictionary = false;
+                continue;
+            } else if (in_container_dictionary && !in_track_dictionary) {
+                // Done parsing tracks.
+                in_container_dictionary = false;
+                break;
+            }
+        }
+    }
+}
+
+void ITunesFeature::parseTrack(QXmlStreamReader &xml, QSqlQuery &query) {
+    //qDebug() << "----------------TRACK-----------------";
+    int id = -1;
+    QString title;
+    QString artist;
+    QString album;
+    QString year;
+    QString genre;
+    QString location;
+
+    int bpm = 0;
+    int bitrate = 0;
+
+    //duration of a track
+    int playtime = 0;
+    int rating = 0;
+    QString comment;
+    QString tracknumber;
+
+    while (!xml.atEnd()) {
+        xml.readNext();
+
+        if (xml.isStartElement()) {
+            if (xml.name() == "key") {
+                QString key = xml.readElementText();
+                QString content =  "";
+
+                if (xml.readNextStartElement()) {
+                    content = xml.readElementText();
+                }
+
+                //qDebug() << "Key: " << key << " Content: " << content;
+
+                if (key == "Track ID") {
+                    id = content.toInt();
+                    continue;
+                }
+                if (key == "Name") {
+                    title = content;
+                    continue;
+                }
+                if (key == "Artist") {
+                    artist = content;
+                    continue;
+                }
+                if (key == "Album") {
+                    album = content;
+                    continue;
+                }
+                if (key == "Genre") {
+                    genre = content;
+                    continue;
+                }
+                if (key == "BPM") {
+                    bpm = content.toInt();
+                    continue;
+                }
+                if (key == "Bit Rate") {
+                    bitrate =  content.toInt();
+                    continue;
+                }
+                if (key == "Comments") {
+                    comment = content;
+                    continue;
+                }
+                if (key == "Total Time") {
+                    playtime = (content.toInt() / 1000);
+                    continue;
+                }
+                if (key == "Year") {
+                    year = content;
+                    continue;
+                }
+                if (key == "Location") {
+                    QByteArray strlocbytes = content.toUtf8();
+                    location = QUrl::fromEncoded(strlocbytes).toLocalFile();
+                    /*
+                     * Strip the crappy file://localhost/ from the URL and
+                     * format URL as in method ITunesTrackModel::parseTrackNode(QDomNode songNode)
+                     */
+#if defined(__WINDOWS__)
+                    location.remove("//localhost/");
+#else
+                    location.remove("//localhost");
+#endif
+                    continue;
+                }
+                if (key == "Track Number") {
+                    tracknumber = content;
+                    continue;
+                }
+                if (key == "Rating") {
+                    //value is an integer and ranges from 0 to 100
+                    rating = (content.toInt() / 20);
+                    continue;
+                }
+            }
+        }
+        //exit loop on closing </dict>
+        if (xml.isEndElement() && xml.name() == "dict") {
+            break;
+        }
+    }
+    /* If we reach the end of <dict>
+     * Save parsed track to database
+     */
+    query.bindValue(":id", id);
+    query.bindValue(":artist", artist);
+    query.bindValue(":title", title);
+    query.bindValue(":album", album);
+    query.bindValue(":genre", genre);
+    query.bindValue(":year", year);
+    query.bindValue(":duration", playtime);
+    query.bindValue(":location", location);
+    query.bindValue(":rating", rating);
+    query.bindValue(":comment", comment);
+    query.bindValue(":tracknumber", tracknumber);
+    query.bindValue(":bpm", bpm);
+    query.bindValue(":bitrate", bitrate);
+
+    bool success = query.exec();
+
+    if (!success) {
+        qDebug() << "SQL Error in itunesfeature.cpp: line" << __LINE__ << " " << query.lastError();
+        return;
+    }
+}
+
+void ITunesFeature::parsePlaylists(QXmlStreamReader &xml) {
+    qDebug() << "Parse Playlists";
+
+    QSqlQuery query_insert_to_playlists(m_database);
+    query_insert_to_playlists.prepare("INSERT INTO itunes_playlists (id, name) "
+                                      "VALUES (:id, :name)");
+
+    QSqlQuery query_insert_to_playlist_tracks(m_database);
+    query_insert_to_playlist_tracks.prepare("INSERT INTO itunes_playlist_tracks (playlist_id, track_id) "
+                                            "VALUES (:playlist_id, :track_id)");
+
+    while (!xml.atEnd()) {
+        xml.readNext();
+        //We process and iterate the <dict> tags holding playlist summary information here
+        if (xml.isStartElement() && xml.name() == "dict") {
+            parsePlaylist(xml, query_insert_to_playlists, query_insert_to_playlist_tracks);
+            continue;
+        }
+        if (xml.isEndElement()) {
+            if (xml.name() == "array")
+                break;
+        }
+    }
+}
+
+void ITunesFeature::parsePlaylist(QXmlStreamReader &xml, QSqlQuery &query_insert_to_playlists,
+                                  QSqlQuery &query_insert_to_playlist_tracks) {
+    //qDebug() << "Parse Playlist";
+
+    QString playlistname;
+    int playlist_id = -1;
+    int track_reference = -1;
+    //indicates that we haven't found the <
+    bool isSystemPlaylist = false;
+
+    QString key;
+
+
+    //We process and iterate the <dict> tags holding playlist summary information here
+    while (!xml.atEnd()) {
+        xml.readNext();
+
+        if (xml.isStartElement()) {
+
+            if (xml.name() == "key") {
+                QString key = xml.readElementText();
+                /*
+                 * The rules are processed in sequence
+                 * That is, XML is ordered.
+                 * For iTunes Playlist names are always followed by the ID.
+                 * Afterwars the playlist entries occur
+                 */
+                if (key == "Name") {
+                    xml.readNextStartElement();
+                    playlistname = xml.readElementText();
+                    continue;
+                }
+                //When parsing the ID, the playlistname has already been found
+                if (key == "Playlist ID") {
+                    xml.readNextStartElement();
+                    playlist_id = xml.readElementText().toInt();
+                    continue;
+                }
+                //Hide playlists that are system playlists
+                if (key == "Master" || key == "Movies" || key == "TV Shows" || key == "Music" ||
+                   key == "Books" || key == "Purchased") {
+                    isSystemPlaylist = true;
+                    continue;
+                }
+
+                if (key == "Playlist Items") {
+                    //if the playlist is prebuild don't hit the database
+                    if (isSystemPlaylist) continue;
+                    query_insert_to_playlists.bindValue(":id", playlist_id);
+                    query_insert_to_playlists.bindValue(":name", playlistname);
+
+                    bool success = query_insert_to_playlists.exec();
+                    if (!success) {
+                        qDebug() << "SQL Error in ITunesTableModel.cpp: line" << __LINE__
+                                 << " " << query_insert_to_playlists.lastError();
+                        return;
+                    }
+                    //for the child model
+                    m_playlists << playlistname;
+
+                }
+                /*
+                 * When processing playlist entries, playlist name and id have already been processed and persisted
+                 */
+                if (key == "Track ID") {
+                    track_reference = -1;
+
+                    xml.readNextStartElement();
+                    track_reference = xml.readElementText().toInt();
+
+                    query_insert_to_playlist_tracks.bindValue(":playlist_id", playlist_id);
+                    query_insert_to_playlist_tracks.bindValue(":track_id", track_reference);
+
+                    //Insert tracks if we are not in a pre-build playlist
+                    if (!isSystemPlaylist && !query_insert_to_playlist_tracks.exec()) {
+                        qDebug() << "SQL Error in ITunesFeature.cpp: line" << __LINE__ << " "
+                                 << query_insert_to_playlist_tracks.lastError();
+                        qDebug() << "trackid" << track_reference;
+                        qDebug() << "playlistname; " << playlistname;
+                        qDebug() << "-----------------";
+                    }
+                }
+            }
+        }
+        if (xml.isEndElement()) {
+            if (xml.name() == "array") {
+                //qDebug() << "exit playlist";
+                break;
+            }
+        }
+    }
+}
+
+void ITunesFeature::clearTable(QString table_name) {
+    QSqlQuery query(m_database);
+    query.prepare("delete from "+table_name);
+    bool success = query.exec();
+
+    if (!success)
+        qDebug() << "Could not delete remove old entries from table " << table_name << " : " << query.lastError();
+    else
+        qDebug() << "iTunes table entries of '" << table_name <<"' have been cleared.";
+}
 
=== modified file 'mixxx/src/library/itunesfeature.h'
--- mixxx/src/library/itunesfeature.h	2009-12-23 03:07:11 +0000
+++ mixxx/src/library/itunesfeature.h	2010-11-21 15:57:13 +0000
@@ -5,18 +5,20 @@
 #define ITUNESBOXFEATURE_H
 
 #include <QStringListModel>
+#include <QtSql>
 
 #include "library/libraryfeature.h"
+#include "library/trackcollection.h"
 
 //class ITunesPlaylistModel;
 class ITunesTrackModel;
 class ITunesPlaylistModel;
-class ProxyTrackModel;
+
 
 class ITunesFeature : public LibraryFeature {
  Q_OBJECT
  public:
-    ITunesFeature(QObject* parent = NULL);
+    ITunesFeature(QObject* parent, TrackCollection* pTrackCollection);
     virtual ~ITunesFeature();
     static bool isSupported();
 
@@ -30,18 +32,28 @@
 
     QAbstractItemModel* getChildModel();
 
-public slots:
+  public slots:
     void activate();
     void activateChild(const QModelIndex& index);
     void onRightClick(const QPoint& globalPos);
     void onRightClickChild(const QPoint& globalPos, QModelIndex index);
 
-private:
+  private:
+    static QString getiTunesMusicPath();
+    bool importLibrary(QString file);
+    void parseTracks(QXmlStreamReader &xml);
+    void parseTrack(QXmlStreamReader &xml, QSqlQuery &query);
+    void parsePlaylists(QXmlStreamReader &xml);
+    void parsePlaylist(QXmlStreamReader &xml, QSqlQuery &query1, QSqlQuery &query2);
+    void clearTable(QString table_name);
+
     ITunesTrackModel* m_pITunesTrackModel;
     ITunesPlaylistModel* m_pITunesPlaylistModel;
-    ProxyTrackModel* m_pTrackModelProxy;
-    ProxyTrackModel* m_pPlaylistModelProxy;
     QStringListModel m_childModel;
+    QStringList m_playlists;
+    TrackCollection* m_pTrackCollection;
+    QSqlDatabase &m_database;
+    bool m_isActivated;
 };
 
 #endif /* ITUNESFEATURE_H */
 
=== modified file 'mixxx/src/library/itunesplaylistmodel.cpp'
--- mixxx/src/library/itunesplaylistmodel.cpp	2010-11-16 21:01:45 +0000
+++ mixxx/src/library/itunesplaylistmodel.cpp	2010-11-21 15:57:13 +0000
@@ -1,258 +1,187 @@
-// itunesplaylistmodel.cpp
-// Created 12/19/2009 by RJ Ryan ([e-mail])
-// Adapted from Philip Whelan's RhythmboxPlaylistModel
-
 #include <QtCore>
 #include <QtGui>
 #include <QtSql>
-#include <QtDebug>
-#include <QtXmlPatterns/QXmlQuery>
-
+#include "library/trackcollection.h"
 #include "library/itunesplaylistmodel.h"
-#include "library/itunestrackmodel.h"
-#include "xmlparse.h"
-#include "trackinfoobject.h"
-#include "defs.h"
 
 #include "mixxxutils.cpp"
 
-ITunesPlaylistModel::ITunesPlaylistModel(ITunesTrackModel *pTrackModel) :
-        TrackModel(QSqlDatabase::database("QSQLITE"), "mixxx.db.model.itunes_playlist"),
-        m_pTrackModel(pTrackModel),
-        m_sCurrentPlaylist("")
-{
-
-}
-
-ITunesPlaylistModel::~ITunesPlaylistModel()
-{
-}
-
-Qt::ItemFlags ITunesPlaylistModel::flags ( const QModelIndex & index ) const
-{
-    Qt::ItemFlags defaultFlags = QAbstractTableModel::flags(index);
-
-    if (!index.isValid())
-        return Qt::ItemIsEnabled;
-
-    defaultFlags |= Qt::ItemIsDragEnabled;
-
-    return defaultFlags;
-}
-
-QMimeData* ITunesPlaylistModel::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;
-}
-
-QVariant ITunesPlaylistModel::data ( const QModelIndex & index, int role ) const
-{
-    if ( m_sCurrentPlaylist == "" )
-        return QVariant();
-
-    if (!index.isValid())
-        return QVariant();
-
-    // OwenB - attempting to make this more efficient, don't create a new
-    // TIO for every row
-	if (role == Qt::DisplayRole || role == Qt::ToolTipRole) {
-		  // get track id
-	    QList<QString> playlistTrackList = m_pTrackModel->m_mPlaylists[m_sCurrentPlaylist];
-	    QString id = playlistTrackList.at(index.row());
-
-          // use this to get DOM node from the TrackModel
-        QDomNode songNode = m_pTrackModel->getTrackNodeById(id);
-
-          // use node to return the data item that was asked for.
-        return m_pTrackModel->getTrackColumnData(songNode, index);
-    }
-
-    return QVariant();
-}
-
-bool ITunesPlaylistModel::isColumnInternal(int column) {
-    return false;
-}
-bool ITunesPlaylistModel::isColumnHiddenByDefault(int column) {
-    return false;
-}
-
-QVariant ITunesPlaylistModel::headerData ( int section, Qt::Orientation orientation, int role ) const
-{
-    /* Only respond to requests for column header display names */
-    if ( role != Qt::DisplayRole )
-        return QVariant();
-
-    if (orientation == Qt::Horizontal)
-    {
-        switch (section)
-        {
-            case ITunesPlaylistModel::COLUMN_ARTIST:
-                return QString(tr("Artist"));
-
-            case ITunesPlaylistModel::COLUMN_TITLE:
-                return QString(tr("Title"));
-
-            case ITunesPlaylistModel::COLUMN_ALBUM:
-                return QString(tr("Album"));
-
-            case ITunesPlaylistModel::COLUMN_DATE:
-                return QString(tr("Date"));
-
-            case ITunesPlaylistModel::COLUMN_BPM:
-                return QString(tr("BPM"));
-
-            case ITunesPlaylistModel::COLUMN_GENRE:
-                return QString(tr("Genre"));
-
-            case ITunesPlaylistModel::COLUMN_LOCATION:
-                return QString(tr("Location"));
-
-            case ITunesPlaylistModel::COLUMN_DURATION:
-                return QString(tr("Duration"));
-
-            default:
-                return QString(tr("Unknown"));
-        }
-    }
-
-    return QVariant();
-}
-
-int ITunesPlaylistModel::rowCount ( const QModelIndex & parent ) const
-{
-    // FIXME
-    //if ( !m_mPlaylists.containts(m_sCurrentPlaylist))
-    //    return 0;
-
-    if (!m_pTrackModel || m_sCurrentPlaylist == "" )
-        return 0;
-
-    return m_pTrackModel->m_mPlaylists[m_sCurrentPlaylist].size();
-}
-
-int ITunesPlaylistModel::columnCount(const QModelIndex& parent) const
-{
-    if (parent != QModelIndex()) //Some weird thing for table-based models.
-        return 0;
-    return ITunesPlaylistModel::NUM_COLUMNS;
+ITunesPlaylistModel::ITunesPlaylistModel(QObject* parent,
+                                         TrackCollection* pTrackCollection)
+        : TrackModel(pTrackCollection->getDatabase(),
+                     "mixxx.db.model.itunes_playlist"),
+          BaseSqlTableModel(parent, pTrackCollection, pTrackCollection->getDatabase()),
+          m_pTrackCollection(pTrackCollection),
+          m_database(m_pTrackCollection->getDatabase())
+{
+    connect(this, SIGNAL(doSearch(const QString&)), this, SLOT(slotSearch(const QString&)));
+}
+
+ITunesPlaylistModel::~ITunesPlaylistModel() {
 }
 
 bool ITunesPlaylistModel::addTrack(const QModelIndex& index, QString location)
 {
-    //Should do nothing... hmmm
+
     return false;
 }
 
-/** Removes a track from the library track collection. */
-void ITunesPlaylistModel::removeTrack(const QModelIndex& index)
-{
-    //Should do nothing... hmmm
-}
-
-void ITunesPlaylistModel::removeTracks(const QModelIndexList& indices)
-{
-}
-
-void ITunesPlaylistModel::moveTrack(const QModelIndex& sourceIndex, const QModelIndex& destIndex)
-{
-    //Should do nothing... hmmm
-}
-
-QString ITunesPlaylistModel::getTrackLocation(const QModelIndex& index) const
-{
-    TrackPointer track = getTrack(index);
-    QString location = track->getLocation();
-    // track is auto-deleted
+TrackPointer ITunesPlaylistModel::getTrack(const QModelIndex& index) const
+{
+    QString artist = index.sibling(index.row(), fieldIndex("artist")).data().toString();
+    QString title = index.sibling(index.row(), fieldIndex("title")).data().toString();
+    QString album = index.sibling(index.row(), fieldIndex("album")).data().toString();
+    QString year = index.sibling(index.row(), fieldIndex("year")).data().toString();
+    QString genre = index.sibling(index.row(), fieldIndex("genre")).data().toString();
+    float bpm = index.sibling(index.row(), fieldIndex("bpm")).data().toString().toFloat();
+
+    QString location = index.sibling(index.row(), fieldIndex("location")).data().toString();
+
+    TrackInfoObject* pTrack = new TrackInfoObject(location);
+    pTrack->setArtist(artist);
+    pTrack->setTitle(title);
+    pTrack->setAlbum(album);
+    pTrack->setYear(year);
+    pTrack->setGenre(genre);
+    pTrack->setBpm(bpm);
+
+    return TrackPointer(pTrack, &QObject::deleteLater);
+}
+
+QString ITunesPlaylistModel::getTrackLocation(const QModelIndex& index) const {
+    QString location = index.sibling(index.row(), fieldIndex("location")).data().toString();
     return location;
 }
 
-TrackPointer ITunesPlaylistModel::getTrack(const QModelIndex& index) const
-{
-    int row = index.row();
-
-    if (!m_pTrackModel ||
-        !m_pTrackModel->m_mPlaylists.contains(m_sCurrentPlaylist)) {
-        return TrackPointer();
-    }
-
-    // Qt should do this by reference for us so we aren't actually making a copy
-    // of the list.
-    QList<QString> songIds = m_pTrackModel->m_mPlaylists[m_sCurrentPlaylist];
-
-    if (row < 0 || row >= songIds.length()) {
-        return TrackPointer();
-    }
-
-    return m_pTrackModel->getTrackById(songIds.at(row));
-}
-
-QItemDelegate* ITunesPlaylistModel::delegateForColumn(const int i) {
-    return NULL;
-}
-
-QList<QString> ITunesPlaylistModel::getPlaylists()
-{
-    if (!m_pTrackModel) {
-        return QList<QString>();
-    }
-    return m_pTrackModel->m_mPlaylists.keys();
-}
-
-int ITunesPlaylistModel::numPlaylists() {
-    if (!m_pTrackModel) {
-            return 0;
-    }
-    return m_pTrackModel->m_mPlaylists.size();
-}
-
-QString ITunesPlaylistModel::playlistTitle(int n) {
-    if (!m_pTrackModel) {
-        return "";
-    }
-    return m_pTrackModel->m_mPlaylists.keys().at(n);
-}
-
-void ITunesPlaylistModel::setPlaylist(QString playlist)
-{
-    if (m_pTrackModel && m_pTrackModel->m_mPlaylists.contains(playlist))
-        m_sCurrentPlaylist = playlist;
-    else
-        m_sCurrentPlaylist = "";
-
-    // force the layout to update
-    emit(layoutChanged());
-}
-
-void ITunesPlaylistModel::search(const QString& searchText)
-{
+void ITunesPlaylistModel::removeTrack(const QModelIndex& index) {
+
+}
+
+void ITunesPlaylistModel::removeTracks(const QModelIndexList& indices) {
+
+}
+
+void ITunesPlaylistModel::moveTrack(const QModelIndex& sourceIndex, const QModelIndex& destIndex) {
+
+}
+
+void ITunesPlaylistModel::search(const QString& searchText) {
+    // qDebug() << "ITunesPlaylistModel::search()" << searchText
+    //          << QThread::currentThread();
+    emit(doSearch(searchText));
+}
+
+void ITunesPlaylistModel::slotSearch(const QString& searchText) {
+    if (!m_currentSearch.isNull() && m_currentSearch == searchText)
+        return;
     m_currentSearch = searchText;
+
+    QString filter;
+    QSqlField search("search", QVariant::String);
+    search.setValue("%" + searchText + "%");
+    QString escapedText = database().driver()->formatValue(search);
+    filter = "(artist LIKE " + escapedText + " OR " +
+            "album LIKE " + escapedText + " OR " +
+            "title  LIKE " + escapedText + ")";
+    setFilter(filter);
 }
 
 const QString ITunesPlaylistModel::currentSearch() {
     return m_currentSearch;
 }
 
-const QList<int>& ITunesPlaylistModel::searchColumns() const {
-    return m_pTrackModel->searchColumns();
+bool ITunesPlaylistModel::isColumnInternal(int column) {
+    if (column == fieldIndex(LIBRARYTABLE_ID) ||
+        column == fieldIndex(LIBRARYTABLE_MIXXXDELETED) ||
+        column == fieldIndex(TRACKLOCATIONSTABLE_FSDELETED) ||
+        column == fieldIndex("name") ||
+        column == fieldIndex("track_id"))
+        return true;
+    return false;
+}
+
+QMimeData* ITunesPlaylistModel::mimeData(const QModelIndexList &indexes) const {
+    return NULL;
+}
+
+
+QItemDelegate* ITunesPlaylistModel::delegateForColumn(const int i) {
+    return NULL;
+}
+
+TrackModel::CapabilitiesFlags ITunesPlaylistModel::getCapabilities() const {
+    return NULL;
+}
+
+Qt::ItemFlags ITunesPlaylistModel::flags(const QModelIndex &index) const {
+    return readOnlyFlags(index);
+}
+
+void ITunesPlaylistModel::setPlaylist(QString playlist_path) {
+    int playlistId = -1;
+    QSqlQuery finder_query(m_database);
+    finder_query.prepare("SELECT id from itunes_playlists where name='"+playlist_path+"'");
+
+    if(finder_query.exec()){
+        while (finder_query.next()) {
+            playlistId = finder_query.value(finder_query.record().indexOf("id")).toInt();
+        }
+    }
+    else
+        qDebug() << "SQL Error in ITunesPlaylistModel.cpp: line" << __LINE__ << " " << finder_query.lastError();
+
+
+    QString playlistID = "ITunesPlaylist_" + QString("%1").arg(playlistId);
+    //Escape the playlist name
+    QSqlDriver* driver = m_pTrackCollection->getDatabase().driver();
+    QSqlField playlistNameField("name", QVariant::String);
+    playlistNameField.setValue(playlistID);
+
+    QSqlQuery query(m_database);
+    query.prepare("CREATE TEMPORARY VIEW IF NOT EXISTS "+ driver->formatValue(playlistNameField) + " AS "
+                  "SELECT "
+                  "itunes_library.id,"
+                  "itunes_library.artist,"
+                  "itunes_library.title,"
+                  "itunes_library.album,"
+                  "itunes_library.year,"
+                  "itunes_library.genre,"
+                  "itunes_library.tracknumber,"
+                  "itunes_library.location,"
+                  "itunes_library.comment,"
+                  "itunes_library.rating,"
+                  "itunes_library.duration,"
+                  "itunes_library.bitrate,"
+                  "itunes_library.bpm,"
+                  "itunes_playlist_tracks.track_id, "
+                  "itunes_playlists.name "
+                  "FROM itunes_library "
+                  "INNER JOIN itunes_playlist_tracks "
+                  "ON itunes_playlist_tracks.track_id = itunes_library.id "
+                  "INNER JOIN itunes_playlists "
+                  "ON itunes_playlist_tracks.playlist_id = itunes_playlists.id "
+                  "where itunes_playlists.name='"+playlist_path+"'"
+                  );
+
+
+    if (!query.exec()) {
+
+        qDebug() << "Error creating temporary view for itunes playlists. ITunesPlaylistModel --> line: " << __LINE__ << " " << query.lastError();
+        qDebug() << "Executed Query: " <<  query.executedQuery();
+        return;
+    }
+    setTable(playlistID);
+
+    //removeColumn(fieldIndex("track_id"));
+    //removeColumn(fieldIndex("name"));
+    //removeColumn(fieldIndex("id"));
+
+    slotSearch("");
+
+    select(); //Populate the data model.
+    initHeaderData();
+}
+
+bool ITunesPlaylistModel::isColumnHiddenByDefault(int column) {
+    return false;
 }
 
=== modified file 'mixxx/src/library/itunesplaylistmodel.h'
--- mixxx/src/library/itunesplaylistmodel.h	2010-11-16 21:01:45 +0000
+++ mixxx/src/library/itunesplaylistmodel.h	2010-11-21 15:57:13 +0000
@@ -1,77 +1,53 @@
-// itunestrackmodel.h
-// Created 12/19/2009 by RJ Ryan ([e-mail])
-// Adapted from Phillip Whelan's RhythmboxPlaylistModel
-
-#ifndef ITUNESPLAYLISTMODEL_H
-#define ITUNESPLAYLISTMODEL_H
+#ifndef ITUNES_PLAYLIST_MODEL_H
+#define ITUNES_PLAYLIST_MODEL_H
 
 #include <QtSql>
-#include <QtXml>
+#include <QItemDelegate>
+#include <QtCore>
 #include "trackmodel.h"
-
-class ITunesTrackModel;
-
-class ITunesPlaylistModel : public QAbstractTableModel, public TrackModel {
-
-    enum Columns {
-        COLUMN_ARTIST = 0,
-        COLUMN_TITLE,
-        COLUMN_ALBUM,
-        COLUMN_DATE,
-        COLUMN_BPM,
-        COLUMN_GENRE,
-        COLUMN_LOCATION,
-        COLUMN_DURATION,
-        NUM_COLUMNS
-    };
-
+#include "library/basesqltablemodel.h"
+#include "library/librarytablemodel.h"
+#include "library/dao/playlistdao.h"
+#include "library/dao/trackdao.h"
+
+class TrackCollection;
+
+class ITunesPlaylistModel : public BaseSqlTableModel, public virtual TrackModel
+{
     Q_OBJECT
-
   public:
-    ITunesPlaylistModel(ITunesTrackModel* pTrackModel);
+    ITunesPlaylistModel(QObject* parent, TrackCollection* pTrackCollection);
     virtual ~ITunesPlaylistModel();
 
-    //QAbstractTableModel stuff
-    virtual Qt::ItemFlags flags(const QModelIndex& index) const;
-    virtual QVariant data(const QModelIndex & index,
-                          int role = Qt::DisplayRole) const;
-    virtual QMimeData* mimeData(const QModelIndexList &indexes) const;
-    virtual QVariant headerData(int section,
-                                Qt::Orientation orientation,
-                                int role = Qt::DisplayRole) const;
-    virtual int rowCount(const QModelIndex& parent = QModelIndex()) const;
-    virtual int columnCount(const QModelIndex& parent) const;
-
-    //Playlist Model stuff
     virtual TrackPointer getTrack(const QModelIndex& index) const;
     virtual QString getTrackLocation(const QModelIndex& index) const;
     virtual void search(const QString& searchText);
     virtual const QString currentSearch();
-    virtual const QList<int>& searchColumns() const;
     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 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);
-
-    virtual QList<QString> getPlaylists();
-    virtual void setPlaylist(QString playlist);
-
-    int numPlaylists();
-    QString playlistTitle(int n);
+    TrackModel::CapabilitiesFlags getCapabilities() const;
+    /** sets the playlist **/
+    void setPlaylist(QString path_name);
+
+  private slots:
+    void slotSearch(const QString& searchText);
 
   signals:
-    void startedLoading();
-    void progressLoading(QString path);
-    void finishedLoading();
+    void doSearch(const QString& searchText);
 
   private:
-    ITunesTrackModel* m_pTrackModel;
-    QString m_sCurrentPlaylist;
+    TrackCollection* m_pTrackCollection;
+    QSqlDatabase &m_database;
     QString m_currentSearch;
 };
 
-#endif /* ITUNESPLAYLISTMODEL_H */
+#endif /* ITUNES_PLAYLIST_MODEL_H */
 
=== modified file 'mixxx/src/library/itunestrackmodel.cpp'
--- mixxx/src/library/itunestrackmodel.cpp	2010-11-16 21:01:45 +0000
+++ mixxx/src/library/itunestrackmodel.cpp	2010-11-21 15:57:13 +0000
@@ -1,316 +1,118 @@
 #include <QtCore>
 #include <QtGui>
 #include <QtSql>
-#include <QtDebug>
-#include <QSettings>
-#include <QRegExp>
-#include <QtXmlPatterns/QXmlQuery>
-#include <QDesktopServices>
-
-#include "itunestrackmodel.h"
-#include "xmlparse.h"
-#include "trackinfoobject.h"
-#include "defs.h"
-#include "soundsourceproxy.h"
+#include "library/trackcollection.h"
+#include "library/itunestrackmodel.h"
 
 #include "mixxxutils.cpp"
 
-ITunesTrackModel::ITunesTrackModel()
-        : AbstractXmlTrackModel("mixxx.db.model.itunes") {
-    QXmlQuery query;
-    QString res, playlistRes;
-    QDomDocument itunesdb;
-
-    QRegExp supportedFileRegex(SoundSourceProxy::supportedFileExtensionsRegex(),
-                               Qt::CaseInsensitive);
-
-    QString itunesXmlPath = getiTunesMusicPath();
-
-    QFile db(itunesXmlPath);
-    if (!db.exists())
-        return;
-
-    if (!db.open(QIODevice::ReadOnly | QIODevice::Text))
-        return;
-
-    // Workaround for Bug #501916. Read the file, convert it to UTF-8 and then
-    // load it.
-    QByteArray db_bytes_utf8 = QString(db.readAll()).toUtf8();
-    QBuffer buffer(&db_bytes_utf8);
-    if (!buffer.open(QIODevice::ReadOnly | QIODevice::Text))
-        return;
-
-    /*
-     * Use QXmlQuery to execute an XPath query. We add the version to
-     * the XPath query to make sure it is the schema we expect.
-     *
-     * TODO: filter /key='Track Type'/string='URL' (remote) files
-     */
-    query.setFocus(&buffer);
-    query.setQuery("/plist[@version='1.0']/dict[key='Tracks']/dict/dict");
-    if ( ! query.isValid())
-        return;
-
-    query.evaluateTo(&res);
-
-    // Both ITunes and Rhythmbox parsing should occur in something completely
-    // separate from the TrackModels, but since we're in a rush, we're just
-    // going to do playlist parsing here so we don't have to re-open the file
-    // again.
-    query.setQuery("/plist[@version='1.0']/dict[key='Playlists']/array/dict");
-    if (query.isValid()) {
-        query.evaluateTo(&playlistRes);
-    }
-    db.close();
-
-    /*
-     * Parse the result as an XML file. These shennanigans actually
-     * reduce the load time from a minute to a matter of seconds.
-     */
-    itunesdb.setContent("<plist version='1.0'>" + res + "</plist>");
-    m_trackNodes = itunesdb.elementsByTagName("dict");
-
-    for (int i = 0; i < m_trackNodes.count(); i++) {
-        QDomNode n = m_trackNodes.at(i);
-        QString trackId = findValueByKey(n, "Track ID");
-        QString location = findValueByKey(n, "Location");
-
-        // Skip files we cannot play.
-        if (location.count(supportedFileRegex) == 0) {
-            continue;
-        }
-
-        m_mTracksByLocation[location] = n;
-        m_mTracksById[trackId] = n;
-    }
-
-    // Now process the playlist data.
-    QDomDocument playlistdb;
-    playlistdb.setContent("<plist version='1.0'>" + playlistRes + "</plist>");
-    QDomNodeList playlistNodes = playlistdb.documentElement().childNodes();
-    for (int i = 0; i < playlistNodes.count(); i++) {
-        QDomNode n = playlistNodes.at(i);
-
-        // Get the playlist name
-        QString name = findValueByKey(n, "Name");
-        qDebug() << "Found playlist" << name;
-
-        // Skip invisible playlists
-        QDomElement visible = findNodeByKey(n, "Visible");
-        if (!visible.isNull() && visible.tagName() == "false") {
-            continue;
-        }
-
-        // Now traverse to the items list
-        QDomElement items = findNodeByKey(n, "Playlist Items");
-        if (items.isNull()) {
-            qDebug() << name << "has no items";
-            continue;
-        }
-
-        // Now extract the song ids that are members of this playlist
-        QDomNodeList playlistEntries = items.childNodes();
-        QList<QString> playlistSongIds;
-        for (int j = 0; j < playlistEntries.count(); j++) {
-            QDomNode entry = playlistEntries.at(j);
-            QString trackId = findValueByKey(entry, "Track ID");
-
-            // If the track index does not contain the given track, that means
-            // either the track is not playable in Mixxx, or the XML is
-            // inconsistent. In this case, don't show the track in the playlist.
-            if (!m_mTracksById.contains(trackId)) {
-                continue;
-            }
-
-            playlistSongIds.append(trackId);
-        }
-
-        // If there were no playable items in the playlist, don't show it.
-        if (playlistSongIds.count() == 0) {
-            qDebug() << name << "has no items";
-            continue;
-        }
-
-        // TODO(XXX) : Do we need to handle duplicate playlist names? If there
-        // are duplicates, only one will show up if we do this.
-        m_mPlaylists[name] = playlistSongIds;
-    }
-
-    qDebug() << "ITunesTrackModel: m_entryNodes size is" << m_trackNodes.size();
-
-    addColumnName(ITunesTrackModel::COLUMN_ARTIST, "Artist");
-    addColumnName(ITunesTrackModel::COLUMN_TITLE, "Title");
-    addColumnName(ITunesTrackModel::COLUMN_ALBUM, "Album");
-    addColumnName(ITunesTrackModel::COLUMN_DATE, "Date");
-    addColumnName(ITunesTrackModel::COLUMN_BPM, "BPM");
-    addColumnName(ITunesTrackModel::COLUMN_GENRE, "Genre");
-    addColumnName(ITunesTrackModel::COLUMN_LOCATION, "Location");
-    addColumnName(ITunesTrackModel::COLUMN_DURATION, "Duration");
-
-    addSearchColumn(ITunesTrackModel::COLUMN_ARTIST);
-    addSearchColumn(ITunesTrackModel::COLUMN_TITLE);
-    addSearchColumn(ITunesTrackModel::COLUMN_ALBUM);
-    addSearchColumn(ITunesTrackModel::COLUMN_GENRE);
-    addSearchColumn(ITunesTrackModel::COLUMN_LOCATION);
-}
-
-ITunesTrackModel::~ITunesTrackModel()
-{
-
-}
-
-QItemDelegate* ITunesTrackModel::delegateForColumn(const int i)
-{
-    return NULL;
-}
-
-QString ITunesTrackModel::findValueByKey(QDomNode dictNode, QString key) const
-{
-    QDomElement curElem;
-
-    curElem = dictNode.firstChildElement("key");
-    while(!curElem.isNull()) {
-        if ( curElem.text() == key ) {
-            QDomElement value;
-            value = curElem.nextSiblingElement();
-            QString textValue = value.text();
-            //Either iTunes lies about the text encoding in its XML file or 
-            //Qt misdetects it. We workaround this explicitly sayi it's UTF-8.
-            textValue = QString::fromUtf8(textValue.toAscii().data(), textValue.size());
-            return textValue;
-        }
-
-        curElem = curElem.nextSiblingElement("key");
-    }
-
-    return QString();
-}
-
-QDomElement ITunesTrackModel::findNodeByKey(QDomNode dictNode, QString key) const
-{
-    QDomElement curElem;
-
-    curElem = dictNode.firstChildElement("key");
-    while(!curElem.isNull()) {
-        if ( curElem.text() == key ) {
-            return curElem.nextSiblingElement();
-        }
-        curElem = curElem.nextSiblingElement("key");
-    }
-
-    return QDomElement();
-}
-
-QVariant ITunesTrackModel::getTrackColumnData(QDomNode songNode, const QModelIndex& index) const
-{
-    QVariant value;
-    switch (index.column()) {
-        case ITunesTrackModel::COLUMN_ARTIST:
-            return findValueByKey(songNode, "Artist");
-        case ITunesTrackModel::COLUMN_TITLE:
-            return findValueByKey(songNode, "Name");
-        case ITunesTrackModel::COLUMN_ALBUM:
-            return findValueByKey(songNode,"Album");
-        case ITunesTrackModel::COLUMN_DATE:
-            return findValueByKey(songNode,"Year");
-        case ITunesTrackModel::COLUMN_BPM:
-            return findValueByKey(songNode,"BPM");
-        case ITunesTrackModel::COLUMN_GENRE:
-            return findValueByKey(songNode,"Genre");
-        case ITunesTrackModel::COLUMN_LOCATION: {
-            /*
-             * Strip the crappy file://localhost/ from the URL and
-             * format URL as in method ITunesTrackModel::parseTrackNode(QDomNode songNode)
-             */
-            QString strloc = findValueByKey(songNode,"Location");
-            QByteArray strlocbytes = strloc.toUtf8();
-            QString location = QUrl::fromEncoded(strlocbytes).toLocalFile();
-#if defined(__WINDOWS__)
-            return location.remove("//localhost/");
-#else
-            return location.remove("//localhost");
-#endif
-        }
-
-        case ITunesTrackModel::COLUMN_DURATION:
-            value = findValueByKey(songNode,"Total Time");
-            if (qVariantCanConvert<int>(value)) {
-                value = MixxxUtils::millisecondsToMinutes(qVariantValue<int>(value));
-            }
-            return value;
-        default:
-            return QVariant();
-    }
+ITunesTrackModel::ITunesTrackModel(QObject* parent,
+                                   TrackCollection* pTrackCollection)
+        : TrackModel(pTrackCollection->getDatabase(),
+                     "mixxx.db.model.itunes"),
+          BaseSqlTableModel(parent, pTrackCollection, pTrackCollection->getDatabase()),
+          m_pTrackCollection(pTrackCollection),
+          m_database(m_pTrackCollection->getDatabase()) {
+    connect(this, SIGNAL(doSearch(const QString&)), this, SLOT(slotSearch(const QString&)));
+    setTable("itunes_library");
+    initHeaderData();
+}
+
+ITunesTrackModel::~ITunesTrackModel() {
+}
+
+bool ITunesTrackModel::addTrack(const QModelIndex& index, QString location) {
+    return false;
+}
+
+TrackPointer ITunesTrackModel::getTrack(const QModelIndex& index) const {
+    QString artist = index.sibling(index.row(), fieldIndex("artist")).data().toString();
+    QString title = index.sibling(index.row(), fieldIndex("title")).data().toString();
+    QString album = index.sibling(index.row(), fieldIndex("album")).data().toString();
+    QString year = index.sibling(index.row(), fieldIndex("year")).data().toString();
+    QString genre = index.sibling(index.row(), fieldIndex("genre")).data().toString();
+    float bpm = index.sibling(index.row(), fieldIndex("bpm")).data().toString().toFloat();
+
+    QString location = index.sibling(index.row(), fieldIndex("location")).data().toString();
+
+    TrackInfoObject* pTrack = new TrackInfoObject(location);
+    pTrack->setArtist(artist);
+    pTrack->setTitle(title);
+    pTrack->setAlbum(album);
+    pTrack->setYear(year);
+    pTrack->setGenre(genre);
+    pTrack->setBpm(bpm);
+
+    return TrackPointer(pTrack, &QObject::deleteLater);
+}
+
+QString ITunesTrackModel::getTrackLocation(const QModelIndex& index) const {
+    QString location = index.sibling(index.row(), fieldIndex("location")).data().toString();
+    return location;
+}
+
+void ITunesTrackModel::removeTrack(const QModelIndex& index) {
+
+}
+
+void ITunesTrackModel::removeTracks(const QModelIndexList& indices) {
+
+}
+
+void ITunesTrackModel::moveTrack(const QModelIndex& sourceIndex, const QModelIndex& destIndex) {
+
+}
+
+void ITunesTrackModel::search(const QString& searchText) {
+    // qDebug() << "ITunesTrackModel::search()" << searchText
+    //          << QThread::currentThread();
+    emit(doSearch(searchText));
+}
+
+void ITunesTrackModel::slotSearch(const QString& searchText) {
+    if (!m_currentSearch.isNull() && m_currentSearch == searchText)
+        return;
+    m_currentSearch = searchText;
+
+    QString filter;
+    QSqlField search("search", QVariant::String);
+    search.setValue("%" + searchText + "%");
+    QString escapedText = database().driver()->formatValue(search);
+    filter = "(artist LIKE " + escapedText + " OR " +
+            "album LIKE " + escapedText + " OR " +
+            "title  LIKE " + escapedText + ")";
+    setFilter(filter);
+
+}
+
+const QString ITunesTrackModel::currentSearch() {
+    return m_currentSearch;
 }
 
 bool ITunesTrackModel::isColumnInternal(int column) {
+    if (column == fieldIndex(LIBRARYTABLE_ID) ||
+        column == fieldIndex(LIBRARYTABLE_MIXXXDELETED) ||
+        column == fieldIndex(TRACKLOCATIONSTABLE_FSDELETED))
+        return true;
     return false;
 }
+
+QMimeData* ITunesTrackModel::mimeData(const QModelIndexList &indexes) const {
+    return NULL;
+}
+
+QItemDelegate* ITunesTrackModel::delegateForColumn(const int i) {
+    return NULL;
+}
+
+TrackModel::CapabilitiesFlags ITunesTrackModel::getCapabilities() const {
+    return NULL;
+}
+
+Qt::ItemFlags ITunesTrackModel::flags(const QModelIndex &index) const {
+    return readOnlyFlags(index);
+}
+
 bool ITunesTrackModel::isColumnHiddenByDefault(int column) {
     return false;
 }
-
-TrackPointer ITunesTrackModel::parseTrackNode(QDomNode songNode) const
-{
-    QString strloc = findValueByKey(songNode,"Location");
-    QByteArray strlocbytes = strloc.toUtf8();
-    QUrl location = QUrl::fromEncoded(strlocbytes);
-
-    QString trackLocation;
-    //Strip the crappy localhost from the URL since Qt barfs on this :(
-#if defined(__WINDOWS__)
-    trackLocation = location.toLocalFile().remove("//localhost/");
-#else
-    trackLocation = location.toLocalFile().remove("//localhost");
-#endif
-    //pTrack->setLocation(QUrl(findValueByKey(songNode,"Location")).toLocalFile());
-
-    TrackInfoObject* pTrack = new TrackInfoObject(trackLocation);
-
-    pTrack->setArtist(findValueByKey(songNode, "Artist"));
-    pTrack->setTitle(findValueByKey(songNode, "Name"));
-    pTrack->setAlbum(findValueByKey(songNode,"Album"));
-    pTrack->setYear(findValueByKey(songNode,"Year"));
-    pTrack->setGenre(findValueByKey(songNode,"Genre"));
-    pTrack->setBpm(findValueByKey(songNode,"BPM").toFloat());
-
-    // ITunes stores time in total milliseconds
-    pTrack->setDuration(findValueByKey(songNode,"Total Time").toInt() / 1000);
-
-    // Let Qt handle deleting the track since it isn't owned by the library.
-    return TrackPointer(pTrack, &QObject::deleteLater);
-}
-
-TrackPointer ITunesTrackModel::getTrackById(QString id) {
-    if (!m_mTracksById.contains(id)) {
-        return TrackPointer();
-    }
-    return parseTrackNode(m_mTracksById[id]);
-}
-
-QString ITunesTrackModel::getiTunesMusicPath() {
-    QString musicFolder;
-#if defined(__APPLE__)
-    musicFolder = QDesktopServices::storageLocation(QDesktopServices::MusicLocation) + "/iTunes/iTunes Music Library.xml";
-#elif defined(__WINDOWS__)
-    musicFolder = QDesktopServices::storageLocation(QDesktopServices::MusicLocation) + "\\iTunes\\iTunes Music Library.xml";
-#elif defined(__LINUX__)
-		musicFolder = QDir::homePath() + "/.itunes.xml";
-#else
-		musicFolder = "";
-#endif
-    qDebug() << "ITunesLibrary=[" << musicFolder << "]";
-    return musicFolder;
-}
-
-//OwenB - for use by the playlistmodel
-QDomNode ITunesTrackModel::getTrackNodeById(const QString& id) const
-{
-    if ( !m_mTracksById.contains(id))
-        return QDomNode();
-
-    QDomNode songNode = m_mTracksById[id];
-    return songNode;
-}
-
-
 
=== modified file 'mixxx/src/library/itunestrackmodel.h'
--- mixxx/src/library/itunestrackmodel.h	2010-11-16 21:01:45 +0000
+++ mixxx/src/library/itunestrackmodel.h	2010-11-21 15:57:13 +0000
@@ -1,82 +1,51 @@
-/***************************************************************************
-                           ituestrackmodel.h
-                              -------------------
-     begin                : 8/28/2009
-     copyright            : (C) 2009 Phillip Whelan
-     email                : [e-mail]
-***************************************************************************/
-
-/***************************************************************************
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- ***************************************************************************/
-
-#ifndef ITUNESTRACKMODEL_H
-#define ITUNESTRACKMODEL_H
+#ifndef ITUNES_TABLE_MODEL_H
+#define ITUNES_TABLE_MODEL_H
 
 #include <QtSql>
-#include <QtXml>
+#include <QItemDelegate>
+#include <QtCore>
 #include "trackmodel.h"
-#include "abstractxmltrackmodel.h"
-#include "itunesplaylistmodel.h"
-
-class QSqlDatabase;
-
-/**
-   @author Phillip Whelan
-*/
-
-// Darn Jobs and his capitalization!
-class ITunesTrackModel : public AbstractXmlTrackModel
+#include "library/basesqltablemodel.h"
+#include "library/librarytablemodel.h"
+#include "library/dao/playlistdao.h"
+#include "library/dao/trackdao.h"
+
+class TrackCollection;
+
+class ITunesTrackModel : public BaseSqlTableModel, public virtual TrackModel
 {
-    enum Columns {
-        COLUMN_ARTIST = 0,
-        COLUMN_TITLE,
-        COLUMN_ALBUM,
-        COLUMN_DATE,
-        COLUMN_BPM,
-        COLUMN_GENRE,
-        COLUMN_LOCATION,
-        COLUMN_DURATION,
-        NUM_COLUMNS
-    };
-
     Q_OBJECT
   public:
-    ITunesTrackModel();
+    ITunesTrackModel(QObject* parent, TrackCollection* pTrackCollection);
     virtual ~ITunesTrackModel();
-    virtual QItemDelegate* delegateForColumn(const int i);
+
+    virtual TrackPointer getTrack(const QModelIndex& index) const;
+    virtual QString getTrackLocation(const QModelIndex& index) const;
+    virtual void search(const QString& searchText);
+    virtual const QString currentSearch();
     virtual bool isColumnInternal(int column);
     virtual bool isColumnHiddenByDefault(int column);
-    static QString getiTunesMusicPath();
-    QDomNode getTrackNodeById(const QString& ) const;
-
-  public slots:
+    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;
+
+  private slots:
+    void slotSearch(const QString& searchText);
 
   signals:
-    void startedLoading();
-    void progressLoading(QString path);
-    void finishedLoading();
-
-  protected:
-    virtual TrackPointer parseTrackNode(QDomNode node) const;
-    /* Implemented by AbstractXmlTrackModel implementations to return the data for song columns */
-    virtual QVariant getTrackColumnData(QDomNode node, const QModelIndex& index) const;
-    /* Called by AbstractXmlTrackModel implementations to enumerate their columns */
+    void doSearch(const QString& searchText);
 
   private:
-    QString findValueByKey(QDomNode dictNode, QString key) const;
-    QDomElement findNodeByKey(QDomNode dictNode, QString key) const;
-    TrackPointer getTrackById(QString id);
-
-    QHash<QString, QDomNode> m_mTracksById;
-    QHash<QString, QList<QString> > m_mPlaylists;
-
-    friend class ITunesPlaylistModel;
+    TrackCollection* m_pTrackCollection;
+    QSqlDatabase &m_database;
+    QString m_currentSearch;
 };
 
-#endif
+#endif /* ITUNES_TABLE_MODEL_H */
 
=== modified file 'mixxx/src/library/library.cpp'
--- mixxx/src/library/library.cpp	2010-10-24 09:50:11 +0000
+++ mixxx/src/library/library.cpp	2010-11-21 15:57:13 +0000
@@ -62,7 +62,7 @@
     if (RhythmboxFeature::isSupported())
         addFeature(new RhythmboxFeature(this));
     if (ITunesFeature::isSupported())
-        addFeature(new ITunesFeature(this));
+        addFeature(new ITunesFeature(this, m_pTrackCollection));
 
     //Show the promo tracks view on first run, otherwise show the library
     if (firstRun) {
 
=== modified file 'mixxx/src/library/trackcollection.cpp'
--- mixxx/src/library/trackcollection.cpp	2010-11-17 21:02:24 +0000
+++ mixxx/src/library/trackcollection.cpp	2010-11-21 15:57:13 +0000
@@ -68,7 +68,7 @@
         return false;
     }
 
-    int requiredSchemaVersion = 7;
+    int requiredSchemaVersion = 8;
     if (!SchemaManager::upgradeToSchemaVersion(m_pConfig, m_db,
                                                requiredSchemaVersion)) {
         QMessageBox::warning(0, tr("Cannot upgrade database schema"),