StelTextureBackend.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 _STELTEXTUREBACKEND_HPP_
#define _STELTEXTUREBACKEND_HPP_

#include <QDebug>
#include <QObject>
#include <QSize>
#include <QString>
#include <QDir>


enum TextureStatus
{
    TextureStatus_Uninitialized,
    TextureStatus_Loading,
    TextureStatus_Loaded,
    TextureStatus_Error
};

inline QString textureStatusName(const TextureStatus status)
{
    switch(status)
    {
        case TextureStatus_Uninitialized: return "TextureStatus_Uninitialized"; break;
        case TextureStatus_Loaded:        return "TextureStatus_Loaded"; break;
        case TextureStatus_Loading:       return "TextureStatus_Loading"; break;
        case TextureStatus_Error:         return "TextureStatus_Error"; break;
        default: Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown texture status");
    }
    // Avoid compiler warnings.
    return QString();
}

enum TextureLoadingMode
{
    TextureLoadingMode_Normal,
    TextureLoadingMode_Asynchronous,
    TextureLoadingMode_LazyAsynchronous
};

class StelTextureBackend : public QObject
{
    Q_OBJECT

public:
    virtual ~StelTextureBackend(){};

    TextureStatus getStatus() const
    {
        return status;
    }

    const QString& getName() const
    {
        return path;
    }

    QSize getDimensions() const
    {
        invariant();
        Q_ASSERT_X(status == TextureStatus_Loaded, Q_FUNC_INFO,
                   "Trying to get dimensions of a texture that is not loaded. "
                   "Use StelTextureBackend::getStatus to determine if the texture "
                   "is loaded or not.");
        return size;
    }

    const QString& getErrorMessage() const
    {
        invariant();
        return errorMessage;
    }

protected:
    const QString path;

    StelTextureBackend(const QString& path)
        : QObject()
        , path(path)
        , errorMessage(QString())
        , size(QSize(0, 0))
        , status(TextureStatus_Uninitialized)
    {
        invariant();
    }

    void startedLoading()
    {
        invariant();
        Q_ASSERT_X(status == TextureStatus_Uninitialized, Q_FUNC_INFO,
                   "Only a texture that has not yet been initialized can start loading");
        status = TextureStatus_Loading;
        invariant();
    }

    void finishedLoading(const QSize dimensions)
    {
        invariant();
        Q_ASSERT_X(status == TextureStatus_Loading, Q_FUNC_INFO,
                   "Only a texture that has started loading can finish loading");
        size = dimensions;
        status = TextureStatus_Loaded;
        invariant();
    }

    void errorOccured(const QString& error)
    {
        invariant();
        if(status != TextureStatus_Loading)
        {
            qWarning() << "Unexpected error - texture " << QDir::toNativeSeparators(path);
            qWarning() << "Texture status: " << textureStatusName(status);
            Q_ASSERT_X(false, Q_FUNC_INFO,
                       "The only time an error can occur with a texture is during loading");
        }
        qWarning() << "Error occured during loading of texture " << QDir::toNativeSeparators(path) <<
                      ": " << error;
        errorMessage = error;
        status = TextureStatus_Error;
        invariant();
    }
    
private:
    QString errorMessage;

    QSize size;

    TextureStatus status;

    void invariant() const
    {
        Q_ASSERT_X(errorMessage.isEmpty() == (status != TextureStatus_Error),
                   Q_FUNC_INFO,
                   "Error message must be empty when status is not Error and non-empty otherwise");
    }
};

#endif // _STELTEXTUREBACKEND_HPP_