mi32/mgps.h

Go to the documentation of this file.

#ifndef  INC_MI32_MGPS_H
#define  INC_MI32_MGPS_H

#ifdef USE_MGUI

#ifndef  INC_MI32_OBSERVER_H
#include <mi32/observer.h>
#endif

#ifndef  INC_MI32_SPATREF_H
#include <mi32/spatref.h>
#endif

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

#ifndef  INC_MI32_COLOR_H
#include <mi32/color.h>
#endif

#ifndef  INC_MI32_FILEPATH_H
#include <mi32/filepath.h>
#endif

#ifndef INC_MI32_XML_H
#include <mi32/xml.h>
#endif

#ifndef  INC_RVC_OBJECTNAME_H
#include <rvc/objectname.h>
#endif

#ifndef  INC_MGUI_TIMER_H
#include <mgui/timer.h>
#endif

#include <mi32/platformsupport.h>

//-------------------------------------------------------------------------------------------------------------------
//    Forward declarations

#ifndef GENERATING_DOXYGEN_OUTPUT
class PORT;
struct POINTSTYLE;
class FILE_TEXT;
namespace MGUI {
   class LAYOUT_PANE_BASE;
   class FORM;
   }
namespace MGD {
   class CONTEXT;
   }
namespace RVC {
   class STYLE;
   }
#endif


namespace MGPS {

class SOURCEMGR;

//-------------------------------------------------------------------------------------------------------------------

struct REPORT {

   enum DATASRC {
      DATASRC_GPS2D =      0,
      DATASRC_GPS3D =      1,
      DATASRC_DGPS2D =     2,
      DATASRC_DGPS3D =     3,
      DATASRC_DR =         6,
      DATASRC_DegradedDR = 8,
      DATASRC_Unknown =    9
      };

   enum VALID {
      VALID_None =         0x0000,
      VALID_PositionXY =   0x0001,
      VALID_PositionZ =    0x0002,
      VALID_VelocityXY =   0x0004,
      VALID_VelocityZ =    0x0008,
      VALID_Heading =      0x0010,
      VALID_Speed =        0x0020,
      VALID_NumSat =       0x0040,
      VALID_DateTime =     0x0080
      };

   DPOINT3D Position;                  
   DPOINT3D Velocity;                  
   double Heading;                     
   double Speed;                       
   DATASRC DataSrc;                    
   VALID Valid;                        
   UINT16 Year;                        
   UINT8 Month;                        
   UINT8 Day;                          
   UINT8 Hour;                         
   UINT8 Minute;                       
   UINT8 Second;                       
   UINT8 NumSatellites;                
   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(REPORT::VALID)
#endif

//-------------------------------------------------------------------------------------------------------------------

class SYMBOL {
   public:

      enum FLAGS {
         FLAG_None =             0,
         FLAG_PatternSymbol =    0x00000001, 
         FLAG_PatternBitmap =    0x00000002, 
         FLAG_SizeBySpeed =      0x00000004, 
         FLAG_SizeLengthOnly =   0x00000008, 
         FLAG_KeepUpright =      0x00000010  
         };

      enum ORIENT {
         ORIENT_HeadingUp =      0,
         ORIENT_HeadingRight =   1,
         ORIENT_HeadingDown =    2,
         ORIENT_HeadingLeft =    3
         };

      SYMBOL (
         );

      SYMBOL (
         const SYMBOL& rhs
         );

      ~SYMBOL (
         );

      SYMBOL& operator= (
         const SYMBOL& rhs
         );

      bool Draw (
         MGD::CONTEXT* ggc,
         const DPOINT2D* point,
         const DPOINT2D* dirpoint,
         const DPOINT2D* waypoint,
         LRECT2D* retextents
         ) const;

      const COLOR& GetColor (
         ) const { return (m_Color); }

      UINT8 GetPatternNum (
         ) const { return (m_PatternNum); }

      double GetSize (
         ) const { return (m_Size); }

      ERRVALUE GetStyle (
         RVC::STYLE& ObjStyle,            
         POINTSTYLE& Style                
         ) const;

      void ReadIniSettings (
         const char* IniGroup,
         const char* SymbolName,
         RVC::STYLE& ObjStyle             
         );

      void ReadPattern (  
         RVC::STYLE& ObjStyle             
         );

      void SetColor (
         const COLOR& color
         ) { m_Color = color; }

      void SetColor (
         const char *name                 
         ) { m_Color.SetByName(name); }

      void SetPatternNum (
         UINT8 PatternNum
         ) { m_PatternNum = PatternNum; }

      void SetSize (
         double size
         ) { m_Size = static_cast<float>(size); }

      ERRVALUE SetStyle (
         RVC::STYLE& ObjStyle,            
         const POINTSTYLE& Style          
         );

      void WriteIniSettings (
         const char* IniGroup,
         const char* SymbolName
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT8 m_PatternNum;                 
      ORIENT m_Orient;                    
      float m_Size;                       
      float m_Angle;                      
      FLAGS m_Flags;
      COLOR m_Color;                      
      RVC::OBJECTNAME m_PatternName;      
      int m_PatternSize;                  
      void *m_Pattern;                    
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(SYMBOL::FLAGS)
#endif


//-------------------------------------------------------------------------------------------------------------------

class SOURCE {
   public:

      enum STATUS {
         STATUS_Good =           0,       
         STATUS_NoResponse =     1,       
         STATUS_Initializing =   2,       
         STATUS_Acquiring =      3,       
         STATUS_SignalLost =     4,       
         STATUS_EndOfLogFile =   5,       
         STATUS_Error =          6
         };

      enum SYMBOLTYPE {
         SYMBOLTYPE_Stopped = 0,          
         SYMBOLTYPE_Moving =  1           
         };

      class OBSERVER;
      class DLG;

      class OBSERVER : public OBSERVER_BASE {
         public:

            OBSERVER (
               SOURCE *source
               ): OBSERVER_BASE(source->m_ObserverMgr) { }

            virtual ~OBSERVER ();

            void NotifyAdd (
               SOURCE *source
               ) { v_OnAdd(source); }

            void NotifyClose (
               SOURCE *source
               ) { v_OnClose(source); }

            void NotifyOpen (
               SOURCE *source
               ) { v_OnOpen(source); }

            void NotifyPoll (
               const SOURCE *source,
               const REPORT& report
               ) { v_OnPoll(source,report); }

            void NotifyRemove (
               SOURCE *source
               ) { v_OnRemove(source); }

         private:

            virtual void v_OnAdd (
               SOURCE *source
               );

            virtual void v_OnClose (
               SOURCE *source
               );

            virtual void v_OnOpen (
               SOURCE *source
               );

            virtual void v_OnPoll (
               const SOURCE *source,
               const REPORT& report
               );

            virtual void v_OnRemove (
               SOURCE *source
               );
         };

      SOURCE (  
         );

      virtual ~SOURCE ( 
         );

      void Close (
         );

      void CloseControlDialog (
         );

   #ifdef USE_MGUI
      MGUI::FORM* CreateControlForm (
         MGUI::LAYOUT_PANE_BASE& parentpane
         ) { return (v_CreateControlForm(parentpane)); }
   #endif

      void DeleteFromIni (
         ) const { v_DeleteFromIni(); }

      const SPATREF::COORDREFSYS& GetCoordRefSys (
         ) const { return (m_CoordRefSys); }

      const char* GetIniGroupKey (
         ) const { return (m_IniGroup); }

      const MISTRING& GetName (
         ) const { return (m_name); }

      double GetPollInterval (
         ) const { return (m_PollInterval); }

      const SYMBOL& GetSymbol (
         SYMBOLTYPE symboltype            
         ) const {
         return ((symboltype == SYMBOLTYPE_Stopped) ? m_SymbolStopped : m_SymbolMoving);
         }

      bool GetLastData (
         REPORT* gpsdata                  
         ) const {
         if (m_HasData) {
            *gpsdata = m_LastData;
            }
         return (m_HasData);
         }

      STATUS GetStatus (
         ) const { return (m_LastStatus); }

      bool IsDevice (
         ) const { return (v_IsDevice()); }

      bool IsManaged (
         ) const { return (m_IsManaged); }

      bool IsOpen (
         ) const { return (m_IsOpen); }

      int Manage (
         );

      ERRVALUE Open (  
         );

      void OpenControlDialog (
         );

      int ReadNext (
         ) { return (v_ReadNext()); }

      void SetName (
         const MISTRING& name             
         ) { m_name = name; }

      void SetPollInterval (
         double PollInterval              
         );

      void SetSymbol (
         SYMBOLTYPE symboltype,           
         const SYMBOL& symbol,         
         bool UpdateIni                   
         );

      void Unmanage (
         );

   protected:

      void ClearLastData (
         ) { m_HasData = false; }

      MDLGPARENT GetDlgParent (
         ) const { return (m_DlgParent); }

      bool HasData (
         ) const { return (m_HasData); }

      void ReadIniSettings (
         const char* IniGroup
         );

      void SetCurrentData (
         const REPORT& gpsdata
         ) { m_HasData = true; m_LastData = gpsdata; }

      void SetCurrentStatus (
         STATUS status
         ) { m_LastStatus = status; }

      void SetDlgParent (
         MDLGPARENT dlgparent
         ) { m_DlgParent = dlgparent; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class OBSERVERMGR : public SUBJECT<OBSERVER> {
         public:
            void NotifyAdd (SOURCE *source);
            void NotifyClose (SOURCE *source);
            void NotifyOpen (SOURCE *source);
            void NotifyPoll (const SOURCE *source, const REPORT& report);
            void NotifyRemove (SOURCE *source);
         };

      OBSERVERMGR m_ObserverMgr;
      MISTRING m_name;                    // Name of source
      char m_IniGroup[16];                // Ini group for source settings if device
      bool m_IsOpen;
      bool m_IsManaged;
      bool m_HasData;
      STATUS m_LastStatus;
      SYMBOL m_SymbolStopped;
      SYMBOL m_SymbolMoving;
      double m_PollInterval;              // Polling interval in seconds
      SPATREF::COORDREFSYS m_CoordRefSys;
      REPORT m_LastData;
      MDLGPARENT m_DlgParent;             // Used as parent for file open, etc...
      DLG *m_pDlg;                        // Control dialog

   #ifdef USE_MGUI
      MGUI::TIMER m_Timer;
      void OnTimer ();
   #endif

      SOURCE (const SOURCE&);
      SOURCE& operator= (const SOURCE&);

      friend class MGPS::SOURCE::OBSERVER;
      friend class MGPS::SOURCE::DLG;
      friend class MGPS::SOURCEMGR;
   #endif // GENERATING_DOXYGEN_OUTPUT

      // SOURCE Overridables

      virtual void v_Close (
         );

   #ifdef USE_MGUI
      virtual MGUI::FORM* v_CreateControlForm (
         MGUI::LAYOUT_PANE_BASE& parentpane
         ) = 0;
   #endif

      virtual void v_DeleteFromIni (
         ) const;

      virtual bool v_IsDevice (
         ) const;

      virtual int v_Open (  
         ) = 0;

      virtual int v_ReadNext (
         ) = 0;

   };


//-------------------------------------------------------------------------------------------------------------------

class SOURCE_DEVICE : public SOURCE {
   public:

      enum PROTOCOL {
         PROTOCOL_NoDevice = 0,           
         PROTOCOL_NMEA = 1,               
         PROTOCOL_TAIP = 2,                  
         PROTOCOL_GARMIN = 3
         };

      enum FORMAT {
         FORMAT_GPX = 0,                  
         FORMAT_MI= 1                  
         };

      class HWPARM {
         public:

            HWPARM (
               );

            ERRVALUE DlgEditSettings (
               MDLGPARENT dlgparent
               );

            const MISTRING& GetDeviceDesc (
               ) const { return (m_devicedesc); }

            int ReadIni (
               INIHANDLE IniHandle,
               UINT16 DeviceNum
               );

            int ReadIni (
               UINT16 DeviceNum
               );

            void SetPortName (
               const MISTRING& portname
               ) { m_portname = portname; }

            void SetPortParm (
               const char *portparm
               ) { strcpy(m_portparm,portparm); }

            void SetPortType (
               UINT16 porttypenum
               ) { m_porttypenum = porttypenum; }

            void SetProtocol (
               PROTOCOL protocol
               ) { m_protocol = protocol; }

            void WriteIni (
               INIHANDLE IniHandle
               ) const;

            ERRVALUE WriteIni (
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            class DLG;
            friend class HWPARM::DLG;

            UINT16 m_devicenum;                 // GPS device number
            UINT16 m_porttypenum;               // PORTTYPE_...
            PROTOCOL m_protocol;                // Protocol
            MISTRING m_portname;                // Port name
            char m_portparm[80];                // Port parameters
            MISTRING m_devicedesc;              // GPS device description
            double m_PollInterval;              // Polling interval in seconds

            friend class MGPS::SOURCE_DEVICE;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      static void CreateDefault ();

      SOURCE_DEVICE (
         const HWPARM& portparm
         );

      virtual ~SOURCE_DEVICE (
         );

      int GetDeviceNum (
         ) const { return (m_hwparm.m_devicenum); }

      ERRVALUE RecordStart (
         const FILEPATH& filepath
         );

      void RecordStop (
         );

      FORMAT GetFormat() const {return m_format;}

      void SetFormat(FORMAT format) {m_format = format;}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      HWPARM m_hwparm;
      PORT *m_port;
      XMLDOC *m_xmldoc;
      FILE_TEXT *m_pFileRecord;
      FILE_TEXT *m_pFileRawLog;
      FILEPATH m_filepath;
      time_t m_lastmsgtime;
      FORMAT m_format;
      char m_tempbuf[100];    // For storage of partial message

      void OpenRawLogFile ();
      int ReadChar (char& c, int failvalue = -3155);  /* EGPS_CantReadMsg */
      int ReadStr (char *str, int len);
      int ReadMsgNMEA (char *datastr);
      int ReadMsgTAIP (const char *msgid, char *datastr);
      int ReadNMEA (REPORT*);
      int ReadTAIP (REPORT*);

      #ifdef PLATFORM_SUPPORTS_GARMIN
      int ReadGARMIN (REPORT*);
      #endif

      SOURCE_DEVICE (const SOURCE_DEVICE&);
      SOURCE_DEVICE& operator= (const SOURCE_DEVICE&);

      // SOURCE overrides.
      virtual void v_Close ();
   #ifdef USE_MGUI
      virtual MGUI::FORM* v_CreateControlForm (MGUI::LAYOUT_PANE_BASE& parentpane);
   #endif
      virtual void v_DeleteFromIni () const;
      virtual bool v_IsDevice () const;
      virtual int v_Open ();
      virtual int v_ReadNext ();

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-------------------------------------------------------------------------------------------------------------------

class SOURCE_LOGFILE : public SOURCE {
   public:

      enum FORMAT {
         FORMAT_Automatic,                
         FORMAT_MicroImages,              
         FORMAT_NMEA,                     
         FORMAT_Satlok,                   
         FORMAT_GPX,                      
         FORMAT_Text                      
         };

      enum DIRECTION {
         DIRECTION_Forward,
         DIRECTION_Reverse
         };

      static ERRVALUE DlgCreate (
         MDLGPARENT dlgparent
         );

      static ERRVALUE DlgCreateImport (
         MDLGPARENT dlgparent
         );

      SOURCE_LOGFILE (
         const FILEPATH& filepath,
         FORMAT format = FORMAT_Automatic
         );

      virtual ~SOURCE_LOGFILE (
         );

      DIRECTION GetDirection (
         ) const { return (m_Direction); }

      double GetPlaybackRate (
         ) const { return (m_PlaybackRate); }

      bool IsAtStart (
         ) const { return (m_CurPosition <= 0); }

      bool IsPaused (
         ) const { return (m_IsPaused); }

      void SetAutoRepeat (
         bool AutoRepeat = true
         ) { m_AutoRepeat = AutoRepeat; }

      void SetDirection (
         DIRECTION direction              
         ) { m_Direction = direction; }

      void SetPaused (
         bool Paused = true               
         ) { m_IsPaused = Paused; }

      void SetPosition (
         double position                  
         );

      void SetPlaybackRate (
         double rate                   
         );

      void SkipForward (
         );

      void SkipReverse (  
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      enum PLAYBTN {
         PLAYBTN_Stop = 0,
         PLAYBTN_Pause = 1,
         PLAYBTN_FastRev = 2,
         PLAYBTN_Reverse = 3,
         PLAYBTN_Forward = 4,
         PLAYBTN_FastFwd = 5,
         PLAYBTN_COUNT
         };

      class LOGPOINT {
         public:
            DPOINT2D Position;                  
            float Time;                         
            float Elevation;                    
            float Heading;                      
            float Speed;                        
            float VelocityZ;                    
            UINT8 DataSource;
            UINT8 NumSatellites;                
            UINT16 ValidFlags;                  
         };

      class SECTIONINFO {
         public:
            float m_StartTime;                  
            float m_EndTime;                    
            int m_FirstPoint;                   
            int m_NumPoints;                    
         };

      FILEPATH m_filepath;
      FORMAT m_Format;
      int m_NumPoints;
      LOGPOINT *m_LogPoints;
      int m_NumSections;
      SECTIONINFO *m_SectionInfo;
      double m_BaseTime;
      float m_TotalTime;
      float m_CurPosition;
      int m_CurSection;
      int m_CurPoint;
      bool m_AutoRepeat;
      bool m_AtSectionEnd;
      bool m_IsPaused;
      double m_PlaybackRate;
      DIRECTION m_Direction;

      int AddLogPoint (
         LOGPOINT& logpoint,
         int& PointsAlloc,
         int logday,
         double logtime
         );

      int ReadLogGPX();

      int ReadLogText();

      int ReadLogMI (
         FILE_TEXT& file
         );

      int ReadLogNMEA (
         FILE_TEXT& file
         );

      int ReadLogSatlok (
         FILE_TEXT& file
         );

      SOURCE_LOGFILE (const SOURCE_LOGFILE&);
      SOURCE_LOGFILE& operator= (const SOURCE_LOGFILE&);

      // SOURCE overrides.
      virtual void v_Close ();
   #ifdef USE_MGUI
      virtual MGUI::FORM* v_CreateControlForm (MGUI::LAYOUT_PANE_BASE& parentpane);
   #endif
      virtual int v_Open ();
      virtual int v_ReadNext ();

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-------------------------------------------------------------------------------------------------------------------

typedef MILIST<SOURCE*> SOURCELIST;

class SOURCEMGR {
   public:

      class OBSERVER;

      class OBSERVER : public OBSERVER_BASE {
         public:

            OBSERVER (
               ): OBSERVER_BASE(SOURCEMGR::s_ObserverMgr) { }

            virtual ~OBSERVER ();

            virtual void v_OnAdd (
               SOURCE *source
               );

            virtual void v_OnClose (
               SOURCE *source
               );

            virtual void v_OnOpen (
               SOURCE *source
               );

            virtual void v_OnPoll (
               const SOURCE *source,
               const REPORT& report
               );

            virtual void v_OnRemove (
               SOURCE *source
               );
         };

      static void DestroyAllSources (
         );

      static int GetNumSources (
         ) { return (s_SourceList.GetNumItems()); }

      static const SOURCELIST& GetSourceList (
         ) { return (s_SourceList); }

      static ERRVALUE OpenDialog (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class OBSERVERMGR : public SUBJECT<OBSERVER> {
         public:
            void NotifyAdd (SOURCE *source);
            void NotifyClose (SOURCE *source);
            void NotifyOpen (SOURCE *source);
            void NotifyPoll (const SOURCE *source, const REPORT& report);
            void NotifyRemove (SOURCE *source);
         };

      class DLG;

      static OBSERVERMGR s_ObserverMgr;
      static SOURCELIST s_SourceList;
      static DLG *s_pDlg;

      static void Add (SOURCE *source);
      static void Remove (SOURCE *source);

      SOURCEMGR (const SOURCEMGR&);
      SOURCEMGR& operator= (const SOURCEMGR&);

   friend class MGPS::SOURCE;
   friend class MGPS::SOURCE::OBSERVERMGR;
   friend class MGPS::SOURCEMGR::OBSERVER;
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-------------------------------------------------------------------------------------------------------------------

}  // End namespace MGPS.

#endif   // USE_MGUI

#endif   // INC_MI32_MGPS_H

---