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