qquickanimatedimage.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 "qquickanimatedimage_p.h"
#include "qquickanimatedimage_p_p.h"
 
#include <QtGui/qguiapplication.h>
#include <QtQml/qqmlinfo.h>
#include <QtQml/qqmlfile.h>
#include <QtQml/qqmlengine.h>
#include <QtGui/qmovie.h>
#if QT_CONFIG(qml_network)
#include <QtNetwork/qnetworkrequest.h>
#include <QtNetwork/qnetworkreply.h>
#endif
 
QT_BEGIN_NAMESPACE
 
QQuickPixmap* QQuickAnimatedImagePrivate::infoForCurrentFrame(QQmlEngine *engine)
{
    if (!movie)
        return nullptr;
 
    int current = movie->currentFrameNumber();
    if (!frameMap.contains(current)) {
        QUrl requestedUrl;
        QQuickPixmap *pixmap = nullptr;
        if (engine && !movie->fileName().isEmpty()) {
            requestedUrl.setUrl(QString::fromUtf8("quickanimatedimage://%1#%2x%3#%4")
                                .arg(movie->fileName())
                                .arg(movie->scaledSize().width())
                                .arg(movie->scaledSize().height())
                                .arg(current));
        }
        if (!requestedUrl.isEmpty()) {
            if (QQuickPixmap::isCached(requestedUrl, QRect(), QSize(), 0, QQuickImageProviderOptions()))
                pixmap = new QQuickPixmap(engine, requestedUrl);
            else
                pixmap = new QQuickPixmap(requestedUrl, movie->currentImage());
        } else {
            pixmap = new QQuickPixmap;
            pixmap->setImage(movie->currentImage());
        }
        frameMap.insert(current, pixmap);
    }
 
    return frameMap.value(current);
}
 
void QQuickAnimatedImagePrivate::clearCache()
{
    qDeleteAll(frameMap);
    frameMap.clear();
}
 
QQuickAnimatedImage::QQuickAnimatedImage(QQuickItem *parent)
    : QQuickImage(*(new QQuickAnimatedImagePrivate), parent)
{
    connect(this, &QQuickImageBase::cacheChanged, this, &QQuickAnimatedImage::onCacheChanged);
    connect(this, &QQuickImageBase::currentFrameChanged, this, &QQuickAnimatedImage::frameChanged);
    connect(this, &QQuickImageBase::currentFrameChanged, this, &QQuickAnimatedImage::currentFrameChanged);
    connect(this, &QQuickImageBase::frameCountChanged, this, &QQuickAnimatedImage::frameCountChanged);
}
 
QQuickAnimatedImage::~QQuickAnimatedImage()
{
    Q_D(QQuickAnimatedImage);
#if QT_CONFIG(qml_network)
    if (d->reply)
        d->reply->deleteLater();
#endif
    delete d->movie;
    d->clearCache();
}
 
bool QQuickAnimatedImage::isPaused() const
{
    Q_D(const QQuickAnimatedImage);
    if (!d->movie)
        return d->paused;
    return d->movie->state()==QMovie::Paused;
}
 
void QQuickAnimatedImage::setPaused(bool pause)
{
    Q_D(QQuickAnimatedImage);
    if (pause == d->paused)
        return;
    if (!d->movie) {
        d->paused = pause;
        emit pausedChanged();
    } else {
        d->movie->setPaused(pause);
    }
}
 
bool QQuickAnimatedImage::isPlaying() const
{
    Q_D(const QQuickAnimatedImage);
    if (!d->movie)
        return d->playing;
    return d->movie->state()!=QMovie::NotRunning;
}
 
void QQuickAnimatedImage::setPlaying(bool play)
{
    Q_D(QQuickAnimatedImage);
    if (play == d->playing)
        return;
    if (!d->movie) {
        d->playing = play;
        emit playingChanged();
        return;
    }
    if (play)
        d->movie->start();
    else
        d->movie->stop();
}
 
int QQuickAnimatedImage::currentFrame() const
{
    Q_D(const QQuickAnimatedImage);
    if (!d->movie)
        return d->presetCurrentFrame;
    return d->movie->currentFrameNumber();
}
 
void QQuickAnimatedImage::setCurrentFrame(int frame)
{
    Q_D(QQuickAnimatedImage);
    if (!d->movie) {
        d->presetCurrentFrame = frame;
        return;
    }
    d->movie->jumpToFrame(frame);
}
 
int QQuickAnimatedImage::frameCount() const
{
    Q_D(const QQuickAnimatedImage);
    if (!d->movie)
        return 0;
    return d->movie->frameCount();
}
 
qreal QQuickAnimatedImage::speed() const
{
    Q_D(const QQuickAnimatedImage);
    return d->speed;
}
 
void QQuickAnimatedImage::setSpeed(qreal speed)
{
    Q_D(QQuickAnimatedImage);
    if (d->speed != speed) {
        d->speed = speed;
        if (d->movie)
            d->movie->setSpeed(qRound(speed * 100.0));
        emit speedChanged();
    }
}
 
void QQuickAnimatedImage::setSource(const QUrl &url)
{
    Q_D(QQuickAnimatedImage);
    if (url == d->url)
        return;
 
#if QT_CONFIG(qml_network)
    if (d->reply) {
        d->reply->deleteLater();
        d->reply = nullptr;
    }
#endif
 
    d->setImage(QImage());
    d->oldPlaying = isPlaying();
    d->setMovie(nullptr);
    d->url = url;
    emit sourceChanged(d->url);
 
    if (isComponentComplete())
        load();
}
 
void QQuickAnimatedImage::load()
{
    Q_D(QQuickAnimatedImage);
 
    if (d->url.isEmpty()) {
        d->setProgress(0);
 
        d->setImage(QImage());
        if (sourceSize() != d->oldSourceSize) {
            d->oldSourceSize = sourceSize();
            emit sourceSizeChanged();
        }
 
        d->setStatus(Null);
        if (isPlaying() != d->oldPlaying)
            emit playingChanged();
    } else {
        const qreal targetDevicePixelRatio = (window() ? window()->effectiveDevicePixelRatio() : qApp->devicePixelRatio());
        d->devicePixelRatio = 1.0;
 
        const auto context = qmlContext(this);
        QUrl loadUrl = context ? context->resolvedUrl(d->url) : d->url;
        const QUrl resolvedUrl = loadUrl;
        resolve2xLocalFile(resolvedUrl, targetDevicePixelRatio, &loadUrl, &d->devicePixelRatio);
        QString lf = QQmlFile::urlToLocalFileOrQrc(loadUrl);
 
        d->status = Null; // reset status, no emit
 
        if (!lf.isEmpty()) {
            d->setMovie(new QMovie(lf));
            movieRequestFinished();
        } else {
#if QT_CONFIG(qml_network)
            if (d->reply)
                return;
 
            d->setStatus(Loading);
            d->setProgress(0);
            QNetworkRequest req(d->url);
            req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);
 
            d->reply = qmlEngine(this)->networkAccessManager()->get(req);
            connect(d->reply, &QNetworkReply::finished, this, &QQuickAnimatedImage::movieRequestFinished);
            connect(d->reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(requestProgress(qint64,qint64)));
#endif
        }
    }
}
 
void QQuickAnimatedImage::movieRequestFinished()
{
    Q_D(QQuickAnimatedImage);
 
#if QT_CONFIG(qml_network)
    if (d->reply) {
        auto movie = new QMovie(d->reply);
        // From this point, we no longer need to handle the reply.
        // I.e. it will be used only as a data source for QMovie,
        // so it should live as long as the movie lives.
        d->reply->disconnect(this);
        d->reply->setParent(movie);
        d->reply = nullptr;
 
        d->setMovie(movie);
    }
#endif
 
    if (!d->movie || !d->movie->isValid()) {
        const QQmlContext *context = qmlContext(this);
        qmlWarning(this) << "Error Reading Animated Image File "
                         << (context ? context->resolvedUrl(d->url) : d->url).toString();
        d->setMovie(nullptr);
 
        d->setImage(QImage());
        if (sourceSize() != d->oldSourceSize) {
            d->oldSourceSize = sourceSize();
            emit sourceSizeChanged();
        }
 
        d->setProgress(0);
        d->setStatus(Error);
 
        if (isPlaying() != d->oldPlaying)
            emit playingChanged();
        return;
    }
 
    connect(d->movie, &QMovie::stateChanged, this, &QQuickAnimatedImage::playingStatusChanged);
    connect(d->movie, &QMovie::frameChanged, this, &QQuickAnimatedImage::movieUpdate);
    if (d->cache)
        d->movie->setCacheMode(QMovie::CacheAll);
    d->movie->setSpeed(qRound(d->speed * 100.0));
 
    d->setProgress(1);
 
    bool pausedAtStart = d->paused;
    if (d->movie && d->playing)
        d->movie->start();
    if (d->movie && pausedAtStart)
        d->movie->setPaused(true);
    if (d->movie && (d->paused || !d->playing)) {
        d->movie->jumpToFrame(d->presetCurrentFrame);
        d->presetCurrentFrame = 0;
    }
 
    QQuickPixmap *pixmap = d->infoForCurrentFrame(qmlEngine(this));
    if (pixmap) {
        d->setPixmap(*pixmap);
        if (sourceSize() != d->oldSourceSize) {
            d->oldSourceSize = sourceSize();
            emit sourceSizeChanged();
        }
    }
 
    d->setStatus(Ready);
 
    if (isPlaying() != d->oldPlaying)
        emit playingChanged();
}
 
void QQuickAnimatedImage::movieUpdate()
{
    Q_D(QQuickAnimatedImage);
 
    if (!d->cache)
        d->clearCache();
 
    if (d->movie) {
        d->setPixmap(*d->infoForCurrentFrame(qmlEngine(this)));
        emit QQuickImageBase::currentFrameChanged();
    }
}
 
void QQuickAnimatedImage::playingStatusChanged()
{
    Q_D(QQuickAnimatedImage);
 
    if ((d->movie->state() != QMovie::NotRunning) != d->playing) {
        d->playing = (d->movie->state() != QMovie::NotRunning);
        emit playingChanged();
    }
    if ((d->movie->state() == QMovie::Paused) != d->paused) {
        d->paused = (d->movie->state() == QMovie::Paused);
        emit pausedChanged();
    }
}
 
void QQuickAnimatedImage::onCacheChanged()
{
    Q_D(QQuickAnimatedImage);
    if (!cache()) {
        d->clearCache();
        if (d->movie)
            d->movie->setCacheMode(QMovie::CacheNone);
    } else {
        if (d->movie)
            d->movie->setCacheMode(QMovie::CacheAll);
    }
}
 
void QQuickAnimatedImage::componentComplete()
{
    QQuickItem::componentComplete(); // NOT QQuickImage
    load();
}
 
void QQuickAnimatedImagePrivate::setMovie(QMovie *m)
{
    if (movie == m)
        return;
 
    Q_Q(QQuickAnimatedImage);
    const int oldFrameCount = q->frameCount();
 
    if (movie) {
        movie->disconnect();
        movie->deleteLater();
    }
 
    movie = m;
    clearCache();
 
    if (movie)
        movie->setScaledSize(sourcesize);
 
    if (oldFrameCount != q->frameCount())
        emit q->frameCountChanged();
}
 
QT_END_NAMESPACE
 
#include "moc_qquickanimatedimage_p.cpp"