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