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 *, void * instance) {
  22                 if (instance) {
  23                         emit static_cast<QPlaylist *>(instance)->loaded();
  24                 }
  25         }
  26
  27         void QPlaylist::changedCallback(xmmsc_result_t * result, void * instance) {
  28                 if (instance) {
  29                         QPlaylist * playlist = static_cast<QPlaylist *>(instance);
  30                         xmms_playlist_changed_actions_t type;
  31                         xmmsc_result_get_dict_entry_uint(result, "type", (quint32 *)(&type));
  32
  33                         switch (type) {
  34                         case XMMS_PLAYLIST_CHANGED_ADD:
  35                                 emit playlist->entryAppended();
  36                                 break;
  37                         case XMMS_PLAYLIST_CHANGED_INSERT:
  38                                 {
  39                                         const char * name;
  40                                         quint32 position, id;
  41
  42                                         xmmsc_result_get_dict_entry_string(result, "name", &name);
  43                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  44                                         xmmsc_result_get_dict_entry_uint(result, "id", &id);
  45                                         emit playlist->entryInserted(position, QString(name), id);
  46                                 }
  47                                 break;
  48                         case XMMS_PLAYLIST_CHANGED_UPDATE:
  49                                 {
  50                                         const char * name;
  51                                         quint32 position;
  52
  53                                         xmmsc_result_get_dict_entry_string(result, "name", &name);
  54                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  55                                         emit playlist->entryUpdated(position, QString(name));
  56                                 }
  57                                 break;
  58                         case XMMS_PLAYLIST_CHANGED_REMOVE:
  59                                 {
  60                                         quint32 position;
  61
  62                                         xmmsc_result_get_dict_entry_uint(result, "position", &position);
  63                                         emit playlist->entryRemoved(position);
  64                                 }
  65                                 break;
  66                         case XMMS_PLAYLIST_CHANGED_MOVE:
  67                                 {
  68                                         quint32 from, to;
  69
  70                                         xmmsc_result_get_dict_entry_uint(result, "position", &from);
  71                                         xmmsc_result_get_dict_entry_uint(result, "newpositionp", &from);
  72                                         emit playlist->entryMoved(from, to);
  73                                 }
  74                                 break;
  75                         case XMMS_PLAYLIST_CHANGED_SORT:
  76                         case XMMS_PLAYLIST_CHANGED_SHUFFLE:
  77                                 emit playlist->sortingChanged();
  78                                 break;
  79                         case XMMS_PLAYLIST_CHANGED_CLEAR:
  80                                 emit playlist->cleared();
  81                                 break;
  82                         default:
  83                                 break;
  84                         }
  85                 }
  86         }
  87
  88         void QPlaylist::currentPosCallback(xmmsc_result_t * result, void * instance) {
  89                 if (instance) {
  90                         quint32 position;
  91
  92                         xmmsc_result_get_uint(result, &position);
  93                         emit static_cast<QPlaylist *>(instance)->currentChanged(position);
  94                 }
  95         }
  96
  97         void QPlaylist::setConnection(xmmsc_connection_t * connection) {
  98                 if (m_Connection == connection)
  99                         return;
 100
 101                 //disconnect
 102                 if (m_Connection) {
 103                         disconnectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection));
 104                         disconnectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection));
 105                         disconnectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection));
 106                 }
 107
 108                 m_Connection = connection;
 109
 110                 //connect
 111                 if (m_Connection) {
 112                         connectNotifierUnref(xmmsc_broadcast_playlist_loaded(m_Connection),      &loadedCallback,     this);
 113                         connectNotifierUnref(xmmsc_broadcast_playlist_changed(m_Connection),     &changedCallback,    this);
 114                         connectNotifierUnref(xmmsc_broadcast_playlist_current_pos(m_Connection), &currentPosCallback, this);
 115                 }
 116         }
 117
 118         void QPlaylist::append(quint32 id) {
 119                 xmmsc_result_unref(xmmsc_playlist_add_id(m_Connection, "Default", id));
 120         }
 121
 122         void QPlaylist::append(QString url) {
 123                 xmmsc_result_unref(xmmsc_playlist_add_url(m_Connection, "Default", url.toAscii().data()));
 124         }
 125
 126         void QPlaylist::append(QStringList urls) {
 127                 foreach(QString i, urls)
 128                         append(i);
 129         }
 130
 131         void QPlaylist::append(QList<quint32> ids) {
 132                 foreach(quint32 i, ids)
 133                         append(i);
 134         }
 135
 136         void QPlaylist::appendRecursive(QString directory) {
 137                 xmmsc_result_unref(xmmsc_playlist_radd(m_Connection, "Default", directory.toAscii().data()));
 138         }
 139
 140         void QPlaylist::insert(quint32 id, quint32 position) {
 141                 xmmsc_result_unref(xmmsc_playlist_insert_id(m_Connection, "Default", position, id));
 142         }
 143
 144         void QPlaylist::insert(QString url, quint32 position) {
 145                 xmmsc_result_unref(xmmsc_playlist_insert_url(m_Connection, "Default", position, url.toAscii().data()));
 146         }
 147
 148         void QPlaylist::insert(QList<quint32> ids, quint32 position) {
 149                 if (ids.count() == 0)
 150                         return;
 151
 152                 QList<quint32>::iterator i = ids.end();
 153                 do {
 154                         i--;
 155                         insert(*i, position);
 156                 }
 157                 while (i != ids.begin());
 158         }
 159
 160         void QPlaylist::insert(QStringList urls, quint32 position) {
 161                 if (urls.count() == 0)
 162                         return;
 163
 164                 QStringList::iterator i = urls.end();
 165                 do {
 166                         i--;
 167                         insert(*i, position);
 168                 }
 169                 while (i != urls.begin());
 170         }
 171
 172         void QPlaylist::remove(quint32 position) {
 173                 xmmsc_result_unref(xmmsc_playlist_remove_entry(m_Connection, "Default", position));
 174         }
 175
 176         void QPlaylist::move(quint32 from, quint32 to) {
 177                 xmmsc_result_unref(xmmsc_playlist_move_entry(m_Connection, "Default", from, to));
 178         }
 179
 180         void QPlaylist::clear() {
 181                 xmmsc_result_unref(xmmsc_playlist_clear(m_Connection, "Default"));
 182         }
 183
 184 /*      void QPlaylist::sort(QStringList properties) {
 185                 xmmsc_result_unref(xmmsc_playlist_sort(m_Connection, "Default"));
 186         }*/
 187
 188         void QPlaylist::shuffle() {
 189                 xmmsc_result_unref(xmmsc_playlist_shuffle(m_Connection, "Default"));
 190         }
 191 }