playlistmodel.cpp

   1 //
   2 // C++ Implementation: playlistmodel
   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 "playlistmodel.h"
   9 #include "common.h"
  10 #include <QIcon>
  11
  12 namespace musique {
  13         using namespace XmmsQt;
  14
  15         CPlaylistModel::CPlaylistModel(QPlayback * playback, QMedialib * medialib, QObject * parent) : QAbstractItemModel(parent),
  16         m_Playlist(0), m_Medialib(medialib), m_Playback(playback), m_OldPosition(0) {
  17         }
  18
  19         CPlaylistModel::~CPlaylistModel() {
  20         }
  21
  22         void CPlaylistModel::setPlaylist(XmmsQt::QPlaylist * playlist) {
  23                 if (m_Playlist == playlist)
  24                         return;
  25
  26                 if (m_Playlist) {
  27                         disconnect(m_Playlist, SIGNAL(entryAboutToBeInserted(quint32, quint32)),
  28                                    this,       SLOT(prepareToInsertEntry(quint32, quint32)));
  29                         disconnect(m_Playlist, SIGNAL(entryInserted(quint32)),
  30                                    this,       SLOT(insertEntry(quint32)));
  31
  32                         disconnect(m_Playlist, SIGNAL(entryAboutToBeRemoved(quint32, quint32)),
  33                                    this,       SLOT(prepareToRemoveEntry(quint32, quint32)));
  34                         disconnect(m_Playlist, SIGNAL(entryRemoved(quint32)),
  35                                    this,       SLOT(removeEntry(quint32)));
  36
  37                         disconnect(m_Playlist, SIGNAL(entryMoved(quint32, quint32)),
  38                                    this,       SLOT(moveEntry(quint32, quint32)));
  39                         disconnect(m_Playlist, SIGNAL(entryUpdated(quint32, quint32)),
  40                                    this,       SLOT(updateEntry(quint32)));
  41                         disconnect(m_Medialib, SIGNAL(mediaInfoReady(quint32)),
  42                                    this,       SLOT(updateEntriesByID(quint32)));
  43                         disconnect(m_Playlist, SIGNAL(reseted()),
  44                                    this,       SLOT(reloadMediaInfo()));
  45                         disconnect(m_Playlist, SIGNAL(positionChanged(quint32)),
  46                                    this,       SLOT(updatePosition(quint32)));
  47                 }
  48
  49                 m_Playlist = playlist;
  50
  51                 if (m_Playlist) {
  52                         connect(m_Playlist, SIGNAL(entryAboutToBeInserted(quint32, quint32)),
  53                                 this,       SLOT(prepareToInsertEntry(quint32, quint32)));
  54                         connect(m_Playlist, SIGNAL(entryInserted(quint32)),
  55                                 this,       SLOT(insertEntry(quint32)));
  56
  57                         connect(m_Playlist, SIGNAL(entryAboutToBeRemoved(quint32, quint32)),
  58                                 this,       SLOT(prepareToRemoveEntry(quint32, quint32)));
  59                         connect(m_Playlist, SIGNAL(entryRemoved(quint32)),
  60                                 this,       SLOT(removeEntry(quint32)));
  61
  62                         connect(m_Playlist, SIGNAL(entryMoved(quint32, quint32)),
  63                                 this,       SLOT(moveEntry(quint32, quint32)));
  64                         connect(m_Playlist, SIGNAL(entryUpdated(quint32, quint32)),
  65                                 this,       SLOT(updateEntry(quint32)));
  66                         connect(m_Medialib, SIGNAL(mediaInfoReady(quint32)),
  67                                 this,       SLOT(updateEntriesByID(quint32)));
  68                         connect(m_Playlist, SIGNAL(reseted()),
  69                                 this,       SLOT(reloadMediaInfo()));
  70
  71                         connect(m_Playlist, SIGNAL(positionChanged(quint32)),
  72                                    this,       SLOT(updatePosition(quint32)));
  73
  74                         reloadMediaInfo();
  75                 }
  76                 else
  77                         emit layoutChanged();
  78         }
  79
  80         void CPlaylistModel::prepareToInsertEntry(quint32 position, quint32 id) {
  81                 beginInsertRows(QModelIndex(), position, position);
  82                 //m_Medialib->checkMediaInfo(id);
  83         }
  84
  85         void CPlaylistModel::insertEntry(quint32 position) {
  86                 endInsertRows();
  87         }
  88
  89         void CPlaylistModel::prepareToRemoveEntry(quint32 position, quint32 id) {
  90                 beginRemoveRows(QModelIndex(), position, position);
  91                 //m_Medialib->removeMediaInfo(id);
  92         }
  93
  94         void CPlaylistModel::removeEntry(quint32 position) {
  95                 endRemoveRows();
  96         }
  97
  98         void CPlaylistModel::moveEntry(quint32 from, quint32 to) {
  99                 emit dataChanged(index(from, 0), index(to, columnCount()));
 100         }
 101
 102         void CPlaylistModel::updateEntry(quint32 position) {
 103                 emit dataChanged(index(position, 0), index(position, columnCount()));
 104                 quint32 id = m_Playlist->idList()[position];
 105                 m_Medialib->checkMediaInfo(id);
 106         }
 107
 108         void CPlaylistModel::updatePosition(quint32 position) {
 109                 emit dataChanged(index(m_OldPosition, 0), index(m_OldPosition, columnCount()));
 110                 m_OldPosition = position;
 111                 emit dataChanged(index(m_OldPosition, 0), index(m_OldPosition, columnCount()));
 112         }
 113
 114         void CPlaylistModel::updateEntriesByID(quint32 id) {
 115                 for(quint32 i = 0; i < m_Playlist->idList().count(); i++){
 116                         if (m_Playlist->idList()[i] == id)
 117                                 emit dataChanged(index(i, 0), index(i, columnCount()));
 118                 }
 119         }
 120
 121         void CPlaylistModel::reloadMediaInfo() {
 122                 foreach(quint32 i, m_Playlist->idList()) {
 123                         m_Medialib->checkMediaInfo(i);
 124                 }
 125                 emit layoutChanged();
 126         }
 127
 128         QVariant CPlaylistModel::data(const QModelIndex & index, int role) const {
 129                 if (!index.isValid())
 130                         return QVariant();
 131
 132                 if ((role == Qt::DecorationRole) && (index.column() == MQ_PLAYLIST_STATUS) &&
 133                         (index.row() == m_Playlist->position())) {
 134 /*                      if ((m_Playlist == m_Medialib->activePlaylist()) && (index.internalId() == m_Playback->currentID()))
 135                                 return QIcon(UI_ICON_NOWPLAYING);
 136                         else*/
 137                                 return QIcon(UI_ICON_POSITION);
 138                 }
 139
 140                 if (role != Qt::DisplayRole)
 141                         return QVariant();
 142
 143                 quint32 id = index.internalId();
 144
 145                 if (m_Medialib->media().contains(id)) {
 146                         MediaInfo * data = m_Medialib->media()[id];
 147                         switch (index.column()) {
 148                         case MQ_PLAYLIST_TITLE:
 149                                 return data->title;
 150                         case MQ_PLAYLIST_ARTIST:
 151                                 return data->artist;
 152                         case MQ_PLAYLIST_DURATION:
 153                                 return formatedTime(data->duration);
 154                         default:
 155                                 break;
 156                         }
 157                 }
 158                 else {
 159                         switch (index.column()) {
 160                         case MQ_PLAYLIST_TITLE:
 161                                 return tr("unknown (id: %1)").arg(id);
 162                         case MQ_PLAYLIST_ARTIST:
 163                                 return tr("unknown");
 164                         case MQ_PLAYLIST_DURATION:
 165                                 return QString("--:--");
 166                         default:
 167                                 break;
 168                         }
 169                 }
 170
 171                 return QVariant();
 172         }
 173
 174         Qt::ItemFlags CPlaylistModel::flags(const QModelIndex & index) const {
 175                 if (!index.isValid())
 176                         return 0;
 177
 178                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 179         }
 180
 181         QVariant CPlaylistModel::headerData(int section, Qt::Orientation orientation, int role) const {
 182                 if (role != Qt::DisplayRole)
 183                         return QVariant();
 184
 185                 if (orientation == Qt::Horizontal) {
 186                         switch (section) {
 187                         case MQ_PLAYLIST_TITLE:
 188                                 return tr("Title");
 189                         case MQ_PLAYLIST_ARTIST:
 190                                 return tr("Artist");
 191                         case MQ_PLAYLIST_DURATION:
 192                                 return tr("Time");
 193                         default:
 194                                 break;
 195                         }
 196                 }
 197                 return QVariant();
 198         }
 199
 200         QModelIndex CPlaylistModel::index(int row, int column, const QModelIndex & parent) const {
 201                 if (!m_Playlist || parent.isValid() || m_Playlist->idList().isEmpty() || row >= m_Playlist->idList().count())
 202                         return QModelIndex();
 203                 else
 204                         return createIndex(row, column, m_Playlist->idList()[row]);
 205         }
 206
 207         QModelIndex CPlaylistModel::parent(const QModelIndex & index) const {
 208                 return QModelIndex();
 209         }
 210
 211         int CPlaylistModel::rowCount(const QModelIndex & parent) const {
 212                 if (!m_Playlist || parent.isValid())
 213                         return 0;
 214                 else
 215                         return m_Playlist->idList().count();
 216         }
 217
 218         int CPlaylistModel::columnCount(const QModelIndex & parent) const {
 219                 return 4;
 220         }
 221 }