Oculars.hpp

/*
 * Copyright (C) 2009 Timothy Reaves
 * Copyright (C) 2011 Bogdan Marinov
 *
 * 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 _OCULARS_HPP_
#define _OCULARS_HPP_

#include "CCD.hpp"
#include "Lens.hpp"
#include "Ocular.hpp"
#include "OcularDialog.hpp"
#include "StelModule.hpp"
#include "StelTexture.hpp"
#include "Telescope.hpp"
#include "VecMath.hpp"

#include <QFont>
#include <QSettings>

#define MIN_OCULARS_INI_VERSION 3.1f

QT_BEGIN_NAMESPACE
class QKeyEvent;
class QMenu;
class QMouseEvent;
class QPixmap;
class QSettings;
class QSignalMapper;
QT_END_NAMESPACE

class StelButton;
class StelAction;

class Oculars : public StelModule
{
    Q_OBJECT

    Q_PROPERTY(bool enableOcular READ getEnableOcular WRITE enableOcular NOTIFY enableOcularChanged)
    Q_PROPERTY(bool enableCrosshairs READ getEnableCrosshairs WRITE toggleCrosshairs NOTIFY enableCrosshairsChanged)
    Q_PROPERTY(bool enableCCD READ getEnableCCD WRITE toggleCCD NOTIFY enableCCDChanged)
    Q_PROPERTY(bool enableTelrad READ getEnableTelrad WRITE toggleTelrad NOTIFY enableTelradChanged)
    Q_PROPERTY(bool flagHideGridsLines READ getFlagHideGridsLines WRITE setFlagHideGridsLines NOTIFY hideGridsLinesChanged)

    //BM: Temporary, until the GUI is finalized and some other method of getting
    //info from the main class is implemented.
    friend class OcularsGuiPanel;

public:
    Oculars();
    virtual ~Oculars();
    static QSettings* appSettings();

    // Methods defined in the StelModule class
    virtual void init();
    virtual void deinit();
    virtual bool configureGui(bool show=true);
    virtual void draw(StelCore* core);
    virtual double getCallOrder(StelModuleActionName actionName) const;
    virtual void handleKeys(class QKeyEvent* event);
    virtual void handleMouseClicks(class QMouseEvent* event);
    virtual void update(double) {;}
    double ccdRotationAngle() const;

    QString getDimensionsString(double fovX, double fovY) const;
    QString getFOVString(double fov) const;

public slots:
    void updateLists();
    void ccdRotationReset();
    void decrementCCDIndex();
    void decrementOcularIndex();
    void decrementTelescopeIndex();
    void decrementLensIndex();
    void displayPopupMenu();
    void enableOcular(bool b);
    bool getEnableOcular() const { return flagShowOculars; }
    void incrementCCDIndex();
    void incrementOcularIndex();
    void incrementTelescopeIndex();
    void incrementLensIndex();
    void disableLens();
    void rotateCCD(QString amount); 
    void selectCCDAtIndex(QString indexString); 
    void selectOcularAtIndex(QString indexString);  
    void selectTelescopeAtIndex(QString indexString);  
    void selectLensAtIndex(QString indexString); 
    void toggleCCD(bool show);
    void toggleCCD();
    bool getEnableCCD() const { return flagShowCCD; }
    void toggleCrosshairs(bool show = true);
    bool getEnableCrosshairs() const { return flagShowCrosshairs; }
    void toggleTelrad(bool show);
    bool getEnableTelrad() const { return flagShowTelrad; }
    void toggleTelrad();
    void enableGuiPanel(bool enable = true);

    void setFlagDecimalDegrees(const bool b);
    bool getFlagDecimalDegrees(void) const;

    void setFlagLimitMagnitude(const bool b);
    bool getFlagLimitMagnitude(void) const;

    void setFlagInitFovUsage(const bool b);
    bool getFlagInitFovUsage(void) const;

    void setFlagInitDirectionUsage(const bool b);
    bool getFlagInitDirectionUsage(void) const;

    void setFlagAutosetMountForCCD(const bool b);
    bool getFlagAutosetMountForCCD(void) const;

    void setFlagUseSemiTransparency(const bool b);
    bool getFlagUseSemiTransparency(void) const;

    void setFlagShowResolutionCriterions(const bool b);
    bool getFlagShowResolutionCriterions(void) const;

    void setFlagHideGridsLines(const bool b);
    bool getFlagHideGridsLines(void) const;

signals:
    void enableOcularChanged(bool value);
    void enableCrosshairsChanged(bool value);
    void enableCCDChanged(bool value);
    void enableTelradChanged(bool value);
    void selectedCCDChanged();
    void selectedOcularChanged();
    void selectedTelescopeChanged();
    void selectedLensChanged();
    void hideGridsLinesChanged(bool value);

private slots:
    void instrumentChanged();
    void determineMaxEyepieceAngle();
    void setRequireSelection(bool state);
    void setScaleImageCircle(bool state);
    void setScreenFOVForCCD();
    void retranslateGui();
    void updateOcularReticle(void);

private:
    void initializeActivationActions();

    bool isBinocularDefined();

    void paintCCDBounds();
    void paintCrosshairs();
    void paintOcularMask(const StelCore * core);
    void paintTelrad();

    void paintText(const StelCore * core);

    void unzoomOcular();

    void validateAndLoadIniFile();

    void zoom(bool zoomedIn);

    void zoomOcular();

    void hideUsageMessageIfDisplayed();

    QMenu* addLensSubmenu(QMenu* parent);

    QMenu* addTelescopeSubmenu(QMenu* parent);

    Lens* selectedLens();

    QList<CCD *> ccds;
    QList<Ocular *> oculars;
    QList<Telescope *> telescopes;
    QList<Lens *> lenses;

    int selectedCCDIndex; 
    int selectedOcularIndex; 
    int selectedTelescopeIndex; 
    int selectedLensIndex; 

    QFont font;         
    bool flagShowCCD;       
    bool flagShowOculars;       
    bool flagShowCrosshairs;    
    bool flagShowTelrad;        
    int usageMessageLabelID;    

    bool flagCardinalPoints;    
    bool flagAdaptation;        

    bool flagLimitStars;        
    float magLimitStars;        
    bool flagLimitDSOs;     
    float magLimitDSOs;     
    bool flagLimitPlanets;      
    float magLimitPlanets;      
    float relativeStarScaleMain;    
    float absoluteStarScaleMain;    
    float relativeStarScaleOculars; 
    float absoluteStarScaleOculars; 
    float relativeStarScaleCCD; 
    float absoluteStarScaleCCD; 
    bool flagMoonScale;     

    double maxEyepieceAngle;    
    bool requireSelection;      
    bool flagLimitMagnitude;    
    bool useMaxEyepieceAngle;   
    bool guiPanelEnabled;
    bool flagDecimalDegrees;
    bool flagSemiTransparency;
    bool flagHideGridsLines;
    bool flagGridLinesDisplayedMain; 
    bool flagConstellationLines;
    bool flagAsterismLines;
    bool flipVert;
    bool flipHorz;

    QSignalMapper * ccdRotationSignalMapper;  
    QSignalMapper * ccdsSignalMapper; 
    QSignalMapper * ocularsSignalMapper; 
    QSignalMapper * telescopesSignalMapper; 
    QSignalMapper * lensesSignalMapper; 

    // for toolbar button
    QPixmap * pxmapGlow;
    QPixmap * pxmapOnIcon;
    QPixmap * pxmapOffIcon;
    StelButton * toolbarButton;

    OcularDialog *ocularDialog;
    bool ready; 

    StelAction * actionShowOcular;
    StelAction * actionShowCrosshairs;
    StelAction * actionShowSensor;
    StelAction * actionShowTelrad;
    StelAction * actionConfiguration;
    StelAction * actionMenu;
    StelAction * actionTelescopeIncrement;
    StelAction * actionTelescopeDecrement;
    StelAction * actionOcularIncrement;
    StelAction * actionOcularDecrement;

    class OcularsGuiPanel * guiPanel;

    //Reticle
    StelTextureSP reticleTexture;
    double actualFOV;       
    double initialFOV;      
    bool flagInitFOVUsage;      
    bool flagInitDirectionUsage;    
    bool flagAutosetMountForCCD;    
    bool flagShowResolutionCriterions;
    bool equatorialMountEnabled;
    double reticleRotation;
};



#include <QObject>
#include "StelPluginInterface.hpp"

class OcularsStelPluginInterface : public QObject, public StelPluginInterface
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID StelPluginInterface_iid)
    Q_INTERFACES(StelPluginInterface)
public:
    virtual StelModule* getStelModule() const;
    virtual StelPluginInfo getPluginInfo() const;
    virtual QObjectList getExtensionList() const { return QObjectList(); }
};

#endif /*_OCULARS_HPP_*/