LandscapeMgr.hpp

/*
 * Stellarium
 * Copyright (C) 2006 Fabien Chereau
 * Copyright (C) 2010 Bogdan Marinov (add/remove landscapes feature)
 * Copyright (C) 2012 Timothy Reaves
 *
 * 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 _LANDSCAPEMGR_HPP_
#define _LANDSCAPEMGR_HPP_

#include "StelModule.hpp"
#include "StelUtils.hpp"

#include <QMap>
#include <QStringList>

class Landscape;
class Atmosphere;
class Cardinals;
class QSettings;

class LandscapeMgr : public StelModule
{
    Q_OBJECT
    Q_PROPERTY(bool atmosphereDisplayed
               READ getFlagAtmosphere
               WRITE setFlagAtmosphere
               NOTIFY atmosphereDisplayedChanged)
    Q_PROPERTY(bool cardinalsPointsDisplayed
               READ getFlagCardinalsPoints
               WRITE setFlagCardinalsPoints
               NOTIFY cardinalsPointsDisplayedChanged)
    Q_PROPERTY(bool fogDisplayed
               READ getFlagFog
               WRITE setFlagFog
               NOTIFY fogDisplayedChanged)
    Q_PROPERTY(bool landscapeDisplayed
               READ getFlagLandscape
               WRITE setFlagLandscape
               NOTIFY landscapeDisplayedChanged)

public:
    LandscapeMgr();
    virtual ~LandscapeMgr();

    // Methods defined in the StelModule class
    virtual void init();

    virtual void draw(StelCore* core, class StelRenderer* renderer);

    virtual void update(double deltaTime);

    virtual double getCallOrder(StelModuleActionName actionName) const;


    // Method specific to the landscape manager
    float getLuminance();

    bool loadLandscape(QMap<QString, QString>& param);

    Landscape* createFromFile(const QString& landscapeFile, const QString& landscapeId);

public slots:
    // Methods callable from script and GUI
    QStringList getAllLandscapeNames() const;

    QStringList getAllLandscapeIDs() const;

    QStringList getUserLandscapeIDs() const;

    const QString& getCurrentLandscapeID() const {return currentLandscapeID;}
    bool setCurrentLandscapeID(const QString& id);
    
    QString getCurrentLandscapeName() const;
    bool setCurrentLandscapeName(const QString& name);

    const QString& getDefaultLandscapeID() const {return defaultLandscapeID;}
    bool setDefaultLandscapeID(const QString& id);

    QString getCurrentLandscapeHtmlDescription() const;

    QString getDescription() const;

    bool getFlagLandscape() const;
    void setFlagLandscape(const bool displayed);

    bool getFlagFog() const;
    void setFlagFog(const bool displayed);

    bool getFlagLandscapeSetsLocation() const {return flagLandscapeSetsLocation;}
    void setFlagLandscapeSetsLocation(bool b) {flagLandscapeSetsLocation=b;}

    bool getFlagLandscapeNightBrightness() const {return flagLandscapeNightBrightness;}
    void setFlagLandscapeNightBrightness(bool b) {flagLandscapeNightBrightness=b;}


    bool getFlagCardinalsPoints() const;
    void setFlagCardinalsPoints(const bool displayed);

    Vec3f getColorCardinalPoints() const;
    void setColorCardinalPoints(const Vec3f& v);

    bool getFlagAtmosphere() const;
    void setFlagAtmosphere(const bool displayed);

    float getAtmosphereFadeDuration() const;
    void setAtmosphereFadeDuration(float f);

    void setAtmosphereBortleLightPollution(int bIndex);
    int getAtmosphereBortleLightPollution();

    void setZRotation(float d);

    QString installLandscapeFromArchive(QString pathToSourceArchive, bool display = false, bool forAllUsers = false);

    // //! Install a landscape from a directory.
    // //! Expected directory structure: the name of the directory that contains
    // //! a landscape.ini file is assumed to be the landscape ID and should be
    // //! unique.
    // //! This directory and all files in it will be installed, but its
    // //! subdirectories will be skipped along with any other files or
    // //! directories in the archive.
    // //! @param pathToSourceLandscapeIni path to a landscape.ini file. Its parent
    // //! directory is assumed to be the landscape source directory.
    // //! @param display If true, the landscape will be set to be the current
    // //! landscape after installation.
    // //! @param forAllUsers If true, this function will try to install the
    // //! landscape in a way that meakes it is available to all users of this
    // //! computer. May require running Stellarium as an administrator (root)
    // //! on some Windows or *nix systems. (NOT IMPLEMENTED!)
    // //! @returns the installed landscape's identifier (the folder name), or
    // //! an empty string on failure.
    // QString installLandscapeFromDirectory(QString pathToSourceLandscapeIni, bool display = false, bool forAllUsers = false);

    bool removeLandscape(QString landscapeID);

    QString loadLandscapeName(QString landscapeID);

    quint64 loadLandscapeSize(QString landscapeID);

    bool getFlagLandscapeAutoSelection() const;
    void setFlagLandscapeAutoSelection(bool enableAutoSelect);

signals:
    void atmosphereDisplayedChanged(const bool displayed);
    void cardinalsPointsDisplayedChanged(const bool displayed);
    void fogDisplayedChanged(const bool displayed);
    void landscapeDisplayedChanged(const bool displayed);

    void landscapesChanged();

    void errorUnableToOpen(QString path);
    void errorNotArchive();
    void errorNotUnique(QString nameOrID);
    void errorRemoveManually(QString path);

private slots:
    void setStelStyle(const QString& section);

    void updateI18n();  

    float getInitialLandscapeBrightness() const {return initialLandscapeBrightness;}
    void setInitialLandscapeBrightness(float b) {initialLandscapeBrightness=b;}

private:
    float getAtmosphereLightPollutionLuminance() const;
    void setAtmosphereLightPollutionLuminance(float f);

    QString nameToID(const QString& name);

    QMap<QString,QString> getNameToDirMap() const;

    QString getLandscapePath(QString landscapeID);

    Atmosphere* atmosphere;         // Atmosphere
    Cardinals* cardinalsPoints;     // Cardinals points
    Landscape* landscape;           // The landscape i.e. the fog, the ground and "decor"

    // Define whether the observer location is to be updated when the landscape is updated.
    bool flagLandscapeSetsLocation;

    bool flagLandscapeAutoSelection;

    bool flagLandscapeNightBrightness;

    // The ID of the currently loaded landscape
    QString currentLandscapeID;

    // The ID of the default landscape
    QString defaultLandscapeID;

    QStringList packagedLandscapeIDs;

    float initialLandscapeBrightness;
};

#endif // _LANDSCAPEMGR_HPP_