playlist.cpp

   1 //
   2 // C++ Implementation: playlist
   3 //
   4 // Author: Oliver Groß <z.o.gross@gmx.de>, (C) 2008
   5 //
   6 // Copyright: See COPYING file that comes with this distribution
   7 //
   8 #include "common.h"
   9 #include "playlist.h"
  10 #include "client.h"
  11
  12 namespace XmmsQt {
  13         QPlaylist::QPlaylist(QClient * parent) : QObject(parent), m_Connection(0) {
  14                 reset();
  15                 connect(parent, SIGNAL(connectionChanged(xmmsc_connection_t *)),
  16                         this,   SLOT(setConnection(xmmsc_connection_t *)));
  17         }
  18
  19         QPlaylist::~QPlaylist() {
  20         }
  21
  22         void QPlaylist::loadedCallback(xmmsc_result_t * result, void * instance) {
  23                 if (instance) {
  24                         static_cast<QPlaylist *>(instance)->reset();
  25                 }
  26                 xmmsc_result_unref(result);
  27         }
  28
  29         void QPlaylist::changedCallback(xmmsc_result_t * result, void * instance) {
  30                 if (instance) {
  31                         QPlaylist * playlist = static_cast<QPlaylist *>(instance);
  32                         xmms_playlist_changed_actions_t type;
  33                         xmmsc_result_get_dict_entry_uint(result, "type", (quint32 *)(&type));
  34
  35                         switch (type) {
  36                         case XMMS_PLAYLIST_CHANGED_ADD:
  37                                 {
  38                                         quint32 id;
  39
  40                                         xmmsc_result_get_dict_entry_uint(result, "id", &id);
  41
  42                                         emit playlist->entryAppended(id);
  43                                 }
  44                                 break;
  45                         case XMMS_PLAYLIST_CHANGED_INSERT:
  46                                 {
  47                                         quint32 position, id;
  48
  49                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  50                                         xmmsc_result_get_dict_entry_uint(result, "id", &id);
  51                                         emit playlist->entryInserted(id, position);
  52                                 }
  53                                 break;
  54                         case XMMS_PLAYLIST_CHANGED_UPDATE:
  55                                 {
  56                                         quint32 position, id;
  57
  58                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  59                                         xmmsc_result_get_dict_entry_uint(result, "id", &id);
  60                                         emit playlist->entryUpdated(id, position);
  61                                 }
  62                                 break;
  63                         case XMMS_PLAYLIST_CHANGED_REMOVE:
  64                                 {
  65                                         quint32 position;
  66
  67                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  68                                         emit playlist->entryRemoved(position);
  69                                 }
  70                                 break;
  71                         case XMMS_PLAYLIST_CHANGED_MOVE:
  72                                 {
  73                                         quint32 from, to;
  74
  75                                         xmmsc_result_get_dict_entry_uint(result, "position", &from);
  76                                         xmmsc_result_get_dict_entry_uint(result, "newposition", &from);
  77                                         emit playlist->entryMoved(from, to);
  78                                 }
  79                                 break;
  80                         case XMMS_PLAYLIST_CHANGED_SORT:
  81                         case XMMS_PLAYLIST_CHANGED_SHUFFLE:
  82                         case XMMS_PLAYLIST_CHANGED_CLEAR:
  83                                 playlist->reset();
  84                                 break;
  85                         default:
  86                                 break;
  87                         }
  88                 }
  89                 xmmsc_result_unref(result);
  90         }
  91
  92         void QPlaylist::fillIDListCallback(xmmsc_result_t * result, void * instance) {
  93                 if (instance) {
  94                         QPlaylist * playlist = static_cast<QPlaylist *>(instance);
  95
  96                         quint32 buffer;
  97                         playlist->m_IDList.clear();
  98
  99                         for (xmmsc_result_t * i = result; xmmsc_result_list_valid(i); xmmsc_result_list_next(i)) {
 100                                 xmmsc_result_get_uint(i, &buffer);
 101                                 playlist->m_IDList << buffer;
 102                         }
 103
 104                         emit playlist->reseted();
 105                 }
 106                 xmmsc_result_unref(result);
 107         }
 108
 109         void QPlaylist::currentPosCallback(xmmsc_result_t * result, void * instance) {
 110                 if (instance) {
 111                         quint32 position;
 112
 113                         xmmsc_result_get_uint(result, &position);
 114                         emit static_cast<QPlaylist *>(instance)->currentChanged(position);
 115                 }
 116                 xmmsc_result_unref(result);
 117         }
 118
 119         void QPlaylist::setConnection(xmmsc_connection_t * connection) {
 120                 if (m_Connection == connection)
 121                         return;
 122
 123                 //disconnect
 124                 if (m_Connection) {
 125                         disconnectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection));
 126                         disconnectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection));
 127                         disconnectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection));
 128                 }
 129
 130                 m_Connection = connection;
 131
 132                 //connect
 133                 if (m_Connection) {
 134                         connectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection),      loadedCallback,     this);
 135                         connectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection),     changedCallback,    this);
 136                         connectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection), currentPosCallback, this);
 137                 }
 138         }
 139
 140         void QPlaylist::reset() {
 141                 connectNotifierUnref(xmmsc_playlist_list_entries(m_Connection, "default"), fillIDListCallback, this);
 142         }
 143
 144         void QPlaylist::append(quint32 id) {
 145                 xmmsc_result_unref(xmmsc_playlist_add_id(m_Connection, "Default", id));
 146         }
 147
 148         void QPlaylist::append(QString url) {
 149                 xmmsc_result_unref(xmmsc_playlist_add_url(m_Connection, "Default", url.toAscii().data()));
 150         }
 151
 152         void QPlaylist::append(QStringList urls) {
 153                 foreach(QString i, urls)
 154                         append(i);
 155         }
 156
 157         void QPlaylist::append(QList<quint32> ids) {
 158                 foreach(quint32 i, ids)
 159                         append(i);
 160         }
 161
 162         void QPlaylist::appendRecursive(QString directory) {
 163                 xmmsc_result_unref(xmmsc_playlist_radd(m_Connection, "Default", directory.toAscii().data()));
 164         }
 165
 166         void QPlaylist::insert(quint32 id, quint32 position) {
 167                 xmmsc_result_unref(xmmsc_playlist_insert_id(m_Connection, "Default", position, id));
 168         }
 169
 170         void QPlaylist::insert(QString url, quint32 position) {
 171                 xmmsc_result_unref(xmmsc_playlist_insert_url(m_Connection, "Default", position, url.toAscii().data()));
 172         }
 173
 174         void QPlaylist::insert(QList<quint32> ids, quint32 position) {
 175                 if (ids.count() == 0)
 176                         return;
 177
 178                 QList<quint32>::iterator i = ids.end();
 179                 do {
 180                         i--;
 181                         insert(*i, position);
 182                 }
 183                 while (i != ids.begin());
 184         }
 185
 186         void QPlaylist::insert(QStringList urls, quint32 position) {
 187                 if (urls.count() == 0)
 188                         return;
 189
 190                 QStringList::iterator i = urls.end();
 191                 do {
 192                         i--;
 193                         insert(*i, position);
 194                 }
 195                 while (i != urls.begin());
 196         }
 197
 198         void QPlaylist::remove(quint32 position) {
 199                 xmmsc_result_unref(xmmsc_playlist_remove_entry(m_Connection, "Default", position));
 200         }
 201
 202         void QPlaylist::move(quint32 from, quint32 to) {
 203                 xmmsc_result_unref(xmmsc_playlist_move_entry(m_Connection, "Default", from, to));
 204         }
 205
 206         void QPlaylist::clear() {
 207                 xmmsc_result_unref(xmmsc_playlist_clear(m_Connection, "Default"));
 208         }
 209
 210 /*      void QPlaylist::sort(QStringList properties) {
 211                 xmmsc_result_unref(xmmsc_playlist_sort(m_Connection, "Default"));
 212         }*/
 213
 214         void QPlaylist::randomize() {
 215                 xmmsc_result_unref(xmmsc_playlist_shuffle(m_Connection, "Default"));
 216         }
 217
 218         void QPlaylist::setNext(quint32 position) {
 219                 xmmsc_result_unref(xmmsc_playlist_set_next(m_Connection, position));
 220         }
 221 }