StelTextureLoader.hpp

/*
 * Stellarium
 * Copyright (C) 2012 Ferdinand Majerech
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELTEXTURELOADER_HPP_
#define _STELTEXTURELOADER_HPP_

#include <QApplication>
#include <QDebug>
#include <QImage>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QObject>
#include <QThread>
#include <QTimer>

#include "StelApp.hpp"
#include "StelUtils.hpp"


class StelTextureLoader : public QObject
{
    Q_OBJECT

public:
    virtual void abort(){};

signals:
    void error(const QString& errorMsg);

protected:
    StelTextureLoader(QThread* loaderThread)
        : QObject()
        , loaderThread(loaderThread)
    {
    }

    void moveToLoaderThread()
    {
        moveToThread(loaderThread);
    }

private:
    QThread* loaderThread;
};


class StelHTTPTextureLoader : public StelTextureLoader
{
    Q_OBJECT

public:
    StelHTTPTextureLoader(const QString& url, int delay, QThread* loaderThread)
        : StelTextureLoader(loaderThread)
        , url(url)
        , networkReply(NULL)
    {
        QTimer::singleShot(delay, this, SLOT(start()));
    }

    virtual void abort()
    {
        Q_ASSERT_X(QThread::currentThread() == QApplication::instance()->thread(),
                   Q_FUNC_INFO,
                   "StelTextureLoader::abort must be called from the main thread");
        if (networkReply != NULL) {networkReply->abort();}
    }

signals:
    void finished(QImage);

private slots:
    void start()
    {
        QNetworkRequest request = QNetworkRequest(QUrl(url));
        // Define that preference should be given to cached files (no etag checks)
        request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, 
                             QNetworkRequest::PreferCache);
        request.setRawHeader("User-Agent", StelUtils::getApplicationName().toAscii());
        networkReply = StelApp::getInstance().getNetworkAccessManager()->get(request);
        connect(networkReply, SIGNAL(finished()), this, SLOT(onNetworkReply()));

        // Move this object outside of the main thread.
        moveToLoaderThread();
    }
    
    void onNetworkReply()
    {
        if (networkReply->error() != QNetworkReply::NoError) 
        {
            emit error(networkReply->errorString());
        } 
        else 
        {
            QByteArray data = networkReply->readAll();
            QImage image = QImage::fromData(data);
            if (image.isNull()) 
            {
                emit error("Unable to parse image data");
            } else 
            {
                emit finished(image);
            }
        }
        networkReply->deleteLater();
        networkReply = NULL; 
    }

private:
    const QString url;
    QNetworkReply* networkReply;
};

class StelFileTextureLoader : public StelTextureLoader
{
    Q_OBJECT

public:
    StelFileTextureLoader(const QString& path, int delay, QThread* loaderThread)
        : StelTextureLoader(loaderThread)
        , path(path)
    {
        QTimer::singleShot(delay, this, SLOT(start()));
    }

signals:
    void finished(QImage);

private slots:
    void start()
    {
        // At next loop iteration we start to load from the file.
        QTimer::singleShot(0, this, SLOT(load()));
        // Move this object outside of the main thread.
        moveToLoaderThread();
    }

    void load()
    {
        QImage image = QImage(path);
        if(image.isNull())
        {
            emit error("Image " + path + " failed to load");
            return;
        }
        emit finished(image);
    }

private:
    const QString path;
};
#endif // _STELTEXTURELOADER_HPP_