NebulaMgr.hpp

/*
 * Stellarium
 * Copyright (C) 2002 Fabien Chereau
 * Copyright (C) 2011 Alexander Wolf
 * Copyright (C) 2015 Georg Zotti
 *
 * 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 _NEBULAMGR_HPP_
#define _NEBULAMGR_HPP_

#include "StelObjectType.hpp"
#include "StelFader.hpp"
#include "StelSphericalIndex.hpp"
#include "StelObjectModule.hpp"
#include "StelTextureTypes.hpp"
#include "Nebula.hpp"

#include <QString>
#include <QStringList>
#include <QFont>

class StelTranslator;
class StelToneReproducer;
class QSettings;
class StelPainter;

typedef QSharedPointer<Nebula> NebulaP;

// GZ: This doc seems outdated/misleading - photo textures are not mamaged here but in StelSkyImageTile

class NebulaMgr : public StelObjectModule
{
    Q_OBJECT
    //StelActions
    Q_PROPERTY(bool flagHintDisplayed
           READ getFlagHints
           WRITE setFlagHints
           NOTIFY flagHintsDisplayedChanged)
    Q_PROPERTY(bool flagTypeFiltersUsage
           READ getFlagUseTypeFilters
           WRITE setFlagUseTypeFilters
           NOTIFY flagUseTypeFiltersChanged)
    //StelProperties
    Q_PROPERTY(Nebula::TypeGroup typeFilters
           READ getTypeFilters
           WRITE setTypeFilters
           NOTIFY typeFiltersChanged
           )
    Q_PROPERTY(Nebula::CatalogGroup catalogFilters
           READ getCatalogFilters
           WRITE setCatalogFilters
           NOTIFY catalogFiltersChanged
           )
    Q_PROPERTY(bool hintsProportional
           READ getHintsProportional
           WRITE setHintsProportional
           NOTIFY hintsProportionalChanged
           )
    Q_PROPERTY(bool flagOutlinesDisplayed
           READ getFlagOutlines
           WRITE setFlagOutlines
           NOTIFY flagOutlinesDisplayedChanged
           )
    Q_PROPERTY(bool flagSurfaceBrightnessUsage
           READ getFlagSurfaceBrightnessUsage
           WRITE setFlagSurfaceBrightnessUsage
           NOTIFY flagSurfaceBrightnessUsageChanged
           )
    Q_PROPERTY(bool flagSurfaceBrightnessArcsecUsage
           READ getFlagSurfaceBrightnessArcsecUsage
           WRITE setFlagSurfaceBrightnessArcsecUsage
           NOTIFY flagSurfaceBrightnessArcsecUsageChanged
           )
    Q_PROPERTY(bool flagSurfaceBrightnessShortNotationUsage
           READ getFlagSurfaceBrightnessShortNotationUsage
           WRITE setFlagSurfaceBrightnessShortNotationUsage
           NOTIFY flagSurfaceBrightnessShortNotationUsageChanged
           )
    Q_PROPERTY(double labelsAmount
           READ getLabelsAmount
           WRITE setLabelsAmount
           NOTIFY labelsAmountChanged
           )
    Q_PROPERTY(double hintsAmount
           READ getHintsAmount
           WRITE setHintsAmount
           NOTIFY hintsAmountChanged
           )
    Q_PROPERTY(bool flagDesignationLabels
           READ getDesignationUsage
           WRITE setDesignationUsage
           NOTIFY designationUsageChanged
           )
    // Colors
    Q_PROPERTY(Vec3f labelsColor
           READ getLabelsColor
           WRITE setLabelsColor
           NOTIFY labelsColorChanged
           )
    Q_PROPERTY(Vec3f circlesColor
           READ getCirclesColor
           WRITE setCirclesColor
           NOTIFY circlesColorChanged
           )
    Q_PROPERTY(Vec3f galaxiesColor
           READ getGalaxyColor
           WRITE setGalaxyColor
           NOTIFY galaxiesColorChanged
           )
    Q_PROPERTY(Vec3f activeGalaxiesColor
           READ getActiveGalaxyColor
           WRITE setActiveGalaxyColor
           NOTIFY activeGalaxiesColorChanged
           )
    Q_PROPERTY(Vec3f radioGalaxiesColor
           READ getRadioGalaxyColor
           WRITE setRadioGalaxyColor
           NOTIFY radioGalaxiesColorChanged
           )
    Q_PROPERTY(Vec3f interactingGalaxiesColor
           READ getInteractingGalaxyColor
           WRITE setInteractingGalaxyColor
           NOTIFY interactingGalaxiesColorChanged
           )
    Q_PROPERTY(Vec3f quasarsColor
           READ getQuasarColor
           WRITE setQuasarColor
           NOTIFY quasarsColorChanged
           )
    Q_PROPERTY(Vec3f possibleQuasarsColor
           READ getPossibleQuasarColor
           WRITE setPossibleQuasarColor
           NOTIFY possibleQuasarsColorChanged
           )
    Q_PROPERTY(Vec3f clustersColor
           READ getClusterColor
           WRITE setClusterColor
           NOTIFY clustersColorChanged
           )
    Q_PROPERTY(Vec3f openClustersColor
           READ getOpenClusterColor
           WRITE setOpenClusterColor
           NOTIFY openClustersColorChanged
           )
    Q_PROPERTY(Vec3f globularClustersColor
           READ getGlobularClusterColor
           WRITE setGlobularClusterColor
           NOTIFY globularClustersColorChanged
           )
    Q_PROPERTY(Vec3f stellarAssociationsColor
           READ getStellarAssociationColor
           WRITE setStellarAssociationColor
           NOTIFY stellarAssociationsColorChanged
           )
    Q_PROPERTY(Vec3f starCloudsColor
           READ getStarCloudColor
           WRITE setStarCloudColor
           NOTIFY starCloudsColorChanged
           )
    Q_PROPERTY(Vec3f starsColor
           READ getStarColor
           WRITE setStarColor
           NOTIFY starsColorChanged
           )
    Q_PROPERTY(Vec3f symbioticStarsColor
           READ getSymbioticStarColor
           WRITE setSymbioticStarColor
           NOTIFY symbioticStarsColorChanged
           )
    Q_PROPERTY(Vec3f emissionLineStarsColor
           READ getEmissionLineStarColor
           WRITE setEmissionLineStarColor
           NOTIFY emissionLineStarsColorChanged
           )
    Q_PROPERTY(Vec3f nebulaeColor
           READ getNebulaColor
           WRITE setNebulaColor
           NOTIFY nebulaeColorChanged
           )
    Q_PROPERTY(Vec3f planetaryNebulaeColor
           READ getPlanetaryNebulaColor
           WRITE setPlanetaryNebulaColor
           NOTIFY planetaryNebulaeColorChanged
           )
    Q_PROPERTY(Vec3f darkNebulaeColor
           READ getDarkNebulaColor
           WRITE setDarkNebulaColor
           NOTIFY darkNebulaeColorChanged
           )
    Q_PROPERTY(Vec3f reflectionNebulaeColor
           READ getReflectionNebulaColor
           WRITE setReflectionNebulaColor
           NOTIFY reflectionNebulaeColorChanged
           )
    Q_PROPERTY(Vec3f bipolarNebulaeColor
           READ getBipolarNebulaColor
           WRITE setBipolarNebulaColor
           NOTIFY bipolarNebulaeColorChanged
           )
    Q_PROPERTY(Vec3f emissionNebulaeColor
           READ getEmissionNebulaColor
           WRITE setEmissionNebulaColor
           NOTIFY emissionNebulaeColorChanged
           )
    Q_PROPERTY(Vec3f possiblePlanetaryNebulaeColor
           READ getPossiblePlanetaryNebulaColor
           WRITE setPossiblePlanetaryNebulaColor
           NOTIFY possiblePlanetaryNebulaeColorChanged
           )
    Q_PROPERTY(Vec3f protoplanetaryNebulaeColor
           READ getProtoplanetaryNebulaColor
           WRITE setProtoplanetaryNebulaColor
           NOTIFY protoplanetaryNebulaeColorChanged
           )
    Q_PROPERTY(Vec3f clusterWithNebulosityColor
           READ getClusterWithNebulosityColor
           WRITE setClusterWithNebulosityColor
           NOTIFY clusterWithNebulosityColorChanged
           )
    Q_PROPERTY(Vec3f hydrogenRegionsColor
           READ getHydrogenRegionColor
           WRITE setHydrogenRegionColor
           NOTIFY hydrogenRegionsColorChanged
           )
    Q_PROPERTY(Vec3f interstellarMatterColor
           READ getInterstellarMatterColor
           WRITE setInterstellarMatterColor
           NOTIFY interstellarMatterColorChanged
           )
    Q_PROPERTY(Vec3f emissionObjectsColor
           READ getEmissionObjectColor
           WRITE setEmissionObjectColor
           NOTIFY emissionObjectsColorChanged
           )
    Q_PROPERTY(Vec3f molecularCloudsColor
           READ getMolecularCloudColor
           WRITE setMolecularCloudColor
           NOTIFY molecularCloudsColorChanged
           )
    Q_PROPERTY(Vec3f blLacObjectsColor
           READ getBlLacObjectColor
           WRITE setBlLacObjectColor
           NOTIFY blLacObjectsColorChanged
           )
    Q_PROPERTY(Vec3f blazarsColor
           READ getBlazarColor
           WRITE setBlazarColor
           NOTIFY blazarsColorChanged
           )
    Q_PROPERTY(Vec3f youngStellarObjectsColor
           READ getYoungStellarObjectColor
           WRITE setYoungStellarObjectColor
           NOTIFY youngStellarObjectsColorChanged
           )
    Q_PROPERTY(Vec3f supernovaRemnantsColor
           READ getSupernovaRemnantColor
           WRITE setSupernovaRemnantColor
           NOTIFY supernovaRemnantsColorChanged
           )
    Q_PROPERTY(Vec3f supernovaCandidatesColor
           READ getSupernovaCandidateColor
           WRITE setSupernovaCandidateColor
           NOTIFY supernovaCandidatesColorChanged
           )
    Q_PROPERTY(Vec3f supernovaRemnantCandidatesColor
           READ getSupernovaRemnantCandidateColor
           WRITE setSupernovaRemnantCandidateColor
           NOTIFY supernovaRemnantCandidatesColorChanged
           )
    Q_PROPERTY(Vec3f galaxyClustersColor
           READ getGalaxyClusterColor
           WRITE setGalaxyClusterColor
           NOTIFY galaxyClustersColorChanged
           )

public:
    NebulaMgr();
    virtual ~NebulaMgr();

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

    virtual void draw(StelCore* core);

    virtual void update(double deltaTime) {hintsFader.update((int)(deltaTime*1000)); flagShow.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 StelObjectP searchByID(const QString &id) const { return searchByName(id); }

    virtual QStringList listMatchingObjects(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false, bool inEnglish=false) const;
    virtual QStringList listAllObjects(bool inEnglish) const;
    virtual QStringList listAllObjectsByType(const QString& objType, bool inEnglish) const;
    virtual QString getName() const { return "Deep-sky objects"; }
    virtual QString getStelObjectType() const { return Nebula::NEBULA_TYPE; }

    float computeMaxMagHint(const class StelSkyDrawer* skyDrawer) const;

    QString getLatestSelectedDSODesignation();

    const QVector<NebulaP>& getAllDeepSkyObjects() const { return dsoArray; }

    QList<NebulaP> getDeepSkyObjectsByType(const QString& objType);

    // Properties setters and getters
public slots:
    void setCatalogFilters(Nebula::CatalogGroup cflags);
    Nebula::CatalogGroup getCatalogFilters() const { return Nebula::catalogFilters; }

    void setTypeFilters(Nebula::TypeGroup tflags);
    Nebula::TypeGroup getTypeFilters() const { return Nebula::typeFilters; }

    void setCirclesColor(const Vec3f& c);
    const Vec3f getCirclesColor(void) const;

    void setGalaxyColor(const Vec3f& c);
    const Vec3f getGalaxyColor(void) const;

    void setActiveGalaxyColor(const Vec3f& c);
    const Vec3f getActiveGalaxyColor(void) const;

    void setInteractingGalaxyColor(const Vec3f& c);
    const Vec3f getInteractingGalaxyColor(void) const;

    void setRadioGalaxyColor(const Vec3f& c);
    const Vec3f getRadioGalaxyColor(void) const;

    void setQuasarColor(const Vec3f& c);
    const Vec3f getQuasarColor(void) const;

    void setBrightNebulaColor(const Vec3f& c);
    const Vec3f getBrightNebulaColor(void) const;

    void setNebulaColor(const Vec3f& c);
    const Vec3f getNebulaColor(void) const;

    void setPlanetaryNebulaColor(const Vec3f& c);
    const Vec3f getPlanetaryNebulaColor(void) const;

    void setReflectionNebulaColor(const Vec3f& c);
    const Vec3f getReflectionNebulaColor(void) const;

    void setBipolarNebulaColor(const Vec3f& c);
    const Vec3f getBipolarNebulaColor(void) const;

    void setEmissionNebulaColor(const Vec3f& c);
    const Vec3f getEmissionNebulaColor(void) const;

    void setHydrogenRegionColor(const Vec3f& c);
    const Vec3f getHydrogenRegionColor(void) const;

    void setSupernovaRemnantColor(const Vec3f& c);
    const Vec3f getSupernovaRemnantColor(void) const;

    void setSupernovaCandidateColor(const Vec3f& c);
    const Vec3f getSupernovaCandidateColor(void) const;


    void setSupernovaRemnantCandidateColor(const Vec3f& c);
    const Vec3f getSupernovaRemnantCandidateColor(void) const;

    void setInterstellarMatterColor(const Vec3f& c);
    const Vec3f getInterstellarMatterColor(void) const;

    void setDarkNebulaColor(const Vec3f& c);
    const Vec3f getDarkNebulaColor(void) const;

    void setClusterWithNebulosityColor(const Vec3f& c);
    const Vec3f getClusterWithNebulosityColor(void) const;

    void setClusterColor(const Vec3f& c);
    const Vec3f getClusterColor(void) const;

    void setOpenClusterColor(const Vec3f& c);
    const Vec3f getOpenClusterColor(void) const;

    void setGlobularClusterColor(const Vec3f& c);
    const Vec3f getGlobularClusterColor(void) const;

    void setStellarAssociationColor(const Vec3f& c);
    const Vec3f getStellarAssociationColor(void) const;

    void setStarCloudColor(const Vec3f& c);
    const Vec3f getStarCloudColor(void) const;

    void setEmissionObjectColor(const Vec3f& c);
    const Vec3f getEmissionObjectColor(void) const;

    void setBlLacObjectColor(const Vec3f& c);
    const Vec3f getBlLacObjectColor(void) const;

    void setBlazarColor(const Vec3f& c);
    const Vec3f getBlazarColor(void) const;

    void setMolecularCloudColor(const Vec3f& c);
    const Vec3f getMolecularCloudColor(void) const;

    void setYoungStellarObjectColor(const Vec3f& c);
    const Vec3f getYoungStellarObjectColor(void) const;

    void setPossibleQuasarColor(const Vec3f& c);
    const Vec3f getPossibleQuasarColor(void) const;

    void setPossiblePlanetaryNebulaColor(const Vec3f& c);
    const Vec3f getPossiblePlanetaryNebulaColor(void) const;

    void setProtoplanetaryNebulaColor(const Vec3f& c);
    const Vec3f getProtoplanetaryNebulaColor(void) const;

    void setStarColor(const Vec3f& c);
    const Vec3f getStarColor(void) const;

    void setSymbioticStarColor(const Vec3f& c);
    const Vec3f getSymbioticStarColor(void) const;

    void setEmissionLineStarColor(const Vec3f& c);
    const Vec3f getEmissionLineStarColor(void) const;

    void setGalaxyClusterColor(const Vec3f& c);
    const Vec3f getGalaxyClusterColor(void) const;

    void setHintsFadeDuration(float duration) {hintsFader.setDuration((int) (duration * 1000.f));}

    void setFlagHints(bool b) { if (hintsFader!=b) { hintsFader=b; emit flagHintsDisplayedChanged(b);}}
    bool getFlagHints(void) const {return hintsFader;}

    void setHintsProportional(const bool proportional);
    bool getHintsProportional(void) const;

    void setFlagOutlines(const bool flag);
    bool getFlagOutlines(void) const;

    void setDesignationUsage(const bool flag);
    bool getDesignationUsage(void) const;

    void setFlagSurfaceBrightnessUsage(const bool usage) {if(usage!=Nebula::surfaceBrightnessUsage){ Nebula::surfaceBrightnessUsage=usage; emit flagSurfaceBrightnessUsageChanged(usage);}}
    bool getFlagSurfaceBrightnessUsage(void) const { return Nebula::surfaceBrightnessUsage; }

    void setFlagSurfaceBrightnessArcsecUsage(const bool usage) { Nebula::flagUseArcsecSurfaceBrightness=usage; }
    bool getFlagSurfaceBrightnessArcsecUsage(void) const { return Nebula::flagUseArcsecSurfaceBrightness; }

    void setFlagSurfaceBrightnessShortNotationUsage(const bool usage) { Nebula::flagUseShortNotationSurfaceBrightness=usage; }
    bool getFlagSurfaceBrightnessShortNotationUsage(void) const { return Nebula::flagUseShortNotationSurfaceBrightness; }

    void setFlagShow(bool b) { flagShow = b; }
    bool getFlagShow(void) const { return flagShow; }

    void setFlagUseTypeFilters(bool b) { if (Nebula::flagUseTypeFilters!=b) { Nebula::flagUseTypeFilters=b; emit flagUseTypeFiltersChanged(b);}}
    bool getFlagUseTypeFilters(void) const { return Nebula::flagUseTypeFilters; }

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

    void setLabelsAmount(double a) {if(a!=labelsAmount){labelsAmount=a; emit labelsAmountChanged(a);}}
    double getLabelsAmount(void) const {return labelsAmount;}

    void setHintsAmount(double f) {if(hintsAmount!=f){hintsAmount = f; emit hintsAmountChanged(f);}}
    double getHintsAmount(void) const {return hintsAmount;}

signals:
    void flagHintsDisplayedChanged(bool b);
    void flagUseTypeFiltersChanged(bool b);
    void catalogFiltersChanged(Nebula::CatalogGroup flags);
    void typeFiltersChanged(Nebula::TypeGroup flags);
    void hintsProportionalChanged(bool b);
    void flagOutlinesDisplayedChanged(bool b);
    void designationUsageChanged(bool b);
    void flagSurfaceBrightnessUsageChanged(bool b);
    void flagSurfaceBrightnessArcsecUsageChanged(bool b);
    void flagSurfaceBrightnessShortNotationUsageChanged(bool b);
    void labelsAmountChanged(double a);
    void hintsAmountChanged(double f);

    void labelsColorChanged(const Vec3f & color) const;
    void circlesColorChanged(const Vec3f & color) const;
    void galaxiesColorChanged(const Vec3f & color) const;
    void activeGalaxiesColorChanged(const Vec3f & color) const;
    void radioGalaxiesColorChanged(const Vec3f & color) const;
    void interactingGalaxiesColorChanged(const Vec3f & color) const;
    void quasarsColorChanged(const Vec3f & color) const;
    void possibleQuasarsColorChanged(const Vec3f & color) const;
    void clustersColorChanged(const Vec3f & color) const;
    void openClustersColorChanged(const Vec3f & color) const;
    void globularClustersColorChanged(const Vec3f & color) const;
    void stellarAssociationsColorChanged(const Vec3f & color) const;
    void starCloudsColorChanged(const Vec3f & color) const;
    void starsColorChanged(const Vec3f & color) const;
    void symbioticStarsColorChanged(const Vec3f & color) const;
    void emissionLineStarsColorChanged(const Vec3f & color) const;
    void nebulaeColorChanged(const Vec3f & color) const;
    void planetaryNebulaeColorChanged(const Vec3f & color) const;
    void darkNebulaeColorChanged(const Vec3f & color) const;
    void reflectionNebulaeColorChanged(const Vec3f & color) const;
    void bipolarNebulaeColorChanged(const Vec3f & color) const;
    void emissionNebulaeColorChanged(const Vec3f & color) const;
    void possiblePlanetaryNebulaeColorChanged(const Vec3f & color) const;
    void protoplanetaryNebulaeColorChanged(const Vec3f & color) const;
    void clusterWithNebulosityColorChanged(const Vec3f & color) const;
    void hydrogenRegionsColorChanged(const Vec3f & color) const;
    void interstellarMatterColorChanged(const Vec3f & color) const;
    void emissionObjectsColorChanged(const Vec3f & color) const;
    void molecularCloudsColorChanged(const Vec3f & color) const;
    void blLacObjectsColorChanged(const Vec3f & color) const;
    void blazarsColorChanged(const Vec3f & color) const;
    void youngStellarObjectsColorChanged(const Vec3f & color) const;
    void supernovaRemnantsColorChanged(const Vec3f & color) const;
    void supernovaCandidatesColorChanged(const Vec3f & color) const;
    void supernovaRemnantCandidatesColorChanged(const Vec3f & color) const;
    void galaxyClustersColorChanged(const Vec3f & color) const;

private slots:
    void updateI18n();
    
    void updateSkyCulture(const QString& skyCultureDir);

private:

    NebulaP search(const QString& name);

    NebulaP search(const Vec3d& pos);

    void loadNebulaSet(const QString& setName);

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

    NebulaP searchDSO(unsigned int DSO);
    NebulaP searchM(unsigned int M);
    NebulaP searchNGC(unsigned int NGC);
    NebulaP searchIC(unsigned int IC);
    NebulaP searchC(unsigned int C);
    NebulaP searchB(unsigned int B);
    NebulaP searchSh2(unsigned int Sh2);
    NebulaP searchVdB(unsigned int VdB);
    NebulaP searchRCW(unsigned int RCW);
    NebulaP searchLDN(unsigned int LDN);
    NebulaP searchLBN(unsigned int LBN);
    NebulaP searchCr(unsigned int Cr);
    NebulaP searchMel(unsigned int Mel);
    NebulaP searchPGC(unsigned int PGC);
    NebulaP searchUGC(unsigned int UGC);
    NebulaP searchCed(QString Ced); 
    NebulaP searchArp(unsigned int Arp);
    NebulaP searchVV(unsigned int VV);
    NebulaP searchPK(QString PK);
    NebulaP searchPNG(QString PNG);
    NebulaP searchSNRG(QString SNRG);
    NebulaP searchACO(QString ACO);

    // Load catalog of DSO
    bool loadDSOCatalog(const QString& filename);
    void convertDSOCatalog(const QString& in, const QString& out, bool decimal);
    // Load proper names for DSO
    bool loadDSONames(const QString& filename);
    // Load outlines for DSO
    bool loadDSOOutlines(const QString& filename);

    QVector<NebulaP> dsoArray;      // The DSO list
    QHash<unsigned int, NebulaP> dsoIndex;

    LinearFader hintsFader;
    LinearFader flagShow;

    StelSphericalIndex nebGrid;

    double hintsAmount;
    double labelsAmount;

    StelTextureSP texPointer;
    
    QFont nebulaFont;      // Font used for names printing

    // For DSO convertor
    bool flagConverter;
    bool flagDecimalCoordinates;
};

#endif // _NEBULAMGR_HPP_