SolarSystem.hpp

/*
 * Stellarium
 * Copyright (C) 2002 Fabien Chereau
 * Copyright (c) 2010 Bogdan Marinov
 *
 * 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 _SOLARSYSTEM_HPP_
#define _SOLARSYSTEM_HPP_
//sun is already defined in Sun C/Solaris
#if defined(sun)
#undef sun
#endif

#include "StelObjectModule.hpp"
#include "StelTextureTypes.hpp"
#include "Planet.hpp"

#include <QFont>

class Orbit;
class StelTranslator;
class StelObject;
class StelCore;
class StelProjector;
class QSettings;

typedef QSharedPointer<Planet> PlanetP;

class SolarSystem : public StelObjectModule
{
    Q_OBJECT
    Q_PROPERTY(bool labelsDisplayed
           READ getFlagLabels
           WRITE setFlagLabels)
    Q_PROPERTY(bool orbitsDisplayed
           READ getFlagOrbits
           WRITE setFlagOrbits)
    Q_PROPERTY(bool trailsDisplayed
           READ getFlagTrails
           WRITE setFlagTrails)
    Q_PROPERTY(bool planetsDisplayed
           READ getFlagPlanets
           WRITE setFlagPlanets)

public:
    SolarSystem();
    virtual ~SolarSystem();

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

    virtual void deinit();
    
    virtual void draw(StelCore *core);

    virtual void update(double deltaTime);

    virtual double getCallOrder(StelModuleActionName actionName) const;

    // Methods defined in StelObjectManager class
    virtual QList<StelObjectP> searchAround(const Vec3d& v, double limitFov, const StelCore* core) const;

    virtual StelObjectP searchByNameI18n(const QString& nameI18n) const;

    virtual StelObjectP searchByName(const QString& name) const;

    virtual QStringList listMatchingObjectsI18n(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false) const;
    virtual QStringList listMatchingObjects(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false) const;
    virtual QStringList listAllObjects(bool inEnglish) const { Q_UNUSED(inEnglish) return QStringList(); }
    virtual QStringList listAllObjectsByType(const QString& objType, bool inEnglish) const;
    virtual QString getName() const { return "Solar System"; }

public slots:
    // Method callable from script and GUI
    // Properties setters and getters
    void setFlagPlanets(bool b);
    bool getFlagPlanets() const;

    void setFlagTrails(bool b);
    bool getFlagTrails() const;

    void setFlagHints(bool b);
    bool getFlagHints() const;

    void setFlagLabels(bool b);
    bool getFlagLabels() const;

    void setLabelsAmount(float a) {labelsAmount=a;}
    float getLabelsAmount(void) const {return labelsAmount;}

    void setFlagOrbits(bool b);
    bool getFlagOrbits() const {return flagOrbits;}

    void setFlagMarkers(bool b) { flagMarker=b; }
    bool getFlagMarkers() const {return flagMarker;}

    void setFlagLightTravelTime(bool b);
    bool getFlagLightTravelTime(void) const {return flagLightTravelTime;}

    void setFontSize(float newFontSize);

    void setLabelsColor(const Vec3f& c);
    const Vec3f& getLabelsColor(void) const;

    void setOrbitsColor(const Vec3f& c);
    Vec3f getOrbitsColor(void) const;

    void setTrailsColor(const Vec3f& c) {trailColor=c;}
    Vec3f getTrailsColor() const {return trailColor;}

    void setPointersColor(const Vec3f& c) {pointerColor=c;}
    Vec3f getPointersColor() const {return pointerColor;}

    void setFlagMoonScale(bool b);
    bool getFlagMoonScale(void) const {return flagMoonScale;}

    void setMoonScale(double f);
    float getMoonScale(void) const {return moonScale;}

    void updateI18n();

    float getPlanetVMagnitude(QString planetName, bool withExtinction=false) const;

    QString getPlanetType(QString planetName) const;

    double getDistanceToPlanet(QString planetName) const;

    double getElongationForPlanet(QString planetName) const;

    double getPhaseAngleForPlanet(QString planetName) const;

    float getPhaseForPlanet(QString planetName) const;

    void setApparentMagnitudeAlgorithmOnEarth(QString algorithm);

    QString getApparentMagnitudeAlgorithmOnEarth() const;

    void setFlagNativeNames(bool b);
    bool getFlagNativeNames(void) const;

    void setFlagTranslatedNames(bool b);
    bool getFlagTranslatedNames(void) const;

    void setFlagIsolatedTrails(bool b);
    bool getFlagIsolatedTrails(void) const;

    void setFlagIsolatedOrbits(bool b);
    bool getFlagIsolatedOrbits(void) const;

public:
    // Other public methods
    PlanetP searchByEnglishName(QString planetEnglishName) const;

    PlanetP getSun() const {return sun;}

    PlanetP getEarth() const {return earth;}

    PlanetP getMoon() const {return moon;}

    bool nearLunarEclipse();

    QStringList getAllPlanetEnglishNames() const;

    QStringList getAllPlanetLocalizedNames() const;

    void reloadPlanets();

    double getEclipseFactor(const StelCore *core) const;

    // DEPRECATED
    QString getPlanetHashString();

    void computePositions(double dateJDE, const Vec3d& observerPos = Vec3d(0.));

    const QList<PlanetP>& getAllPlanets() const {return systemPlanets;} 

private slots:
    void selectedObjectChange(StelModule::StelModuleSelectAction action);

    void setStelStyle(const QString& section);

    void updateSkyCulture(const QString& skyCultureDir);

private:
    StelObjectP search(Vec3d v, const StelCore* core) const;

    void computeTransMatrices(double dateJDE, const Vec3d& observerPos = Vec3d(0.));

    void drawPointer(const StelCore* core);

    void loadPlanets();

    bool loadPlanets(const QString& filePath);

    void recreateTrails();

    void setFlagPermanentOrbits(bool b);

    int shadowPlanetCount;
    PlanetP sun;
    PlanetP moon;
    PlanetP earth;

    void setSelected(const QString& englishName);
    void setSelected(PlanetP obj);
    PlanetP getSelected(void) const {return selected;}
    PlanetP selected;

    // Moon scale value
    bool flagMoonScale;
    float moonScale;

    QFont planetNameFont;

    float labelsAmount;

    QList<PlanetP> systemPlanets;

    // Master settings
    bool flagOrbits;
    bool flagLightTravelTime;

    StelTextureSP texPointer;

    bool flagShow;
    bool flagMarker;
    bool flagNativeNames;
    bool flagTranslatedNames;
    bool flagIsolatedTrails;
    bool flagIsolatedOrbits;

    class TrailGroup* allTrails;
    LinearFader trailFader;
    Vec3f trailColor;
    Vec3f pointerColor;

    QHash<QString, QString> planetNativeNamesMap;

    // DEPRECATED
    QList<Orbit*> orbits;           // Pointers on created elliptical orbits
};


#endif // _SOLARSYSTEM_HPP_