playback.cpp

   1 //
   2 // C++ Implementation: playback
   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 "playback.h"
  10 #include "client.h"
  11
  12 namespace XmmsQt {
  13         QPlayback::QPlayback(QClient * parent) : QObject(parent), m_Connection(0) {
  14                 connect(parent, SIGNAL(connectionChanged(xmmsc_connection_t *)),
  15                         this,   SLOT(setConnection(xmmsc_connection_t *)));
  16                 if (parent->isConnectedToServer())
  17                         setConnection(parent->connection());
  18                 else
  19                         m_Connection = NULL;
  20         }
  21
  22         QPlayback::~QPlayback() {
  23         }
  24
  25         void QPlayback::setVolumeChannel(const void * key, xmmsc_result_value_type_t, const void * value, void * instance) {
  26                 QPlayback * playback = static_cast<QPlayback *>(instance);
  27                 if (playback) {
  28                         QString hashKey((const char *)key);
  29                         quint32 volume = XPOINTER_TO_INT(value);
  30                         if (playback->m_Volume.contains(hashKey))
  31                                 playback->m_Volume[hashKey] = volume;
  32                         else
  33                                 playback->m_Volume.insert(hashKey, volume);
  34                 }
  35         }
  36
  37         //callback for the "volume changed"-broadcast
  38         void QPlayback::volumeCallback(xmmsc_result_t * result, void * instance) {
  39                 if (instance) {
  40                         QPlayback * playback = static_cast<QPlayback *>(instance);
  41                         xmmsc_result_dict_foreach(result, setVolumeChannel, instance);
  42                         emit playback->volumeChanged();
  43                 }
  44                 //xmmsc_result_unref(result);
  45         }
  46
  47         //callback for the "status changed"-broadcast
  48         void QPlayback::statusCallback(xmmsc_result_t * result, void * instance) {
  49                 if (instance) {
  50                         QPlayback * playback = static_cast<QPlayback *>(instance);
  51                         xmmsc_result_get_uint(result, (quint32 *)(&playback->m_Status));
  52                         emit playback->statusChanged(playback->m_Status);
  53                 }
  54                 //xmmsc_result_unref(result);
  55         }
  56
  57         //callback for the "id changed"-broadcast
  58         void QPlayback::idCallback(xmmsc_result_t * result, void * instance) {
  59                 if (instance) {
  60                         QPlayback * playback = static_cast<QPlayback *>(instance);
  61                         xmmsc_result_get_uint(result, &playback->m_CurrentID);
  62                         emit playback->idChanged(playback->m_CurrentID);
  63                 }
  64                 //xmmsc_result_unref(result);
  65         }
  66
  67         //callback for the "play time changed"-signal
  68         void QPlayback::playTimeCallback(xmmsc_result_t * result, void * instance) {
  69                 if (instance) {
  70                         QPlayback * playback = static_cast<QPlayback *>(instance);
  71                         quint32 time;
  72                         xmmsc_result_get_uint(result, &time);
  73                         xmmsc_result_unref(xmmsc_result_restart(result));
  74                         emit playback->playTimeChanged(time);
  75                 }
  76                 xmmsc_result_unref(result);
  77         }
  78
  79         void QPlayback::reset() {
  80                 if (m_Connection) {
  81                         connectNotifierUnref(xmmsc_playback_volume_get(m_Connection), volumeCallback,   this);
  82                         connectNotifierUnref(xmmsc_playback_current_id(m_Connection), idCallback,       this);
  83                         connectNotifierUnref(xmmsc_playback_status(m_Connection),     statusCallback,   this);
  84                 }
  85         }
  86
  87         void QPlayback::setConnection(xmmsc_connection_t * connection) {
  88                 if (m_Connection == connection)
  89                         return;
  90
  91                 m_Volume.clear();
  92
  93                 //disconnect
  94                 if (m_Connection) {
  95                         disconnectNotifierUnref(xmmsc_broadcast_playback_volume_changed(m_Connection));
  96                         disconnectNotifierUnref(xmmsc_broadcast_playback_current_id(m_Connection));
  97                         disconnectNotifierUnref(xmmsc_broadcast_playback_status(m_Connection));
  98                         disconnectNotifierUnref(xmmsc_signal_playback_playtime(m_Connection));
  99                 }
 100
 101                 m_Connection = connection;
 102                 m_CurrentID = 0;
 103                 m_Status = XMMS_PLAYBACK_STATUS_STOP;
 104
 105                 //connect
 106                 if (m_Connection) {
 107                         connectNotifierUnref(xmmsc_broadcast_playback_volume_changed(m_Connection), volumeCallback,   this);
 108                         connectNotifierUnref(xmmsc_broadcast_playback_current_id(m_Connection),     idCallback,       this);
 109                         connectNotifierUnref(xmmsc_broadcast_playback_status(m_Connection),         statusCallback,   this);
 110                         connectNotifierUnref(xmmsc_signal_playback_playtime(m_Connection),          playTimeCallback, this);
 111
 112                         connectNotifierUnref(xmmsc_playback_volume_get(m_Connection), volumeCallback,   this);
 113                         connectNotifierUnref(xmmsc_playback_current_id(m_Connection), idCallback,       this);
 114                         connectNotifierUnref(xmmsc_playback_status(m_Connection),     statusCallback,   this);
 115                 }
 116                 else {
 117                         emit idChanged(0);
 118                         emit volumeChanged();
 119                         emit statusChanged(XMMS_PLAYBACK_STATUS_STOP);
 120                 }
 121         }
 122
 123         void QPlayback::start() {
 124                 xmmsc_result_unref(xmmsc_playback_start(m_Connection));
 125         }
 126
 127         void QPlayback::pause() {
 128                 xmmsc_result_unref(xmmsc_playback_pause(m_Connection));
 129         }
 130
 131         void QPlayback::stop() {
 132                 xmmsc_result_unref(xmmsc_playback_stop(m_Connection));
 133         }
 134
 135         void QPlayback::tickle() {
 136                 xmmsc_result_unref(xmmsc_playback_tickle(m_Connection));
 137         }
 138
 139         void QPlayback::setVolume(int volume, QString channel) {
 140                 if (channel.isEmpty()) {
 141                         foreach(QString i, m_Volume.keys())
 142                                 xmmsc_result_unref(xmmsc_playback_volume_set(m_Connection, i.toAscii().data(), volume));
 143                 }
 144                 else
 145                         xmmsc_result_unref(xmmsc_playback_volume_set(m_Connection, channel.toAscii().data(), volume));
 146         }
 147
 148         void QPlayback::setNext(quint32 position) {
 149                 xmmsc_result_unref(xmmsc_playlist_set_next(m_Connection, position));
 150         }
 151 }