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