SimulatorInterfaceMock.cs

// VBConversions Note: VB project level imports
using System.Collections.Generic;
using System;
using System.Diagnostics;
using System.Data;
using System.Xml.Linq;
using Microsoft.VisualBasic;
using System.Collections;
using System.Linq;
// End of VB project level imports



namespace ManagedAnimatInterfaces
{
        public class SimulatorInterfaceMock : ISimulatorInterface
        {
                
                public bool AddItem(string sParentID, string sItemType, string sID, string sXml, bool bThrowError, bool bDoNotInit)
                {
                        return true;
                }
                
                public string AddKeyFrame(string strType, long lStartMillisecond, long lEndMillisecond)
                {
                        return "";
                }
                
                public bool AddWindow(System.IntPtr hParentWnd, string sWindowType, string sWindowXml)
                {
                        return true;
                }
                
                public void CreateAndRunSimulation(bool bPaused)
                {
                        
                }
                
                public void CreateSimulation()
                {
                        
                }
                
                public void CreateSimulation(string sXml)
                {
                        
                }
                
                public long CurrentMillisecond()
                {
                        return 0;
                }
                
                public void DisableVideoPlayback()
                {
                        
                }
                
                public void EnableVideoPlayback(string strID)
                {
                        
                }
                
                public string ErrorMessage()
                {
                        return "";
                }
                
                public bool FindItem(string sID, bool bThrowError)
                {
                        return false;
                }
                
                public void FireHandleCriticalErrorEvent(string strError)
                {
                        
                }
                
                public void FireHandleNonCriticalErrorEvent(string strError)
                {
                        
                }
                
                public void FireNeedToStopSimulationEvent()
                {
                        
                }
                
                public void ConvertV1MeshFile(string sOriginalMeshFile, string NewMeshFile, string strTexture)
                {
                        
                }
                
                public void GenerateCollisionMeshFile(string sOriginalMeshFile, string sCollisionMeshFile, float fltScaleX, float fltScaleY, float fltScaleZ)
                {
                        
                }
                
                public delegate void HandleCriticalErrorEventHandler(string strError);
                private HandleCriticalErrorEventHandler HandleCriticalErrorEvent;
                
                public event HandleCriticalErrorEventHandler HandleCriticalError
                {
                        add
                        {
                                HandleCriticalErrorEvent = (HandleCriticalErrorEventHandler) System.Delegate.Combine(HandleCriticalErrorEvent, value);
                        }
                        remove
                        {
                                HandleCriticalErrorEvent = (HandleCriticalErrorEventHandler) System.Delegate.Remove(HandleCriticalErrorEvent, value);
                        }
                }
                
                
                public delegate void HandleNonCriticalErrorEventHandler(string strError);
                private HandleNonCriticalErrorEventHandler HandleNonCriticalErrorEvent;
                
                public event HandleNonCriticalErrorEventHandler HandleNonCriticalError
                {
                        add
                        {
                                HandleNonCriticalErrorEvent = (HandleNonCriticalErrorEventHandler) System.Delegate.Combine(HandleNonCriticalErrorEvent, value);
                        }
                        remove
                        {
                                HandleNonCriticalErrorEvent = (HandleNonCriticalErrorEventHandler) System.Delegate.Remove(HandleNonCriticalErrorEvent, value);
                        }
                }
                
                
                public bool Loaded()
                {
                        return false;
                }
                
                public string MoveKeyFrame(string strID, long lStartMillisecond, long lEndMillisecond)
                {
                        return "";
                }
                
                public void MoveSimulationToKeyFrame(string strID)
                {
                        
                }
                
                public delegate void NeedToStopSimulationEventHandler();
                private NeedToStopSimulationEventHandler NeedToStopSimulationEvent;
                
                public event NeedToStopSimulationEventHandler NeedToStopSimulation
                {
                        add
                        {
                                NeedToStopSimulationEvent = (NeedToStopSimulationEventHandler) System.Delegate.Combine(NeedToStopSimulationEvent, value);
                        }
                        remove
                        {
                                NeedToStopSimulationEvent = (NeedToStopSimulationEventHandler) System.Delegate.Remove(NeedToStopSimulationEvent, value);
                        }
                }
                
                
                public delegate void OnSimulationCreateEventHandler(ref string strXml);
                private OnSimulationCreateEventHandler OnSimulationCreateEvent;
                
                public event OnSimulationCreateEventHandler OnSimulationCreate
                {
                        add
                        {
                                OnSimulationCreateEvent = (OnSimulationCreateEventHandler) System.Delegate.Combine(OnSimulationCreateEvent, value);
                        }
                        remove
                        {
                                OnSimulationCreateEvent = (OnSimulationCreateEventHandler) System.Delegate.Remove(OnSimulationCreateEvent, value);
                        }
                }
                
                
                public void OnWindowGetFocus(string sID)
                {
                        
                }
                
                public void OnWindowLoseFocus(string sID)
                {
                        
                }
                
                public bool Paused()
                {
                        return true;
                }
                
                public bool PauseSimulation()
                {
                        return true;
                }
                
                public void ReInitializeSimulation()
                {
                        
                }
                
                public bool RemoveItem(string sParentID, string sItemType, string sID, bool bThrowError)
                {
                        return true;
                }
                
                public void RemoveKeyFrame(string strID)
                {
                        
                }
                
                public void RemoveWindow(System.IntPtr hParentWnd)
                {
                        
                }
                
                public int RetrieveChartData(string sChartKey, ref float[,] aryTimeData, ref float[,] aryData)
                {
                        return 1;
                }
                
                public void SaveSimulationFile(string sFile)
                {
                        
                }
                
                public void SaveVideo(string strPath)
                {
                        
                }
                
                public bool SetData(string sID, string sDataType, string sValue, bool bThrowError)
                {
                        return true;
                }
                
                public void SetLogger(ILogger lpLog)
                {
                        
                }
                
                public void SetProjectPath(string strPath)
                {
                        
                }
                
                public void ShutdownSimulation()
                {
                        
                }
                
                public bool SimOpen()
                {
                        return true;
                }
                
                public bool SimRunning()
                {
                        return true;
                }
                
                public void Simulate(bool bPaused)
                {
                        
                }
                
                public delegate void SimulationRunningEventHandler();
                private SimulationRunningEventHandler SimulationRunningEvent;
                
                public event SimulationRunningEventHandler SimulationRunning
                {
                        add
                        {
                                SimulationRunningEvent = (SimulationRunningEventHandler) System.Delegate.Combine(SimulationRunningEvent, value);
                        }
                        remove
                        {
                                SimulationRunningEvent = (SimulationRunningEventHandler) System.Delegate.Remove(SimulationRunningEvent, value);
                        }
                }
                
                
                public bool StartSimulation()
                {
                        return true;
                }
                
                public void StartVideoPlayback()
                {
                        
                }
                
                public void StepVideoPlayback(int iFrameCount)
                {
                        
                }
                
                public void StopSimulation()
                {
                        
                }
                
                public void StopVideoPlayback()
                {
                        
                }
                
                public void TrackCamera(bool bTrackCamera, string sLookAtStructureID, string sLookAtBodyID)
                {
                        
                }
                
                public PositionRotationInfo GetPositionAndRotationFromD3DMatrix(double[,] aryTransform)
                {
                        return null;
                }
                
                public void CreateStandAloneSim(string sModuleName, string sExePath)
                {
                        
                }
        }
        
}