StarMgr.hpp

/*
 * Stellarium
 * Copyright (C) 2002 Fabien Chereau
 *
 * 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 _STARMGR_HPP_
#define _STARMGR_HPP_

#include <QFont>
#include <QVariantMap>
#include <QVector>
#include "StelFader.hpp"
#include "StelObjectModule.hpp"
#include "StelTextureTypes.hpp"
#include "StelProjectorType.hpp"

class StelObject;
class StelToneReproducer;
class StelProjector;
class StelPainter;
class QSettings;

class ZoneArray;
struct HipIndexStruct;

static const int RCMAG_TABLE_SIZE = 4096;

typedef struct
{
    QString designation;    
    QString vtype;      
    float maxmag;       
    int mflag;      
    float min1mag;      
    float min2mag;      
    QString photosys;   
    double epoch;       
    double period;      
    int Mm;         
    QString stype;      
} varstar;

class StarMgr : public StelObjectModule
{
    Q_OBJECT
    Q_PROPERTY(bool flagStarsDisplayed
           READ getFlagStars
           WRITE setFlagStars
           NOTIFY starsDisplayedChanged)
    Q_PROPERTY(bool flagLabelsDisplayed
           READ getFlagLabels
           WRITE setFlagLabels
           NOTIFY starLabelsDisplayedChanged)

public:
    StarMgr(void);
    ~StarMgr(void);

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

    virtual void draw(StelCore* core);

    virtual void update(double deltaTime) {labelsFader.update((int)(deltaTime*1000)); starsFader.update((int)(deltaTime*1000));}

    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;   
    virtual QStringList listAllObjectsByType(const QString& objType, bool inEnglish) const { Q_UNUSED(objType) Q_UNUSED(inEnglish) return QStringList(); }
    virtual QString getName() const { return "Stars"; }

public slots:
    // Methods callable from script and GUI
    void setLabelColor(const Vec3f& c) {labelColor = c;}
    Vec3f getLabelColor(void) const {return labelColor;}

    void setFlagStars(bool b) {starsFader=b;}
    bool getFlagStars(void) const {return starsFader==true;}

    void setFlagLabels(bool b) {labelsFader=b;}
    bool getFlagLabels(void) const {return labelsFader==true;}

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

    void setFontSize(float newFontSize);

    static void setFlagSciNames(bool f) {flagSciNames = f;}
    static bool getFlagSciNames(void) {return flagSciNames;}

public:
    // Other methods
    StelObjectP searchHP(int hip) const;

    static QString getCommonName(int hip);

    static QString getSciName(int hip);

    static QString getSciAdditionalName(int hip);

    static QString getGcvsName(int hip);

    static QString getCommonEnglishName(int hip);

    static QString getGcvsVariabilityType(int hip);

    static float getGcvsMaxMagnitude(int hip);

    static int getGcvsMagnitudeFlag(int hip);

    static float getGcvsMinMagnitude(int hip, bool firstMinimumFlag=true);

    static QString getGcvsPhotometricSystem(int hip);

    static double getGcvsEpoch(int hip);

    static double getGcvsPeriod(int hip);

    static int getGcvsMM(int hip);

    static QString convertToSpectralType(int index);
    static QString convertToComponentIds(int index);

    QVariantList getCatalogsDescription() const {return catalogsDescription;}

    bool checkAndLoadCatalog(const QVariantMap& m);

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

    void updateSkyCulture(const QString& skyCultureDir);

signals:
    void starLabelsDisplayedChanged(const bool displayed);
    void starsDisplayedChanged(const bool displayed);

private:

    void setCheckFlag(const QString& catalogId, bool b);

    void copyDefaultConfigFile();

    int loadCommonNames(const QString& commonNameFile);

    void loadSciNames(const QString& sciNameFile);

    void loadGcvs(const QString& GcvsFile);

    // TODO: add a non-lame description - what is the purpose of the max search level?
    int getMaxSearchLevel() const;

    void loadData(QVariantMap starsConfigFile);

    void drawPointer(StelPainter& sPainter, const StelCore* core);

    LinearFader labelsFader;
    LinearFader starsFader;

    bool flagStarName;
    float labelsAmount;
    bool gravityLabel;

    int maxGeodesicGridLevel;
    int lastMaxSearchLevel;
    
    // A ZoneArray per grid level
    QVector<ZoneArray*> gridLevels;
    static void initTriangleFunc(int lev, int index,
                                 const Vec3f &c0,
                                 const Vec3f &c1,
                                 const Vec3f &c2,
                                 void *context)
    {
        reinterpret_cast<StarMgr*>(context)->initTriangle(lev, index, c0, c1, c2);
    }

    void initTriangle(int lev, int index,
                      const Vec3f &c0,
                      const Vec3f &c1,
                      const Vec3f &c2);

    HipIndexStruct *hipIndex; // array of Hipparcos stars

    static QHash<int, QString> commonNamesMap;     // the original names from skyculture (star_names.fab)
    static QHash<int, QString> commonNamesMapI18n; // translated names
    static QMap<QString, int> commonNamesIndexI18n;
    static QMap<QString, int> commonNamesIndex;

    static QHash<int, QString> sciNamesMapI18n; 
    static QMap<QString, int> sciNamesIndexI18n;

    static QHash<int, QString> sciAdditionalNamesMapI18n;
    static QMap<QString, int> sciAdditionalNamesIndexI18n;

    static QHash<int, varstar> varStarsMapI18n;
    static QMap<QString, int> varStarsIndexI18n;

    QFont starFont;
    static bool flagSciNames;
    Vec3f labelColor;

    StelTextureSP texPointer;       // The selection pointer texture

    class StelObjectMgr* objectMgr;

    QString starConfigFileFullPath;
    QVariantMap starSettings;
    QVariantList catalogsDescription;
};


#endif // _STARMGR_HPP_