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 #include <QDebug>
  12
  13 namespace XmmsQt {
  14         QPlaylist::QPlaylist(QClient * parent) : QObject(parent), m_Connection(0) {
  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 *, 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                                         emit playlist->entryAboutToBeInserted(playlist->m_IDList.size(), id);
  42                                         playlist->m_IDList << id;
  43 //                                      emit playlist->entryAppended(id);
  44                                         emit playlist->entryInserted(playlist->m_IDList.size(), id);
  45                                 }
  46                                 break;
  47                         case XMMS_PLAYLIST_CHANGED_INSERT:
  48                                 {
  49                                         quint32 position, id;
  50
  51                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  52                                         xmmsc_result_get_dict_entry_uint(result, "id", &id);
  53                                         emit playlist->entryAboutToBeInserted(position, id);
  54                                         playlist->m_IDList.insert(position, id);
  55                                         emit playlist->entryInserted(position, id);
  56                                 }
  57                                 break;
  58                         case XMMS_PLAYLIST_CHANGED_UPDATE:
  59                                 {
  60                                         quint32 position, oldid;
  61
  62                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  63                                         oldid = playlist->m_IDList[position];
  64                                         xmmsc_result_get_dict_entry_uint(result, "id", &playlist->m_IDList[position]);
  65                                         emit playlist->entryUpdated(position, oldid);
  66                                 }
  67                                 break;
  68                         case XMMS_PLAYLIST_CHANGED_REMOVE:
  69                                 {
  70                                         quint32 position, id;
  71
  72                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  73                                         id = playlist->m_IDList[position];
  74                                         emit playlist->entryAboutToBeRemoved(position, id);
  75                                         playlist->m_IDList.removeAt(position);
  76                                         emit playlist->entryRemoved(position, id);
  77                                 }
  78                                 break;
  79                         case XMMS_PLAYLIST_CHANGED_MOVE:
  80                                 {
  81                                         quint32 from, to;
  82
  83                                         xmmsc_result_get_dict_entry_uint(result, "position", &from);
  84                                         xmmsc_result_get_dict_entry_uint(result, "newposition", &from);
  85                                         playlist->m_IDList.move(from, to);
  86                                         emit playlist->entryMoved(from, to);
  87                                 }
  88                                 break;
  89                         case XMMS_PLAYLIST_CHANGED_SORT:
  90                         case XMMS_PLAYLIST_CHANGED_SHUFFLE:
  91                         case XMMS_PLAYLIST_CHANGED_CLEAR:
  92                                 playlist->reset();
  93                                 break;
  94                         default:
  95                                 break;
  96                         }
  97                 }
  98                 //xmmsc_result_unref(result);
  99         }
 100
 101         void QPlaylist::fillIDListCallback(xmmsc_result_t * result, void * instance) {
 102                 if (instance) {
 103                         QPlaylist * playlist = static_cast<QPlaylist *>(instance);
 104
 105                         quint32 buffer;
 106
 107                         xmmsc_result_t * i = result;
 108                         while (xmmsc_result_list_valid(i)) {
 109                                 xmmsc_result_get_uint(i, &buffer);
 110                                 playlist->m_IDList << buffer;
 111                                 xmmsc_result_list_next(i);
 112                         }
 113
 114                         emit playlist->reseted();
 115                 }
 116                 //xmmsc_result_unref(result);
 117         }
 118
 119         void QPlaylist::currentPosCallback(xmmsc_result_t * result, void * instance) {
 120                 if (instance) {
 121                         QPlaylist * playlist = static_cast<QPlaylist *>(instance);
 122                         xmmsc_result_get_uint(result, &playlist->m_Position);
 123                         emit playlist->currentChanged(playlist->m_Position);
 124                 }
 125                 //xmmsc_result_unref(result);
 126         }
 127
 128         void QPlaylist::setConnection(xmmsc_connection_t * connection) {
 129                 if (m_Connection == connection)
 130                         return;
 131
 132                 //disconnect
 133                 if (m_Connection) {
 134                         disconnectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection));
 135                         disconnectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection));
 136                         disconnectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection));
 137                 }
 138
 139                 m_Connection = connection;
 140
 141                 m_IDList.clear();
 142                 m_Position = 0;
 143
 144                 //connect
 145                 if (m_Connection) {
 146                         connectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection),      loadedCallback,     this);
 147                         connectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection),     changedCallback,    this);
 148                         connectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection), currentPosCallback, this);
 149
 150                         connectNotifierUnref(xmmsc_playlist_list_entries(m_Connection, NULL), fillIDListCallback, this);
 151                         connectNotifierUnref(xmmsc_playlist_current_pos(m_Connection, NULL), currentPosCallback, this);
 152                 }
 153                 else {
 154                         emit reseted();
 155                         emit currentChanged(0);
 156                 }
 157         }
 158
 159         void QPlaylist::reset() {
 160                 m_IDList.clear();
 161                 emit reseted();
 162                 if (m_Connection) {
 163                         connectNotifierUnref(xmmsc_playlist_list_entries(m_Connection, NULL), fillIDListCallback, this);
 164                         connectNotifierUnref(xmmsc_playlist_current_pos(m_Connection, NULL), currentPosCallback, this);
 165                 }
 166
 167         }
 168
 169         void QPlaylist::append(quint32 id) {
 170                 xmmsc_result_unref(xmmsc_playlist_add_id(m_Connection, NULL, id));
 171         }
 172
 173         void QPlaylist::append(QString url) {
 174                 xmmsc_result_unref(xmmsc_playlist_add_url(m_Connection, NULL, url.toAscii().data()));
 175         }
 176
 177         void QPlaylist::append(QStringList urls) {
 178                 foreach(QString i, urls)
 179                         append(i);
 180         }
 181
 182         void QPlaylist::append(QList<quint32> ids) {
 183                 foreach(quint32 i, ids)
 184                         append(i);
 185         }
 186
 187         void QPlaylist::appendRecursive(QString directory) {
 188                 xmmsc_result_unref(xmmsc_playlist_radd(m_Connection, NULL, directory.toAscii().data()));
 189         }
 190
 191         void QPlaylist::insert(quint32 id, quint32 position) {
 192                 xmmsc_result_unref(xmmsc_playlist_insert_id(m_Connection, NULL, position, id));
 193         }
 194
 195         void QPlaylist::insert(QString url, quint32 position) {
 196                 xmmsc_result_unref(xmmsc_playlist_insert_url(m_Connection, NULL, position, url.toAscii().data()));
 197         }
 198
 199         void QPlaylist::insert(QList<quint32> ids, quint32 position) {
 200                 if (ids.count() == 0)
 201                         return;
 202
 203                 QList<quint32>::iterator i = ids.end();
 204                 do {
 205                         i--;
 206                         insert(*i, position);
 207                 }
 208                 while (i != ids.begin());
 209         }
 210
 211         void QPlaylist::insert(QStringList urls, quint32 position) {
 212                 if (urls.count() == 0)
 213                         return;
 214
 215                 QStringList::iterator i = urls.end();
 216                 do {
 217                         i--;
 218                         insert(*i, position);
 219                 }
 220                 while (i != urls.begin());
 221         }
 222
 223         void QPlaylist::remove(quint32 position) {
 224                 xmmsc_result_unref(xmmsc_playlist_remove_entry(m_Connection, NULL, position));
 225         }
 226
 227         void QPlaylist::move(quint32 from, quint32 to) {
 228                 xmmsc_result_unref(xmmsc_playlist_move_entry(m_Connection, NULL, from, to));
 229         }
 230
 231         void QPlaylist::clear() {
 232                 xmmsc_result_unref(xmmsc_playlist_clear(m_Connection, NULL));
 233         }
 234
 235 /*      void QPlaylist::sort(QStringList properties) {
 236                 xmmsc_result_unref(xmmsc_playlist_sort(m_Connection, "Default"));
 237         }*/
 238
 239         void QPlaylist::randomize() {
 240                 xmmsc_result_unref(xmmsc_playlist_shuffle(m_Connection, NULL));
 241         }
 242
 243         void QPlaylist::setNext(quint32 position) {
 244                 xmmsc_result_unref(xmmsc_playlist_set_next(m_Connection, position));
 245         }
 246 }