void PlaylistPlayer::handlePlayerEnd()
{
if (_currentIndex == _playlist->count() - 1) {
switch(_loop){
case BIGLOOP:
next(); // auto next
play();
break;
case SINGLELOOP:
playItemAt(_currentIndex);
break;
case NOLOOP:
emit end();
break;
default:
break;
}
} else {
switch(_loop){
case BIGLOOP:
next(); // auto next
play();
break;
case SINGLELOOP:
playItemAt(_currentIndex);
break;
case NOLOOP:
next(); // auto next
play();
break;
default:
break;
}
}
}
void PlaylistPlayer::next()
{
if(_mediaPlayer->isStopped() || _mediaPlayer->isPaused()){
if (_currentIndex >= _playlist->count() - 1) {
initItemAt(0);
} else {
initItemAt(++_currentIndex);
}
}
else
{
if (_currentIndex >= _playlist->count() - 1) {
playItemAt(0);
} else {
playItemAt(++_currentIndex);
}
}
}
void PlaylistPlayer::previous()
{
if(_mediaPlayer->isStopped() || _mediaPlayer->isPaused()){
if (_currentIndex == 0) {
initItemAt(_playlist->count() - 1);
} else {
initItemAt(--_currentIndex);
}
}
else
{
if (_currentIndex == 0) {
playItemAt(_playlist->count() - 1);
} else {
playItemAt(--_currentIndex);
}
}
}
void PlaylistPlayer::play()
{
//Creation de la video window si elle n'existe pas
((MainWindow*)this->parent())->needVideoWindow();
// play or resume playback
QModelIndexList indexes = ((MainWindow*)this->parent())->currentPlaylistTableView()->selectionModel()->selectedRows();
// if no selected item play current playlist from first item
if (indexes.count() == 0) {
playItemAt(0);
// play playlist at selected item otherwise
} else {
const int index = indexes.first().row();
playItemAt(index);
}
}
void Playlist::playNext()
{
if (m_mediaObject->state() == Phonon::PlayingState || m_mediaObject->state() == Phonon::PausedState || m_mediaObject->state() == Phonon::LoadingState || m_mediaObject->state() == Phonon::ErrorState) {
//Add currently playing item to history
if (m_queue->rowCount() > 1) {
playItemAt(1, Playlist::QueueModel);
}
}
}
void Playlist::start()
{
m_playlistIndices.clear();
m_playlistIndicesHistory.clear();
m_playlistUrlHistory.clear();
m_queue->clearMediaListData();
for (int i = 0; i < m_currentPlaylist->rowCount(); ++i) {
m_playlistIndices.append(i);
}
if (!m_shuffle) {
orderByPlaylist();
} else {
shuffle();
}
playItemAt(0, Playlist::QueueModel);
}
void Playlist::playPrevious()
{
if (m_mediaObject->state() == Phonon::PlayingState || m_mediaObject->state() == Phonon::PausedState || m_mediaObject->state() == Phonon::LoadingState) {
if (m_playlistIndicesHistory.count() > 0) {
//Get previously played item and remove from history
int previousRow = m_playlistIndicesHistory.last();
m_playlistIndicesHistory.removeLast();
m_playlistUrlHistory.removeLast();
MediaItem previousItem = m_currentPlaylist->mediaItemAt(previousRow);
previousItem.playlistIndex = previousRow;
m_queue->insertMediaItemAt(0, previousItem);
playItemAt(0, Playlist::QueueModel);
}
}
}
void Playlist::insertMediaItemAt(int row, Model model, const MediaItem &mediaItem)
{
if (model == PlaylistModel) {
if (row >= m_currentPlaylist->rowCount()) {
return;
}
m_currentPlaylist->insertMediaItemAt(row, mediaItem, true);
} else {
if (row >= m_queue->rowCount()) {
return;
}
//Update history
int playlistIndex = m_currentPlaylist->rowOfUrl(mediaItem.url);
if (m_playlistIndicesHistory.contains(playlistIndex)) {
m_playlistIndicesHistory.removeAll(playlistIndex);
m_playlistUrlHistory.removeAll(mediaItem.url);
}
if (m_playlistIndices.contains(playlistIndex)) {
m_playlistIndices.removeAll(playlistIndex);
}
//Update Playlist
int playlistRow = -1;
if (m_shuffle) {
m_currentPlaylist->loadMediaItem(mediaItem, false);
playlistRow = m_currentPlaylist->rowCount() - 1;
} else {
MediaItem itemAtRow = m_queue->mediaItemAt(row);
playlistRow = m_currentPlaylist->rowOfUrl(itemAtRow.url);
if (playlistRow != -1) {
m_currentPlaylist->insertMediaItemAt(playlistRow, mediaItem, false);
}
}
//Update queue
MediaItem queueItem = mediaItem;
queueItem.playlistIndex = playlistRow;
m_queue->insertMediaItemAt(row, queueItem);
if (m_queue->rowCount() > m_queueDepth) {
m_queue->removeMediaItemAt(m_queue->rowCount() - 1);
}
if (row == 0 && (m_mediaObject->state() == Phonon::PlayingState ||
m_mediaObject->state() == Phonon::PausedState)) {
playItemAt(0, QueueModel);
}
}
}
void PlaylistPlayer::playPlaylist(Playlist *playlist)
{
setPlaylist(playlist);
playItemAt(0);
}
//--------------------------------
//--- MediaItemModel SLOTS ---
//--------------------------------
void Playlist::playlistChanged()
{
m_state = Playlist::Finished;
if (playWhenPlaylistChanges && m_currentPlaylist->rowCount() > 0) {
//Start playing with clean playlist, queue and history
playWhenPlaylistChanges = false;
if (m_currentPlaylist->mediaItemAt(0).type == "Audio" ||
m_currentPlaylist->mediaItemAt(0).type == "Video") {
start();
} else {
if (m_currentPlaylist->mediaItemAt(0).fields["messageType"].toString() == "No Results") {
m_currentPlaylist->removeMediaItemAt(0,false);
}
m_mediaObject->stop();
emit playlistFinished();
}
} else if (m_currentPlaylist->rowCount() > 0){
//if playlist mode is normal (sequential)
// - rebuild history to just before currently playing/paused url
// - rebuild queue from currently playing item to queue depth
// - rebuild playlist indices using remaining items
if (!m_shuffle) {
int currentRow = 0;
if ((m_mediaObject->state() == Phonon::PlayingState) || (m_mediaObject->state() == Phonon::PausedState)) {
//Starting with the currently playing item, check to see if item
//is in the new playlist. If not continue through the existing queue
//until an item is found in the playlist.
for (int i = 0; i < m_queue->rowCount(); i++) {
QString url = m_queue->mediaItemAt(i).url;
currentRow = m_currentPlaylist->rowOfUrl(url);
if (currentRow != -1) {
break;
}
}
} else {
currentRow = 0;
}
buildQueueFrom(currentRow);
} else {
//if playlist mode is shuffle
// - remove from history any items NOT in the current playlist
// - remove from queue any items NOT in the current playlist
// - rebuild playlist indices using remaining items
// - add items to queu to fill queue depth
QList<QString> oldPlaylistUrlHistory = m_playlistUrlHistory;
m_playlistIndicesHistory.clear();
m_playlistUrlHistory.clear();
for (int i = 0; i < oldPlaylistUrlHistory.count(); i++) {
int rowOfUrl = m_currentPlaylist->rowOfUrl(oldPlaylistUrlHistory.at(i));
if (rowOfUrl != -1) {
m_playlistIndicesHistory.append(rowOfUrl);
m_playlistUrlHistory.append(oldPlaylistUrlHistory.at(i));
}
}
QList<MediaItem> newQueueMediaList;
for (int i = 0; i < m_queue->rowCount(); i++) {
MediaItem mediaItem = m_queue->mediaItemAt(i);
QString urlToSearch = mediaItem.url;
int rowOfUrl = m_currentPlaylist->rowOfUrl(urlToSearch);
if (rowOfUrl != -1) {
newQueueMediaList.append(mediaItem);
}
}
m_queue->clearMediaListData();
m_queue->loadMediaList(newQueueMediaList);
m_playlistIndices.clear();
for (int i = 0; i < m_currentPlaylist->rowCount(); i++) {
if (m_playlistIndicesHistory.indexOf(i) == -1) {
MediaItem mediaItem = m_currentPlaylist->mediaItemAt(i);
QString urlToSearch = mediaItem.url;
int rowInQueue = m_queue->rowOfUrl(urlToSearch);
if (rowInQueue == -1) {
m_playlistIndices.append(i);
}
}
}
for (int i = m_queue->rowCount(); i < m_queueDepth; i++) {
addToQueue();
}
}
//if currently playing url is not at front of queueMediaList
// stop playing and play item at front of queue
if ((m_mediaObject->state() == Phonon::PlayingState) || (m_mediaObject->state() == Phonon::PausedState)) {
if (m_currentUrl != QUrl::fromEncoded(m_queue->mediaItemAt(0).url.toUtf8()).toString()) {
m_mediaObject->stop();
playItemAt(0, Playlist::QueueModel);
}
}
} else { //playlist was cleared
stop();
}
}
