qquickplaylist.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquickplaylist_p.h"
 
QT_BEGIN_NAMESPACE
 
QQuickPlaylistItem::QQuickPlaylistItem(QObject *parent)
    : QObject(parent)
{
}
 
QUrl QQuickPlaylistItem::source() const
{
    return m_source;
}
 
void QQuickPlaylistItem::setSource(const QUrl &source)
{
    m_source = source;
}
 
void QQuickPlaylist::_q_mediaAboutToBeInserted(int start, int end)
{
    emit itemAboutToBeInserted(start, end);
 
    beginInsertRows(QModelIndex(), start, end);
}
 
void QQuickPlaylist::_q_mediaInserted(int start, int end)
{
    endInsertRows();
 
    emit itemCountChanged();
    emit itemInserted(start, end);
}
 
void QQuickPlaylist::_q_mediaAboutToBeRemoved(int start, int end)
{
    emit itemAboutToBeRemoved(start, end);
 
    beginRemoveRows(QModelIndex(), start, end);
}
 
void QQuickPlaylist::_q_mediaRemoved(int start, int end)
{
    endRemoveRows();
 
    emit itemCountChanged();
    emit itemRemoved(start, end);
}
 
void QQuickPlaylist::_q_mediaChanged(int start, int end)
{
    emit dataChanged(createIndex(start, 0), createIndex(end, 0));
    emit itemChanged(start, end);
}
 
void QQuickPlaylist::_q_loadFailed()
{
    m_error = m_playlist->error();
    m_errorString = m_playlist->errorString();
 
    emit error(Error(m_error), m_errorString);
    emit errorChanged();
    emit loadFailed();
}
 
QQuickPlaylist::QQuickPlaylist(QObject *parent)
    : QAbstractListModel(parent)
    , m_playlist(nullptr)
    , m_error(QMediaPlaylist::NoError)
{
}
 
QQuickPlaylist::~QQuickPlaylist()
{
    delete m_playlist;
}
 
QQuickPlaylist::PlaybackMode QQuickPlaylist::playbackMode() const
{
    return PlaybackMode(m_playlist->playbackMode());
}
 
void QQuickPlaylist::setPlaybackMode(PlaybackMode mode)
{
    if (playbackMode() == mode)
        return;
 
    m_playlist->setPlaybackMode(QMediaPlaylist::PlaybackMode(mode));
}
 
QUrl QQuickPlaylist::currentItemSource() const
{
    return m_playlist->currentMedia();
}
 
int QQuickPlaylist::currentIndex() const
{
    return m_playlist->currentIndex();
}
 
void QQuickPlaylist::setCurrentIndex(int index)
{
    if (currentIndex() == index)
        return;
 
    m_playlist->setCurrentIndex(index);
}
 
int QQuickPlaylist::itemCount() const
{
    return m_playlist->mediaCount();
}
 
QQuickPlaylist::Error QQuickPlaylist::error() const
{
    return Error(m_error);
}
 
QString QQuickPlaylist::errorString() const
{
    return m_errorString;
}
 
QUrl QQuickPlaylist::itemSource(int index)
{
    return m_playlist->media(index);
}
 
int QQuickPlaylist::nextIndex(int steps)
{
    return m_playlist->nextIndex(steps);
}
 
int QQuickPlaylist::previousIndex(int steps)
{
    return m_playlist->previousIndex(steps);
}
 
void QQuickPlaylist::next()
{
    m_playlist->next();
}
 
void QQuickPlaylist::previous()
{
    m_playlist->previous();
}
 
void QQuickPlaylist::shuffle()
{
    m_playlist->shuffle();
}
 
void QQuickPlaylist::load(const QUrl &location, const QString &format)
{
    m_error = QMediaPlaylist::NoError;
    m_errorString = QString();
    emit errorChanged();
    m_playlist->load(location, format.toLatin1().constData());
}
 
bool QQuickPlaylist::save(const QUrl &location, const QString &format)
{
    return m_playlist->save(location, format.toLatin1().constData());
}
 
void QQuickPlaylist::addItem(const QUrl &source)
{
    m_playlist->addMedia(QUrl(source));
}
 
void QQuickPlaylist::addItems(const QList<QUrl> &sources)
{
    if (sources.isEmpty())
        return;
 
    QList<QUrl> contents;
    QList<QUrl>::const_iterator it = sources.constBegin();
    while (it != sources.constEnd()) {
        contents.push_back(QUrl(*it));
        ++it;
    }
    m_playlist->addMedia(contents);
}
 
bool QQuickPlaylist::insertItem(int index, const QUrl &source)
{
    return m_playlist->insertMedia(index, QUrl(source));
}
 
bool QQuickPlaylist::insertItems(int index, const QList<QUrl> &sources)
{
    if (sources.empty())
        return false;
 
    QList<QUrl> contents;
    QList<QUrl>::const_iterator it = sources.constBegin();
    while (it != sources.constEnd()) {
        contents.push_back(QUrl(*it));
        ++it;
    }
    return m_playlist->insertMedia(index, contents);
}
 
bool QQuickPlaylist::moveItem(int from, int to)
{
    return m_playlist->moveMedia(from, to);
}
 
bool QQuickPlaylist::removeItem(int index)
{
    return m_playlist->removeMedia(index);
}
 
bool QQuickPlaylist::removeItems(int start, int end)
{
    return m_playlist->removeMedia(start, end);
}
 
void QQuickPlaylist::clear()
{
    m_playlist->clear();
}
 
int QQuickPlaylist::rowCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return 0;
 
    return m_playlist->mediaCount();
}
 
QVariant QQuickPlaylist::data(const QModelIndex &index, int role) const
{
    Q_UNUSED(role);
 
    if (!index.isValid())
        return QVariant();
 
    return m_playlist->media(index.row());
}
 
QHash<int, QByteArray> QQuickPlaylist::roleNames() const
{
    QHash<int, QByteArray> roleNames;
    roleNames[SourceRole] = "source";
    return roleNames;
}
 
void QQuickPlaylist::classBegin()
{
    m_playlist = new QMediaPlaylist(this);
 
    connect(m_playlist, SIGNAL(currentIndexChanged(int)),
            this, SIGNAL(currentIndexChanged()));
    connect(m_playlist, SIGNAL(playbackModeChanged(QMediaPlaylist::PlaybackMode)),
            this, SIGNAL(playbackModeChanged()));
    connect(m_playlist, SIGNAL(currentMediaChanged(QUrl)),
            this, SIGNAL(currentItemSourceChanged()));
    connect(m_playlist, SIGNAL(mediaAboutToBeInserted(int,int)),
            this, SLOT(_q_mediaAboutToBeInserted(int,int)));
    connect(m_playlist, SIGNAL(mediaInserted(int,int)),
            this, SLOT(_q_mediaInserted(int,int)));
    connect(m_playlist, SIGNAL(mediaAboutToBeRemoved(int,int)),
            this, SLOT(_q_mediaAboutToBeRemoved(int,int)));
    connect(m_playlist, SIGNAL(mediaRemoved(int,int)),
            this, SLOT(_q_mediaRemoved(int,int)));
    connect(m_playlist, SIGNAL(mediaChanged(int,int)),
            this, SLOT(_q_mediaChanged(int,int)));
    connect(m_playlist, SIGNAL(loaded()),
            this, SIGNAL(loaded()));
    connect(m_playlist, SIGNAL(loadFailed()),
            this, SLOT(_q_loadFailed()));
}
 
void QQuickPlaylist::componentComplete()
{
}
 
QT_END_NAMESPACE
 
#include "moc_qquickplaylist_p.cpp"