x2mount.h

#pragma once
#include "../../licensedinterfaces/mountdriverinterface.h"
 
//Optional interfaces, uncomment and implement as required.
//#include "../../licensedinterfaces/mount/slewtointerface.h"
//#include "../../licensedinterfaces/mount/syncmountinterface.h"
//#include "../../licensedinterfaces/mount/asymmetricalequatorialinterface.h"
//#include "../../licensedinterfaces/mount/openloopmoveinterface.h"
//#include "../../licensedinterfaces/mount/needsrefractioninterface.h"
//#include "../../licensedinterfaces/mount/linkfromuithreadinterface.h"
//#include "../../licensedinterfaces/mount/trackingratesinterface.h"
 
// Forward declare the interfaces that the this driver is "given" by TheSkyX
class SerXInterface;
class TheSkyXFacadeForDriversInterface;
class SleeperInterface;
class BasicIniUtilInterface;
class LoggerInterface;
class MutexInterface;
class AbstractSyncMount;
class TickCountInterface;
 
class X2Mount : public MountDriverInterface 
                                                //Optional interfaces, uncomment and implement as required.
                                                //,public SyncMountInterface, 
                                                //,public SlewToInterface,
                                                //,public AsymmetricalEquatorialInterface,
                                                //,public OpenLoopMoveInterface,
                                                //,public NeedsRefractionInterface,
                                                //,public LinkFromUIThreadInterface,
                                                //,public TrackingRatesInterface 
{
public:
        X2Mount(const char* pszDriverSelection,
                                const int& nInstanceIndex,
                                SerXInterface                                   * pSerX, 
                                TheSkyXFacadeForDriversInterface        * pTheSkyX, 
                                SleeperInterface                                        * pSleeper,
                                BasicIniUtilInterface                   * pIniUtil,
                                LoggerInterface                                 * pLogger,
                                MutexInterface                                  * pIOMutex,
                                TickCountInterface                              * pTickCount);
 
        ~X2Mount();
 
// Operations
public:
 
        virtual DeviceType                                                      deviceType(void)                                                          {return DriverRootInterface::DT_MOUNT;}
        virtual int                                                                     queryAbstraction(const char* pszName, void** ppVal) ;
 
        virtual int                                                                     establishLink(void)                                             ;
        virtual int                                                                     terminateLink(void)                                             ;
        virtual bool                                                            isLinked(void) const                                    ;
        virtual bool                                                            isEstablishLinkAbortable(void) const    ;
 
        virtual void                                                            driverInfoDetailedInfo(BasicStringInterface& str) const;
        virtual double                                                          driverInfoVersion(void) const                           ;
 
        virtual void deviceInfoNameShort(BasicStringInterface& str) const                               ;
        virtual void deviceInfoNameLong(BasicStringInterface& str) const                                ;
        virtual void deviceInfoDetailedDescription(BasicStringInterface& str) const     ;
        virtual void deviceInfoFirmwareVersion(BasicStringInterface& str)                               ;
        virtual void deviceInfoModel(BasicStringInterface& str)                                         ;
 
        virtual int                                                                     raDec(double& ra, double& dec, const bool& bCached = false)                                     ;
        virtual int                                                                     abort(void)                                                                                                                                     ;
 
        //Optional interfaces, uncomment and implement as required.
 
        //SyncMountInterface
        //virtual int syncMount(const double& ra, const double& dec)                                                                    ;
        //virtual bool isSynced()                                                                                                                                               ;
 
        //SlewToInterface
        //virtual int                                                           startSlewTo(const double& dRa, const double& dDec)      ;
        //virtual int                                                           isCompleteSlewTo(bool& bComplete) const                         ;
        //virtual int                                                           endSlewTo(void)                                                                         ;
        
        //AsymmetricalEquatorialInterface
        //virtual bool knowsBeyondThePole(); 
        //virtual int beyondThePole(bool& bYes);
        //virtual double flipHourAngle();
        //virtual int gemLimits(double& dHoursEast, double& dHoursWest);
 
        //OpenLoopMoveInterface
        //virtual int                                                           startOpenLoopMove(const MountDriverInterface::MoveDir& Dir, const int& nRateIndex);
        //virtual int                                                           endOpenLoopMove(void)                                                                                                                   ;
        //virtual bool                                                          allowDiagonalMoves()                                                                                                                    ;
        //virtual int                                                           rateCountOpenLoopMove(void) const                                                                                               ;
        //virtual int                                                           rateNameFromIndexOpenLoopMove(const int& nZeroBasedIndex, char* pszOut, const int& nOutMaxSize);
        //virtual int                                                           rateIndexOpenLoopMove(void);
 
        //NeedsRefractionInterface
        //virtual bool                                                  needsRefactionAdjustments(void);
 
        //LinkFromUIThreadInterface
 
        //TrackingRatesInterface 
        //virtual int setTrackingRates( const bool& bTrackingOn, const bool& bIgnoreRates, const double& dRaRateArcSecPerSec, const double& dDecRateArcSecPerSec);
        //virtual int trackingRates( bool& bTrackingOn, double& dRaRateArcSecPerSec, double& dDecRateArcSecPerSec);
 
// Implementation
private:        
 
        SerXInterface                                                   *GetSerX() {return m_pSerX; }           
        TheSkyXFacadeForDriversInterface                        *GetTheSkyXFacadeForMounts() {return m_pTheSkyXForMounts;}
        SleeperInterface                                                *GetSleeper() {return m_pSleeper; }
        BasicIniUtilInterface                                   *GetSimpleIniUtil() {return m_pIniUtil; }
        LoggerInterface                                                 *GetLogger() {return m_pLogger; }
        MutexInterface                                                  *GetMutex()  {return m_pIOMutex;}
        TickCountInterface                                              *GetTickCountInterface() {return m_pTickCount;}
        
 
        int m_nPrivateMulitInstanceIndex;
        SerXInterface*                                                  m_pSerX;                
        TheSkyXFacadeForDriversInterface*               m_pTheSkyXForMounts;
        SleeperInterface*                                               m_pSleeper;
        BasicIniUtilInterface*                                  m_pIniUtil;
        LoggerInterface*                                                        m_pLogger;
        MutexInterface*                                                 m_pIOMutex;
        TickCountInterface*                                             m_pTickCount;
 
 
 
};