RemoteControlLinkage.h

#pragma once

namespace AnimatSim
{
        namespace Robotics
        {
                class RemoteControl;

                class ANIMAT_PORT RemoteControlData
                {
                public:
                        std::string m_strProperty;
                        int m_iButtonID;
                        float m_fltStart;
                        float m_fltValue;      // vertical stick movement = forward speed
                        float m_fltStop;
                        float m_fltPrev;
                        int m_iCount;
                        bool m_bStarted;
                        int m_iStartDir;

                        int m_iSimStepped;

                        int m_iChangeSimStepCount;

                        RemoteControlData()
                        {
                                m_iButtonID = -1;
                                m_iChangeSimStepCount = 5;
                                ClearData();
                        }

                        RemoteControlData(std::string strName, int iButtonID, int iChangeSimStepCount)
                        {
                                m_strProperty = strName;
                                m_iButtonID = iButtonID;
                                m_iChangeSimStepCount = iChangeSimStepCount;
                                ClearData();
                        }

                        void ClearData()
                        {
                                m_fltStart = 0;
                                m_fltValue = 0;      
                                m_fltStop = 0;
                                m_fltPrev = 0;
                                m_iCount = 0;
                                m_bStarted = 0;
                                m_iSimStepped = 0;
                                m_iStartDir = 1;
                        }

                        void CheckStartedStopped();
                        void ClearStartStops();
                };

                class ANIMAT_PORT RemoteControlLinkage : public AnimatBase
                {
                protected:
                        RemoteControl *m_lpParentRemoteControl;

                        AnimatBase *m_lpSource;

                        AnimatBase *m_lpTarget;

                        std::string m_strSourceID;

                        std::string m_strTargetID;

                        std::string m_strSourceDataTypeID;

                        std::string m_strTargetDataTypeID;

                        int m_iPropertyID;

                        std::string m_strPropertyName;

                        int m_iTargetDataType;

                        float *m_lpSourceData;
                        
                        float *m_lpTargetData;

                        float m_fltAppliedValue;

                        bool m_bInLink;

                        virtual float CalculateAppliedValue(float fltData) = 0;
                        virtual void ApplyValue(float fltData);

                public:
                        RemoteControlLinkage(void);
                        virtual ~RemoteControlLinkage(void);
                                                
                        static RemoteControlLinkage *CastToDerived(AnimatBase *lpBase) {return static_cast<RemoteControlLinkage*>(lpBase);}

                        RemoteControlData m_Data;

                        virtual void ParentRemoteControl(RemoteControl *lpParent);
                        virtual RemoteControl *ParentRemoteControl();

                        virtual std::string SourceID();
                        virtual void SourceID(std::string strID);

                        virtual std::string TargetID();
                        virtual void TargetID(std::string strID);

                        virtual int PropertyID();
                        virtual void PropertyID(int iID, bool bCreateDataTypes = true);

                        virtual std::string SourceDataTypeID();
                        virtual void SourceDataTypeID(std::string strTypeID);

                        virtual std::string TargetDataTypeID();
                        virtual void TargetDataTypeID(std::string strTypeID);

                        virtual std::string PropertyName();
                        virtual void PropertyName(std::string strName);

                        virtual bool InLink();
                        virtual void InLink(bool bVal);

                        virtual float AppliedValue();
                        virtual void AppliedValue(float fltVal);

                        virtual float *GetDataPointer(const std::string &strDataType);
                        virtual bool SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError = true);
                        virtual void QueryProperties(CStdPtrArray<TypeProperty> &aryProperties);

                        virtual void SetupIO();
                        virtual void StepIO();
                        virtual void ShutdownIO();

                        virtual void Initialize();
                        virtual void ResetSimulation();
                        virtual void StepSimulation();
                        virtual void Load(CStdXml &oXml);
                };

        }
}