File indexing completed on 2024-04-21 03:45:05

 /*
     SPDX-FileCopyrightText: 2016 Artem Fedoskin <afedoskin3@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "config-kstars.h"
 
 //Needed for Projection enum
 #include "projections/projector.h"
 
 #include <QQuickWindow>
 #include <QPalette>
 #include <QString>
 #include <QtQml/QQmlApplicationEngine>
 
 #include <memory>
 
 // forward declaration is enough. We only need pointers
 class KStarsData;
 class SkyMapLite;
 class SkyPoint;
 class GeoLocation;
 class ImageProvider;
 
 class FindDialogLite;
 class DetailDialogLite;
 class LocationDialogLite;
 
 class ClientManagerLite;
 
 class QQuickItem;
 
 /**
  * @class KStarsLite
  * @short This class loads QML files and connects SkyMapLite and KStarsData
  * Unlike KStars class it is not a main window (see KStarsLite::m_Engine) but a root object that contains the program clock and
  * holds pointers to SkyMapLite and KStarsData objects.
  * KStarsLite is a singleton, use KStarsLite::createInstance() to create an instance and KStarsLite::Instance() to get a pointer to the instance
  *
  * @author Artem Fedoskin
  * @version 1.0
  */
 class KStarsLite : public QObject
 {
     Q_OBJECT
     //runTutorial is a wrapper for Options::RunStartupWizard()
     Q_PROPERTY(bool runTutorial WRITE setRunTutorial READ getRunTutorial NOTIFY runTutorialChanged)
   private:
 
     /**
      * @short Constructor.
      * @param doSplash should the splash panel be displayed during initialization.
      * @param startClockRunning should the clock be running on startup?
      * @param startDateString date (in string representation) to start running from.
      */
     explicit KStarsLite(bool doSplash, bool startClockRunning = true, const QString &startDateString = QString());
     virtual ~KStarsLite();
 
     static KStarsLite *pinstance; // Pointer to an instance of KStarsLite
 
   public:
     /**
      * @short Create an instance of this class. Destroy any previous instance
      * @param doSplash
      * @param clockrunning
      * @param startDateString
      * @note See KStarsLite::KStarsLite for details on parameters
      * @return a pointer to the instance
      */
     static KStarsLite *createInstance(bool doSplash, bool clockrunning = true,
                                       const QString &startDateString = QString());
 
     /** @return a pointer to the instance of this class */
     inline static KStarsLite *Instance() { return pinstance; }
 
     /** @return pointer to SkyMapLite object which draws SkyMap. */
     inline SkyMapLite *map() const { return m_SkyMapLite; }
 
     /** @return pointer to the main window. */
     QQuickWindow *getMainWindow();
 
     /** @return pointer to KStarsData object which contains application data. */
     inline KStarsData *data() const { return m_KStarsData; }
 
     /** @return pointer to ImageProvider that is used in QML to display image fetched from CCD **/
     inline ImageProvider *imageProvider() const { return m_imgProvider.get(); }
 
     /** @return pointer to QQmlApplicationEngine that runs QML **/
     inline QQmlApplicationEngine *qmlEngine() { return &m_Engine; }
 
     /** @short used from QML to update positions of sky objects and update SkyMapLite */
     Q_INVOKABLE void fullUpdate();
 
     /** @short currently sets color scheme from config **/
     Q_INVOKABLE void applyConfig(bool doApplyFocus = true);
 
     /** @short set whether tutorial should be shown on next startup **/
     void setRunTutorial(bool runTutorial);
 
     /** @return true if tutorial should be shown **/
     bool getRunTutorial();
 
     /** @return pointer to KStarsData object which handles connection to INDI server. */
     inline ClientManagerLite *clientManagerLite() const { return m_clientManager; }
 
     /**
      * @defgroup kconfigwrappers QML wrappers around KConfig
      * @{
      */
     enum class ObjectsToToggle
     {
         Stars,
         DeepSky,
         Planets,
         CLines,
         CBounds,
         ConstellationArt,
         MilkyWay,
         CNames,
         EquatorialGrid,
         HorizontalGrid,
         Ground,
         Flags,
         Satellites,
         Supernovae
     };
 
     Q_ENUMS(ObjectsToToggle)
 
     /** setProjection calls Options::setProjection(proj) and updates SkyMapLite */
     // Having projection as uint is not good but it will go away once KConfig is fixed
     // The reason for this is that you can't use Enums of another in class in Q_INVOKABLE function
     Q_INVOKABLE void setProjection(uint proj);
 
     // These functions are just convenient getters to access internals of KStars from QML
 
     /**
      * @short returns color with key name from current color scheme
      * @param name the key name of the color to be retrieved from current color scheme
      * @return color from name
      */
     Q_INVOKABLE QColor getColor(QString name);
 
     Q_INVOKABLE QString getConfigCScheme();
 
     /**
      * @short toggles on/off objects of group toToggle
      * @see ObjectsToToggle
      */
     Q_INVOKABLE void toggleObjects(ObjectsToToggle toToggle, bool toggle);
 
     /** @return true if objects from group toToggle are currently toggled on **/
     Q_INVOKABLE bool isToggled(ObjectsToToggle toToggle);
 
     /** @} */ // end of kconfigwrappers group
 
 signals:
     /** Sent when KStarsData finishes loading data */
     void dataLoadFinished();
 
     /** Makes splash (Splash.qml) visible on startup */
     void showSplash();
 
     /** Emitted whenever TimeSpinBox in QML changes the scale **/
     void scaleChanged(float);
 
     void runTutorialChanged();
 
     /**
      * Once this signal is emitted, notification with text msg will appear on the screen.
      * Use this signal to output messages to user (warnings, info etc.)
      */
     void notificationMessage(QString msg);
 
   public Q_SLOTS:
     /**
      * Update time-dependent data and (possibly) repaint the sky map.
      * @param automaticDSTchange change DST status automatically?
      */
     void updateTime(const bool automaticDSTchange = true);
 
     /** Write current settings to config file. Used to save config file upon exit */
     bool writeConfig();
 
     /**
      * Load a color scheme.
      * @param name the name of the color scheme to load (e.g., "Moonless Night")
      */
     void loadColorScheme(const QString &name);
 
     /** sets time and date according to parameter time*/
     void slotSetTime(QDateTime time);
 
     /** action slot: toggle whether kstars clock is running or not */
     void slotToggleTimer();
 
     /** action slot: advance one step forward in time */
     void slotStepForward();
 
     /** action slot: advance one step backward in time */
     void slotStepBackward();
 
     /** start tracking clickedPoint or stop tracking if we are already tracking some object **/
     void slotTrack();
 
 private slots:
     /** finish setting up after the KStarsData has finished */
     void datainitFinished();
 
     /** Save data to config file before exiting.*/
     void handleStateChange(Qt::ApplicationState state);
 
   private:
     /** Initialize focus position */
     void initFocus();
 
     QQmlApplicationEngine m_Engine;
     SkyMapLite *m_SkyMapLite { nullptr };
     QPalette OriginalPalette, DarkPalette;
 
     QObject *m_RootObject { nullptr };
     bool StartClockRunning { false };
 
     KStarsData *m_KStarsData { nullptr };
     std::unique_ptr<ImageProvider> m_imgProvider;
 
     //Dialogs
     FindDialogLite *m_findDialogLite { nullptr };
     DetailDialogLite *m_detailDialogLite { nullptr };
     LocationDialogLite *m_locationDialogLite { nullptr };
 
     ClientManagerLite *m_clientManager { nullptr };
 };