StelApp.hpp

/*
 * Stellarium
 * Copyright (C) 2006 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 _STELAPP_HPP_
#define _STELAPP_HPP_

#include <QString>
#include <QObject>
#include "StelModule.hpp"

// Predeclaration of some classes
class StelCore;
class StelTextureMgr;
class StelObjectMgr;
class StelLocaleMgr;
class StelModuleMgr;
class StelMainView;
class StelSkyCultureMgr;
class StelViewportEffect;
class QOpenGLFramebufferObject;
class QOpenGLFunctions;
class QSettings;
class QNetworkAccessManager;
class QNetworkReply;
class QTimer;
class StelLocationMgr;
class StelSkyLayerMgr;
class StelAudioMgr;
class StelVideoMgr;
class StelGuiBase;
class StelMainScriptAPIProxy;
class StelScriptMgr;
class StelActionMgr;
class StelPropertyMgr;
class StelProgressController;

#ifdef  ENABLE_SPOUT
class SpoutSender;
#endif

class StelApp : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool nightMode READ getVisionModeNight WRITE setVisionModeNight NOTIFY visionNightModeChanged)

public:
    friend class StelAppGraphicsWidget;
    friend class StelRootItem;

    StelApp(StelMainView* parent);

    virtual ~StelApp();

    void init(QSettings* conf);
    void deinit();

    void initPlugIns();

    void initScriptMgr();

    static QStringList getCommandlineArguments();

    static StelApp& getInstance() {Q_ASSERT(singleton); return *singleton;}

    StelModuleMgr& getModuleMgr() {return *moduleMgr;}

    StelLocaleMgr& getLocaleMgr() {return *localeMgr;}

    StelSkyCultureMgr& getSkyCultureMgr() {return *skyCultureMgr;}

    StelTextureMgr& getTextureManager() {return *textureMgr;}

    StelLocationMgr& getLocationMgr() {return *planetLocationMgr;}

    StelObjectMgr& getStelObjectMgr() {return *stelObjectMgr;}

    StelSkyLayerMgr& getSkyImageMgr() {return *skyImageMgr;}

    StelAudioMgr* getStelAudioMgr() {return audioMgr;}

    StelActionMgr* getStelActionManager() {return actionMgr;}

    StelPropertyMgr* getStelPropertyManager() {return propMgr;}

    StelVideoMgr* getStelVideoMgr() {return videoMgr;}

    StelCore* getCore() {return core;}

    QNetworkAccessManager* getNetworkAccessManager() {return networkAccessManager;}

    void updateI18n();

    QSettings* getSettings() {return confSettings;}

    QString getCurrentStelStyle() {return "color";}

    void update(double deltaTime);

    // 2014-11: OLD COMMENT? What does a void return?
    // @return the max squared distance in pixels that any object has travelled since the last update.
    void draw();

    float getDevicePixelsPerPixel() const {return devicePixelsPerPixel;}
    void setDevicePixelsPerPixel(float dppp);
    
    float getGlobalScalingRatio() const {return globalScalingRatio;}
    void setGlobalScalingRatio(float r) {globalScalingRatio=r;}

    int getBaseFontSize() const { return baseFontSize; }
    void setBaseFontSize(int s) { baseFontSize=s; }

    StelGuiBase* getGui() const {return stelGui;}
    void setGui(StelGuiBase* b) {stelGui=b;}

#ifndef DISABLE_SCRIPTING
    StelMainScriptAPIProxy* getMainScriptAPIProxy() {return scriptAPIProxy;}
    StelScriptMgr& getScriptMgr() {return *scriptMgr;}
#endif

    static void initStatic();
    static void deinitStatic();

    StelProgressController* addProgressBar();
    void removeProgressBar(StelProgressController* p);

    void setViewportEffect(const QString& effectName);
    QString getViewportEffect() const;

    void dumpModuleActionPriorities(StelModule::StelModuleActionName actionName);
    
    // Scriptable methods
public slots:
    void glWindowHasBeenResized(const QRectF &rect);

    void setVisionModeNight(bool);
    bool getVisionModeNight() const {return flagNightVision;}

    void setFlagShowDecimalDegrees(bool b);
    bool getFlagShowDecimalDegrees() const {return flagShowDecimalDegrees;}

    bool getFlagSouthAzimuthUsage() const { return flagUseAzimuthFromSouth; }
    void setFlagSouthAzimuthUsage(bool use) { flagUseAzimuthFromSouth=use; }
    
    void setFlagUseFormattingOutput(bool b);
    bool getFlagUseFormattingOutput() const {return flagUseFormattingOutput;}

    void setFlagUseCCSDesignation(bool b);
    bool getFlagUseCCSDesignation() const {return flagUseCCSDesignation;}

    float getFps() const {return fps;}

    quint32 getDefaultFBO() const { return currentFbo; }

    void ensureGLContextCurrent();

    static double getTotalRunTime();

    static double getAnimationTime();

    void reportFileDownloadFinished(QNetworkReply* reply);

    void quit();
signals:
    void visionNightModeChanged(bool);
    void colorSchemeChanged(const QString&);
    void languageChanged();

    void progressBarAdded(const StelProgressController*);
    void progressBarRemoved(const StelProgressController*);
    void aboutToQuit();
private:

    void handleClick(class QMouseEvent* event);
    void handleWheel(class QWheelEvent* event);
    bool handleMove(float x, float y, Qt::MouseButtons b);
    void handleKeys(class QKeyEvent* event);
    void handlePinch(qreal scale, bool started);

    void prepareRenderBuffer();
    void applyRenderBuffer(quint32 drawFbo=0);

    // The StelApp singleton
    static StelApp* singleton;

    StelMainView* mainWin;

    // The associated StelCore instance
    StelCore* core;

    // Module manager for the application
    StelModuleMgr* moduleMgr;

    // Locale manager for the application
    StelLocaleMgr* localeMgr;

    // Sky cultures manager for the application
    StelSkyCultureMgr* skyCultureMgr;

    //Actions manager fot the application.  Will replace shortcutMgr.
    StelActionMgr* actionMgr;

    //Property manager for the application
    StelPropertyMgr* propMgr;

    // Textures manager for the application
    StelTextureMgr* textureMgr;

    // Manager for all the StelObjects of the program
    StelObjectMgr* stelObjectMgr;

    // Manager for the list of observer locations on planets
    StelLocationMgr* planetLocationMgr;

    // Main network manager used for the program
    QNetworkAccessManager* networkAccessManager;

    void setupNetworkProxy();

    // The audio manager.  Must execute in the main thread.
    StelAudioMgr* audioMgr;

    // The video manager.  Must execute in the main thread.
    StelVideoMgr* videoMgr;

    StelSkyLayerMgr* skyImageMgr;

#ifndef DISABLE_SCRIPTING
    // The script API proxy object (for bridging threads)
    StelMainScriptAPIProxy* scriptAPIProxy;

    // The script manager based on Qt script engine
    StelScriptMgr* scriptMgr;
#endif



    StelGuiBase* stelGui;
    
    // Store the ratio between real device pixel in "Device Independent Pixel"
    // Usually this value is 1, but for a mac with retina screen this will be value 2.
    float devicePixelsPerPixel;

    // The scaling ratio to apply on all display elements, like GUI, text etc..
    float globalScalingRatio;
    
    // Used to collect wheel events
    QTimer * wheelEventTimer;

    // Accumulated horizontal and vertical wheel event deltas
    int wheelEventDelta[2];

    float fps;
    int frame;
    double frameTimeAccum;      // Used for fps counter

    bool flagNightVision;

    QSettings* confSettings;

    // Define whether the StelApp instance has completed initialization
    bool initialized;

    static qint64 startMSecs;
    static float animationScale;

    // Temporary variables used to store the last gl window resize
    // if the core was not yet initialized
    int saveProjW;
    int saveProjH;

    int nbDownloadedFiles;
    qint64 totalDownloadedSize;

    int nbUsedCache;
    qint64 totalUsedCacheSize;

    QList<StelProgressController*> progressControllers;

    int baseFontSize;   

    // Framebuffer object used for viewport effects.
    QOpenGLFramebufferObject* renderBuffer;
    StelViewportEffect* viewportEffect;
    QOpenGLFunctions* gl;
    
    bool flagShowDecimalDegrees;
    // flag to indicate we want calculate azimuth from south towards west (as in old astronomical literature)
    bool flagUseAzimuthFromSouth;
    bool flagUseFormattingOutput;
    bool flagUseCCSDesignation;
#ifdef  ENABLE_SPOUT
    SpoutSender* spoutSender;
#endif

    // The current main FBO/render target handle, without requiring GL queries. Valid through a draw() call
    quint32 currentFbo;

};

#endif // _STELAPP_HPP_