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
  11 namespace musique {
  12         using namespace XmmsQt;
  13
  14         CPlaylistModel::CPlaylistModel(XmmsQt::QPlaylist * playlist, XmmsQt::QMedialib * medialib, QObject * parent) : QAbstractItemModel(parent),
  15         m_Playlist(playlist), m_Medialib(medialib) {
  16                 if (m_Playlist) {
  17                         connect(m_Playlist, SIGNAL(entryAboutToBeInserted(quint32, quint32)),
  18                                 this,       SLOT(prepareToInsertEntry(quint32, quint32)));
  19                         connect(m_Playlist, SIGNAL(entryInserted(quint32)),
  20                                 this,       SLOT(insertEntry(quint32)));
  21
  22                         connect(m_Playlist, SIGNAL(entryAboutToBeRemoved(quint32, quint32)),
  23                                 this,       SLOT(prepareToRemoveEntry(quint32, quint32)));
  24                         connect(m_Playlist, SIGNAL(entryRemoved(quint32)),
  25                                 this,       SLOT(removeEntry(quint32)));
  26
  27                         connect(m_Playlist, SIGNAL(entryMoved(quint32, quint32)),
  28                                 this,       SLOT(moveEntry(quint32, quint32)));
  29                         connect(m_Playlist, SIGNAL(entryUpdated(quint32, quint32)),
  30                                 this,       SLOT(updateEntry(quint32, quint32)));
  31                         connect(m_Medialib, SIGNAL(mediaInfoReady(quint32)),
  32                                 this,       SLOT(updateEntriesByID(quint32)));
  33                         connect(m_Playlist, SIGNAL(reseted()),
  34                                 this,       SLOT(reloadMediaInfo()));
  35                 }
  36         }
  37
  38         CPlaylistModel::~CPlaylistModel() {
  39         }
  40
  41         void CPlaylistModel::prepareToInsertEntry(quint32 position, quint32 id) {
  42                 beginInsertRows(QModelIndex(), position, position);
  43                 if (!m_Medialib->media().contains(id))
  44                         m_Medialib->requestMediaInfo(id);
  45         }
  46
  47         void CPlaylistModel::insertEntry(quint32 position) {
  48                 endInsertRows();
  49         }
  50
  51         void CPlaylistModel::prepareToRemoveEntry(quint32 position, quint32 id) {
  52                 beginRemoveRows(QModelIndex(), position, position);
  53                 m_Medialib->removeMediaInfo(id);
  54         }
  55
  56         void CPlaylistModel::removeEntry(quint32 position) {
  57                 endRemoveRows();
  58         }
  59
  60         void CPlaylistModel::moveEntry(quint32 from, quint32 to) {
  61                 emit dataChanged(index(from, 0), index(to, columnCount()));
  62         }
  63
  64         void CPlaylistModel::updateEntry(quint32 position, quint32 oldid) {
  65                 //m_Medialib->removeMediaInfo(oldid);
  66                 emit dataChanged(index(position, 0), index(position, columnCount()));
  67                 quint32 id = m_Playlist->idList()[position];
  68                 m_Medialib->checkMediaInfo(id);
  69         }
  70
  71         void CPlaylistModel::updateEntriesByID(quint32 id) {
  72                 for(quint32 i = 0; i < m_Playlist->idList().count(); i++){
  73                         if (m_Playlist->idList()[i] == id)
  74                                 emit dataChanged(index(i, 0), index(i, columnCount()));
  75                 }
  76         }
  77
  78         void CPlaylistModel::reloadMediaInfo() {
  79                 //m_Medialib->clearMediaInfo();
  80                 foreach(quint32 i, m_Playlist->idList()) {
  81                         m_Medialib->requestMediaInfo(i);
  82                 }
  83                 emit layoutChanged();
  84         }
  85
  86         QVariant CPlaylistModel::data(const QModelIndex & index, int role) const {
  87                 if (!index.isValid())
  88                         return QVariant();
  89
  90                 //TODO: entry icon
  91 /*              if ((role == Qt::DecorationRole) && (index.column() == 0))
  92                         return QIcon();*/
  93
  94                 if (role != Qt::DisplayRole)
  95                         return QVariant();
  96
  97                 quint32 id = index.internalId();
  98
  99                 if (m_Medialib->media().contains(id)) {
 100                         MediaInfo * data = m_Medialib->media()[id];
 101                         switch (index.column()) {
 102                         case MQ_PLAYLIST_TITLE:
 103                                 return data->title;
 104                         case MQ_PLAYLIST_ARTIST:
 105                                 return data->artist;
 106                         case MQ_PLAYLIST_DURATION:
 107                                 return formatedTime(data->duration);
 108                         default:
 109                                 break;
 110                         }
 111                 }
 112                 else {
 113                         switch (index.column()) {
 114                         case MQ_PLAYLIST_TITLE:
 115                                 return tr("unknown (id: %1)").arg(id);
 116                         case MQ_PLAYLIST_ARTIST:
 117                                 return tr("unknown");
 118                         case MQ_PLAYLIST_DURATION:
 119                                 return QString("--:--");
 120                         default:
 121                                 break;
 122                         }
 123                 }
 124
 125                 return QVariant();
 126         }
 127
 128         Qt::ItemFlags CPlaylistModel::flags(const QModelIndex & index) const {
 129                 if (!index.isValid())
 130                         return 0;
 131
 132                 return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 133         }
 134
 135         QVariant CPlaylistModel::headerData(int section, Qt::Orientation orientation, int role) const {
 136                 if (role != Qt::DisplayRole)
 137                         return QVariant();
 138
 139                 if (orientation == Qt::Horizontal) {
 140                         switch (section) {
 141                         case MQ_PLAYLIST_TITLE:
 142                                 return tr("Title");
 143                         case MQ_PLAYLIST_ARTIST:
 144                                 return tr("Artist");
 145                         case MQ_PLAYLIST_DURATION:
 146                                 return tr("Time");
 147                         default:
 148                                 break;
 149                         }
 150                 }
 151                 return QVariant();
 152         }
 153
 154         QModelIndex CPlaylistModel::index(int row, int column, const QModelIndex & parent) const {
 155                 if (m_Playlist->idList().isEmpty() || parent.isValid() || row >= m_Playlist->idList().count())
 156                         return QModelIndex();
 157                 else
 158                         return createIndex(row, column, m_Playlist->idList()[row]);
 159         }
 160
 161         QModelIndex CPlaylistModel::parent(const QModelIndex & index) const {
 162                 return QModelIndex();
 163         }
 164
 165         int CPlaylistModel::rowCount(const QModelIndex & parent) const {
 166                 if (parent.isValid())
 167                         return 0;
 168                 else
 169                         return m_Playlist->idList().count();
 170         }
 171
 172         int CPlaylistModel::columnCount(const QModelIndex & parent) const {
 173                 return 3;
 174         }
 175 }