kstarsdata.h

Go to the documentation of this file.

/***************************************************************************
                          kstarsdata.h  -  K Desktop Planetarium
                             -------------------
    begin                : Sun Jul 29 2001
    copyright            : (C) 2001 by Heiko Evermann
    email                : [email protected]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#pragma once

#include "catalogdb.h"
#include "colorscheme.h"
#include "geolocation.h"
#include "ksnumbers.h"
#include "kstarsdatetime.h"
#include "ksuserdb.h"
#include "simclock.h"
#ifndef KSTARS_LITE
#include "oal/oal.h"
#include "oal/log.h"
#endif

#include <QList>
#include <QMap>
#include <QKeySequence>

#include <iostream>
#include <memory>

#define MINZOOM     250.
#define MAXZOOM     5000000.
#define DEFAULTZOOM 2000.
#define DZOOM       1.189207115 // 2^(1/4)
#define AU_KM       1.49605e8   //km in one AU

class QFile;

class Execute;
class FOV;
class ImageExporter;
class SkyMap;
class SkyMapComposite;
class SkyObject;
class ObservingList;
class TimeZoneRule;

#ifdef KSTARS_LITE
//Will go away when details window will be implemented in KStars Lite
struct ADVTreeData
{
    QString Name;
    QString Link;
    int Type;
};
#else
struct ADVTreeData;
#endif

class KStarsData : public QObject
{
        Q_OBJECT

    protected:
        KStarsData();

    public:
        // FIXME: It uses temporary trail. There must be way to
        //        this better. And resumeKey in DBUS code
        friend class KStars;
        // FIXME: it uses temporary trail and resumeKey
        friend class SkyMap;
        // FIXME: uses geoList and changes it.
        friend class LocationDialog;
        friend class LocationDialogLite;

        static KStarsData *Create();

        static inline KStarsData *Instance()
        {
            return pinstance;
        }

        bool initialize();

        ~KStarsData() override;

        void setNextDSTChange(const KStarsDateTime &dt)
        {
            NextDSTChange = dt;
        }

        bool isTimeRunningForward() const
        {
            return TimeRunsForward;
        }

        //KLocale *getLocale() { return locale; }

        SkyObject *objectNamed(const QString &name);

        void setFullTimeUpdate();

        void changeDateTime(const KStarsDateTime &newDate);

        const KStarsDateTime &lt() const
        {
            return LTime;
        }

        const KStarsDateTime &ut() const
        {
            return Clock.utc();
        }

        void syncLST();

        SkyMapComposite *skyComposite()
        {
            return m_SkyComposite.get();
        }

        ColorScheme *colorScheme()
        {
            return &CScheme;
        }

        Q_INVOKABLE QString colorSchemeName()
        {
            return CScheme.fileName();
        }

        KSUserDB *userdb()
        {
            return &m_ksuserdb;
        }

        CatalogDB *catalogdb()
        {
            return &m_catalogdb;
        }

        Q_INVOKABLE SimClock *clock()
        {
            return &Clock;
        }

        CachingDms *lst()
        {
            return &LST;
        }

        GeoLocation *geo()
        {
            return &m_Geo;
        }

        QList<GeoLocation *> &getGeoList()
        {
            return geoList;
        }

        GeoLocation *locationNamed(const QString &city, const QString &province = QString(),
                                   const QString &country = QString());

        GeoLocation *nearestLocation(double longitude, double latitude);

        void setLocation(const GeoLocation &l);

        void setLocationFromOptions();

        const QMap<QString, TimeZoneRule> &getRulebook() const
        {
            return Rulebook;
        }

        bool snapNextFocus() const
        {
            return snapToFocus;
        }

        void setSnapNextFocus(bool b = true)
        {
            snapToFocus = b;
        }

        bool executeScript(const QString &name, SkyMap *map);

#ifndef KSTARS_LITE
        void syncFOV();
#endif

        inline const QList<FOV *> getVisibleFOVs() const
        {
            return visibleFOVs;
        }

        inline const QList<FOV *> getAvailableFOVs() const
        {
            return availFOVs;
        }

        inline void addTransientFOV(std::shared_ptr<FOV> newFOV)
        {
            transientFOVs.append(newFOV);
        }
        inline void clearTransientFOVs()
        {
            transientFOVs.clear();
        }

        inline const QList<std::shared_ptr<FOV>> getTransientFOVs() const
        {
            return transientFOVs;
        }
#ifndef KSTARS_LITE

        OAL::Log *logObject()
        {
            return m_LogObject.get();
        }

        QList<ADVTreeData *> avdTree()
        {
            return ADVtreeList;
        }

        inline ObservingList *observingList() const
        {
            return m_ObservingList;
        }

        ImageExporter *imageExporter();

        Execute *executeSession();
#endif
        /*@short Increments the updateID, forcing a recomputation of star positions as well */
        unsigned int incUpdateID();

        unsigned int updateID() const
        {
            return m_updateID;
        }
        unsigned int updateNumID() const
        {
            return m_updateNumID;
        }
        KSNumbers *updateNum()
        {
            return &m_updateNum;
        }
        void syncUpdateIDs();

    signals:
        void progressText(const QString &text);

        void skyUpdate(bool);

        void clearCache();

        void geoChanged();

    public slots:
        void slotConsoleMessage(QString s)
        {
            std::cout << (const char *)(s.toLocal8Bit()) << std::endl;
        }

        void updateTime(GeoLocation *geo, const bool automaticDSTchange = true);

        void setTimeDirection(float scale);

    private:
        bool readCityData();

        bool readTimeZoneRulebook();

        //TODO JM: ADV tree should use XML instead
        bool readADVTreeData();

        bool readINDIHosts();

        //TODO JM: Use XML instead; The logger should have more features
        // that allow users to enter details about their observation logs
        // objects observed, eye pieces, telescope, conditions, mag..etc
        bool readUserLog();

        bool readURLData(const QString &url, int type = 0, bool deepOnly = false);

        bool openUrlFile(const QString &urlfile, QFile &file);

        void resetToNewDST(GeoLocation *geo, const bool automaticDSTchange);

        QList<ADVTreeData *> ADVtreeList;
        std::unique_ptr<SkyMapComposite> m_SkyComposite;

        GeoLocation m_Geo;
        SimClock Clock;
        KStarsDateTime LTime;
        KSUserDB m_ksuserdb;
        CatalogDB m_catalogdb;
        ColorScheme CScheme;
#ifndef KSTARS_LITE
        ObservingList* m_ObservingList { nullptr };
        std::unique_ptr<OAL::Log> m_LogObject;
        std::unique_ptr<Execute> m_Execute;
        std::unique_ptr<ImageExporter> m_ImageExporter;
#endif

        //EquipmentWriter *m_equipmentWriter;

        bool TimeRunsForward { false };
        bool temporaryTrail { false };
        // FIXME: Used in SkyMap only. Check!
        bool snapToFocus { false };

        //KLocale *locale;

        CachingDms LST;

        QKeySequence resumeKey;

        QList<FOV *> availFOVs;         // List of all available FOVs
        QList<FOV *> visibleFOVs;       // List of visible FOVs. Cached from Options::FOVNames
        QList<std::shared_ptr<FOV>> transientFOVs;     // List of non-permenant transient FOVs.

        KStarsDateTime LastNumUpdate, LastSkyUpdate, LastPlanetUpdate, LastMoonUpdate;
        KStarsDateTime NextDSTChange;
        // FIXME: Used in kstarsdcop.cpp only
        KStarsDateTime StoredDate;

        QList<GeoLocation *> geoList;
        QMap<QString, TimeZoneRule> Rulebook;

        quint32 m_preUpdateID, m_updateID;
        quint32 m_preUpdateNumID, m_updateNumID;
        KSNumbers m_preUpdateNum, m_updateNum;

        static KStarsData *pinstance;
};