Code Example CPP-File

Code example (.\otxruntime\ReferenceApplication\src\Gui\SampleForm.cpp) of the OTX-Runtime API Sample Program.

 #include "SampleForm.h"
 using namespace OpenTestSystem::Otx::Runtime2::Api::Sample;
  
 #include "HmiWindow.h"
 #include "LicenseForm.h"
 #include "SampleConstants.h"
 #include "Util/LicenseUtil.h"
 #include "Util/Util.h"
 #include "CallbackToAction.h"
 #include "Setting/UserSettings.h"
 #include "IpcTypes.h"
 #include "Util/OtxDiagUtil.h"
  
 #include "OutputCustomImplementation/BasicScreenOutputImpl.h"
 #include "OutputCustomImplementation/CommonDialogsOutputImpl.h"
 #include "OutputCustomImplementation/ContextVariableOutputImpl.h"
 #include "OutputCustomImplementation/CustomScreenOutputImpl.h"
 #include "OutputCustomImplementation/ExternalServiceProviderOutputImpl.h"
 #include "OutputCustomImplementation/I18nOutputImpl.h"
 #include "OutputCustomImplementation/LoggingOutputImpl.h"
 #include "OutputCustomImplementation/MeasureOutputImpl.h"
 #include "OutputCustomImplementation/SqlOutputImpl.h"
 #include "OutputCustomImplementation/StateVariableOutputImpl.h"
 using namespace OpenTestSystem::Otx::Runtime2::Api::Sample::OutputCustomImplementation;
  
 #include <RuntimeManagerFactory.h>
 #include <RuntimeConfig.h>
 #include <License/LicenseManager.h>
 #include <Project/IProject.h>
 #include <Project/IPlayerProject.h>
 #include <IRuntimeContext.h>
 #include <DiagConnectionState.h>
 #include <Otx/IProcedureParameter.h>
 #include <Otx/IProcedureInOutParameter.h>
 #include <Otx/IProcedureInParameter.h>
 #include <Otx/IProcedureOutParameter.h>
 #include <DataTypes/ValueConverter.h>
 #include <Otx/IContextVariable.h>
 #include <Otx/IStateVariable.h>
  
 #include <Custom/ICustomScreenImplementation.h>
 #include <DefaultCustomScreenImplementation.h>
 #include <WpfKeyEventArgs.h>
 #include <FormKeyEventArgs.h>
 #include <ContextVariableImplementation.h>
  
 #include <StateVariableImplementation.h>
 #include <DefaultMeasureImplementation.h>
 #include <DefaultExternalServiceProviderImplementation.h>
  
 #include <DataTypes/TranslationKey.h>
 #include <DataTypes/EnumerationElement.h>
 #include "Otx/Signature/IEnumerationSignature.h"
  
 #include <IOtxDiag.h>
 #include <IDiagConfiguration.h>
  
 #include <msclr/auto_gcroot.h>
 #include <msclr/lock.h>
 #include <vector>
 #include <map>
 #include <memory>
  
 struct OpenTestSystem::Otx::Runtime2::Api::Sample::SampleFormImpl
 {
 public:
     SampleFormImpl(msclr::auto_gcroot<SampleForm^> owner)
     {
         Owner = owner;
  
         _ProcedurePending = nullptr;
         _ProcedureStarted = nullptr;
         _ProcedurePaused = nullptr;
         _ProcedureContinued = nullptr;
         _ProcedureFinished = nullptr;
         _ProcedureStopped = nullptr;
         _ProcedureAborted = nullptr;
         _ProcedureTimeout = nullptr;
         _DiagConnectionStateChanged = nullptr;
         _InOutParameterValueChanged = nullptr;
  
         _KeyDown = nullptr;
         _ContextVariableRead = nullptr;
  
         CreatorForm = nullptr;
         HmiWindow = nullptr;
         WebServerTimer = nullptr;
  
         GlobalRuntimeManager = nullptr;
         RuntimeContexts.clear();
         LockRuntimeContexts = gcnew System::Object();
         EventListenerLock = gcnew System::Object();
         PrintTextLock = gcnew System::Object();
  
         RuntimeContextIdsExecutionStartTick.clear();
  
         ErrorProvider = nullptr;
  
         Project = nullptr;
         PlayerProject = nullptr;
         ProcedureToExecute = nullptr;
  
         StartUpNode = nullptr;
  
         ProcedureExecutionCount = 0;
  
         LastTime = System::DateTime::Now;
  
         Title = SampleConstants::MAIN_INSTANCE_NAME;
  
         UseConnectionState = false;
  
         IsPathChanging = false;
  
         IsLoadding = false;
  
         DefaultDiagPort = SampleConstants::DEFAULT_DM_PORT;
         DefaultRuntimePort = SampleConstants::DEFAULT_RT_PORT;
         DefaultDiagPipeName = SampleConstants::DEFAULT_DM_PIPE_NAME;
         DefaultRuntimePipeName = SampleConstants::DEFAULT_RT_PIPE_NAME;
  
         IsStartWebSever = -1;
         RuntimeContextName = "";
         CyclicExecutionCount = 0;
         CyclicExecuteAsyncIsProcessing = false;
         ExpectedConnectionState = ExpectedState::None;
  
         KL15State = -1;
  
         CustomScreenImplementation = nullptr;
         ContextVariableImplementation = nullptr;
  
         StateVariableImplementation = nullptr;
         MeasureImplementation = nullptr;
         ServiceProviderImplementation = nullptr;
  
         _BasicScreenOutputImpl = nullptr;
         _CommonDialogsOutputImpl = nullptr;
         _ContextVariableOutputImpl = nullptr;
         _CustomScreenOutputImpl = nullptr;
         _ServiceProviderOutputImpl = nullptr;
         _I18nOutputImpl = nullptr;
         _LoggingOutputImpl = nullptr;
         _MeasureOutputImpl = nullptr;
         _SqlOutputImpl = nullptr;
         _StateVariableOutputImpl = nullptr;
  
         WebServerTimer = gcnew System::Windows::Forms::Timer();
         ErrorProvider = gcnew System::Windows::Forms::ErrorProvider();
     }
  
     static bool IsRegistered;
     static std::string FileVersion;
     static std::vector<msclr::auto_gcroot<SampleForm^>> ListForms;
  
     msclr::auto_gcroot<SampleForm^> CreatorForm;
     msclr::auto_gcroot<HmiWindow^> HmiWindow;
     msclr::auto_gcroot<System::Windows::Forms::Timer^> WebServerTimer;
     msclr::auto_gcroot<System::DateTime^> LastTime;
     std::shared_ptr<IRuntimeManager> GlobalRuntimeManager;
     std::vector<OpenTestSystem::Otx::Runtime::Api::IRuntimeContext*> RuntimeContexts;
     msclr::auto_gcroot<System::Object^> LockRuntimeContexts;
     msclr::auto_gcroot<System::Object^> EventListenerLock;
     msclr::auto_gcroot<System::Object^> PrintTextLock;
     std::map<long long, long long> RuntimeContextIdsExecutionStartTick;
     msclr::auto_gcroot<System::Windows::Forms::ErrorProvider^> ErrorProvider;
  
     std::shared_ptr<OpenTestSystem::Otx::Runtime::Api::Project::IProject> Project;
     std::shared_ptr<OpenTestSystem::Otx::Runtime::Api::Project::IPlayerProject> PlayerProject;
     std::shared_ptr<OpenTestSystem::Otx::Runtime::Api::Otx::IProcedure> ProcedureToExecute;
  
     msclr::auto_gcroot<System::Windows::Forms::TreeNode^> StartUpNode;
  
     long ProcedureExecutionCount;
  
     std::string Title;
  
     bool IsPathChanging;
  
     bool UseConnectionState;
  
     bool IsLoadding;
  
     int DefaultDiagPort;
     int DefaultRuntimePort;
     std::string DefaultDiagPipeName;
     std::string DefaultRuntimePipeName;
  
     int IsStartWebSever;
     std::string RuntimeContextName;
     int CyclicExecutionCount;
     bool CyclicExecuteAsyncIsProcessing;
     ExpectedState ExpectedConnectionState;
  
 #pragma region C++ for RAW-mode
     std::string IpcInitializedBefore;
 #pragma endregion
  
  
     int KL15State; // There are 3 states -1, 0 and 1 which correspond to NULL, false and true in C#
  
     std::shared_ptr<Custom::DefaultCustomScreenImplementation> CustomScreenImplementation;
     std::shared_ptr<Custom::ContextVariableImplementation> ContextVariableImplementation;
  
     std::shared_ptr<Custom::StateVariableImplementation> StateVariableImplementation;
     std::shared_ptr<Custom::DefaultMeasureImplementation> MeasureImplementation;
     std::shared_ptr<Custom::DefaultExternalServiceProviderImplementation> ServiceProviderImplementation;
  
     std::shared_ptr<BasicScreenOutputImpl> _BasicScreenOutputImpl;
     std::shared_ptr<CommonDialogsOutputImpl> _CommonDialogsOutputImpl;
     std::shared_ptr<ContextVariableOutputImpl> _ContextVariableOutputImpl;
     std::shared_ptr<CustomScreenOutputImpl> _CustomScreenOutputImpl;
     std::shared_ptr<ExternalServiceProviderOutputImpl> _ServiceProviderOutputImpl;
     std::shared_ptr<I18nOutputImpl> _I18nOutputImpl;
     std::shared_ptr<LoggingOutputImpl> _LoggingOutputImpl;
     std::shared_ptr<MeasureOutputImpl> _MeasureOutputImpl;
     std::shared_ptr<SqlOutputImpl> _SqlOutputImpl;
     std::shared_ptr<StateVariableOutputImpl> _StateVariableOutputImpl;
  
     const int VALUE_STRING_MAX_LENGTH = 1024;
     const int FORM_OFFSET = 25;
     const int DEFAULT_POLLING_TIME = 500;
     const int DEFAULT_BATTERY_VOLTAGE_THRESHOLD = 6000;
  
     void InitializeRuntimeEvents(std::shared_ptr<IRuntimeManager> runtimeManager)
     {
         REFAPP_START_METHOD();
         if (runtimeManager == nullptr)
         {
             REFAPP_END_METHOD();
             return;
         }
  
         RemoveRuntimeEvents(runtimeManager);
  
         _ProcedurePending = std::make_shared<std::function<void(const IRuntimeContext&)>>(std::bind(&SampleFormImpl::ProcedurePending, this, std::placeholders::_1));
         _ProcedureStarted = std::make_shared<std::function<void(const IRuntimeContext&)>>(std::bind(&SampleFormImpl::ProcedureStarted, this, std::placeholders::_1));
         _ProcedurePaused = std::make_shared<std::function<void(const IRuntimeContext&, ExecutionStateChangeReason)>>(std::bind(&SampleFormImpl::ProcedurePaused, this, std::placeholders::_1, std::placeholders::_2));
         _ProcedureContinued = std::make_shared<std::function<void(const IRuntimeContext&)>>(std::bind(&SampleFormImpl::ProcedureContinued, this, std::placeholders::_1));
         _ProcedureFinished = std::make_shared<std::function<void(const IRuntimeContext&)>>(std::bind(&SampleFormImpl::ProcedureFinished, this, std::placeholders::_1));
         _ProcedureStopped = std::make_shared<std::function<void(const IRuntimeContext&)>>(std::bind(&SampleFormImpl::ProcedureStopped, this, std::placeholders::_1));
         _ProcedureAborted = std::make_shared<std::function<void(const IRuntimeContext&)>>(std::bind(&SampleFormImpl::ProcedureAborted, this, std::placeholders::_1));
         _ProcedureTimeout = std::make_shared<std::function<void(const IRuntimeContext&)>>(std::bind(&SampleFormImpl::ProcedureTimeout, this, std::placeholders::_1));
         _DiagConnectionStateChanged = std::make_shared<std::function<void(ClampState, ClampState)>>(std::bind(&SampleFormImpl::DiagConnectionStateChanged, this, std::placeholders::_1, std::placeholders::_2));
         _InOutParameterValueChanged = std::make_shared<std::function<void(const IRuntimeContext&, const IProcedureInOutParameter&)>>(std::bind(&SampleFormImpl::InOutParameterValueChanged, this, std::placeholders::_1, std::placeholders::_2));
  
         runtimeManager->AddProcedurePendingListener(_ProcedurePending);
         runtimeManager->AddProcedureStartedListener(_ProcedureStarted);
         runtimeManager->AddProcedurePausedListener(_ProcedurePaused);
         runtimeManager->AddProcedureContinuedListener(_ProcedureContinued);
         runtimeManager->AddProcedureFinishedListener(_ProcedureFinished);
         runtimeManager->AddProcedureStoppedListener(_ProcedureStopped);
         runtimeManager->AddProcedureAbortedListener(_ProcedureAborted);
         runtimeManager->AddProcedureTimeoutListener(_ProcedureTimeout);
         runtimeManager->AddDiagConnectionStateChangedListener(_DiagConnectionStateChanged);
         runtimeManager->AddInOutParameterValueChangedListener(_InOutParameterValueChanged);
         REFAPP_END_METHOD();
     }
  
     void RemoveRuntimeEvents(std::shared_ptr<IRuntimeManager> runtimeManager)
     {
         REFAPP_START_METHOD();
         if (_ProcedurePending != nullptr)
         {
             runtimeManager->RemoveProcedurePendingListener(_ProcedurePending);
         }
  
         if (_ProcedureStarted != nullptr)
         {
             runtimeManager->RemoveProcedureStartedListener(_ProcedureStarted);
         }
  
         if (_ProcedurePaused != nullptr)
         {
             runtimeManager->RemoveProcedurePausedListener(_ProcedurePaused);
         }
  
         if (_ProcedureContinued != nullptr)
         {
             runtimeManager->RemoveProcedureContinuedListener(_ProcedureContinued);
         }
  
         if (_ProcedureFinished != nullptr)
         {
             runtimeManager->RemoveProcedureFinishedListener(_ProcedureFinished);
         }
  
         if (_ProcedureStopped != nullptr)
         {
             runtimeManager->RemoveProcedureStoppedListener(_ProcedureStopped);
         }
  
         if (_ProcedureAborted != nullptr)
         {
             runtimeManager->RemoveProcedureAbortedListener(_ProcedureAborted);
         }
  
         if (_ProcedureTimeout != nullptr)
         {
             runtimeManager->RemoveProcedureTimeoutListener(_ProcedureTimeout);
         }
  
         if (_DiagConnectionStateChanged != nullptr)
         {
             runtimeManager->RemoveDiagConnectionStateChangedListener(_DiagConnectionStateChanged);
         }
  
         if (_InOutParameterValueChanged != nullptr)
         {
             runtimeManager->RemoveInOutParameterValueChangedListener(_InOutParameterValueChanged);
         }
         REFAPP_END_METHOD();
     }
  
     void ProcedurePending(const IRuntimeContext& context)
     {
         Owner->ProcedurePendingCallback(gcnew CLRWrapper<IRuntimeContext*>(const_cast<IRuntimeContext*>(&context)));
     }
  
     void ProcedureStarted(const IRuntimeContext& context)
     {
         Owner->ProcedureStartedCallback(gcnew CLRWrapper<IRuntimeContext*>(const_cast<IRuntimeContext*>(&context)));
     }
  
     void ProcedurePaused(const IRuntimeContext& context, ExecutionStateChangeReason reason)
     {
         IRuntimeContext* pContext = const_cast<IRuntimeContext*>(&context);
         Owner->ProcedurePaused(pContext, reason);
     }
  
     void ProcedureContinued(const IRuntimeContext& context)
     {
         Owner->ProcedureContinuedCallback(gcnew CLRWrapper<IRuntimeContext*>(const_cast<IRuntimeContext*>(&context)));
     }
  
     void ProcedureFinished(const IRuntimeContext& context)
     {
         Owner->ProcedureFinishedCallback(gcnew CLRWrapper<IRuntimeContext*>(const_cast<IRuntimeContext*>(&context)));
     }
  
     void ProcedureStopped(const IRuntimeContext& context)
     {
         Owner->ProcedureStoppedCallback(gcnew CLRWrapper<IRuntimeContext*>(const_cast<IRuntimeContext*>(&context)));
     }
  
     void ProcedureAborted(const IRuntimeContext& context)
     {
         Owner->ProcedureAbortedCallback(gcnew CLRWrapper<IRuntimeContext*>(const_cast<IRuntimeContext*>(&context)));
     }
  
     void ProcedureTimeout(const IRuntimeContext& context)
     {
         Owner->ProcedureTimeoutCallback(gcnew CLRWrapper<IRuntimeContext*>(const_cast<IRuntimeContext*>(&context)));
     }
  
     void DiagConnectionStateChanged(ClampState batteryState, ClampState ignitionState)
     {
         Owner->DiagConnectionStateChanged(batteryState, ignitionState);
     }
  
     void InOutParameterValueChanged(const IRuntimeContext& context, const IProcedureInOutParameter& parameter)
     {
         REFAPP_START_METHOD();
         IRuntimeContext* pContext = const_cast<IRuntimeContext*>(&context);
         IProcedureInOutParameter* pParameter = const_cast<IProcedureInOutParameter*>(&parameter);
         Owner->InOutParameterValueChanged(pContext, pParameter);
         REFAPP_END_METHOD();
     }
  
     void SetDefaultCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
     {
         REFAPP_START_METHOD();
         if (runtimeManager == nullptr)
         {
             REFAPP_END_METHOD();
             return;
         }
  
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::IBasicScreenImplementation>)nullptr);
         runtimeManager->SetCustomImplementation(CustomScreenImplementation);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::ILoggingImplementation>)nullptr);
         runtimeManager->SetCustomImplementation(ContextVariableImplementation);
  
         runtimeManager->SetCustomImplementation(StateVariableImplementation);
         runtimeManager->SetCustomImplementation(MeasureImplementation);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::Ii18nImplementation>)nullptr);
         runtimeManager->SetCustomImplementation(ServiceProviderImplementation);
  
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::ISqlImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::ICommonDialogsImplementation>)nullptr);
         REFAPP_END_METHOD();
     }
  
     void RemoveCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
     {
         REFAPP_START_METHOD();
         if (runtimeManager == nullptr)
         {
             REFAPP_END_METHOD();
             return;
         }
  
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::IBasicScreenImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::ICustomScreenImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::ICommonDialogsImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::IContextVariableImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::IExternalServiceProviderImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::Ii18nImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::ILoggingImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::IMeasureImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::ISqlImplementation>)nullptr);
         runtimeManager->SetCustomImplementation((std::shared_ptr<Custom::IStateVariableImplementation>)nullptr);
         REFAPP_END_METHOD();
     }
  
     void ClearCustomImplemetationCaches()
     {
         REFAPP_START_METHOD();
         if (IS_NOT_NULL(ContextVariableImplementation))
         {
             ContextVariableImplementation->ResetAllValues();
         }
  
         if (IS_NOT_NULL(_ContextVariableOutputImpl))
         {
             _ContextVariableOutputImpl->ResetAllValues();
         }
  
         if (IS_NOT_NULL(StateVariableImplementation))
         {
             StateVariableImplementation->ResetAllValues();
         }
  
         //TODO: if (StateVariableOutputImpl != null)
         REFAPP_END_METHOD();
     }
  
     void CreateDefaultCustomImpl()
     {
         REFAPP_START_METHOD();
         CustomScreenImplementation = std::make_shared<Custom::DefaultCustomScreenImplementation>();
         _KeyDown = std::make_shared<std::function<void(std::shared_ptr<Custom::KeyEventArgs>)>>(std::bind(&SampleFormImpl::CustomScreenImplementation_KeyDown, this, std::placeholders::_1));
         CustomScreenImplementation->AddKeyDownListener(_KeyDown);
  
         ContextVariableImplementation = std::make_shared<Custom::ContextVariableImplementation>();
         _ContextVariableRead = std::make_shared<std::function<void(std::shared_ptr<IContextVariable>, std::shared_ptr<DataTypes::Object>)>>(std::bind(&SampleFormImpl::ContextVariableRead, this, std::placeholders::_1, std::placeholders::_2));
         ContextVariableImplementation->SetContextVariableReadHandler(_ContextVariableRead);
  
         StateVariableImplementation = std::make_shared<Custom::StateVariableImplementation>();
         _StateVariableValueChanged = std::make_shared<std::function<void(std::shared_ptr<IStateVariable>, std::shared_ptr<DataTypes::Object>)>>(std::bind(&SampleFormImpl::StateVariableValueChanged, this, std::placeholders::_1, std::placeholders::_2));
         StateVariableImplementation->SetStateVariableValueChangedHandler(_StateVariableValueChanged);
  
         MeasureImplementation = std::make_shared<Custom::DefaultMeasureImplementation>();
         ServiceProviderImplementation = std::make_shared<Custom::DefaultExternalServiceProviderImplementation>();
         REFAPP_END_METHOD();
     }
  
     void CustomScreenImplementation_KeyDown(std::shared_ptr<Custom::KeyEventArgs> eventArgs)
     {
         Owner->CustomScreenImplementation_KeyDown(eventArgs);
     }
  
     void ContextVariableRead(std::shared_ptr<IContextVariable> contextVariable, std::shared_ptr<DataTypes::Object> value)
     {
         Owner->ContextVariableRead(contextVariable, value);
     }
  
     void StateVariableValueChanged(std::shared_ptr<IStateVariable> stateVariable, std::shared_ptr<DataTypes::Object> value)
     {
         Owner->StateVariableValueChanged(stateVariable, value);
     }
  
     void CreateOutputWindowCustomImpl()
     {
         REFAPP_START_METHOD();
         _BasicScreenOutputImpl = std::make_shared<BasicScreenOutputImpl>();
         _CustomScreenOutputImpl = std::make_shared<CustomScreenOutputImpl>();
         _LoggingOutputImpl = std::make_shared<LoggingOutputImpl>();
         _ContextVariableOutputImpl = std::make_shared<ContextVariableOutputImpl>();
  
         _StateVariableOutputImpl = std::make_shared<StateVariableOutputImpl>();
         _MeasureOutputImpl = std::make_shared<MeasureOutputImpl>();
         _I18nOutputImpl = std::make_shared<I18nOutputImpl>();
         _ServiceProviderOutputImpl = std::make_shared<ExternalServiceProviderOutputImpl>();
  
         _CommonDialogsOutputImpl = std::make_shared<CommonDialogsOutputImpl>();
         _SqlOutputImpl = std::make_shared<SqlOutputImpl>();
  
         _BasicScreenOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         _CustomScreenOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         _LoggingOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         _ContextVariableOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
  
         _StateVariableOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         _MeasureOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         _I18nOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         _ServiceProviderOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
  
         _CommonDialogsOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         _SqlOutputImpl->_logEventHandler = std::make_shared<std::function<void(const std::string&)>>(std::bind(&SampleFormImpl::WriteLogEvent, this, std::placeholders::_1));
         REFAPP_END_METHOD();
     }
  
     void RemoveOutputImplLogEventHandler()
     {
         REFAPP_START_METHOD();
         if (_BasicScreenOutputImpl != nullptr)
             _BasicScreenOutputImpl->_logEventHandler = nullptr;
         if (_CustomScreenOutputImpl != nullptr)
             _CustomScreenOutputImpl->_logEventHandler = nullptr;
         if (_LoggingOutputImpl != nullptr)
             _LoggingOutputImpl->_logEventHandler = nullptr;
         if (_ContextVariableOutputImpl != nullptr)
             _ContextVariableOutputImpl->_logEventHandler = nullptr;
  
         if (_StateVariableOutputImpl != nullptr)
             _StateVariableOutputImpl->_logEventHandler = nullptr;
         if (_MeasureOutputImpl != nullptr)
             _MeasureOutputImpl->_logEventHandler = nullptr;
         if (_I18nOutputImpl != nullptr)
             _I18nOutputImpl->_logEventHandler = nullptr;
         if (_ServiceProviderOutputImpl != nullptr)
             _ServiceProviderOutputImpl->_logEventHandler = nullptr;
  
         if (_CommonDialogsOutputImpl != nullptr)
             _CommonDialogsOutputImpl->_logEventHandler = nullptr;
         if (_SqlOutputImpl != nullptr)
             _SqlOutputImpl->_logEventHandler = nullptr;
  
         _BasicScreenOutputImpl = nullptr;
         _CustomScreenOutputImpl = nullptr;
         _LoggingOutputImpl = nullptr;
         _ContextVariableOutputImpl = nullptr;
  
         _StateVariableOutputImpl = nullptr;
         _MeasureOutputImpl = nullptr;
         _I18nOutputImpl = nullptr;
         _ServiceProviderOutputImpl = nullptr;
  
         _CommonDialogsOutputImpl = nullptr;
         _SqlOutputImpl = nullptr;
         REFAPP_END_METHOD();
     }
  
     void WriteLogEvent(const std::string& text)
     {
         Owner->PrintTextCallback(Util::Util::ToString(text));
     }
  
     void SetOutputWindowImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
     {
         REFAPP_START_METHOD();
         if (runtimeManager == nullptr)
         {
             return;
         }
  
         runtimeManager->SetCustomImplementation(_BasicScreenOutputImpl);
         runtimeManager->SetCustomImplementation(_CommonDialogsOutputImpl);
         runtimeManager->SetCustomImplementation(_ContextVariableOutputImpl);
         runtimeManager->SetCustomImplementation(_CustomScreenOutputImpl);
         runtimeManager->SetCustomImplementation(_ServiceProviderOutputImpl);
         runtimeManager->SetCustomImplementation(_I18nOutputImpl);
         runtimeManager->SetCustomImplementation(_LoggingOutputImpl);
         runtimeManager->SetCustomImplementation(_MeasureOutputImpl);
         runtimeManager->SetCustomImplementation(_SqlOutputImpl);
         runtimeManager->SetCustomImplementation(_StateVariableOutputImpl);
         REFAPP_END_METHOD();
     }
  
 private:
     msclr::auto_gcroot<SampleForm^> Owner;
     std::shared_ptr<std::function<void(const IRuntimeContext&)>> _ProcedurePending;
     std::shared_ptr<std::function<void(const IRuntimeContext&)>> _ProcedureStarted;
     std::shared_ptr<std::function<void(const IRuntimeContext&, ExecutionStateChangeReason)>> _ProcedurePaused;
     std::shared_ptr<std::function<void(const IRuntimeContext&)>> _ProcedureContinued;
     std::shared_ptr<std::function<void(const IRuntimeContext&)>> _ProcedureFinished;
     std::shared_ptr<std::function<void(const IRuntimeContext&)>> _ProcedureStopped;
     std::shared_ptr<std::function<void(const IRuntimeContext&)>> _ProcedureAborted;
     std::shared_ptr<std::function<void(const IRuntimeContext&)>> _ProcedureTimeout;
     std::shared_ptr<std::function<void(ClampState, ClampState)>> _DiagConnectionStateChanged;
     std::shared_ptr<std::function<void(const IRuntimeContext&, const IProcedureInOutParameter&)>> _InOutParameterValueChanged;
  
     std::shared_ptr<std::function<void(std::shared_ptr<Custom::KeyEventArgs>)>> _KeyDown;
     std::shared_ptr<std::function<void(std::shared_ptr<IContextVariable>, std::shared_ptr<DataTypes::Object>)>> _ContextVariableRead;
     std::shared_ptr<std::function<void(std::shared_ptr<IStateVariable>, std::shared_ptr<DataTypes::Object>)>> _StateVariableValueChanged;
 };
  
 bool SampleFormImpl::IsRegistered = false;
 std::string SampleFormImpl::FileVersion = "";
 std::vector<msclr::auto_gcroot<SampleForm^>> SampleFormImpl::ListForms;
  
 void SampleForm::RegisterSettingsEvent()
 {
     REFAPP_START_METHOD();
     if (!SampleFormImpl::IsRegistered)
     {
         SampleFormImpl::IsRegistered = true;
  
         SampleFormImpl::FileVersion = RuntimeConfig::GetInstance().GetVersion();
         // Reason: See #15223. Only implement at Sample Dotnet
         //String^ licenseKeyFromOTForOTPLicense = OpenTestSystem::Common::LicensingV5::Util::CreateLicenseKeyFromOTForOTPLicense();
         System::String^ licenseKeyFromOTForOTPLicense;
         // isAcceptEmptyLicenseValue = licenseKeyFromOTForOTPLicense.Equals("") ? false : true;
  
         if (!System::String::IsNullOrEmpty(licenseKeyFromOTForOTPLicense) && Util::LicenseUtil::CheckLicenseFormat(Util::Util::ToString(licenseKeyFromOTForOTPLicense)))
         {
             OpenTestSystem::Otx::Runtime::Api::License::LicenseManager::SetLicenseKey(Util::Util::ToString(licenseKeyFromOTForOTPLicense));
         }
         else
         {
             std::string licenseKey = Setting::UserSettings::GetInstance().GetLicenseKey();
             licenseKey = Util::LicenseUtil::Decrypt(licenseKey);
             if (Util::LicenseUtil::CheckLicenseFormat(licenseKey))
             {
                 OpenTestSystem::Otx::Runtime::Api::License::LicenseManager::SetLicenseKey(licenseKey);
             }
             else
             {
                 System::Windows::Forms::MessageBox::Show("There is an invalid license key format. Please set your new key in license box.", "Warning!", System::Windows::Forms::MessageBoxButtons::OK, System::Windows::Forms::MessageBoxIcon::Warning);
             }
         }
  
         Microsoft::Win32::SystemEvents::DisplaySettingsChanged += gcnew System::EventHandler(this, &OpenTestSystem::Otx::Runtime2::Api::Sample::SampleForm::SystemEvents_DisplaySettingsChanged);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SystemEvents_DisplaySettingsChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         for (int i = 0; i < SampleFormImpl::ListForms.size(); i++)
         {
             msclr::auto_gcroot<SampleForm^> frm = SampleFormImpl::ListForms.at(i);
             try
             {
                 if (frm.get()->InvokeRequired)
                 {
                     frm.get()->Invoke(gcnew System::Action(frm.get(), &SampleForm::Refresh));
                 }
                 else
                 {
                     frm.get()->Refresh();
                 }
             }
             catch (...) {}
         }
     }
     catch (...) {}
     REFAPP_END_METHOD();
 }
  
 void SampleForm::InitializeInternalComponent()
 {
     REFAPP_START_METHOD();
     piml = new SampleFormImpl(this);
     RegisterSettingsEvent();
     REFAPP_END_METHOD();
 }
  
 SampleForm::SampleForm(System::String^ title, SampleForm^ creatorForm)
 {
     REFAPP_START_METHOD();
     ShowInTaskbar = false;
     InitializeInternalComponent();
  
     piml->Title = System::String::IsNullOrEmpty(title) ? SampleConstants::MAIN_INSTANCE_NAME : Util::Util::ToString(title);
     piml->CreatorForm = creatorForm;
  
     piml->WebServerTimer->Interval = 1000;
     piml->WebServerTimer->Enabled = true;
     piml->WebServerTimer->Tick += gcnew System::EventHandler(this, &SampleForm::WebServerTimer_Tick);
  
     InitializeComponent();
  
     piml->ListForms.push_back(this);
  
     PrintTextCallback("Application started");
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::SampleForm_Load(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     Visible = false;
     PrintTextCallback("Start Initialization...");
  
     CreateCustomImpl();
     InitializeSampleDefaultValues();
     UpdateWebServerButtonCallback();
  
     if (IS_NOT_NULL(piml->CreatorForm))
     {
         checkBoxStartAllParents->Visible = true;
         checkBoxStartAllParents->Checked = piml->CreatorForm->checkBoxStartAllParents->Checked;
     }
  
     SetRuntimeContextName();
     SetTitle(Util::Util::ToString(piml->Title));
     SetLocation(piml->CreatorForm.get());
  
     toolTip1->SetToolTip(labelProcedureExecutionTimes, "Total procedure execution time.");
     toolTip1->SetToolTip(textBoxTimeout, "Timeout for procedure execution in milliseconds. The default value 0 means without timeout.");
     toolTip1->SetToolTip(checkBoxUseConnectionState, "Use expected connection state during procedure execution.");
     toolTip1->SetToolTip(labelBatteryState, "State of the battery (KL 30)");
     toolTip1->SetToolTip(checkBoxIgnition, "Expected ignition (KL 15) state during procedure execution");
     toolTip1->SetToolTip(labelIgnitionState, "State of the ignition (KL 15)");
     toolTip1->SetToolTip(buttonCheckBatteryIgnition, "Check current battery (KL30) and ignition (KL15) state.");
     toolTip1->SetToolTip(textBoxPollingTime, "Time in milliseconds between the next check of the connection state during the procedure execution (Polling). The default value is 500 ms.");
     toolTip1->SetToolTip(textBoxVoltageThreshold, "Voltage threshold in millivolt from which the battery voltage, see GetBatteryVoltage is enough for KL30 = On. The default value is 6000 mV.");
  
     LoadContextFile(piml->GlobalRuntimeManager);
  
     PrintTextCallback("... Initialization finished.");
     ShowInTaskbar = true;
 #pragma region Only Cpp: See issue 15942 - bug 7
     WindowState = System::Windows::Forms::FormWindowState::Normal;
 #pragma endregion
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::SampleForm_Shown(System::Object^ sender, System::EventArgs^ e)
 {
     cbFilePath->SelectionLength = 0;
     Visible = true;
 }
  
 void SampleForm::SetRuntimeContextName()
 {
     REFAPP_START_METHOD();
     if (IS_NOT_NULL(piml->CreatorForm) && !System::String::IsNullOrEmpty(Util::Util::ToString(piml->CreatorForm->piml->RuntimeContextName)))
     {
         System::String^ contextName = Util::Util::ToString(piml->CreatorForm->piml->RuntimeContextName);
         System::Text::RegularExpressions::Match^ regExpMatch = System::Text::RegularExpressions::Regex::Match(contextName, "\d*$");
         int number;
         if (System::Int32::TryParse(regExpMatch->Value, number))
         {
             number++;
  
             if (Util::Util::IsInstance<System::Windows::Forms::TextBox^>(textBoxRuntimeContextName))
             {
                 textBoxRuntimeContextName->Text = Util::Util::ToString(piml->CreatorForm->piml->RuntimeContextName.substr(0, regExpMatch->Index) + std::to_string(number));
             }
         }
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetTitle(System::String^ title)
 {
     REFAPP_START_METHOD();
     if (System::String::IsNullOrWhiteSpace(title))
     {
         title = Util::Util::ToString(SampleConstants::MAIN_INSTANCE_NAME);
     }
  
     bool runningAsAdmin = System::Security::Principal::WindowsIdentity::GetCurrent()->Owner->IsWellKnown(System::Security::Principal::WellKnownSidType::BuiltinAdministratorsSid);
  
     Text = System::String::Format(
         "emotive OTX-Runtime API for Cpp - Reference Application - Version {0} - {1} Bit - {2} - Thread-ID {3}{4}",
         Util::Util::ToString(piml->FileVersion),
         System::Environment::Is64BitProcess ? "64" : "32",
         Util::Util::ToString(piml->Title),
         System::Threading::Thread::CurrentThread->ManagedThreadId,
         runningAsAdmin ? " - Administrator" : System::String::Empty
     );
  
     if (Util::Util::IsInstance<System::Windows::Forms::ComboBox^>(cbFilePath) && !System::String::IsNullOrEmpty(cbFilePath->Text))
     {
         Text = Text + " - " + System::IO::Path::GetFileName(cbFilePath->Text);
     }
  
     System::String^ runtimeContextNameCliStr = Util::Util::ToString(piml->RuntimeContextName);
     if (!System::String::IsNullOrEmpty(runtimeContextNameCliStr))
     {
         Text = Text + " - " + runtimeContextNameCliStr;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetLocation(SampleForm^ creatorForm)
 {
     REFAPP_START_METHOD();
     if (creatorForm != nullptr)
     {
         int xOffset = piml->FORM_OFFSET;
         int yOffset = piml->FORM_OFFSET;
  
         if (IS_NOT_NULL(creatorForm->piml->CreatorForm))
         {
             xOffset = creatorForm->Location.X - creatorForm->piml->CreatorForm->Location.X;
             yOffset = creatorForm->Location.Y - creatorForm->piml->CreatorForm->Location.Y;
         }
  
         Location = Point(creatorForm->Location.X + xOffset, creatorForm->Location.Y + yOffset);
         Size = creatorForm->Size;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CreateCustomImpl()
 {
     REFAPP_START_METHOD();
     CreateDefaultCustomImpl();
     CreateOutputWindowCustomImpl();
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CreateDefaultCustomImpl()
 {
     REFAPP_START_METHOD();
     PrintTextCallback("Create default custom implementation");
  
     piml->CreateDefaultCustomImpl();
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CreateOutputWindowCustomImpl()
 {
     REFAPP_START_METHOD();
     PrintTextCallback("Create output window custom implementation");
  
     piml->CreateOutputWindowCustomImpl();
     REFAPP_END_METHOD();
 }
  
 void SampleForm::InitializeSampleDefaultValues()
 {
     REFAPP_START_METHOD();
     PrintTextCallback("Initialize default values");
  
     comboBoxTraceLevel->Items->AddRange(Util::Util::ArrayTraceLevels2String());
  
     // Avoid changing order
     treeViewOtxProject->ImageList = imageList1;
  
     textBoxRtPortPipe->Name = Util::Util::ToString(SampleConstants::RT_PORT_PIPE_TEXT_BOX_NAME);
     textBoxDiagPortPipe->Name = Util::Util::ToString(SampleConstants::DM_PORT_PIPE_TEXT_BOX_NAME);
  
     LoadSetting();
  
     EnableConnectionState();
     REFAPP_END_METHOD();
 }
  
 void SampleForm::LoadSetting()
 {
     REFAPP_START_METHOD();
     Setting::UserSettings::GetInstance().Reload();
     try
     {
         SetupTraceLevel();
         SetupTraceFolder();
         SetupTraceFileProfilerMaxCountAndSize();
  
         // Avoid changing order of the time
         SetupDefaultPortAndPipeName();
  
         cbFilePath->Text = Util::Util::ToString(Setting::UserSettings::GetInstance().GetPtxPpxDirectory());
         if (!Setting::UserSettings::GetInstance().GetPtxPpxDirectoryList().empty())
         {
             cbFilePath->Items->AddRange(Util::Util::ToString(Setting::UserSettings::GetInstance().GetPtxPpxDirectoryList())->Split(';'));
         }
         AddComboBoxFileOrPath(cbFilePath);
  
         SetupCustomImplType();
         SetupWindowSize();
         SetupWindowLocation();
  
         checkBoxAsyncExecution->Checked = Setting::UserSettings::GetInstance().GetAsynchron();
         checkBoxCyclicExecution->Checked = Setting::UserSettings::GetInstance().GetCyclic();
         checkBoxCyclicReload->Checked = Setting::UserSettings::GetInstance().GetCyclicReload();
         checkBoxNewRuntimeManager->Checked = Setting::UserSettings::GetInstance().GetNewRuntimeManager();
         checkBoxAdd2Output->Checked = Setting::UserSettings::GetInstance().GetAddMessageToOutput();
         checkBoxStartAllParents->Checked = Setting::UserSettings::GetInstance().GetStartAllParents();
  
         SetupTimeOut();
         checkBoxUseConnectionState->Checked = Setting::UserSettings::GetInstance().GetConnectionState();
         checkBoxIgnition->CheckState = Setting::UserSettings::GetInstance().GetIgnition() == 1 ? System::Windows::Forms::CheckState::Checked
             : (Setting::UserSettings::GetInstance().GetIgnition() == 0 ? System::Windows::Forms::CheckState::Unchecked
                 : System::Windows::Forms::CheckState::Indeterminate);
         SetupPollingTime();
         SetupVoltageThreshold();
  
         textBoxRuntimeContextName->Text = Util::Util::ToString(Setting::UserSettings::GetInstance().GetRuntimeContextName());
  
 #pragma region C++ for RAW-Mode
         textBoxDiagManagerLicenseKey->Text = Util::Util::ToString(Util::LicenseUtil::Decrypt(Setting::UserSettings::GetInstance().GetDiagManagerLicenseKey()));
         checkBoxIncludedDiagLogging->Checked = Setting::UserSettings::GetInstance().GetIncludeTraceDiagLogging();
  
         std::string traceFolder = Setting::UserSettings::GetInstance().GetDiagTraceDirectory();
         textBoxDiagManagerTraceFolder->Text = Util::Util::ToString(traceFolder.empty() ? Util::OtxDiagUtil::GetPathLoggerDefault() : traceFolder);
 #pragma endregion
  
     }
     catch (const std::exception& e)
     {
         PrintTextCallback(Util::Util::ToString(e.what()));
         Setting::UserSettings::GetInstance().Reset();
     }
     catch (System::Exception^ e)
     {
         PrintTextCallback(e->Message);
         Setting::UserSettings::GetInstance().Reset();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::AddComboBoxFileOrPath(System::Windows::Forms::ComboBox^ comboBox)
 {
     REFAPP_START_METHOD();
     if (comboBox != nullptr && !piml->IsPathChanging)
     {
         piml->IsPathChanging = true;
  
         System::String^ path = comboBox->Text;
  
         if (System::IO::Directory::Exists(path) || System::IO::File::Exists(path))
         {
             while (comboBox->Items->Contains(path))
             {
                 comboBox->Items->Remove(path);
             }
  
             while (comboBox->Items->Contains(path->TrimEnd(gcnew cli::array<wchar_t>(2) { '/', '\\' })))
             {
                 comboBox->Items->Remove(path->TrimEnd(gcnew cli::array<wchar_t>(2) { '/', '\\' }));
             }
  
             path = path->TrimEnd(gcnew cli::array<wchar_t>(2) { '/', '\\' });
  
             comboBox->Items->Insert(0, path);
             comboBox->Text = path;
             comboBox->SelectAll();
         }
  
         piml->IsPathChanging = false;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupTraceFileProfilerMaxCountAndSize()
 {
     REFAPP_START_METHOD();
     RuntimeConfig::GetInstance().SetTraceFileMaxCount(Setting::UserSettings::GetInstance().GetTraceFileMaxCount());
     textBoxTraceFileMaxCount->Text = Setting::UserSettings::GetInstance().GetTraceFileMaxCount().ToString();
  
     RuntimeConfig::GetInstance().SetTraceFileMaxSize(Setting::UserSettings::GetInstance().GetTraceFileMaxSize());
     textBoxTraceFileMaxSize->Text = Setting::UserSettings::GetInstance().GetTraceFileMaxSize().ToString();
  
     RuntimeConfig::GetInstance().SetProfiling(Setting::UserSettings::GetInstance().GetProfiling());
     checkBoxProfiling->Checked = Setting::UserSettings::GetInstance().GetProfiling();
  
     RuntimeConfig::GetInstance().SetProfilingMaxFileSize(Setting::UserSettings::GetInstance().GetProfilingMaxFileSize());
     textBoxProfilingSize->Text = Setting::UserSettings::GetInstance().GetProfilingMaxFileSize().ToString();
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupDefaultPortAndPipeName()
 {
     REFAPP_START_METHOD();
     piml->DefaultDiagPort = Setting::UserSettings::GetInstance().GetDiagManagerPort();
     piml->DefaultRuntimePort = Setting::UserSettings::GetInstance().GetRuntimePort();
  
     piml->DefaultDiagPipeName = Setting::UserSettings::GetInstance().GetDiagManagerPipeName();
     piml->DefaultRuntimePipeName = Setting::UserSettings::GetInstance().GetRuntimePipeName();
  
     IpcTypes ipcType = IpcTypes::Socket;
     ipcType = Setting::UserSettings::GetInstance().GetIpcType();
  
     if (comboBoxIpcType->Items->Count == 0)
     {
         // Mode: Raw (Only C++), Socket, Pipe
         comboBoxIpcType->Items->AddRange(Util::Util::ArrayIpcTypes2String());
     }
  
     comboBoxIpcType->SelectedItem = Util::Util::ToString(ipcType);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupTraceLevel()
 {
     REFAPP_START_METHOD();
     TraceLevels traceLevels = Setting::UserSettings::GetInstance().GetTraceLevels();
     OpenTestSystem::Otx::Runtime::Api::RuntimeConfig::GetInstance().SetTraceLevel(traceLevels);
  
     traceLevels = OpenTestSystem::Otx::Runtime::Api::RuntimeConfig::GetInstance().GetTraceLevel();
     comboBoxTraceLevel->SelectedItem = Util::Util::ToString(traceLevels);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupTraceFolder()
 {
     REFAPP_START_METHOD();
     if (Setting::UserSettings::GetInstance().GetTracingDirectory().empty() != true)
     {
         OpenTestSystem::Otx::Runtime::Api::RuntimeConfig::GetInstance().SetTraceFolder(Setting::UserSettings::GetInstance().GetTracingDirectory());
     }
  
     textBoxTraceFolder->Text = Util::Util::ToString(RuntimeConfig::GetInstance().GetTraceFolder());
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupCustomImplType()
 {
     REFAPP_START_METHOD();
     if (Setting::UserSettings::GetInstance().GetCustomImplTypes() == CustomImplTypes::OutputImpl)
     {
         radioButtonOuputWindow->Checked = true;
     }
     else if (Setting::UserSettings::GetInstance().GetCustomImplTypes() == CustomImplTypes::NoCustom)
     {
         radioButtonNoCustomImplementation->Checked = true;
     }
     else
     {
         radioButtonDefaultImplementation->Checked = true;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupWindowSize()
 {
     REFAPP_START_METHOD();
     int width = Setting::UserSettings::GetInstance().GetWindowWidth();
     int height = Setting::UserSettings::GetInstance().GetWindowHeight();
     Size = System::Drawing::Size(width, height);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupWindowLocation()
 {
     REFAPP_START_METHOD();
     int locationX = Setting::UserSettings::GetInstance().GetWindowLocationX();
     int locationY = Setting::UserSettings::GetInstance().GetWindowLocationY();
     System::Drawing::Point location = System::Drawing::Point(locationX, locationY);
  
     if (CheckFormIsInBound(location))
     {
         Location = location;
         REFAPP_END_METHOD();
         return;
     }
  
     CenterToScreen();
     REFAPP_END_METHOD();
 }
  
 bool SampleForm::CheckFormIsInBound(System::Drawing::Point location)
 {
     REFAPP_START_METHOD();
     try
     {
 #pragma region C++ can not use Linq
         cli::array<System::Windows::Forms::Screen^>^ formContainScreens = System::Windows::Forms::Screen::AllScreens;
         for (int i = 0; i < formContainScreens->Length; i++)
         {
             if (formContainScreens[i]->Bounds.Contains(location))
             {
                 REFAPP_END_METHOD();
                 return true;
             }
         }
  
         REFAPP_END_METHOD();
         return false;
 #pragma endregion
     }
     catch (...)
     {
         REFAPP_END_METHOD();
         return false;
     }
 }
  
 void SampleForm::SetupTimeOut()
 {
     REFAPP_START_METHOD();
     System::String^ timeOutString = Setting::UserSettings::GetInstance().GetTimeOut().ToString();
     textBoxTimeout->Text = timeOutString;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupPollingTime()
 {
     REFAPP_START_METHOD();
     std::string pollingTimeString = std::to_string(Setting::UserSettings::GetInstance().GetPollingTime());
     textBoxPollingTime->Text = Util::Util::ToString(pollingTimeString);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupVoltageThreshold()
 {
     REFAPP_START_METHOD();
     std::string voltageThreshold = std::to_string(Setting::UserSettings::GetInstance().GetVoltageThreshold());
     textBoxVoltageThreshold->Text = Util::Util::ToString(voltageThreshold);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::comboBoxIpcType_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     // Avoid RuntimeManager creation on DiagManager's port changed in this method
     textBoxDiagPortPipe->TextChanged -= gcnew System::EventHandler(this, &SampleForm::textBoxPortPipe_TextChanged);
     IpcTypes ipcType = Util::Util::ToIpcType(comboBoxIpcType->SelectedItem->ToString());
  
 #pragma region C++ for design has RAW-mode
     // hide some input when initialize runtime manager
     textBoxDiagPortPipe->Hide();
     textBoxRtPortPipe->Hide();
     comboBoxODXProject->Hide();
     label13->Hide();
     comboBoxODXVehicle->Hide();
     portPipeLabel->Hide();
     labelOdxProject->Hide();
  
     // collapse content configuration DiagManager 
     panel1->Size = System::Drawing::Size(panel1->Size.Width, 61);
     portPipeLabel->Location = System::Drawing::Point(portPipeLabel->Location.X, 34);
     textBoxDiagPortPipe->Location = System::Drawing::Point(Width - 95, 31);
     textBoxDiagPortPipe->Size = System::Drawing::Size(55, 22);
 #pragma endregion
  
     switch (ipcType)
     {
 #pragma region C++ for RAW-mode
     case IpcTypes::Raw:
         // expand content configuration DiagManager 
         panel1->Size = System::Drawing::Size(panel1->Size.Width, 116);
  
         SetupDiagManagerControls();
  
         comboBoxDiagIpcType_SelectedValueChanged(comboBoxDiagIpcType, nullptr);
  
         break;
 #pragma endregion
  
     case IpcTypes::Socket:
  
         portPipeLabel->Show();
         portPipeLabel->Text = "Runner / DiagManager Ports";
  
 #pragma region C++ for design has RAW-mode
         textBoxRtPortPipe->Show();
         label13->Show();
         textBoxDiagPortPipe->Show();
 #pragma endregion
  
         textBoxDiagPortPipe->Text = piml->DefaultDiagPort.ToString();
         textBoxDiagPortPipe->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxPortPipe_TextChanged);
  
         textBoxRtPortPipe->Text = piml->DefaultRuntimePort.ToString();
         break;
  
     case IpcTypes::Pipe:
  
         portPipeLabel->Show();
         portPipeLabel->Text = "Runner / DiagManager Pipes";
  
 #pragma region C++ for design has RAW-mode
         textBoxRtPortPipe->Show();
         label13->Show();
         textBoxDiagPortPipe->Show();
 #pragma endregion
  
         textBoxDiagPortPipe->Text = Util::Util::ToString(piml->DefaultDiagPipeName);
         textBoxDiagPortPipe->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxPortPipe_TextChanged);
  
         textBoxRtPortPipe->Text = Util::Util::ToString(piml->DefaultRuntimePipeName);
         break;
  
     default:
         break;
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxPortPipe_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     PrintTextCallback("Create RuntimeManager...");
  
     try
     {
         piml->GlobalRuntimeManager = CreateRuntimeManager();
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
         PrintTextCallback("No RuntimeManager created");
     }
     catch (System::Exception^ ex)
     {
         System::String^ senderName = (dynamic_cast<System::Windows::Forms::TextBox^>(sender))->Name;
         if (senderName->Equals(Util::Util::ToString(SampleConstants::RT_PORT_PIPE_TEXT_BOX_NAME)))
         {
             PrintTextCallback(System::String::Format("Invalid Otx Runtime {0}", IpcPortPipeString()));
         }
         else if (senderName->Equals(Util::Util::ToString(SampleConstants::DM_PORT_PIPE_TEXT_BOX_NAME)))
         {
             PrintTextCallback(System::String::Format("Invalid Diag Manager {0}", IpcPortPipeString()));
         }
  
         PrintException(ex);
         PrintTextCallback("No RuntimeManager created");
     }
     catch (...)
     {
         PrintTextCallback("No RuntimeManager created");
     }
  
     if (piml->GlobalRuntimeManager == nullptr)
     {
         PrintTextCallback("RuntimeManager is null.");
     }
     REFAPP_END_METHOD();
 }
  
 std::shared_ptr<IRuntimeManager> SampleForm::CreateRuntimeManager()
 {
     REFAPP_START_METHOD();
     std::shared_ptr<IRuntimeManager> runtimeManager = nullptr;
     try
     {
         System::String^ ipcType = "";
         switch (Util::Util::ToIpcType(comboBoxIpcType->SelectedItem->ToString()))
         {
 #pragma region C++ for RAW-mode
         case IpcTypes::Raw:
  
             runtimeManager = CreateRawRuntimeManager();
  
             if (runtimeManager == nullptr)
             {
                 REFAPP_END_METHOD();
                 return piml->GlobalRuntimeManager;
             }
  
             ipcType = Util::Util::ToString(IpcTypes::Raw);
  
             break;
 #pragma endregion
  
         case IpcTypes::Socket:
  
             runtimeManager = CreateSocketRuntimeManager();
             ipcType = Util::Util::ToString(IpcTypes::Socket);
             break;
  
         case IpcTypes::Pipe:
  
             runtimeManager = CreatePipeRuntimeManager();
             ipcType = Util::Util::ToString(IpcTypes::Pipe);
             break;
         }
  
         PrintTextCallback(System::String::Format("... {0} RuntimeManager created (MinBinVersion: {1})", ipcType, Util::Util::ToString(RuntimeConfig::GetInstance().GetMinBinVersion())));
  
         InitializeRuntimeEvents(runtimeManager);
         SetCustomImplementation(runtimeManager);
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
         PrintTextCallback("... No RuntimeManager created.");
  
         REFAPP_END_METHOD();
         return runtimeManager;
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
         PrintTextCallback("... No RuntimeManager created.");
  
         REFAPP_END_METHOD();
         return runtimeManager;
     }
     catch (...)
     {
         PrintTextCallback("... No RuntimeManager created.");
  
         REFAPP_END_METHOD();
         return runtimeManager;
     }
  
     REFAPP_END_METHOD();
     return runtimeManager;
 }
  
 System::String^ SampleForm::IpcPortPipeString()
 {
     IpcTypes ipcType = Util::Util::ToIpcType(comboBoxIpcType->SelectedItem->ToString());
     switch (ipcType)
     {
     case IpcTypes::Socket:
         return Util::Util::ToString(SampleConstants::PORT_STRING);
     case IpcTypes::Pipe:
         return Util::Util::ToString(SampleConstants::PIPE_STRING);
     default:
         // Should not reach here
         return System::String::Empty;
     }
 }
  
 std::shared_ptr<IRuntimeManager> SampleForm::CreateSocketRuntimeManager()
 {
     REFAPP_START_METHOD();
     unsigned short rtPort = System::Convert::ToUInt16(textBoxRtPortPipe->Text);
  
     if (NoDiag())
     {
         return RuntimeManagerFactory::CreateSocketRuntimeManager(rtPort);
     }
     else
     {
         unsigned short diagPort = System::Convert::ToUInt16(textBoxDiagPortPipe->Text);
         return RuntimeManagerFactory::CreateSocketRuntimeManager(rtPort, diagPort);
     }
     REFAPP_END_METHOD();
 }
  
 std::shared_ptr<IRuntimeManager> SampleForm::CreatePipeRuntimeManager()
 {
     REFAPP_START_METHOD();
     if (NoDiag())
     {
         return RuntimeManagerFactory::CreatePipeRuntimeManager(Util::Util::ToString(textBoxRtPortPipe->Text));
     }
     else
     {
         return RuntimeManagerFactory::CreatePipeRuntimeManager(Util::Util::ToString(textBoxRtPortPipe->Text), Util::Util::ToString(textBoxDiagPortPipe->Text));
     }
     REFAPP_END_METHOD();
 }
  
 bool SampleForm::NoDiag()
 {
     return System::String::IsNullOrWhiteSpace(textBoxDiagPortPipe->Text);
 }
  
 void SampleForm::InitializeRuntimeEvents(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     REFAPP_START_METHOD();
     if (runtimeManager == nullptr)
     {
         return;
     }
  
     piml->InitializeRuntimeEvents(runtimeManager);
  
     PrintTextCallback("Initialization of runtime events finished");
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::radioButtonCustomImpl_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->GlobalRuntimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (sender != nullptr && (dynamic_cast<System::Windows::Forms::RadioButton^>(sender))->Checked == false)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     SetCustomImplementation(piml->GlobalRuntimeManager);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     REFAPP_START_METHOD();
     if (runtimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::String^ type = "";
     CustomImplTypes currentCustomImpl = GetCurrentCustomImpl();
     switch (currentCustomImpl)
     {
     case OutputImpl:
  
         SetOutputWindowImplementation(runtimeManager);
         type = "output ";
         break;
  
     case DefaultCustomImpl:
  
         SetDefaultCustomImplementation(runtimeManager);
         type = "default ";
         break;
  
     case NoCustom:
  
         RemoveCustomImplementation(runtimeManager);
         type = "no ";
         break;
  
     default:
         break;
     }
  
     if (currentCustomImpl != CustomImplTypes::None)
     {
         PrintTextCallback("Set up " + type + "custom implementation finished");
     }
     REFAPP_END_METHOD();
 }
  
 CustomImplTypes SampleForm::GetCurrentCustomImpl()
 {
     if (radioButtonOuputWindow->Checked)
     {
         return CustomImplTypes::OutputImpl;
     }
     else if (radioButtonDefaultImplementation->Checked)
     {
         return CustomImplTypes::DefaultCustomImpl;
     }
     else if (radioButtonNoCustomImplementation->Checked)
     {
         return CustomImplTypes::NoCustom;
     }
  
     return CustomImplTypes::None;
 }
  
 void SampleForm::SetOutputWindowImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     if (runtimeManager == nullptr)
     {
         return;
     }
  
     piml->SetOutputWindowImplementation(runtimeManager);
 }
  
 void SampleForm::SetDefaultCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     if (runtimeManager == nullptr)
     {
         return;
     }
  
     piml->SetDefaultCustomImplementation(runtimeManager);
 }
  
 void SampleForm::RemoveCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     if (runtimeManager == nullptr)
     {
         return;
     }
  
     piml->RemoveCustomImplementation(runtimeManager);
 }
  
 void SampleForm::ProcedurePendingCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<CLRWrapper< IRuntimeContext*>^>(this, &SampleForm::ProcedurePendingCallback), clrContext);
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         IRuntimeContext* context = clrContext->GetPtr();
         PrintTextCallback(System::String::Format("Event ProcedurePending occurred - {0} - ExecutionState = {1}",
             Util::Util::ToString(context->GetProcedure()->GetFullName()),
             Util::Util::ToString(context->GetExecutionState())));
         UpdateExecutionState(context);
         ShowConnectionStateMessage(context);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ProcedureStartedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureStartedCallback), clrContext);
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         IRuntimeContext* context = clrContext->GetPtr();
         PrintTextCallback(System::String::Format("Event ProcedureStarted occurred - {0} - ExecutionState = {1} - RuntimeId = {2} - ProcessId = {3}",
             Util::Util::ToString(context->GetProcedure()->GetFullName()),
             Util::Util::ToString(context->GetExecutionState()),
             context->GetRuntimeId().ToString(),
             context->GetProcessId().ToString()));
         UpdateExecutionState(context);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ProcedurePaused(IRuntimeContext* context, ExecutionStateChangeReason reason)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = gcnew cli::array<System::Object^>(2);
     arr[0] = gcnew CLRWrapper<IRuntimeContext*>(context);
     arr[1] = gcnew CLRWrapper<ExecutionStateChangeReason>(reason);
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::ProcedurePausedCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         ProcedurePausedCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ProcedurePausedCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     IRuntimeContext* context = Util::Util::CastTo<IRuntimeContext*>(arr[0]);
     ExecutionStateChangeReason reason = Util::Util::CastToEnum<ExecutionStateChangeReason>(arr[1]);
  
     if (context == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         PrintTextCallback(System::String::Format("Event ProcedurePaused occurred - {0} - ExecutionState = {1} - ExecutionStateChangeReason = {2}",
                                         Util::Util::ToString(context->GetProcedure()->GetFullName()),
                                         Util::Util::ToString(context->GetExecutionState()),
                                         Util::Util::ToString(reason)));
         UpdateExecutionState(context, reason);
         if (reason == ExecutionStateChangeReason::UnexpectedDiagConnectionState)
         {
             ShowConnectionStateMessage(context);
         }
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ProcedureContinuedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureContinuedCallback), clrContext);
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         IRuntimeContext* context = clrContext->GetPtr();
         PrintTextCallback(System::String::Format("Event ProcedureContinued occurred - {0} - ExecutionState = {1}",
             Util::Util::ToString(context->GetProcedure()->GetFullName()),
             Util::Util::ToString(context->GetExecutionState())));
         UpdateExecutionState(context);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ProcedureStoppedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureStoppedCallback), clrContext);
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         IRuntimeContext* context = clrContext->GetPtr();
         PrintTextCallback(System::String::Format("Event ProcedureStopped occurred - {0} - ExecutionState = {1}",
             Util::Util::ToString(context->GetProcedure()->GetFullName()),
             Util::Util::ToString(context->GetExecutionState())));
         UpdateExecutionState(context);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ProcedureTimeoutCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureTimeoutCallback), clrContext);
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         IRuntimeContext* context = clrContext->GetPtr();
         PrintTextCallback(System::String::Format("Event ProcedureTimeout occurred - {0} - ExecutionState = {1}",
             Util::Util::ToString(context->GetProcedure()->GetFullName()),
             Util::Util::ToString(context->GetExecutionState())));
  
         UpdateExecutionState(context);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::DiagConnectionStateChanged(ClampState batteryState, ClampState ignitionState)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = gcnew cli::array<System::Object^>(2);
     arr[0] = gcnew CLRWrapper<ClampState>(batteryState);
     arr[1] = gcnew CLRWrapper<ClampState>(ignitionState);
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::DiagConnectionStateChangedCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         DiagConnectionStateChangedCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::DiagConnectionStateChangedCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
  
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     ClampState batteryState = Util::Util::CastToEnum<ClampState>(arr[0]);
     ClampState ignitionState = Util::Util::CastToEnum<ClampState>(arr[1]);
  
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         PrintTextCallback(System::String::Format("Event DiagConnectionStateChanged occurred - BatteryState = {0}, IgnitionState = {1}",
                                         Util::Util::ToString(batteryState),
                                         Util::Util::ToString(ignitionState)));
         System::Media::SystemSounds::Beep->Play();
  
         SetBatteryIgnitionState(batteryState, ignitionState);
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor. handle multithread?
 void SampleForm::ProcedureFinishedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
 {
     REFAPP_START_METHOD();
  
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureFinishedCallback), clrContext);
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         IRuntimeContext* context = clrContext->GetPtr();
         std::shared_ptr<IProcedureParameter> procedureParameter;
         std::string procedureName = context->GetProcedure()->GetFullName();
         std::string parameterOutput;
  
         for (int i = 0; i < context->GetProcedure()->GetParameters().size(); i++)
         {
             procedureParameter = context->GetProcedure()->GetParameters().at(i);
             parameterOutput = "Parameter Changed - " + procedureParameter->GetName() + "(" + procedureParameter->GetDataType() + ") = ";
  
             if (IS_NOT_NULL(procedureParameter->GetValue()))
             {
                 parameterOutput += ShortenedValueString(procedureParameter->GetValue());
             }
             else
             {
                 parameterOutput += "";
             }
  
             PrintTextCallback(Util::Util::ToString(parameterOutput));
         }
         System::DateTime duration = System::DateTime::Now.Subtract(System::TimeSpan(piml->RuntimeContextIdsExecutionStartTick[context->GetRuntimeId()]));
         UpdateGridviewParameter(context->GetProcedure());
  
         System::String^ stringRunningTime;
         double runningTime;
         if (System::Double::TryParse(context->GetExecutionTime().ToString(), runningTime) == false)
         {
             runningTime = 0;
         }
         stringRunningTime = System::DateTime().AddMilliseconds(runningTime).ToString("HH':'mm':'ss','fff");
  
         PrintTextCallback(System::String::Format("ProcedureFinished({0}) ExecutionState({1}) - Execution duration {2} - Running time {3} - Used memory {4})",
             Util::Util::ToString(context->GetProcedure()->GetFullName()),
             Util::Util::ToString(context->GetExecutionState()),
             duration.ToString("HH':'mm':'ss','fff"),
             stringRunningTime,
             System::String::Format("{0:0,0} kB", context->GetProcessMemory() / 1024))
         );
  
         UpdateExecutionState(context);
  
         piml->CyclicExecuteAsyncIsProcessing = false;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ProcedureAbortedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureAbortedCallback), clrContext);
         REFAPP_END_METHOD();
         return;
     }
  
     IRuntimeContext* context = clrContext->GetPtr();
     PrintTextCallback(System::String::Format("ProcedureAborted({0}) ExecutionState({1})",
         Util::Util::ToString(context->GetProcedure()->GetFullName()),
         Util::Util::ToString(context->GetExecutionState())));
  
     if (context->HasRuntimeException())
     {
         PrintException(context->GetRuntimeException(), "Reason: API ");
     }
  
     if (context->HasOtxException())
     {
         PrintException(context->GetOtxException(), "Reason: OTX ");
     }
     piml->CyclicExecuteAsyncIsProcessing = false;
     UpdateExecutionState(context);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateExecutionState(IRuntimeContext* context, ExecutionStateChangeReason reason)
 {
     REFAPP_START_METHOD();
     if (context->GetExecutionState() == OpenTestSystem::Otx::Runtime::Api::ExecutionState::Paused)
     {
         piml->ProcedureExecutionCount--;
         if (reason == ExecutionStateChangeReason::Explicit)
         {
             DisplayProcedureExecutionState(context);
         }
  
         UpdatePauseButton(false, reason == ExecutionStateChangeReason::Explicit);
     }
     else
     {
         UpdateExecutionState(context);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateExecutionState(IRuntimeContext* context)
 {
     REFAPP_START_METHOD();
     if (context != nullptr)
     {
         System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
  
         switch (context->GetExecutionState())
         {
         case ExecutionState::Running:
  
             piml->ProcedureExecutionCount++;
  
             AddRuntimeContext(context);
             DisplayProcedureExecutionState(context);
  
             buttonExecuteMain->Enabled = checkBoxAsyncExecution->Checked;
             buttonExecuteSelectedProcedure->Enabled = checkBoxAsyncExecution->Checked;
  
             UpdateExecutionStateButtons(true);
             UpdatePauseButton(true);
  
             break;
  
         case ExecutionState::Paused:
  
             piml->ProcedureExecutionCount--;
             UpdatePauseButton(false);
  
             break;
  
         case ExecutionState::Pending:
  
             DisplayProcedureExecutionState(context);
             UpdateExecutionStateButtons(true);
             UpdatePauseButton(true, false);
  
             break;
  
         case ExecutionState::Finished:
  
             piml->ProcedureExecutionCount--;
  
             RemoveRuntimeContext(context);
             DisplayProcedureExecutionState(context);
  
             buttonExecuteMain->Enabled = !checkBoxCyclicExecution->Checked;
             buttonExecuteSelectedProcedure->Enabled = !checkBoxCyclicExecution->Checked;
  
             UpdateExecutionStateButtons(false);
             UpdatePauseButton(true, false);
  
             labelBatteryState->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBattery16"));
             labelVoltageThreshold->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnition16"));
  
             break;
  
         case ExecutionState::Stopped:
  
             piml->ProcedureExecutionCount--;
  
             RemoveRuntimeContext(context);
             DisplayProcedureExecutionState(context);
  
             buttonExecuteMain->Enabled = true;
             buttonExecuteSelectedProcedure->Enabled = true;
  
             UpdateExecutionStateButtons(false);
             UpdatePauseButton(true, false);
  
             labelBatteryState->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBattery16"));
             labelVoltageThreshold->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnition16"));
  
             break;
  
         case ExecutionState::Aborted:
  
             piml->ProcedureExecutionCount--;
  
             RemoveRuntimeContext(context);
             DisplayProcedureExecutionState(context);
  
             buttonExecuteMain->Enabled = true;
             buttonExecuteSelectedProcedure->Enabled = true;
  
             UpdateExecutionStateButtons(false);
             UpdatePauseButton(true, false);
  
             labelBatteryState->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBattery16"));
             labelVoltageThreshold->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnition16"));
  
             break;
         case ExecutionState::Timeout:
  
             System::Media::SystemSounds::Hand->Play();
  
             piml->ProcedureExecutionCount--;
  
             RemoveRuntimeContext(context);
             DisplayProcedureExecutionState(context);
  
             buttonExecuteMain->Enabled = true;
             buttonExecuteSelectedProcedure->Enabled = true;
  
             UpdateExecutionStateButtons(false);
             UpdatePauseButton(true, false);
  
             labelBatteryState->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBattery16"));
             labelVoltageThreshold->Image = cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnition16"));
  
             break;
         }
  
         StartStopUpdateGuiTimer();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::StartStopUpdateGuiTimer()
 {
     if (piml->ProcedureExecutionCount <= 0)
     {
         updateGuiTimer->Enabled = false;
         labelSeparator1->Visible = false;
         labelProcedureExecutionTimes->Visible = false;
     }
     else if (!updateGuiTimer->Enabled)
     {
         updateGuiTimer->Enabled = true;
     }
 }
  
 System::Void SampleForm::updateGuiTimer_Tick(System::Object^ sender, System::EventArgs^ e)
 {
     DisplayProcedureExecutionTimes();
 }
  
 void SampleForm::DisplayProcedureExecutionTimes()
 {
     REFAPP_START_METHOD();
     System::String^ text = System::String::Empty;
  
     if (piml->RuntimeContextIdsExecutionStartTick.size() > 0)
     {
         for (std::map<long long, long long>::iterator itr = piml->RuntimeContextIdsExecutionStartTick.begin();
             itr != piml->RuntimeContextIdsExecutionStartTick.end(); ++itr)
         {
             System::TimeSpan duration = System::TimeSpan(System::DateTime::Now.Ticks - itr->second);
             text += System::String::Format("{0}: {1} |",
                                             Util::Util::ToString(GetRuntimeContext(itr->first)->GetProcedure()->GetName()),
                                             duration.ToString("hh':'mm':'ss"));
         }
         text = text->TrimEnd(gcnew cli::array<wchar_t>{' ', '|'});
     }
  
     labelProcedureExecutionTimes->Text = text;
     labelSeparator1->Visible = true;
     labelProcedureExecutionTimes->Visible = true;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::InOutParameterValueChanged(IRuntimeContext* context, IProcedureInOutParameter* parameter)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = gcnew cli::array<System::Object^>(2);
     arr[0] = gcnew CLRWrapper<IRuntimeContext*>(context);
     arr[1] = gcnew CLRWrapper<IProcedureInOutParameter*>(parameter);
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::InOutParameterValueChangedCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         InOutParameterValueChangedCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::InOutParameterValueChangedCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
  
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     IRuntimeContext* context = Util::Util::CastTo<IRuntimeContext*>(arr[0]);
     IProcedureInOutParameter* parameter = Util::Util::CastTo<IProcedureInOutParameter*>(arr[1]);
  
     if (context == nullptr || parameter == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     msclr::lock l(piml->EventListenerLock.get());
     {
         try
         {
             std::string valueStr = ShortenedValueString(parameter->GetValue());
             System::String^ message = System::String::Format("Parameter '{0}' new value = {1}",
                                                             Util::Util::ToString(parameter->GetName()),
                                                             Util::Util::ToString(valueStr));
             PrintTextCallback(message);
             UpdateGridviewParameter(context->GetProcedure());
         }
         catch (const std::exception& ex)
         {
             PrintTextCallback(Util::Util::ToString(ex.what()));
         }
         catch (System::InvalidCastException^ ex)
         {
             PrintTextCallback(ex->Message);
         }
     }
     REFAPP_END_METHOD();
 }
  
 std::string SampleForm::ShortenedValueString(std::shared_ptr<DataTypes::Object> value)
 {
     try
     {
         std::string valueStr = ValueConverter::Value2String(value);
         if (valueStr.size() > piml->VALUE_STRING_MAX_LENGTH)
         {
             return valueStr.substr(0, piml->VALUE_STRING_MAX_LENGTH) + "...";
         }
  
         return valueStr;
     }
     catch (...)
     {
     }
  
     return "";
 }
  
 void SampleForm::UpdatePauseButton(bool pauseAvailable)
 {
     UpdatePauseButton(pauseAvailable, true);
 }
  
 void SampleForm::UpdatePauseButton(bool pauseAvailable, bool enabled)
 {
     REFAPP_START_METHOD();
 #pragma region C++ for initialize resources
     System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
 #pragma endregion
  
     buttonPause->Enabled = enabled;
     buttonPause->Checked = !pauseAvailable;
     buttonPause->Image = pauseAvailable ?
         (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonPause.Image"))) :
         (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonContinue.Image")));
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateExecutionStateButtons(bool wasExecuted)
 {
     if (piml->UseConnectionState)
     {
         labelTimeout->Enabled = !wasExecuted;
         textBoxTimeout->Enabled = !wasExecuted;
         checkBoxUseConnectionState->Enabled = !wasExecuted;
         labelExpectedState->Enabled = !wasExecuted;
         checkBoxIgnition->Enabled = !wasExecuted;
         labelPollingTime->Enabled = !wasExecuted;
         textBoxPollingTime->Enabled = !wasExecuted;
         labelVoltageThreshold->Enabled = !wasExecuted;
         textBoxVoltageThreshold->Enabled = !wasExecuted;
     }
  
     if (wasExecuted)
     {
         if (checkBoxAsyncExecution->Checked == false)
         {
             buttonExecuteMain->Enabled = false;
             buttonExecuteSelectedProcedure->Enabled = false;
         }
  
         buttonStop->Enabled = true;
     }
     else
     {
         if (IS_NOT_NULL(piml->Project) && IS_NOT_NULL(piml->Project->GetMainProcedure()))
         {
             buttonExecuteMain->Enabled = true;
         }
  
         buttonExecuteSelectedProcedure->Enabled = true;
  
         buttonStop->Enabled = false;
     }
 }
  
 void SampleForm::DisplayProcedureExecutionState(IRuntimeContext* context)
 {
     DisplayProcedureExecutionState(context, "");
 }
  
 void SampleForm::DisplayProcedureExecutionState(IRuntimeContext* context, System::String^ errorMessage)
 {
     REFAPP_START_METHOD();
 #pragma region C++ for intialize resource
     System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
 #pragma endregion
  
     if (System::String::IsNullOrEmpty(errorMessage))
     {
         labelIconProcedureExecutionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"Info16")));
  
         if (piml->ProcedureExecutionCount <= 0)
         {
             piml->ProcedureExecutionCount = 0;
             if (context->GetExecutionState() == ExecutionState::Paused)
             {
                 labelProcedureExecutionState->Text = "Execution is paused, click \"Continue\"...";
             }
             else
             {
                 labelProcedureExecutionState->Text = "Select a procedure and click \"Start\"...";
             }
         }
         else if (piml->ProcedureExecutionCount == 1)
         {
             labelProcedureExecutionState->Text = "1 Procedure is running";
         }
         else
         {
             labelProcedureExecutionState->Text = System::String::Format("{0} Procedures are running", piml->ProcedureExecutionCount);
         }
     }
     else
     {
         labelIconProcedureExecutionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"Error16")));
         labelProcedureExecutionState->Text = errorMessage;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SyncWithParent(System::Object^ parentControl)
 {
     REFAPP_START_METHOD();
     SyncWithParent(parentControl, nullptr);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SyncWithParent(System::Object^ parentControl, System::Object^ control)
 {
     REFAPP_START_METHOD();
     SyncWithParent(parentControl, control, false);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SyncWithParent(System::Object^ parentControl, System::Object^ control, bool newThread)
 {
     REFAPP_START_METHOD();
     if (parentControl != nullptr)
     {
         if (IS_NOT_NULL(piml->CreatorForm) && checkBoxStartAllParents->Checked)
         {
             if (Util::Util::IsInstance<System::Windows::Forms::Button^>(parentControl))
             {
                 if (newThread)
                 {
                     System::Threading::ThreadPool::QueueUserWorkItem(gcnew System::Threading::WaitCallback(this, &SampleForm::ParentButtonClickCallback), parentControl);
                 }
                 else
                 {
                     ParentButtonClickCallback(parentControl);
                 }
             }
             else if (Util::Util::IsInstance<System::Windows::Forms::TextBox^>(parentControl) && Util::Util::IsInstance<System::Windows::Forms::TextBox^>(control))
             {
                 cli::array<System::Object^>^ state = gcnew cli::array<System::Object^>(2);
                 state[0] = parentControl;
                 state[1] = (dynamic_cast<System::Windows::Forms::TextBox^>(control))->Text;
                 if (newThread)
                 {
                     System::Threading::ThreadPool::QueueUserWorkItem(gcnew System::Threading::WaitCallback(this, &SampleForm::ParentTextBoxSetTextCallback), state);
                 }
                 else
                 {
                     ParentTextBoxSetTextCallback(state);
                 }
             }
             else if (Util::Util::IsInstance<System::Windows::Forms::CheckBox^>(parentControl) && Util::Util::IsInstance<System::Windows::Forms::CheckBox^>(control))
             {
                 cli::array<System::Object^>^ state = gcnew cli::array<System::Object^>(2);
                 state[0] = parentControl;
                 state[1] = (dynamic_cast<System::Windows::Forms::CheckBox^> (control))->CheckState;
                 if (newThread)
                 {
                     System::Threading::ThreadPool::QueueUserWorkItem(gcnew System::Threading::WaitCallback(this, &SampleForm::ParentCheckBoxSetCheckStateCallback), state);
                 }
                 else
                 {
                     ParentCheckBoxSetCheckStateCallback(state);
                 }
             }
             else if (Util::Util::IsInstance<System::Windows::Forms::ComboBox^>(parentControl) && Util::Util::IsInstance<System::Windows::Forms::ComboBox^>(control))
             {
                 cli::array<System::Object^>^ state = gcnew cli::array<System::Object^>(2);
                 state[0] = parentControl;
                 state[1] = (dynamic_cast<System::Windows::Forms::ComboBox^>(control))->SelectedIndex;
                 if (newThread)
                 {
                     System::Threading::ThreadPool::QueueUserWorkItem(gcnew System::Threading::WaitCallback(this, &SampleForm::ParentComboBoxSetIndexCallback), state);
                 }
                 else
                 {
                     ParentComboBoxSetIndexCallback(state);
                 }
             }
             else if (Util::Util::IsInstance<System::Windows::Forms::NumericUpDown^>(parentControl) && Util::Util::IsInstance<System::Windows::Forms::NumericUpDown^>(control))
             {
                 cli::array<System::Object^>^ state = gcnew cli::array<System::Object^>(2);
                 state[0] = parentControl;
                 state[1] = System::Decimal::ToInt32((dynamic_cast<System::Windows::Forms::NumericUpDown^>(control))->Value);
                 if (newThread)
                 {
                     System::Threading::ThreadPool::QueueUserWorkItem(gcnew System::Threading::WaitCallback(this, &SampleForm::ParentNumericUpDownSetValueCallback), state);
                 }
                 else
                 {
                     ParentNumericUpDownSetValueCallback(state);
                 }
             }
         }
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ParentButtonClickCallback(System::Object^ state)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::Button^ parentButton = dynamic_cast<System::Windows::Forms::Button^> (state);
     if (parentButton == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (parentButton->InvokeRequired)
     {
         piml->CreatorForm->Invoke(gcnew System::Action<System::Object^>(this, &SampleForm::ParentButtonClickCallback), parentButton);
     }
     else
     {
         parentButton->PerformClick();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::TextBoxSetTextCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::TextBox^ parentTextBox = dynamic_cast<System::Windows::Forms::TextBox^>(arr[0]);
     System::Windows::Forms::TextBox^ textBox = dynamic_cast<System::Windows::Forms::TextBox^>(arr[1]);
  
     if (parentTextBox == nullptr || textBox == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     parentTextBox->Text = textBox->Text;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ParentTextBoxSetTextCallback(System::Object^ state)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::TextBox^ parentTextBox = dynamic_cast<System::Windows::Forms::TextBox^>(arr[0]);
     System::Windows::Forms::TextBox^ textBox = dynamic_cast<System::Windows::Forms::TextBox^>(arr[1]);
  
     if (parentTextBox == nullptr || textBox == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (parentTextBox->InvokeRequired)
     {
         piml->CreatorForm->Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::TextBoxSetTextCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         TextBoxSetTextCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CheckBoxSetCheckStateCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::CheckBox^ parentCheckBox = dynamic_cast<System::Windows::Forms::CheckBox^>(arr[0]);
     System::Windows::Forms::CheckBox^ checkBox = dynamic_cast<System::Windows::Forms::CheckBox^>(arr[1]);
     if (parentCheckBox == nullptr || checkBox == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     parentCheckBox->CheckState = checkBox->CheckState;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ParentCheckBoxSetCheckStateCallback(System::Object^ state)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::CheckBox^ parentCheckBox = dynamic_cast<System::Windows::Forms::CheckBox^>(arr[0]);
     System::Windows::Forms::CheckBox^ checkBox = dynamic_cast<System::Windows::Forms::CheckBox^>(arr[1]);
  
     if (parentCheckBox == nullptr || checkBox == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (checkBox->InvokeRequired)
     {
         piml->CreatorForm->Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::CheckBoxSetCheckStateCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         CheckBoxSetCheckStateCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ComboBoxSetIndexCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::ComboBox^ parentComboBox = dynamic_cast<System::Windows::Forms::ComboBox^>(arr[0]);
     System::Windows::Forms::ComboBox^ comboBox = dynamic_cast<System::Windows::Forms::ComboBox^>(arr[1]);
  
     if (parentComboBox == nullptr || comboBox == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     parentComboBox->SelectedIndex = comboBox->SelectedIndex;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ParentComboBoxSetIndexCallback(System::Object^ state)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::ComboBox^ parentComboBox = dynamic_cast<System::Windows::Forms::ComboBox^>(arr[0]);
     System::Windows::Forms::ComboBox^ comboBox = dynamic_cast<System::Windows::Forms::ComboBox^>(arr[1]);
  
     if (parentComboBox == nullptr || comboBox == nullptr)
     {
         return;
     }
  
     if (parentComboBox->InvokeRequired)
     {
         piml->CreatorForm->Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::ComboBoxSetIndexCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         ComboBoxSetIndexCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonBrowseTraceFolder_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     folderBrowserDialog1->SelectedPath = textBoxTraceFolder->Text;
     folderBrowserDialog1->ShowNewFolderButton = true;
  
     System::Windows::Forms::DialogResult result = folderBrowserDialog1->ShowDialog();
     if (result == System::Windows::Forms::DialogResult::OK)
     {
         textBoxTraceFolder->Text = folderBrowserDialog1->SelectedPath;
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonOpenTraceFolder_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::String^ path = textBoxTraceFolder->Text;
     if (System::IO::Directory::Exists(path))
     {
         System::Diagnostics::Process::Start(path);
     }
     REFAPP_END_METHOD();
 }
  
 // This will not automatically update GUI if it is modified internally
 System::Void SampleForm::textBoxTraceFolder_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml == nullptr || piml->GlobalRuntimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     std::string path = Util::Util::ToString(textBoxTraceFolder->Text);
  
     if (path._Equal(RuntimeConfig::GetInstance().GetTraceFolder()) == false)
     {
         if (System::IO::Directory::Exists(Util::Util::ToString(path)))
         {
             RuntimeConfig::GetInstance().SetTraceFolder(Util::Util::ToString(textBoxTraceFolder->Text));
             buttonOpenTraceFolder->Enabled = true;
  
             PrintTextCallback("Set trace folder to " + Util::Util::ToString(RuntimeConfig::GetInstance().GetTraceFolder()));
         }
         else
         {
             buttonOpenTraceFolder->Enabled = false;
         }
     }
     else
     {
         buttonOpenTraceFolder->Enabled = true;
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm.get()->textBoxTraceFolder : nullptr, textBoxTraceFolder);
     REFAPP_END_METHOD();
 }
  
 // This will not automatically update GUI if it is modified internally
 System::Void SampleForm::comboBoxTraceLevel_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->GlobalRuntimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     TraceLevels traceLevel = Util::Util::ToTraceLevel(comboBoxTraceLevel->SelectedItem->ToString());
     if (traceLevel == RuntimeConfig::GetInstance().GetTraceLevel())
     {
         REFAPP_END_METHOD();
         return;
     }
  
     RuntimeConfig::GetInstance().SetTraceLevel(traceLevel);
     PrintTextCallback("Updated trace level");
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonBrowseFile_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::DialogResult result = openFileDialog1->ShowDialog();
     if (result == System::Windows::Forms::DialogResult::OK)
     {
         cbFilePath->Text = openFileDialog1->FileName;
  
         buttonReload->PerformClick();
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::cbFilePath_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     AddComboBoxFileOrPath(cbFilePath);
  
     if (System::String::IsNullOrWhiteSpace(cbFilePath->Text) || !System::IO::File::Exists(cbFilePath->Text->Trim()))
     {
         buttonReload->Enabled = false;
     }
     else
     {
         buttonReload->Enabled = true;
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->cbFilePath : nullptr, cbFilePath);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::cbFilePath_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (System::String::IsNullOrWhiteSpace(cbFilePath->Text) || !System::IO::File::Exists(cbFilePath->Text->Trim()))
     {
         buttonReload->Enabled = false;
     }
     else
     {
         buttonReload->Enabled = true;
         if (piml->IsPathChanging == false)
         {
             buttonReload->PerformClick();
         }
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->cbFilePath : nullptr, cbFilePath);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonReload_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     LoadContextFile(piml->GlobalRuntimeManager);
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonReload : nullptr);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::LoadContextFile(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     REFAPP_START_METHOD();
     if (System::String::IsNullOrWhiteSpace(cbFilePath->Text))
     {
         REFAPP_END_METHOD();
         return;
     }
  
     PrintTextCallback("Load '" + cbFilePath->Text + "'...");
  
     if (runtimeManager == nullptr)
     {
         PrintTextCallback("... No RuntimeManager exists!");
         REFAPP_END_METHOD();
         return;
     }
  
     if (System::String::IsNullOrWhiteSpace(cbFilePath->Text->Trim()))
     {
         PrintTextCallback(".. wrong file name.");
         REFAPP_END_METHOD();
         return;
     }
  
     SetTitle(Util::Util::ToString(piml->Title));
  
     try
     {
         // TODO: move these 3 set up away
         piml->IsLoadding = true;
         piml->PlayerProject = nullptr;
         piml->Project = nullptr;
         piml->ContextVariableImplementation->ResetAllValues();
         piml->StateVariableImplementation->ResetAllValues();
         ClearSampleGUI();
  
         System::String^ filePathExtension = System::IO::Path::GetExtension(cbFilePath->Text->Trim());
         if (filePathExtension->Contains("ptx"))
         {
             piml->Project = LoadPtx(runtimeManager);
  
             if (IS_NOT_NULL(piml->Project)) // TODO: might be obsolete in the future
             {
                 PrintTextCallback("... Project '" + Util::Util::ToString(piml->Project->GetName()) + "' successfully loaded.");
  
                 ClearCustomImplemetationCaches();
  
                 LoadPackage(piml->Project);
  
                 ReadSettings(piml->Project->GetSettings());
  
                 piml->IsLoadding = false;
                 REFAPP_END_METHOD();
                 return;
             }
         }
         else if (filePathExtension->Contains("ppx"))
         {
             piml->PlayerProject = LoadPpx(runtimeManager);
  
             if (IS_NOT_NULL(piml->PlayerProject))  // TODO: might be obsolete in the future
             {
                 ClearCustomImplemetationCaches();
  
                 PrintTextCallback("... Player '" + Util::Util::ToString(piml->PlayerProject->GetName()) + "' successfully loaded.");
  
                 std::vector<std::shared_ptr<Project::IProject>> projects = piml->PlayerProject->GetProjects();
                 for (int i = 0; i < projects.size(); i++)
                 {
                     piml->Project = projects[i]; // TODO: what is this?
                     LoadPackage(projects[i]);
                 }
  
                 ReadSettings(piml->PlayerProject->GetSettings());
  
                 piml->IsLoadding = false;
                 REFAPP_END_METHOD();
                 return;
             }
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
  
     piml->IsLoadding = false;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ClearSampleGUI()
 {
     treeViewOtxProject->Nodes->Clear();
     gridViewParameter->Rows->Clear();
     gridViewContext->Rows->Clear();
     gridViewState->Rows->Clear();
     gridViewSettings->Rows->Clear();
 }
  
 void SampleForm::ClearCustomImplemetationCaches()
 {
     piml->ClearCustomImplemetationCaches();
 }
  
 // TODO: refactor
 std::shared_ptr<Project::IProject> SampleForm::LoadPtx(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     REFAPP_START_METHOD();
     std::shared_ptr<Project::IProject> project = nullptr;
  
     if (runtimeManager->IsProtected(Util::Util::ToString(cbFilePath->Text)))
     {
         project = runtimeManager->LoadPtx(Util::Util::ToString(cbFilePath->Text),
             Util::Util::ToString(txtPassword->Text->Trim()));
     }
     else
     {
         project = runtimeManager->LoadPtx(Util::Util::ToString(cbFilePath->Text));
     }
  
     if (project->GetMainProcedure() != nullptr)
     {
         buttonExecuteMain->Enabled = true;
     }
  
     REFAPP_END_METHOD();
     return project;
 }
  
 // TODO: refactor
 std::shared_ptr<Project::IPlayerProject> SampleForm::LoadPpx(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     REFAPP_START_METHOD();
     std::shared_ptr<Project::IPlayerProject> playerProject = nullptr;
  
     if (runtimeManager->IsProtected(Util::Util::ToString(cbFilePath->Text)))
     {
         playerProject = runtimeManager->LoadPpx(
             Util::Util::ToString(cbFilePath->Text),
             Util::Util::ToString(txtPassword->Text->Trim()));
     }
     else
     {
         playerProject = runtimeManager->LoadPpx(
             Util::Util::ToString(cbFilePath->Text));
     }
  
     REFAPP_END_METHOD();
     return playerProject;
 }
  
 // TODO: refactor
 void SampleForm::LoadPackage(std::shared_ptr<Project::IProject> project)
 {
     REFAPP_START_METHOD();
     PrintTextCallback("Browse project...");
  
     std::vector<std::shared_ptr<Otx::Runtime::Api::Otx::IPackage>> packages = project->GetPackages();
     if (packages.size() == 0)
     {
         std::shared_ptr<IDocument> document = project->GetStartupDocument();
         treeViewOtxProject->Nodes->Add(CreateDocumentNode(document));
     }
     else
     {
         System::String^ treeNodeText = Util::Util::ToString(project->GetName());
         if (!System::String::IsNullOrWhiteSpace(Util::Util::ToString(piml->Project->GetVersion())))
         {
             treeNodeText = System::String::Format("{0} ({1})", treeNodeText, Util::Util::ToString(project->GetVersion()));
         }
  
         System::Windows::Forms::TreeNode^ root = gcnew System::Windows::Forms::TreeNode(treeNodeText);
         root->ImageKey = "ODFProject.bmp"; // TODO: move
         root->SelectedImageKey = "Package.bmp";  // TODO: move
         for (int i = 0; i < packages.size(); i++)
         {
             root->Nodes->Add(CreatePackageNode(packages[i]));
         }
  
         treeViewOtxProject->Nodes->Add(root);
     }
  
     treeViewOtxProject->Enabled = true;
     gridViewParameter->Enabled = true;
     treeViewOtxProject->ExpandAll();
     treeViewOtxProject->SelectedNode = piml->StartUpNode.get();
     treeViewOtxProject->Focus();
  
     PrintTextCallback("... project browsing finished.");
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 System::Windows::Forms::TreeNode^ SampleForm::CreateDocumentNode(std::shared_ptr<Otx::Runtime::Api::Otx::IDocument> doc)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::TreeNode^ documentNode = gcnew System::Windows::Forms::TreeNode(Util::Util::ToString(doc->GetName()));
     documentNode->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::Otx::IDocument>>(doc);
     documentNode->ImageKey = "DocumentOTX16.bmp";
     documentNode->SelectedImageKey = "DocumentOTX16.bmp";
     if (doc->IsStartup())
     {
         documentNode->Text += " (StartUp)";
     }
  
     std::vector<std::shared_ptr<Otx::Runtime::Api::Otx::IProcedure>> procedures = doc->GetProcedures();
     for (int i = 0; i < procedures.size(); i++)
     {
         System::Windows::Forms::TreeNode^ procedureNode = CreateProcedureName(procedures[i]);
         documentNode->Nodes->Add(procedureNode);
         if (doc->IsStartup() && procedures[i]->GetName()._Equal("main"))
         {
             piml->StartUpNode = procedureNode;
             buttonExecuteMain->Enabled = true;
         }
         else if (IS_NULL(piml->StartUpNode))
         {
             piml->StartUpNode = procedureNode;
         }
     }
  
     REFAPP_END_METHOD();
     return documentNode;
 }
  
 // TODO: refactor
 System::Windows::Forms::TreeNode^ SampleForm::CreateProcedureName(std::shared_ptr<Otx::Runtime::Api::Otx::IProcedure> proc)
 {
     REFAPP_START_METHOD();
     if (checkBoxCyclicReload->Checked &&
         IS_NOT_NULL(piml->ProcedureToExecute) &&
         piml->ProcedureToExecute->GetFullName()._Equal(proc->GetFullName()))
     {
         piml->ProcedureToExecute = proc;
     }
  
     System::Windows::Forms::TreeNode^ procedureNode = gcnew System::Windows::Forms::TreeNode(Util::Util::ToString(proc->GetName()));
     procedureNode->ImageKey = "Procedure.bmp"; // TODO: move
     procedureNode->SelectedImageKey = "Procedure.bmp"; // TODO: move
     procedureNode->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::Otx::IProcedure>>(proc);
     REFAPP_END_METHOD();
     return procedureNode;
 }
  
 System::Windows::Forms::TreeNode^ SampleForm::CreatePackageNode(std::shared_ptr<Otx::Runtime::Api::Otx::IPackage> pack)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::TreeNode^ packageNode = gcnew System::Windows::Forms::TreeNode(Util::Util::ToString(pack->GetName()));
     packageNode->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::Otx::IPackage>>(pack);
     packageNode->ImageKey = "Package.bmp"; // TODO: move
     packageNode->SelectedImageKey = "Package.bmp"; // TODO: move
  
     std::vector<std::shared_ptr<Otx::Runtime::Api::Otx::IDocument>> documents = pack->GetDocuments();
     for (int i = 0; i < documents.size(); i++)
     {
         packageNode->Nodes->Add(CreateDocumentNode(documents[i]));
     }
  
     std::vector<std::shared_ptr<IPackage>> packages = pack->GetPackages();
     for (int i = 0; i < packages.size(); i++)
     {
         packageNode->Nodes->Add(CreatePackageNode(packages[i]));
     }
  
     REFAPP_END_METHOD();
     return packageNode;
 }
  
 System::Void SampleForm::gridView_CellContentClick(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         if (e != nullptr)
         {
             System::Windows::Forms::DataGridView^ gridView = dynamic_cast<System::Windows::Forms::DataGridView^>(sender);
             System::Windows::Forms::DataGridViewComboBoxCell^ comboBoxCell = dynamic_cast<System::Windows::Forms::DataGridViewComboBoxCell^>(gridView->Rows[e->RowIndex]->Cells[e->ColumnIndex]);
             if (comboBoxCell != nullptr)
             {
                 gridView->BeginEdit(true);
                 dynamic_cast<System::Windows::Forms::DataGridViewComboBoxEditingControl^>(gridView->EditingControl)->DroppedDown = true;
                 REFAPP_END_METHOD();
                 return;
             }
         }
     }
     catch (...) {}
  
     gridView_CellValueChanged(sender, e);
     REFAPP_END_METHOD();
 }
  
 // Commit new value for gridView's data source (only apply for DataGridViewCheckBoxCell and DataGridViewComboBoxCell)
 System::Void SampleForm::gridView_CellValueChanged(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::DataGridView^ gridView = dynamic_cast<System::Windows::Forms::DataGridView^>(sender);
     System::String^ columnName;
  
     if (gridView == gridViewParameter)
     {
         columnName = dataGridViewTextBoxColumnValue->Name;
     }
     else if (gridView == gridViewContext)
     {
         columnName = dataGridViewTextBoxColumnContextValue->Name;
     }
     else
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (piml != nullptr &&
         !piml->IsLoadding &&
         e->RowIndex >= 0 &&
         gridView->Columns[e->ColumnIndex]->Name == columnName &&
         (
             Util::Util::IsInstance<System::Windows::Forms::DataGridViewCheckBoxCell^>(gridView->Rows[e->RowIndex]->Cells[columnName]) ||
             Util::Util::IsInstance<System::Windows::Forms::DataGridViewComboBoxCell^>(gridView->Rows[e->RowIndex]->Cells[columnName])
             )
         )
     {
         // Force a validation to set the value after CheckBox click
         Validate(false);
     }
     REFAPP_END_METHOD();
 }
  
 // Convert parameter's value into valid string then display it on gridview
 System::Void SampleForm::gridViewParameter_CellValidated(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::DataGridView^ gridView = dynamic_cast<System::Windows::Forms::DataGridView^>(sender);
     if (piml != nullptr &&
         !piml->IsLoadding &&
         gridView != nullptr &&
         e->RowIndex >= 0 &&
         gridView->Columns[e->ColumnIndex]->Name == dataGridViewTextBoxColumnValue->Name)
     {
         std::shared_ptr<IProcedureParameter> parameter = Util::Util::CastTo<std::shared_ptr<IProcedureParameter>>(gridView->Rows[e->RowIndex]->Tag);
  
         if (parameter->GetValue() != nullptr)
         {
             gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnValue->Name]->Value = ConvertValue2String(parameter->GetValue());
             gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnDetails->Name]->Value = GetDetails(parameter->GetValue());
         }
     }
     REFAPP_END_METHOD();
 }
  
 // Trigger if the "value" cell is changed, convert new string into new value,
 // then set into corresponding parameter (only apply for IProcedureInParameter and IProcedureInOutParameter)
 System::Void SampleForm::gridViewParameter_CellValidating(System::Object^ sender, System::Windows::Forms::DataGridViewCellValidatingEventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::DataGridView^ gridView = dynamic_cast<System::Windows::Forms::DataGridView^>(sender);
     if (piml != nullptr &&
         !piml->IsLoadding &&
         gridView != nullptr &&
         e->RowIndex >= 0 &&
         gridView->Columns[e->ColumnIndex]->Name == dataGridViewTextBoxColumnValue->Name &&
         !gridView->Rows[e->RowIndex]->ReadOnly &&
         e->FormattedValue != nullptr)
     {
         std::shared_ptr<IProcedureParameter> parameter = Util::Util::CastTo<std::shared_ptr<IProcedureParameter>>(gridView->Rows[e->RowIndex]->Tag);
         if (e->FormattedValue->ToString() == Util::Util::ToString(DataTypes::ValueConverter::Value2String(parameter->GetValue())) ||
             e->FormattedValue->ToString() == ConvertValue2String(parameter->GetValue()))
         {
             REFAPP_END_METHOD();
             return;
         }
  
         std::shared_ptr<DataTypes::Object> value = nullptr;
  
         try
         {
             value = DataTypes::ValueConverter::String2Value(Util::Util::ToString(e->FormattedValue->ToString()), parameter->GetDataType());
         }
         catch (const std::exception& ex)
         {
             //string errorMsg = ex.GetType().FullName;
             //errorMsg += Environment.NewLine;
             //errorMsg += ex.Message;
             //gridView.Rows[e.RowIndex].Cells[1].ErrorText = errorMsg;
             PrintException(ex);
             // e.Cancel = true;
             REFAPP_END_METHOD();
             return;
         }
         catch (System::Exception^ ex)
         {
             //string errorMsg = ex.GetType().FullName;
             //errorMsg += Environment.NewLine;
             //errorMsg += ex.Message;
             //gridView.Rows[e.RowIndex].Cells[1].ErrorText = errorMsg;
             PrintException(ex);
             // e.Cancel = true;
             REFAPP_END_METHOD();
             return;
         }
  
         if (value == nullptr)
         {
             System::Media::SystemSounds::Exclamation->Play();
         }
         else
         {
             gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnDataType->Name]->ErrorText = System::String::Empty;
             if (std::shared_ptr<IProcedureInParameter> inParam = std::dynamic_pointer_cast<IProcedureInParameter>(parameter))
             {
                 inParam->SetValue(value);
             }
             else if (std::shared_ptr<IProcedureInOutParameter> inOutParam = std::dynamic_pointer_cast<IProcedureInOutParameter>(parameter))
             {
                 inOutParam->SetValue(value);
             }
         }
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::gridViewContextVariable_CellValidated(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::DataGridView^ gridView = dynamic_cast<System::Windows::Forms::DataGridView^>(sender);
     if (piml != nullptr &&
         !piml->IsLoadding &&
         gridView != nullptr &&
         e->RowIndex >= 0 &&
         gridView->Columns[e->ColumnIndex]->Name == dataGridViewTextBoxColumnContextValue->Name)
     {
         std::shared_ptr<IContextVariable> context = Util::Util::CastTo<std::shared_ptr<IContextVariable>>(gridView->Rows[e->RowIndex]->Tag);
         if (gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Tag != nullptr)
         {
             gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Value = ConvertValue2String(Util::Util::CastTo<std::shared_ptr<DataTypes::Object>>(gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Tag));
             gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextDetails->Name]->Value = GetDetails(Util::Util::CastTo<std::shared_ptr<DataTypes::Object>>(gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Tag));
         }
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor. consider update to use together with Parameter validating?
 System::Void SampleForm::gridViewContextVariable_CellValidating(System::Object^ sender, System::Windows::Forms::DataGridViewCellValidatingEventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::DataGridView^ gridView = dynamic_cast<System::Windows::Forms::DataGridView^>(sender);
     if (piml != nullptr &&
         !piml->IsLoadding &&
         gridView != nullptr &&
         e->RowIndex >= 0 &&
         gridView->Columns[e->ColumnIndex]->Name == dataGridViewTextBoxColumnContextValue->Name &&
         !gridView->Rows[e->RowIndex]->ReadOnly &&
         e->FormattedValue != nullptr)
     {
         std::shared_ptr<IContextVariable> context = Util::Util::CastTo<std::shared_ptr<IContextVariable>>(gridView->Rows[e->RowIndex]->Tag);
  
         if (e->FormattedValue->ToString() == Util::Util::ToString(DataTypes::ValueConverter::Value2String(Util::Util::CastTo<std::shared_ptr<DataTypes::Object>>(gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Tag))) ||
             e->FormattedValue->ToString() == ConvertValue2String(Util::Util::CastTo<std::shared_ptr<DataTypes::Object>>(gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Tag)))
         {
             REFAPP_END_METHOD();
             return;
         }
  
         std::shared_ptr<DataTypes::Object> value = nullptr;
  
         try
         {
             value = DataTypes::ValueConverter::String2Value(Util::Util::ToString(e->FormattedValue->ToString()), context->GetDataType());
         }
         catch (System::Exception^ ex)
         {
             //string errorMsg = ex.GetType().FullName;
             //errorMsg += Environment.NewLine;
             //errorMsg += ex.Message;
             //gridView.Rows[e.RowIndex].Cells[1].ErrorText = errorMsg;
             PrintException(ex);
             // e.Cancel = true;
             REFAPP_END_METHOD();
             return;
         }
  
         if (value == nullptr)
         {
             System::Media::SystemSounds::Exclamation->Play();
         }
         else
         {
             //we will save value with fullName of context, if not the bug of #10798 occurs.
             //Because the name of context variable in imported document may have the same name.
             std::string fullNameContextVariable = context->GetDocument()->GetFullName() + "." + context->GetName();
             piml->ContextVariableImplementation->SetValue(fullNameContextVariable, value);
             piml->_ContextVariableOutputImpl->SetValue(fullNameContextVariable, value);
             gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Tag = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(value); // used at gridViewContextVariable_CellValidated
             gridView->Rows[e->RowIndex]->Cells[dataGridViewTextBoxColumnContextDataType->Name]->ErrorText = System::String::Empty; //refresh error text
         }
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::treeViewOtxProject_AfterSelect(System::Object^ sender, System::Windows::Forms::TreeViewEventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Windows::Forms::TreeNode^ node = e->Node;
     if (node != nullptr)
     {
         // TODO: move to different method
         gridViewParameter->Rows->Clear();
         gridViewContext->Rows->Clear();
         gridViewState->Rows->Clear();
  
         if (Util::Util::IsInstance<CLRWrapper<std::shared_ptr<IProcedure>>^>(node->Tag))
         {
             std::shared_ptr<IProcedure> procedure = Util::Util::CastTo<std::shared_ptr<IProcedure>>(node->Tag);
             ClearCustomImplemetationCaches();
             UpdateGridView(procedure);
  
             buttonExecuteSelectedProcedure->Enabled = true;
             piml->Project = GetProject(procedure); // TODO: why update this???
             REFAPP_END_METHOD();
             return;
         }
     }
  
     buttonExecuteSelectedProcedure->Enabled = false;
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 std::shared_ptr<Project::IProject> SampleForm::GetProject(std::shared_ptr<IProcedure> procedure)
 {
     REFAPP_START_METHOD();
     if (procedure != nullptr)
     {
         std::shared_ptr<IPackage> package = procedure->GetDocument()->GetPackage();
         if (package != nullptr)
         {
             while (package->GetParent() != nullptr)
             {
                 package = package->GetParent();
             }
             REFAPP_END_METHOD();
             return package->GetProject();
         }
     }
     REFAPP_END_METHOD();
     return nullptr;
 }
  
 System::Void SampleForm::treeViewOtxProject_DrawNode(System::Object^ sender, System::Windows::Forms::DrawTreeNodeEventArgs^ e)
 {
     e->DrawDefault = true;
 }
  
 System::Void SampleForm::buttonReadSettings_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     std::map<std::string, std::string> settings;
     if (piml->PlayerProject != nullptr)
     {
         settings = piml->PlayerProject->GetSettings();
     }
     else
     {
         settings = piml->Project->GetSettings();
     }
     ReadSettings(settings);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ReadSettings(std::map<std::string, std::string> settings)
 {
     REFAPP_START_METHOD();
     PrintTextCallback("Read settings");
  
     gridViewSettings->Rows->Clear();
  
     for (std::pair<std::string, std::string> it : settings)
     {
         cli::array<System::String^>^ values = {
             Util::Util::ToString(it.first),
             Util::Util::ToString(it.second)
         };
         gridViewSettings->Rows->Add(values);
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 System::Void SampleForm::buttonWriteSettings_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::String^ nameSetting;
     System::String^ valueSetting;
     int selectedSettingPosition = 0;
     std::map<std::string, std::string> newSettings;
  
     if (gridViewSettings->SelectedRows->Count != 0)
     {
         selectedSettingPosition = gridViewSettings->SelectedRows[0]->Index;
     }
  
     try
     {
         if (IS_NOT_NULL(piml->Project) || IS_NOT_NULL(piml->PlayerProject))
         {
             for (int i = 0; i < gridViewSettings->Rows->Count; i++)
             {
                 nameSetting = gridViewSettings->Rows[i]->Cells[dataGridViewTextBoxColumnSettingName->Name]->Value->ToString();
  
                 System::Object^ cellSettingValueValue = gridViewSettings->Rows[i]->Cells[dataGridViewTextBoxColumnSettingValue->Name]->Value;
                 valueSetting = cellSettingValueValue == nullptr ? nullptr : cellSettingValueValue->ToString();
  
                 newSettings.insert({ Util::Util::ToString(nameSetting),Util::Util::ToString(valueSetting) });
             }
  
             if (piml->PlayerProject != nullptr)
             {
                 piml->PlayerProject->SetSettings(newSettings);
                 ReadSettings(piml->PlayerProject->GetSettings()); //Refresh gridViewSettings
             }
             else
             {
                 piml->Project->SetSettings(newSettings);
                 ReadSettings(piml->Project->GetSettings()); //Refresh gridViewSettings
             }
             // focus on previous selected row
             gridViewSettings->Rows[selectedSettingPosition]->Selected = true;
             gridViewSettings->Rows[selectedSettingPosition]->Cells[dataGridViewTextBoxColumnSettingValue->Name]->Selected = true;
  
             PrintTextCallback("Write setting finished");
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxCyclicExecution_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     checkBoxCyclicReload->Enabled = checkBoxCyclicExecution->Checked;
     checkBoxNewRuntimeManager->Enabled = checkBoxCyclicExecution->Checked;
  
     if (!checkBoxCyclicExecution->Checked)
     {
         checkBoxCyclicReload->Checked = false;
         checkBoxNewRuntimeManager->Checked = false;
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxCyclicExecution : nullptr, checkBoxCyclicExecution);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxAsyncExecution_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxAsyncExecution : nullptr, checkBoxAsyncExecution);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxNewRuntimeManager_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (checkBoxNewRuntimeManager->Checked)
     {
         checkBoxCyclicReload->Checked = true;
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxNewRuntimeManager : nullptr, checkBoxNewRuntimeManager);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxCyclicReload_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxCyclicReload : nullptr, checkBoxCyclicReload);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonExecuteSelectedProcedure_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         if (treeViewOtxProject->SelectedNode != nullptr && Util::Util::IsInstance<CLRWrapper<std::shared_ptr<IProcedure>>^>(treeViewOtxProject->SelectedNode->Tag))
         {
             std::shared_ptr<IDocument> document = Util::Util::CastTo<std::shared_ptr<IDocument>>(treeViewOtxProject->SelectedNode->Parent->Tag);
  
             piml->ProcedureToExecute = Util::Util::CastTo<std::shared_ptr<IProcedure>>(treeViewOtxProject->SelectedNode->Tag);
             ExecuteProcedure();
         }
         else
         {
             PrintTextCallback("Please select Procedure to execute");
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonExecuteSelectedProcedure : nullptr, nullptr, true);
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 System::Void SampleForm::buttonExecuteMain_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         if (IS_NOT_NULL(piml->Project))
         {
             treeViewOtxProject->SelectedNode = piml->StartUpNode.get();
             piml->ProcedureToExecute = piml->Project->GetMainProcedure();
             ExecuteProcedure();
         }
         else
         {
             PrintTextCallback("There is no project has been loaded. Please reload the project");
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonExecuteMain : nullptr, nullptr, true);
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 void SampleForm::ExecuteProcedure()
 {
     REFAPP_START_METHOD();
     unsigned long long timeOut = 0;
     PrintTextCallback("Start procedure execution...");
  
     if (checkBoxAsyncExecution->Checked == false)
     {
         buttonExecuteMain->Enabled = false;
         buttonExecuteSelectedProcedure->Enabled = false;
     }
  
     try
     {
         if (IS_NOT_NULL(piml->GlobalRuntimeManager) && IS_NOT_NULL(piml->ProcedureToExecute))
         {
             buttonStop->Enabled = true;
  
             CheckBatteryIgnitionState(piml->GlobalRuntimeManager);
  
             if (checkBoxCyclicExecution->Checked)
             {
                 System::Threading::ThreadPool::QueueUserWorkItem(gcnew System::Threading::WaitCallback(this, &SampleForm::DoCyclic), nullptr);
             }
             else
             {
                 if (System::UInt64::TryParse(textBoxTimeout->Text->Trim(), timeOut) == false) {
                     timeOut = 0;
                 }
  
                 //OtxDiagManager.OtxDiagApi.License.LicenseManager.SetLicenseKey(SampleConstants.LICENSE_KEY);
                 if (checkBoxAsyncExecution->Checked)
                 {
                     piml->GlobalRuntimeManager->ExecuteAsync(
                         Util::Util::ToString(textBoxRuntimeContextName->Text->Trim()),
                         piml->ProcedureToExecute,
                         piml->ExpectedConnectionState,
                         timeOut
                     );
                 }
                 else
                 {
                     cli::array<System::Object^>^ args = gcnew cli::array<System::Object^>(4);
                     args[0] = textBoxRuntimeContextName->Text->Trim();
                     args[1] = gcnew CLRWrapper<std::shared_ptr<IProcedure>>(piml->ProcedureToExecute);
                     args[2] = (int)piml->ExpectedConnectionState;
                     args[3] = timeOut;
  
                     System::Threading::Tasks::Task::Factory->StartNew(
                         CallbackToAction::Convert(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::ExecuteProcedureSync),
                                                   args));
                 }
             }
         }
         else
         {
             PrintTextCallback("RuntimeManager is null or no Procedure is selected to run.");
         }
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
  
         UpdateButtonStateAfterThrowException();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ExecuteProcedureSync(cli::array<System::Object^>^ args)
 {
     REFAPP_START_METHOD();
     if (args->Length != 4)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::String^ runtimeContextName = dynamic_cast<System::String^>(args[0]);
     std::shared_ptr<IProcedure> procedureWrapper = Util::Util::CastTo<std::shared_ptr<IProcedure>>(args[1]);
     int expectedState = safe_cast<int>(args[2]);
     unsigned long long timeout = safe_cast<unsigned long long>(args[3]);
  
     if (procedureWrapper == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     piml->GlobalRuntimeManager->Execute(
         Util::Util::ToString(runtimeContextName),
         procedureWrapper,
         (ExpectedState)expectedState,
         timeout);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateButtonStateAfterThrowException()
 {
     REFAPP_START_METHOD();
 #pragma region C++ for initialize resource
     System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
 #pragma endregion
  
     buttonExecuteMain->Enabled = !checkBoxAsyncExecution->Checked;
     buttonExecuteSelectedProcedure->Enabled = !checkBoxAsyncExecution->Checked;
  
     UpdateExecutionStateButtons(false);
     UpdatePauseButton(true, false);
  
     labelBatteryState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBattery16")));
     labelIgnitionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnition16")));
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 void SampleForm::DoCyclic(System::Object^ args)
 {
     REFAPP_START_METHOD();
     System::DateTime^ startTime = System::DateTime::Now;
     unsigned long long timeOut = 0;
  
     int cyclic = 0;
     try
     {
         while (checkBoxCyclicExecution->Checked)
         {
             std::shared_ptr<IRuntimeManager> runtimeManager = nullptr;
             std::shared_ptr<IRuntimeContext> runtimeContext = nullptr;
  
             cyclic++;
             piml->CyclicExecutionCount++;
  
             if (checkBoxNewRuntimeManager->Checked)
             {
                 runtimeManager = CreateRuntimeManager();
             }
             else
             {
                 runtimeManager = piml->GlobalRuntimeManager;
             }
  
             CheckCyclicReloadOrNewRuntimeManager(runtimeManager);
  
             piml->CyclicExecuteAsyncIsProcessing = true;
             CheckBatteryIgnitionState(piml->GlobalRuntimeManager);
  
             if (System::UInt64::TryParse(textBoxTimeout->Text->Trim(), timeOut) == false)
             {
                 timeOut = 0;
             }
  
             if (checkBoxAsyncExecution->Checked)
             {
                 runtimeContext = runtimeManager->ExecuteAsync(
                     Util::Util::ToString(textBoxRuntimeContextName->Text->Trim()),
                     piml->ProcedureToExecute,
                     piml->ExpectedConnectionState,
                     timeOut
                 );
                 if (runtimeContext != nullptr)
                 {
                     //Let it break for a little bit to avoid freezing the GUI
                     System::Windows::Forms::Application::DoEvents();
                     System::Threading::Thread::Sleep(50);
                 }
             }
             else
             {
                 runtimeContext = runtimeManager->Execute(
                     Util::Util::ToString(textBoxRuntimeContextName->Text->Trim()),
                     piml->ProcedureToExecute,
                     piml->ExpectedConnectionState,
                     timeOut
                 );
             }
  
             if (runtimeContext->GetExecutionState() == ExecutionState::Stopped)
             {
                 piml->CyclicExecutionCount = 0;
                 break;
             }
         }
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
  
         UpdateButtonStateAfterThrowException();
     }
  
     //TODO: Do we need to load this again?
     Invoke(gcnew System::Action<CLRWrapper<std::shared_ptr<IRuntimeManager>>^>(this, &SampleForm::ReloadContextFileCallback), gcnew CLRWrapper<std::shared_ptr<IRuntimeManager>>(piml->GlobalRuntimeManager));
  
     PrintTextCallback("Cyclic execution finished");
  
     System::TimeSpan duration = System::TimeSpan(System::DateTime::Now.Ticks - startTime->Ticks);
     System::String^ text = System::String::Format("Execution Statistics: Duration {0} (hh:mm:ss) with {1} cycles and {2:0} ms per cycle",
                                                   duration.ToString("hh':'mm':'ss"), cyclic, duration.TotalMilliseconds / cyclic);
  
     piml->CyclicExecutionCount -= cyclic;
     if (piml->CyclicExecutionCount < 0)
     {
         piml->CyclicExecutionCount = 0;
     }
  
     if (checkBoxAdd2Output->Checked)
     {
         PrintTextCallback(text);
     }
     else
     {
         System::Windows::Forms::MessageBox::Show(text);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::WaitCyclicExecuteAsyncIsProcessing()
 {
     REFAPP_START_METHOD();
     if (checkBoxCyclicReload->Checked || checkBoxNewRuntimeManager->Checked)
     {
         // OR while(!piml->RuntimeContext->IsFinished() || piml->RuntimeContext->IsStopped())
         while (piml->CyclicExecuteAsyncIsProcessing)
         {
             //detail in #10461
             System::Windows::Forms::Application::DoEvents();
             System::Threading::Thread::Sleep(50);
         }
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CheckCyclicReloadOrNewRuntimeManager(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     REFAPP_START_METHOD();
     CheckCyclicReloadOrNewRuntimeManager(runtimeManager, true);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CheckCyclicReloadOrNewRuntimeManager(std::shared_ptr<IRuntimeManager> runtimeManager, bool waitCyclic)
 {
     REFAPP_START_METHOD();
     if (waitCyclic)
     {
         WaitCyclicExecuteAsyncIsProcessing();
     }
  
     cli::array<System::Object^>^ arr = gcnew cli::array<System::Object^>(2);
     arr[0] = gcnew CLRWrapper<std::shared_ptr<IRuntimeManager>>(runtimeManager);
     arr[1] = waitCyclic;
  
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::CheckCyclicReloadOrNewRuntimeManagerCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         CheckCyclicReloadOrNewRuntimeManagerCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CheckCyclicReloadOrNewRuntimeManagerCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     std::shared_ptr<IRuntimeManager> runtimeManager = Util::Util::CastTo<std::shared_ptr<IRuntimeManager>>(arr[0]);
     System::Boolean^ waitCyclic = dynamic_cast<System::Boolean^>(arr[1]);
  
     if (runtimeManager == nullptr || waitCyclic == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (checkBoxCyclicReload->Checked || checkBoxNewRuntimeManager->Checked)
     {
         LoadContextFile(runtimeManager);
     }
  
     if (checkBoxCyclicExecution->Checked)
     {
         checkBoxCyclicExecution->Text = "Cyclic (" + piml->CyclicExecutionCount.ToString() + ")";
     }
     else
     {
         checkBoxCyclicExecution->Text = "Cyclic";
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 System::Void SampleForm::buttonStop_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->GlobalRuntimeManager != nullptr)
     {
         PrintTextCallback("Try to stop all running procedures...");
         piml->GlobalRuntimeManager->StopAll();
         piml->ProcedureExecutionCount = 0;
     }
  
     // To make sure that cyclic execution will stop in some cases
     checkBoxCyclicExecution->Checked = false;
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonStop : nullptr);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::PrintException(System::Exception^ ex)
 {
     PrintException(ex, "");
 }
  
 void SampleForm::PrintException(System::Exception^ ex, System::String^ additionalText)
 {
     PrintTextCallback(System::String::Format("!!! {2}{0}: {1}", ex->GetType()->Name, ex->Message, additionalText));
     System::Media::SystemSounds::Hand->Play();
 }
  
 void SampleForm::PrintException(const std::exception& ex)
 {
     PrintException(ex, "");
 }
  
 void SampleForm::PrintException(const std::exception& ex, System::String^ additionalText)
 {
     PrintTextCallback(System::String::Format("!!! {2}{0}: {1}",
         "Exception",
         Util::Util::ToString(ex.what()),
         additionalText));
     System::Media::SystemSounds::Hand->Play();
 }
  
 void SampleForm::PrintTextCallback(System::String^ text)
 {
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<System::String^>(this, &SampleForm::PrintTextCallback), text);
         return;
     }
  
     if (!checkBoxAdd2Output->Checked)
     {
         return;
     }
  
     // TODO: handle multithreading?
     msclr::lock l(piml->PrintTextLock.get());
     {
         if (listBoxOuput->Items->Count >= 10000)
         {
             buttonClearOutput_Click(nullptr, nullptr);
         }
  
         System::String^ prefixString = GetTimeAndDurationStringSinceLastTimeAndUpdateLastTime();
         System::String^ itemToAdd = prefixString + text + "\t\t";
  
         listBoxOuput->Items->Add(itemToAdd);
         listBoxOuput->SelectedItems->Clear();
         listBoxOuput->TopIndex = listBoxOuput->Items->Count - 1;
  
         if (listBoxOuput->Items->Count >= 7500)
         {
             labelOutputOverflow->Visible = true;
         }
  
         // If many procedures are running simultaneously,
         // Stop button or other controls cannot receive events. This code allows controls to receive events.
         System::Windows::Forms::Application::DoEvents();
     }
 }
  
 System::String^ SampleForm::GetTimeAndDurationStringSinceLastTimeAndUpdateLastTime()
 {
     System::DateTime^ now = System::DateTime::Now;
     System::TimeSpan duration = System::TimeSpan(now->Ticks - piml->LastTime.get()->Ticks);
  
     piml->LastTime = now;
  
     System::String^ timeDurationString = System::String::Format("{0:HH:mm:ss.fff} {1,6:#,##0} ms ", now, duration.TotalMilliseconds);
     return timeDurationString;
 }
  
 System::Void SampleForm::buttonCopyRow_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (listBoxOuput->SelectedItems != nullptr)
     {
         System::String^ text = System::String::Empty;
         for (int i = 0; i < listBoxOuput->SelectedItems->Count; i++)
         {
             text += listBoxOuput->SelectedItems[i]->ToString()->Trim('\t') + "\n";
         }
  
         System::Windows::Forms::Clipboard::SetText(text);
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonClearOutput_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     listBoxOuput->Items->Clear();
     labelOutputOverflow->Visible = false;
     buttonCopyRow->Enabled = false;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateGridView(std::shared_ptr<IProcedure> procedure)
 {
     REFAPP_START_METHOD();
     // || procedure->GetParameters() != nullptr
     if (procedure == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     UpdateGridviewParameter(procedure);
  
     std::shared_ptr<Otx::Runtime::Api::Otx::IDocument> document = procedure->GetDocument();
     if (IS_NOT_NULL(document))
     {
         std::vector<std::string> listItemReviewed;
         UpdateGridViewContextVariable(document, false, listItemReviewed);
  
         listItemReviewed.clear();
         UpdateGridViewStateVariable(document, false, listItemReviewed);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateGridviewParameter(std::shared_ptr<IProcedure> procedure)
 {
     REFAPP_START_METHOD();
     std::vector<std::shared_ptr<IProcedureParameter>> parameters = procedure->GetParameters();
     for (int i = 0; i < parameters.size(); i++)
     {
         UpdateGridviewParameter(parameters[i]);
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 void SampleForm::UpdateGridviewParameter(std::shared_ptr<IProcedureParameter> parameter)
 {
     REFAPP_START_METHOD();
     if (IS_NULL(parameter))
     {
         REFAPP_END_METHOD();
         return;
     }
  
     bool bValueWasSet = false;
  
     // Update existing value
     System::String^ collumnName = dataGridViewTextBoxColumnName->Name;
     System::String^ collumnValue = dataGridViewTextBoxColumnValue->Name;
     System::String^ collumnDetails = dataGridViewTextBoxColumnDetails->Name;
     System::Windows::Forms::DataGridViewRowCollection^ rows = gridViewParameter->Rows;
     for (int i = 0; i < rows->Count; i++)
     {
         System::Windows::Forms::DataGridViewRow^ row = rows[i];
         if (row->Cells[collumnName]->Value->Equals(Util::Util::ToString(parameter->GetName())))
         {
             try
             {
                 if (parameter->GetValue() != nullptr)
                 {
                     row->Cells[collumnValue]->Value = Util::Util::ToString(ValueConverter::Value2String(parameter->GetValue()));
                 }
             }
             catch (System::Exception^ ex)
             {
                 row->Cells[collumnName]->ErrorText = ex->Message;
             }
  
             bValueWasSet = true;
             break;
         }
     }
  
     // Add value if not exist
     if (!bValueWasSet)
     {
         System::String^ directory = std::dynamic_pointer_cast<IProcedureInParameter>(parameter) ? "In" :
             (std::dynamic_pointer_cast<IProcedureInOutParameter>(parameter) ?
              "InOut" : "Out");
  
         cli::array<System::Object^>^ values = {
             Util::Util::ToString(parameter->GetName()),
             directory,
             Util::Util::ToString(parameter->GetDataType())
         };
         int index = gridViewParameter->Rows->Add(values);
  
         gridViewParameter->Rows[index]->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::Otx::IProcedureParameter>>(parameter);
  
         gridViewParameter->Rows[index]->ReadOnly = std::dynamic_pointer_cast<IProcedureOutParameter>(parameter) != nullptr || parameter->GetInitValue() == nullptr;
  
         if (parameter->GetDataType()._Equal("Boolean"))
         {
             System::Windows::Forms::DataGridViewCheckBoxCell^ cell = gcnew System::Windows::Forms::DataGridViewCheckBoxCell();
             cell->Value = ConvertValue2String(parameter->GetValue());
             cell->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::DataTypes::Object>>(parameter->GetValue());
             cell->Style->NullValue = false;
             cell->TrueValue = true;
             cell->FalseValue = false;
             gridViewParameter->Rows[index]->Cells[collumnValue] = cell;
         }
         else if (std::shared_ptr<DataTypes::EnumerationElement> enumerationElement = std::dynamic_pointer_cast<DataTypes::EnumerationElement>(parameter->GetValue())) // Enumeration type
         {
             gridViewParameter->Rows[index]->Cells[collumnValue] = gcnew System::Windows::Forms::DataGridViewComboBoxCell();
             System::Windows::Forms::DataGridViewComboBoxCell^ cell = dynamic_cast<System::Windows::Forms::DataGridViewComboBoxCell^>(gridViewParameter->Rows[index]->Cells[collumnValue]);
             cell->DisplayStyle = System::Windows::Forms::DataGridViewComboBoxDisplayStyle::ComboBox;
             cell->FlatStyle = System::Windows::Forms::FlatStyle::Flat;
             cell->DisplayMember = "Name";
             cell->ValueMember = "Name";
             cell->DataSource = Util::Util::ArrayEnumerationElements2String(enumerationElement->GetEnumeration()->GetElements());
             cell->Value = ConvertValue2String(parameter->GetValue());
             cell->Tag = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(parameter->GetValue());
         }
         else
         {
             try
             {
                 if (parameter->GetValue() != nullptr)
                 {
                     gridViewParameter->Rows[index]->Cells[collumnValue]->Value = ConvertValue2String(parameter->GetValue());
                 }
             }
             catch (System::Exception^ ex)
             {
                 gridViewParameter->Rows[index]->Cells[collumnValue]->ErrorText = ex->Message;
             }
         }
  
         gridViewParameter->Rows[index]->Cells[collumnDetails]->Value = GetDetails(parameter->GetValue());
     }
     REFAPP_END_METHOD();
 }
  
 System::String^ SampleForm::ConvertValue2String(std::shared_ptr<DataTypes::Object> value)
 {
     if (value == nullptr)
     {
         return System::String::Empty;
     }
  
     return Util::Util::ToString(ValueConverter::Value2String(value));
 }
  
 System::String^ SampleForm::GetDetails(std::shared_ptr<DataTypes::Object> value)
 {
     REFAPP_START_METHOD();
     if (value == nullptr)
     {
         REFAPP_END_METHOD();
         return System::String::Empty;
     }
  
     if (std::shared_ptr<DataTypes::TranslationKey> translationKey = std::dynamic_pointer_cast<DataTypes::TranslationKey>(value))
     {
         if (!translationKey->GetTextIdMappingName().empty())
         {
             REFAPP_END_METHOD();
             return System::String::Format("MappingName: {0}", Util::Util::ToString(translationKey->GetTextIdMappingName()));
         }
     }
     else if (std::shared_ptr<DataTypes::EnumerationElement> enumerationElement = std::dynamic_pointer_cast<DataTypes::EnumerationElement>(value))
     {
         if (IS_NOT_NULL(enumerationElement->GetTranslationKey()))
         {
             if (!enumerationElement->GetTranslationKey()->GetTextId().empty() && !enumerationElement->GetTranslationKey()->GetTextIdMappingName().empty())
             {
                 REFAPP_END_METHOD();
                 return System::String::Format("TextId: {0}, MappingName: {1}",
                                               Util::Util::ToString(enumerationElement->GetTranslationKey()->GetTextId()),
                                               Util::Util::ToString(enumerationElement->GetTranslationKey()->GetTextIdMappingName()));
             }
             else if (!enumerationElement->GetTranslationKey()->GetTextId().empty())
             {
                 REFAPP_END_METHOD();
                 return System::String::Format("TextId: {0}",
                                               Util::Util::ToString(enumerationElement->GetTranslationKey()->GetTextId()));
             }
  
             REFAPP_END_METHOD();
             return System::String::Format("MappingName: {0}",
                                           Util::Util::ToString(enumerationElement->GetTranslationKey()->GetTextIdMappingName()));
         }
     }
  
     REFAPP_END_METHOD();
     return System::String::Empty;
 }
  
 // TODO: refactor
 void SampleForm::UpdateGridViewContextVariable(std::shared_ptr<IDocument> document, bool withPrefix, std::vector<std::string>& listItemReviewed)
 {
     REFAPP_START_METHOD();
     std::string documentFullName = document->GetPackage()->GetName() + "." + document->GetName();
     if (std::find(listItemReviewed.begin(), listItemReviewed.end(), documentFullName) != listItemReviewed.end())
     {
         REFAPP_END_METHOD();
         return;
     }
  
     listItemReviewed.push_back(documentFullName);
     for (int i = 0; i < document->GetContextVariables().size(); i++)
     {
         std::shared_ptr<IContextVariable> contextVariable = document->GetContextVariables().at(i);
  
         if (contextVariable == nullptr)
         {
             REFAPP_END_METHOD();
             return;
         }
  
         bool bValueWasSet = false;
  
         // Update existing value
         for (int iRow = 0; iRow < gridViewContext->Rows->Count; iRow++)
         {
             System::Windows::Forms::DataGridViewRow^ row = gridViewContext->Rows[iRow];
  
             if (row->Cells[dataGridViewTextBoxColumnContextName->Name]->Value != nullptr &&
                 row->Cells[dataGridViewTextBoxColumnContextName->Name]->Value->Equals(withPrefix ?
                                                                                      Util::Util::ToString(document->GetPackage()->GetFullName() + "." + document->GetName() + "." + contextVariable->GetName()) :
                                                                                      Util::Util::ToString(contextVariable->GetName())))
             {
                 if (radioButtonDefaultImplementation->Checked)
                 {
                     std::shared_ptr<DataTypes::Object> contextVariableValue = piml->ContextVariableImplementation->GetValue(nullptr, contextVariable, nullptr);
                     row->Cells[dataGridViewTextBoxColumnContextValue->Name]->Value = IS_NOT_NULL(contextVariableValue) ?
                         ConvertValue2String(contextVariableValue) :
                         nullptr;
                 }
                 else
                 {
                     row->Cells[dataGridViewTextBoxColumnContextValue->Name]->Value = IS_NOT_NULL(contextVariable->GetInitValue()) ?
                         ConvertValue2String(contextVariable->GetInitValue()) :
                         nullptr;
                 }
  
                 bValueWasSet = true;
                 break;
             }
         }
  
         // Add value if not exist
         if (!bValueWasSet)
         {
             cli::array<System::String^>^ values = nullptr;
             values = gcnew cli::array<System::String^>{
                 withPrefix ? Util::Util::ToString(document->GetPackage()->GetFullName() + "." + document->GetName() + "." + contextVariable->GetName()) :
                     Util::Util::ToString(contextVariable->GetName()),
                     Util::Util::ToString(contextVariable->GetDataType())
             };
             int index = gridViewContext->Rows->Add(values);
  
             std::shared_ptr<DataTypes::Object> contextVariableValue = contextVariable->GetInitValue();
  
             gridViewContext->Rows[index]->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::Otx::IContextVariable>>(contextVariable);
             gridViewContext->Rows[index]->ReadOnly = contextVariable->GetInitValue() == nullptr;
             gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::DataTypes::Object>>(contextVariable->GetInitValue());
             if (contextVariable->GetDataType()._Equal("Boolean"))
             {
                 System::Windows::Forms::DataGridViewCheckBoxCell^ cell = gcnew System::Windows::Forms::DataGridViewCheckBoxCell();
                 cell->Value = ConvertValue2String(contextVariableValue);
                 gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextValue->Name] = cell;
                 cell->Tag = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(contextVariableValue);
                 cell->Style->NullValue = false;
                 cell->TrueValue = true;
                 cell->FalseValue = false;
             }
             else if (std::shared_ptr<DataTypes::EnumerationElement> enumerationElement = std::dynamic_pointer_cast<DataTypes::EnumerationElement>(contextVariableValue)) // Enumeration type
             {
                 gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextValue->Name] = gcnew System::Windows::Forms::DataGridViewComboBoxCell();
                 System::Windows::Forms::DataGridViewComboBoxCell^ cell = dynamic_cast<System::Windows::Forms::DataGridViewComboBoxCell^>(gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextValue->Name]);
                 cell->DisplayStyle = System::Windows::Forms::DataGridViewComboBoxDisplayStyle::ComboBox;
                 cell->FlatStyle = System::Windows::Forms::FlatStyle::Flat;
                 cell->DisplayMember = "Name";
                 cell->ValueMember = "Name";
                 cell->DataSource = Util::Util::ArrayEnumerationElements2String(enumerationElement->GetEnumeration()->GetElements());;
                 cell->Value = ConvertValue2String(contextVariableValue);
                 cell->Tag = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(contextVariableValue);
             }
             else
             {
                 try
                 {
                     if (IS_NOT_NULL(contextVariableValue))
                     {
                         gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Value = ConvertValue2String(contextVariableValue);
                     }
                     else
                     {
                         gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextValue->Name]->Value = nullptr;
                     }
                 }
                 catch (System::Exception^ ex)
                 {
                     gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextValue->Name]->ErrorText = ex->Message;
                 }
             }
  
             gridViewContext->Rows[index]->Cells[dataGridViewTextBoxColumnContextDetails->Name]->Value = GetDetails(contextVariableValue);
         }
     }
  
     try
     {
         std::vector<std::shared_ptr<IDocument>> importDocs = document->GetImports();
         for (int i = 0; i < importDocs.size(); i++)
         {
             UpdateGridViewContextVariable(importDocs[i], true, listItemReviewed);
         }
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor this
 void SampleForm::StateVariableValueChanged(std::shared_ptr<IStateVariable> stateVariable, std::shared_ptr<DataTypes::Object> value)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = gcnew cli::array<System::Object^>(2);
     arr[0] = gcnew CLRWrapper<std::shared_ptr<IStateVariable>>(stateVariable);
     arr[1] = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(value);
  
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::StateVariableValueChangedCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         StateVariableValueChangedCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor this
 void SampleForm::StateVariableValueChangedCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     std::shared_ptr<IStateVariable> stateVariable = Util::Util::CastTo<std::shared_ptr<IStateVariable>>(arr[0]);
     std::shared_ptr<DataTypes::Object> value = Util::Util::CastTo<std::shared_ptr<DataTypes::Object>>(arr[1]);
  
     if (stateVariable == nullptr || value == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::String^ mappingStr = System::String::Format("[MappedTo: {0}{1}",
                                                         Util::Util::ToString(stateVariable->GetMappingName()),
                                                         stateVariable->GetMappingIndex() > -1 ? ("[" + stateVariable->GetMappingIndex() + "]") : System::String::Empty);
     System::String^ strValue = "null";
     try
     {
         strValue = Util::Util::ToString(ValueConverter::Value2String(value));
     }
     catch (...)
     {
     }
  
     System::String^ outputLog = System::String::Format("StateVariableChanged({0} {1}.{2}{3} = {4})",
                                                         Util::Util::ToString(stateVariable->GetDataType()),
                                                         Util::Util::ToString(stateVariable->GetDocument()->GetFullName()),
                                                         Util::Util::ToString(stateVariable->GetName()),
                                                         mappingStr,
                                                         strValue);
     PrintTextCallback(outputLog);
     UpdateGridViewStateVariable(stateVariable);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ContextVariableRead(std::shared_ptr<IContextVariable> contextVariable, std::shared_ptr<DataTypes::Object> value)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = gcnew cli::array<System::Object^>(2);
     arr[0] = gcnew CLRWrapper<std::shared_ptr<IContextVariable>>(contextVariable);
     arr[1] = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(value);
  
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::ContextVariableReadCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         ContextVariableReadCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ContextVariableReadCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     std::shared_ptr<IContextVariable> contextVariable = Util::Util::CastTo<std::shared_ptr<IContextVariable>>(arr[0]);
     std::shared_ptr<DataTypes::Object> value = Util::Util::CastTo<std::shared_ptr<DataTypes::Object>>(arr[1]);
  
     if (contextVariable == nullptr || value == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::String^ mappingStr = System::String::Format("[MappedTo: {0}{1}",
                                                         Util::Util::ToString(contextVariable->GetMappingName()),
                                                         (contextVariable->GetMappingIndex() > -1 ? ("[" + contextVariable->GetMappingIndex() + "]") : System::String::Empty));
     System::String^ strValue = "null";
     try
     {
         strValue = Util::Util::ToString(ValueConverter::Value2String(value));
     }
     catch (...)
     {
     }
     System::String^ outputLog = System::String::Format("ContextVariableRead({0} {1}.{2}{3} = {4})",
                                                         Util::Util::ToString(contextVariable->GetDataType()),
                                                         Util::Util::ToString(contextVariable->GetDocument()->GetFullName()),
                                                         Util::Util::ToString(contextVariable->GetName()),
                                                         mappingStr,
                                                         strValue);
  
     PrintTextCallback(outputLog);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateGridViewStateVariable(std::shared_ptr<IDocument> document, bool withPrefix, std::vector<std::string>& listItemReviewed)
 {
     REFAPP_START_METHOD();
     std::string documentFullName = document->GetPackage()->GetName() + "." + document->GetName();
     if (std::find(listItemReviewed.begin(), listItemReviewed.end(), documentFullName) != listItemReviewed.end())
     {
         REFAPP_END_METHOD();
         return;
     }
  
     listItemReviewed.push_back(documentFullName);
     std::vector<std::shared_ptr<IStateVariable>> stateVariables = document->GetStateVariables();
     for (int i = 0; i < stateVariables.size(); i++)
     {
         std::shared_ptr<IStateVariable> stateVariable = stateVariables[i];
         cli::array<System::String^>^ values = nullptr;
         values = gcnew cli::array<System::String^>{
             withPrefix ? Util::Util::ToString(document->GetPackage()->GetFullName() + "." + document->GetName() + "." + stateVariable->GetName()) :
                 Util::Util::ToString(stateVariable->GetName()),
                 Util::Util::ToString(stateVariable->GetDataType())
         };
         int index = gridViewState->Rows->Add(values);
  
         gridViewState->Rows[index]->Tag = gcnew CLRWrapper<std::shared_ptr<Otx::Runtime::Api::Otx::IStateVariable>>(stateVariable);
  
         if (stateVariable->GetDataType()._Equal("Boolean"))
         {
             gridViewState->Rows[index]->Cells[dataGridViewTextBoxColumnStateValue->Name] = gcnew System::Windows::Forms::DataGridViewCheckBoxCell();
             System::Windows::Forms::DataGridViewCheckBoxCell^ cell = dynamic_cast<System::Windows::Forms::DataGridViewCheckBoxCell^>(gridViewState->Rows[index]->Cells[dataGridViewTextBoxColumnStateValue->Name]);
             cell->Value = ConvertValue2String(stateVariable->GetInitValue());
             cell->Tag = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(stateVariable->GetInitValue());
             cell->Style->NullValue = false;
             cell->TrueValue = true;
             cell->FalseValue = false;
         }
         else if (std::shared_ptr<DataTypes::EnumerationElement> enumerationElement = std::dynamic_pointer_cast<DataTypes::EnumerationElement>(stateVariable->GetInitValue())) // Enumeration type
         {
             gridViewState->Rows[index]->Cells[dataGridViewTextBoxColumnStateValue->Name] = gcnew System::Windows::Forms::DataGridViewComboBoxCell();
             System::Windows::Forms::DataGridViewComboBoxCell^ cell = dynamic_cast<System::Windows::Forms::DataGridViewComboBoxCell^>(gridViewState->Rows[index]->Cells[dataGridViewTextBoxColumnStateValue->Name]);
             cell->DisplayStyle = System::Windows::Forms::DataGridViewComboBoxDisplayStyle::ComboBox;
             cell->FlatStyle = System::Windows::Forms::FlatStyle::Flat;
             cell->DisplayMember = "Name";
             cell->ValueMember = "Name";
             cell->DataSource = Util::Util::ArrayEnumerationElements2String(enumerationElement->GetEnumeration()->GetElements());;
             cell->Value = ConvertValue2String(stateVariable->GetInitValue());
             cell->Tag = gcnew CLRWrapper<std::shared_ptr<DataTypes::Object>>(stateVariable->GetInitValue());
         }
         else
         {
             try
             {
                 if (IS_NOT_NULL(stateVariable->GetInitValue()))
                 {
                     gridViewState->Rows[index]->Cells[dataGridViewTextBoxColumnStateValue->Name]->Value = ConvertValue2String(stateVariable->GetInitValue());
                 }
             }
             catch (System::Exception^ ex)
             {
                 gridViewState->Rows[index]->Cells[dataGridViewTextBoxColumnStateValue->Name]->ErrorText = ex->Message;
             }
         }
  
         if (IS_NOT_NULL(stateVariable->GetInitValue()))
         {
             gridViewState->Rows[index]->Cells[dataGridViewTextBoxColumnStateDetails->Name]->Value = GetDetails(stateVariable->GetInitValue());
         }
     }
  
     try
     {
         std::vector<std::shared_ptr<IDocument>> importDocs = document->GetImports();
         for (int i = 0; i < importDocs.size(); i++)
         {
             UpdateGridViewStateVariable(importDocs[i], true, listItemReviewed);
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     REFAPP_END_METHOD();
 }
  
 // TODO: refactor
 void SampleForm::UpdateGridViewStateVariable(std::shared_ptr<IStateVariable> stateVariable)
 {
     REFAPP_START_METHOD();
     if (stateVariable == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     // Update existing value
     for (int i = 0; i < gridViewState->Rows->Count; i++)
     {
         System::Windows::Forms::DataGridViewRow^ row = gridViewState->Rows[i];
         if (row->Cells[dataGridViewTextBoxColumnStateName->Name]->Value != nullptr && Util::Util::CastTo<std::shared_ptr<IStateVariable>>(row->Tag) == stateVariable)
         {
             std::shared_ptr<DataTypes::Object> stateVariableValue = nullptr;
  
             if (radioButtonDefaultImplementation->Checked)
             {
                 stateVariableValue = piml->StateVariableImplementation->GetValue(stateVariable);
             }
             else
             {
                 stateVariableValue = stateVariable->GetInitValue();
             }
  
             if (IS_NOT_NULL(stateVariableValue))
             {
                 try
                 {
                     row->Cells[dataGridViewTextBoxColumnStateValue->Name]->Value = ConvertValue2String(stateVariableValue);
                 }
                 catch (System::Exception^ ex)
                 {
                     row->Cells[dataGridViewTextBoxColumnStateValue->Name]->ErrorText = ex->Message;
                 }
  
                 row->Cells[dataGridViewTextBoxColumnStateDetails->Name]->Value = GetDetails(stateVariableValue);
             }
             else
             {
                 row->Cells[dataGridViewTextBoxColumnStateValue->Name]->Value = nullptr;
                 row->Cells[dataGridViewTextBoxColumnStateDetails->Name]->Value = System::String::Empty;
             }
             break;
         }
     }
  
     System::Windows::Forms::Application::DoEvents();
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonNewInstance_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     SampleForm^ form = gcnew SampleForm();
     form->SetInstanceName(Util::Util::ToString(SampleConstants::CHILD_INSTANCE_NAME));
     form->SetCreatorForm(this);
     form->Show();
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonNewInstanceNewThread_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     System::Threading::Thread^ thread = gcnew System::Threading::Thread(gcnew System::Threading::ThreadStart(this, &SampleForm::NewInstanceInThread));
     thread->SetApartmentState(System::Threading::ApartmentState::STA);
     thread->Start();
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::NewInstanceInThread()
 {
     REFAPP_START_METHOD();
     SampleForm^ form = gcnew SampleForm();
     form->SetInstanceName(Util::Util::ToString(SampleConstants::CHILD_INSTANCE_NAME));
     form->SetCreatorForm(this);
     System::Windows::Forms::Application::Run(form);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonHmi_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (buttonHmi->Checked)
     {
         piml->HmiWindow = gcnew HmiWindow();
         piml->HmiWindow->FormClosing += gcnew System::Windows::Forms::FormClosingEventHandler(this, &SampleForm::HmiWindow_FormClosing);
         piml->HmiWindow->SizeChanged += gcnew System::EventHandler(this, &SampleForm::HmiWindow_SizeChanged);
         piml->HmiWindow->Activated += gcnew System::EventHandler(this, &SampleForm::HmiWindow_Activated);
         piml->HmiWindow->Show();
  
         piml->HmiWindow->Size = System::Drawing::Size(Setting::UserSettings::GetInstance().GetHmiWindowWidth(), Setting::UserSettings::GetInstance().GetHmiWindowHeight());
         piml->HmiWindow->Location = System::Drawing::Point(Location.X + Size.Width, Location.Y);
         if (IS_NOT_NULL(piml->CreatorForm) && IS_NOT_NULL(piml->CreatorForm->piml->HmiWindow))
         {
             piml->HmiWindow->Size = piml->CreatorForm->piml->HmiWindow->Size;
         }
  
         piml->HmiWindow->BringToFront();
  
         piml->CustomScreenImplementation->SetHmiScreenHandle(piml->HmiWindow->GetHmiControl()->Handle.ToInt64());
     }
     else if (IS_NOT_NULL(piml->HmiWindow))
     {
         piml->HmiWindow->Close();
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonHmi : nullptr, buttonHmi);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::HmiWindow_FormClosing(System::Object^ sender, System::Windows::Forms::FormClosingEventArgs^ e)
 {
     REFAPP_START_METHOD();
     piml->CustomScreenImplementation->SetHmiScreenHandle(NULL);
     piml->HmiWindow = nullptr;
  
     buttonHmi->Checked = false;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::HmiWindow_Activated(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->CustomScreenImplementation != nullptr)
     {
         piml->CustomScreenImplementation->ActivateHmiScreen();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::HmiWindow_SizeChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     Setting::UserSettings::GetInstance().SetHmiWindowWidth(piml->HmiWindow->Width);
     Setting::UserSettings::GetInstance().SetHmiWindowHeight(piml->HmiWindow->Height);
  
     if (piml->CustomScreenImplementation != nullptr)
     {
         piml->CustomScreenImplementation->RefreshHmiScreen();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CustomScreenImplementation_KeyDown(std::shared_ptr<Custom::KeyEventArgs> eventArgs)
 {
     REFAPP_START_METHOD();
     std::string key = "Unknown";
     if (std::shared_ptr<Custom::WpfKeyEventArgs> wpfKeyEventArgs = std::dynamic_pointer_cast<Custom::WpfKeyEventArgs>(eventArgs))
     {
         key = wpfKeyEventArgs->ToString();
         if (wpfKeyEventArgs->GetModifierKeys() == Custom::ModifierKeys::Alt &&
             wpfKeyEventArgs->GetKey() == Custom::Key::F4)
         {
             if (IS_NOT_NULL(piml->HmiWindow))
             {
                 piml->HmiWindow->Close();
             }
         }
         else if (wpfKeyEventArgs->GetKey() == Custom::Key::F10 ||
             wpfKeyEventArgs->GetKey() == Custom::Key::LeftAlt ||
             wpfKeyEventArgs->GetKey() == Custom::Key::RightAlt)
         {
             eventArgs->SetHandled(true);
         }
     }
     else if (std::shared_ptr<Custom::FormKeyEventArgs> formKeyEventArgs = std::dynamic_pointer_cast<Custom::FormKeyEventArgs>(eventArgs))
     {
         if (formKeyEventArgs->GetModifierKeys() == Custom::Keys::Alt &&
             formKeyEventArgs->GetKey() == Custom::Keys::F4)
         {
             if (IS_NOT_NULL(piml->HmiWindow))
             {
                 piml->HmiWindow->Close();
             }
         }
         else if (formKeyEventArgs->GetKey() == Custom::Keys::F10 ||
             formKeyEventArgs->GetKey() == Custom::Keys::Alt)
         {
             eventArgs->SetHandled(true);
         }
         key = formKeyEventArgs->ToString();
     }
  
     PrintTextCallback("CustomScreenImplementation_KeyDown(" + Util::Util::ToString(key) + ")");
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::SampleForm_FormClosing(System::Object^ sender, System::Windows::Forms::FormClosingEventArgs^ e)
 {
     REFAPP_START_METHOD();
     // at C#: listForms.Remove(this)
     for (size_t i = 0; i < piml->ListForms.size(); i++)
     {
         if (piml->ListForms.at(i).get() == this)
         {
             // Possibly crash application
             // piml->ListForms.erase(piml->ListForms.begin() + i);
         }
     }
  
     // Remove Event
     if (piml->GlobalRuntimeManager != nullptr)
     {
         piml->GlobalRuntimeManager->StopAll();
         piml->RemoveRuntimeEvents(piml->GlobalRuntimeManager);
     }
  
     //piml->StateVariableImplementation->SetStateVariableValueChangedHandler(nullptr);
  
     piml->RemoveOutputImplLogEventHandler();
  
     SaveSettings();
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SaveSettings()
 {
     REFAPP_START_METHOD();
  
     int integerValue;
     unsigned long long longValue;
  
     if (piml != NULL && IS_NULL(piml->CreatorForm))
     {
         // Only main form
         Setting::UserSettings::GetInstance().SetPtxPpxDirectory(Util::Util::ToString(cbFilePath->Text->Trim()));
         Setting::UserSettings::GetInstance().SetPtxPpxDirectoryList(Util::Util::Join(";", cbFilePath->Items->GetEnumerator()));
  
         Setting::UserSettings::GetInstance().SetTraceFileMaxCount(System::Int32::TryParse(textBoxTraceFileMaxCount->Text->Trim(), integerValue) ?
             integerValue :
             Setting::UserSettings::GetInstance().GetTraceFileMaxCount());
         Setting::UserSettings::GetInstance().SetTraceFileMaxSize(System::Int32::TryParse(textBoxTraceFileMaxSize->Text->Trim(), integerValue) ?
             integerValue :
             Setting::UserSettings::GetInstance().GetTraceFileMaxSize());
         Setting::UserSettings::GetInstance().SetProfiling(checkBoxProfiling->Checked);
         Setting::UserSettings::GetInstance().SetProfilingMaxFileSize(System::Int32::TryParse(textBoxProfilingSize->Text->Trim(), integerValue) ?
             integerValue :
             Setting::UserSettings::GetInstance().GetProfilingMaxFileSize());
         Setting::UserSettings::GetInstance().SetTraceLevels(RuntimeConfig::GetInstance().GetTraceLevel());
         Setting::UserSettings::GetInstance().SetTracingDirectory(Util::Util::ToString(textBoxTraceFolder->Text->Trim()));
  
         Setting::UserSettings::GetInstance().SetWindowWidth(Size.Height);
         Setting::UserSettings::GetInstance().SetWindowWidth(Size.Width);
         Setting::UserSettings::GetInstance().SetWindowLocationX(Location.X);
         Setting::UserSettings::GetInstance().SetWindowLocationY(Location.Y);
         Setting::UserSettings::GetInstance().SetCustomImplTypes(GetCurrentCustomImpl());
         SaveSocketPortOrPipeName();
  
         Setting::UserSettings::GetInstance().SetAsynchron(checkBoxAsyncExecution->Checked);
         Setting::UserSettings::GetInstance().SetCyclic(checkBoxCyclicExecution->Checked);
         Setting::UserSettings::GetInstance().SetCyclicReload(checkBoxCyclicReload->Checked);
         Setting::UserSettings::GetInstance().SetNewRuntimeManager(checkBoxNewRuntimeManager->Checked);
         Setting::UserSettings::GetInstance().SetAddMessageToOutput(checkBoxAdd2Output->Checked);
         Setting::UserSettings::GetInstance().SetStartAllParents(checkBoxStartAllParents->Checked);
  
         Setting::UserSettings::GetInstance().SetTimeout(System::UInt64::TryParse(textBoxTimeout->Text->Trim(), longValue) ?
             longValue :
             Setting::UserSettings::GetInstance().GetTimeOut());
         Setting::UserSettings::GetInstance().SetConnectionState(checkBoxUseConnectionState->Checked);
         Setting::UserSettings::GetInstance().SetIgnition((int)checkBoxIgnition->CheckState);
         Setting::UserSettings::GetInstance().SetPollingTime(System::Int32::TryParse(textBoxPollingTime->Text->Trim(), integerValue) ?
             integerValue :
             Setting::UserSettings::GetInstance().GetPollingTime());
         Setting::UserSettings::GetInstance().SetVoltageThreshold(System::Int32::TryParse(textBoxVoltageThreshold->Text->Trim(), integerValue) ?
             integerValue :
             Setting::UserSettings::GetInstance().GetVoltageThreshold());
  
         Setting::UserSettings::GetInstance().SetRuntimeContextName(Util::Util::ToString(textBoxRuntimeContextName->Text->Trim()));
  
 #pragma region C++ for RAW-mode
         Setting::UserSettings::GetInstance().SetDiagIpcType(comboBoxDiagIpcType->SelectedItem != nullptr ?
             Util::Util::ToIpcType(comboBoxDiagIpcType->SelectedItem->ToString()) :
             IpcTypes::Raw);
         Setting::UserSettings::GetInstance().SetDiagManagerLicenseKey(Util::LicenseUtil::Encrypt(Util::Util::ToString(textBoxDiagManagerLicenseKey->Text)));
         Setting::UserSettings::GetInstance().SetDiagManagerTraceLevel(comboBoxDiagManagerTraceLevel->SelectedItem != nullptr ?
             Util::Util::ToLoggerLevel(comboBoxDiagManagerTraceLevel->SelectedItem->ToString()) :
             (DiagManager::Common::ILog::Level)Util::OtxDiagUtil::GetLevelLoggerDefault());
         Setting::UserSettings::GetInstance().SetDiagLoggingTraceLevel(comboBoxDiagLoggingTraceLevel->SelectedItem != nullptr ?
             Util::Util::ToDiagDiagnosticsLogLevel(comboBoxDiagLoggingTraceLevel->SelectedItem->ToString()) :
             (DiagManager::NoneOtxDiagApi::INoneOtxDiag::LogLevels)Util::OtxDiagUtil::GetDiagnosticLogLevelDefault());
         Setting::UserSettings::GetInstance().SetIncludeTraceDiagLogging(checkBoxIncludedDiagLogging->Checked);
         Setting::UserSettings::GetInstance().SetDiagTraceDirectory(Util::Util::ToString(textBoxDiagManagerTraceFolder->Text));
         Setting::UserSettings::GetInstance().SetOdxProject(comboBoxODXProject->SelectedItem != nullptr ?
             Util::Util::ToString(comboBoxODXProject->SelectedItem->ToString()) :
             "");
         Setting::UserSettings::GetInstance().SetOdxVehicleInformation(comboBoxODXVehicle->SelectedItem != nullptr ?
             Util::Util::ToString(comboBoxODXVehicle->SelectedItem->ToString()) :
             "");
 #pragma endregion//Only C++
  
         Setting::UserSettings::GetInstance().Save();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SaveSocketPortOrPipeName()
 {
     REFAPP_START_METHOD();
     IpcTypes ipcType = Util::Util::ToIpcType(comboBoxIpcType->SelectedItem->ToString());
     unsigned short unsignedShortValue;
  
     switch (ipcType)
     {
 #pragma region C++ for RAW-mode
     case IpcTypes::Raw:
     {
         Setting::UserSettings::GetInstance().SetIpcType(ipcType);
         break;
     }
 #pragma endregion//C++ for RAW-mode
     case IpcTypes::Socket:
     {
         try
         {
             Setting::UserSettings::GetInstance().SetDiagManagerPort(System::UInt16::TryParse(textBoxDiagPortPipe->Text->Trim(), unsignedShortValue) ?
                 unsignedShortValue :
                 SampleConstants::DEFAULT_DM_PORT);
             Setting::UserSettings::GetInstance().SetRuntimePort(System::UInt16::TryParse(textBoxRtPortPipe->Text->Trim(), unsignedShortValue) ?
                 unsignedShortValue :
                 SampleConstants::DEFAULT_RT_PORT);
             Setting::UserSettings::GetInstance().SetIpcType(ipcType);
         }
         catch (...)
         {
             Setting::UserSettings::GetInstance().SetDiagManagerPort(SampleConstants::DEFAULT_DM_PORT);
             Setting::UserSettings::GetInstance().SetRuntimePort(SampleConstants::DEFAULT_RT_PORT);
         }
         break;
     }
     case IpcTypes::Pipe:
     {
         std::string diagManagerPipeName = Util::Util::ToString(textBoxDiagPortPipe->Text->Trim());
         std::string runtimePipeName = Util::Util::ToString(textBoxRtPortPipe->Text->Trim());
  
         Setting::UserSettings::GetInstance().SetDiagManagerPipeName(!diagManagerPipeName.empty() ? diagManagerPipeName : SampleConstants::DEFAULT_DM_PIPE_NAME);
         Setting::UserSettings::GetInstance().SetRuntimePipeName(!runtimePipeName.empty() ? runtimePipeName : SampleConstants::DEFAULT_RT_PIPE_NAME);
         Setting::UserSettings::GetInstance().SetIpcType(ipcType);
         break;
     }
     default:
         break;
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxRuntimeContextName_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     textBoxRuntimeContextName->Text = textBoxRuntimeContextName->Text->Trim();
     piml->RuntimeContextName = Util::Util::ToString(textBoxRuntimeContextName->Text);
  
     SetTitle(Util::Util::ToString(piml->Title));
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::listBoxOuput_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     buttonCopyRow->Enabled = listBoxOuput->SelectedItems->Count > 0;
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonPause_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     msclr::lock l(piml->LockRuntimeContexts.get());
     {
         if (buttonPause->Checked)
         {
             for (int i = 0; i < piml->RuntimeContexts.size(); i++)
             {
                 if (piml->RuntimeContexts[i]->GetExecutionState() == ExecutionState::Running)
                 {
                     piml->RuntimeContexts[i]->Pause();
                 }
             }
         }
         else
         {
             for (int i = 0; i < piml->RuntimeContexts.size(); i++)
             {
                 if (piml->RuntimeContexts[i]->GetExecutionState() == ExecutionState::Paused)
                 {
                     piml->RuntimeContexts[i]->Continue();
                 }
             }
         }
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonPause : nullptr, buttonPause);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::AddRuntimeContext(IRuntimeContext* context)
 {
     REFAPP_START_METHOD();
     msclr::lock l(piml->LockRuntimeContexts.get());
     {
         if (std::find(piml->RuntimeContexts.begin(), piml->RuntimeContexts.end(), context) == piml->RuntimeContexts.end()) // context not exist into vector
         {
             piml->RuntimeContexts.push_back(context);
         }
  
         if (piml->RuntimeContextIdsExecutionStartTick.find(context->GetRuntimeId()) == piml->RuntimeContextIdsExecutionStartTick.end())
         {
             piml->RuntimeContextIdsExecutionStartTick.insert({ context->GetRuntimeId(), System::DateTime::Now.Ticks });
         }
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::RemoveRuntimeContext(IRuntimeContext* context)
 {
     REFAPP_START_METHOD();
     long long contextRuntimeId = context->GetRuntimeId();
  
     msclr::lock l(piml->LockRuntimeContexts.get());
     {
         for (int i = 0; i < piml->RuntimeContexts.size(); i++)
         {
             if (piml->RuntimeContexts[i]->GetRuntimeId() == contextRuntimeId)
             {
                 piml->RuntimeContexts.erase(piml->RuntimeContexts.begin() + i);
             }
         }
  
         std::map<long long, long long>::iterator itr = piml->RuntimeContextIdsExecutionStartTick.find(contextRuntimeId);
         if (itr != piml->RuntimeContextIdsExecutionStartTick.end())
         {
             piml->RuntimeContextIdsExecutionStartTick.erase(itr);
         }
     }
     REFAPP_END_METHOD();
 }
  
 bool SampleForm::IsPauseEnabled()
 {
     REFAPP_START_METHOD();
     msclr::lock l(piml->LockRuntimeContexts.get());
     {
         for (int i = 0; i < piml->RuntimeContexts.size(); i++)
         {
             if (piml->RuntimeContexts[i]->GetExecutionState() == ExecutionState::Running)
             {
                 REFAPP_END_METHOD();
                 return true;
             }
         }
  
         REFAPP_END_METHOD();
         return false;
     }
 }
  
 bool SampleForm::IsContinueEnable()
 {
     REFAPP_START_METHOD();
     msclr::lock l(piml->LockRuntimeContexts.get());
     {
         for (int i = 0; i < piml->RuntimeContexts.size(); i++)
         {
             if (piml->RuntimeContexts[i]->GetExecutionState() == ExecutionState::Paused)
             {
                 REFAPP_END_METHOD();
                 return true;
             }
         }
         REFAPP_END_METHOD();
         return false;
     }
 }
  
 void SampleForm::SetExpectedState()
 {
     REFAPP_START_METHOD();
     if (piml->UseConnectionState)
     {
         if (piml->KL15State == -1)
         {
             piml->ExpectedConnectionState = ExpectedState::BatteryOn;
         }
         else if (piml->KL15State == 1)
         {
             piml->ExpectedConnectionState = ExpectedState::IgnitionOn;
         }
         else
         {
             piml->ExpectedConnectionState = ExpectedState::IgnitionOff;
         }
     }
     else
     {
         piml->ExpectedConnectionState = ExpectedState::None;
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxUseConnectionState_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     piml->UseConnectionState = checkBoxUseConnectionState->Checked;
     EnableConnectionState();
     SetExpectedState();
  
     System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
     labelBatteryState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBattery16")));
     labelIgnitionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnition16")));
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxUseConnectionState : nullptr, checkBoxUseConnectionState);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::CheckBoxKL15_CheckStateChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     switch (checkBoxIgnition->CheckState)
     {
     case System::Windows::Forms::CheckState::Checked:
         piml->KL15State = 1;
         break;
     case System::Windows::Forms::CheckState::Unchecked:
         piml->KL15State = 0;
         break;
     default:
         piml->KL15State = -1;
         break;
     }
  
     SetExpectedState();
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxIgnition : nullptr, checkBoxIgnition);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::EnableConnectionState()
 {
     labelExpectedState->Enabled = piml->UseConnectionState;
     labelBatteryState->Enabled = piml->UseConnectionState;
     checkBoxIgnition->Enabled = piml->UseConnectionState;
     labelPollingTime->Enabled = piml->UseConnectionState;
     textBoxPollingTime->Enabled = piml->UseConnectionState;
     labelVoltageThreshold->Enabled = piml->UseConnectionState;
     textBoxVoltageThreshold->Enabled = piml->UseConnectionState;
     buttonCheckBatteryIgnition->Enabled = piml->UseConnectionState;
 }
  
 System::Void SampleForm::buttonCheckBatteryIgnition_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     CheckBatteryIgnitionState(piml->GlobalRuntimeManager);
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonCheckBatteryIgnition : nullptr, buttonCheckBatteryIgnition);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxPollingTime_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         if (System::Convert::ToInt32(textBoxPollingTime->Text->Trim()) <= 0)
         {
             textBoxPollingTime->Text = piml->DEFAULT_POLLING_TIME.ToString();
         }
     }
     catch (...)
     {
         textBoxPollingTime->Text = piml->DEFAULT_POLLING_TIME.ToString();
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->textBoxPollingTime : nullptr, textBoxPollingTime);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxBatteryVoltageThreshold_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         if (System::Convert::ToInt32(textBoxVoltageThreshold->Text->Trim()) <= 0)
         {
             textBoxVoltageThreshold->Text = piml->DEFAULT_POLLING_TIME.ToString();
         }
     }
     catch (...)
     {
         textBoxVoltageThreshold->Text = piml->DEFAULT_POLLING_TIME.ToString();
     }
  
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->textBoxVoltageThreshold : nullptr, textBoxVoltageThreshold);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::CheckBatteryIgnitionState(std::shared_ptr<IRuntimeManager> runtimeManager)
 {
     REFAPP_START_METHOD();
     if (piml->UseConnectionState)
     {
         runtimeManager->GetDiagConnectionState()->SetPollingTime(System::Convert::ToInt32(textBoxPollingTime->Text));
         runtimeManager->GetDiagConnectionState()->SetBatteryVoltageThreshold(System::Convert::ToInt32(textBoxVoltageThreshold->Text));
         ClampState batteryState = runtimeManager->GetDiagConnectionState()->GetBatteryState();
         ClampState ignitionState = runtimeManager->GetDiagConnectionState()->GetIgnitionState();
  
         SetBatteryIgnitionState(batteryState, ignitionState);
  
         PrintTextCallback("Check DiagConnection State - BatteryState = " + Util::Util::ToString(batteryState) + ", IgnitionState = " + Util::Util::ToString(ignitionState));
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetBatteryIgnitionState(ClampState batteryState, ClampState ignitionState)
 {
     REFAPP_START_METHOD();
 #pragma region C++ for initialize resource
     System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
 #pragma endregion
  
     switch (batteryState)
     {
     case OpenTestSystem::Otx::Runtime::Api::ClampState::NotAvailable:
         labelBatteryState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBatteryNotAvailable16")));
         break;
     case OpenTestSystem::Otx::Runtime::Api::ClampState::Off:
         labelBatteryState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBatteryOff16")));
         break;
     case OpenTestSystem::Otx::Runtime::Api::ClampState::On:
         labelBatteryState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconBatteryOn16")));
         break;
     }
  
     switch (ignitionState)
     {
     case OpenTestSystem::Otx::Runtime::Api::ClampState::NotAvailable:
         labelIgnitionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnitionNotAvailable16")));
         break;
     case OpenTestSystem::Otx::Runtime::Api::ClampState::Off:
         labelIgnitionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnitionOff16")));
         break;
     case OpenTestSystem::Otx::Runtime::Api::ClampState::On:
         labelIgnitionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"IconIgnitionOn16")));
         break;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ShowConnectionStateMessage(IRuntimeContext* runtimeContext)
 {
     REFAPP_START_METHOD();
     if (runtimeContext != nullptr)
     {
         System::Media::SystemSounds::Beep->Play();
  
         switch (piml->ExpectedConnectionState)
         {
         case OpenTestSystem::Otx::Runtime::Api::ExpectedState::BatteryOn:
             PrintTextCallback("----------------------------------------------------------------------------------------------------------------------------------------------");
             PrintTextCallback("-- Not expected connection state: Either it is not possible to communicate with the VCI or the battery is not connected. Please connect it! --");
             PrintTextCallback("----------------------------------------------------------------------------------------------------------------------------------------------");
             break;
         case OpenTestSystem::Otx::Runtime::Api::ExpectedState::IgnitionOff:
             PrintTextCallback("------------------------------------------------------------------------------------");
             PrintTextCallback("-- Not expected connection state: The ignition must be OFF. Please switch it OFF! --");
             PrintTextCallback("------------------------------------------------------------------------------------");
             break;
         case OpenTestSystem::Otx::Runtime::Api::ExpectedState::IgnitionOn:
             PrintTextCallback("----------------------------------------------------------------------------------");
             PrintTextCallback("-- Not expected connection state: The ignition must be ON. Please switch it ON! --");
             PrintTextCallback("----------------------------------------------------------------------------------");
             break;
         default:
             break;
         }
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxAdd2Output_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxAdd2Output : nullptr, checkBoxAdd2Output);
     REFAPP_END_METHOD();
 }
  
 void SampleForm::NumericUpDownSetValueCallback(cli::array<System::Object^>^ arr)
 {
     REFAPP_START_METHOD();
     if (arr == nullptr || arr->Length != 2)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::NumericUpDown^ numericUpDown = dynamic_cast<System::Windows::Forms::NumericUpDown^>(arr[0]);
     System::Windows::Forms::NumericUpDown^ control = dynamic_cast<System::Windows::Forms::NumericUpDown^>(arr[1]);
  
     numericUpDown->Value = control->Value;
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ParentNumericUpDownSetValueCallback(System::Object^ state)
 {
     REFAPP_START_METHOD();
     cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
     if (arr == nullptr || arr->Length != 2) {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::NumericUpDown^ numericUpDown = dynamic_cast<System::Windows::Forms::NumericUpDown^>(arr[0]);
     System::Windows::Forms::NumericUpDown^ control = dynamic_cast<System::Windows::Forms::NumericUpDown^>(arr[1]);
  
     if (numericUpDown == nullptr || control == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (numericUpDown->InvokeRequired)
     {
         piml->CreatorForm->Invoke(gcnew System::Action<cli::array<System::Object^>^>(this, &SampleForm::NumericUpDownSetValueCallback), gcnew cli::array<System::Object^>{arr});
     }
     else
     {
         NumericUpDownSetValueCallback(arr);
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::comboBoxTraceLevel_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->comboBoxTraceLevel : nullptr,
         comboBoxTraceLevel);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::txtPassword_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->txtPassword : nullptr, txtPassword);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxTimeout_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->textBoxTimeout : nullptr, textBoxTimeout);
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxProfiling_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->GlobalRuntimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     PrintTextCallback("Set Profiling to " + checkBoxProfiling->Checked.ToString());
  
     try
     {
         RuntimeConfig::GetInstance().SetProfiling(checkBoxProfiling->Checked);
         SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxProfiling : nullptr);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
         checkBoxProfiling->Checked = RuntimeConfig::GetInstance().GetProfiling();
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxTraceFileMaxSize_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->GlobalRuntimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     PrintTextCallback("Set TraceFileMaxSize to " + textBoxTraceFileMaxSize->Text);
  
     try
     {
         RuntimeConfig::GetInstance().SetTraceFileMaxSize(System::Convert::ToInt32(textBoxTraceFileMaxSize->Text));
         SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->textBoxTraceFileMaxSize : nullptr, textBoxTraceFileMaxSize);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
         textBoxTraceFileMaxSize->Text = RuntimeConfig::GetInstance().GetTraceFileMaxSize().ToString();
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxProfilingSize_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->GlobalRuntimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     PrintTextCallback("Set ProfilingFileMaxSize to " + textBoxProfilingSize->Text->Trim());
  
     try
     {
         RuntimeConfig::GetInstance().SetProfilingMaxFileSize(System::Convert::ToUInt32(textBoxProfilingSize->Text));
         SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->textBoxProfilingSize : nullptr, textBoxProfilingSize);
     }
  
     catch (System::Exception^ ex)
     {
         PrintException(ex);
         textBoxProfilingSize->Text = RuntimeConfig::GetInstance().GetProfilingMaxFileSize().ToString();
     }
 }
  
 System::Void SampleForm::textBoxTraceFileMaxCount_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (piml->GlobalRuntimeManager == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     PrintTextCallback("Set TraceFileMaxCount to " + textBoxTraceFileMaxCount->Text);
  
     try
     {
         RuntimeConfig::GetInstance().SetTraceFileMaxCount(System::Convert::ToInt32(textBoxTraceFileMaxCount->Text));
         SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->textBoxTraceFileMaxCount : nullptr,
             textBoxTraceFileMaxCount);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
         textBoxTraceFileMaxCount->Text = RuntimeConfig::GetInstance().GetTraceFileMaxCount().ToString();
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::WebServerTimer_Tick(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     UpdateWebServerButtonCallback();
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateWebServerButtonCallback()
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action(this, &SampleForm::UpdateWebServerButtonCallback));
         REFAPP_END_METHOD();
         return;
     }
     if (piml->CustomScreenImplementation == nullptr)
     {
         buttonStartStopWebServer->Enabled = false;
         REFAPP_END_METHOD();
         return;
     }
  
     buttonStartStopWebServer->Enabled = true;
 #pragma region C++ for initialize resource
     System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
 #pragma endregion
     if (Custom::DefaultCustomScreenImplementation::IsStartedHtmlWebserver()) // Has Start  WebServer
     {
         if (piml->IsStartWebSever == 1 || resources == nullptr)
         {
             REFAPP_END_METHOD();
             return;
         }
  
         if (Util::Util::IsInstance<System::Object^>(resources->GetObject(L"StopWebServer.image")))
         {
             buttonStartStopWebServer->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"StopWebServer.image")));
             piml->IsStartWebSever = 1;
         }
     }
     else
     {
         if (piml->IsStartWebSever == 0 || resources == nullptr)
         {
             REFAPP_END_METHOD();
             return;
         }
  
         if (Util::Util::IsInstance<System::Object^>(resources->GetObject(L"StartWebServer.image")))
         {
             buttonStartStopWebServer->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"StartWebServer.image")));
             piml->IsStartWebSever = 0;
         }
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonStartStopWebServer_Click(System::Object^ sender, System::EventArgs^ e)
 {
     StartStopWebServerCallback();
 }
  
 void SampleForm::StartStopWebServerCallback()
 {
     REFAPP_START_METHOD();
     if (InvokeRequired)
     {
         Invoke(gcnew System::Action(this, &SampleForm::StartStopWebServerCallback));
         REFAPP_END_METHOD();
         return;
     }
  
     if (piml->CustomScreenImplementation == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (Custom::DefaultCustomScreenImplementation::IsStartedHtmlWebserver() == false) // No Start WebServer
     {
         piml->CustomScreenImplementation->StartHtmlWebServer();
     }
     else
     {
         piml->CustomScreenImplementation->StopHtmlWebServer();
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonLicense_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     LicenseForm^ form = gcnew LicenseForm();
     form->SetParentForm(this);
     if (form != nullptr)
     {
         form->ShowDialog(this);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::ReloadRuntimeManager()
 {
     REFAPP_START_METHOD();
     try
     {
         // Reason: See #15223. Only implement at Sample Dotnet
         //std::string licenseKeyFromOTForOTPLicense = OpenTestSystem::Common::LicensingV5::Util->CreateLicenseKeyFromOTForOTPLicense();
         //if (!licenseKeyFromOTForOTPLicense.empty()&&LicenseUtil::Util::CheckLicenesFormat(licenseKeyFromOTForOTPLicense))
         //{
         //  OpenTestSystem::Otx::Runtime::Api::License::LicenseManager::SetLicenseKey(licenseKeyFromOTForOTPLicense);
         //}
  
         piml->IpcInitializedBefore = "Reloading RuntimeManager";
         piml->GlobalRuntimeManager = CreateRuntimeManager();
  
         // TODO: update GUI if license is not valid
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
         PrintTextCallback("No RuntimeManager created");
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
         PrintTextCallback("No RuntimeManager created");
     }
     REFAPP_END_METHOD();
 }
  
 #pragma region C++ for Invoke inside DoCyclic
 void SampleForm::ReloadContextFileCallback(CLRWrapper<std::shared_ptr<IRuntimeManager>>^ clrRuntimeManager)
 {
     REFAPP_START_METHOD();
     if (checkBoxNewRuntimeManager->Checked)
     {
         LoadContextFile(clrRuntimeManager->GetPtr());
     }
     REFAPP_END_METHOD();
 }
 #pragma endregion
  
 #pragma region C++
 IRuntimeContext* SampleForm::GetRuntimeContext(long long runtimeId)
 {
     REFAPP_START_METHOD();
     for (int i = 0; i < piml->RuntimeContexts.size(); i++)
     {
         if (piml->RuntimeContexts[i]->GetRuntimeId() == runtimeId)
         {
             REFAPP_END_METHOD();
             return piml->RuntimeContexts[i];
         }
     }
     REFAPP_END_METHOD();
     return nullptr;
 }
  
 void SampleForm::SetInstanceName(System::String^ instanceName)
 {
     REFAPP_START_METHOD();
     if (System::String::IsNullOrEmpty(instanceName) == false)
     {
         piml->Title = Util::Util::ToString(instanceName);
     }
     else
     {
         piml->Title = SampleConstants::MAIN_INSTANCE_NAME;
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetCreatorForm(SampleForm^ creatorForm)
 {
     piml->CreatorForm = creatorForm;
 }
 #pragma endregion
  
  
 #pragma region C++ for RAW-mode
 std::shared_ptr<IRuntimeManager> SampleForm::CreateRawRuntimeManager()
 {
     REFAPP_START_METHOD();
     std::shared_ptr<IRuntimeManager> runtimeManager = nullptr;
     System::String^ ipcTypeString = "";
     if (comboBoxDiagIpcType->SelectedItem != nullptr)
     {
         ipcTypeString = comboBoxDiagIpcType->SelectedItem->ToString()->Trim();
     }
     IpcTypes ipcType = Util::Util::ToIpcType(ipcTypeString);
     std::string licenseKey;
     std::shared_ptr<Otx::DiagManager::OtxDiagApi::IOtxDiag> rawOtxDiag = nullptr;
     unsigned short diagPort;
     std::string inforRuntimeManagerCurrent;
  
     switch (ipcType)
     {
     case OpenTestSystem::Otx::Runtime2::Api::Sample::Raw:
  
         comboBoxODXProject->Items->Clear();
         comboBoxODXVehicle->Items->Clear();
  
         licenseKey = Util::Util::ToString(textBoxDiagManagerLicenseKey->Text);
  
         inforRuntimeManagerCurrent = "ipcRaw-diagIPCRaw with licenseKey=" + licenseKey;
         if (piml->IpcInitializedBefore._Equal(inforRuntimeManagerCurrent))
         {
             REFAPP_END_METHOD();
             return runtimeManager;
         }
         else
         {
             piml->IpcInitializedBefore = inforRuntimeManagerCurrent;
         }
  
         rawOtxDiag = Util::OtxDiagUtil::RawOtxDiag(licenseKey);
         runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(rawOtxDiag);
  
         InitializeODXProject();
  
         break;
     case OpenTestSystem::Otx::Runtime2::Api::Sample::Socket:
  
         diagPort = System::Convert::ToUInt16(textBoxDiagPortPipe->Text);
  
         inforRuntimeManagerCurrent = "ipcRaw-diagIPCSocket with port=" + std::to_string(diagPort);
         if (piml->IpcInitializedBefore._Equal(inforRuntimeManagerCurrent))
         {
             REFAPP_END_METHOD();
             return runtimeManager;
         }
         else
         {
             piml->IpcInitializedBefore = inforRuntimeManagerCurrent;
         }
  
         runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(diagPort);
  
         break;
     case OpenTestSystem::Otx::Runtime2::Api::Sample::Pipe:
  
         inforRuntimeManagerCurrent = "ipcRaw-diagIPCPipe  with pipe=" + Util::Util::ToString(textBoxDiagPortPipe->Text);
         if (piml->IpcInitializedBefore._Equal(inforRuntimeManagerCurrent))
         {
             REFAPP_END_METHOD();
             return runtimeManager;
         }
         else
         {
             piml->IpcInitializedBefore = inforRuntimeManagerCurrent;
         }
 #pragma endregion
  
         runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(Util::Util::ToString(textBoxDiagPortPipe->Text));
  
         break;
     }
  
     REFAPP_END_METHOD();
     return runtimeManager;
 }
  
 System::Void SampleForm::comboBoxODXProject_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         System::String^ stringOdxProject = comboBoxODXProject->SelectedItem->ToString();
         comboBoxODXVehicle->Items->Clear();
         std::shared_ptr<Otx::DiagManager::OtxDiagApi::IOtxDiag> rawOtxDiag = Util::OtxDiagUtil::RawOtxDiag();
         if (rawOtxDiag != nullptr && rawOtxDiag->GetDiagConfiguration() != nullptr && System::String::IsNullOrEmpty(stringOdxProject) == false)
         {
             std::string odxProject = Util::Util::ToString(comboBoxODXProject->SelectedItem->ToString());
             rawOtxDiag->GetDiagConfiguration()->SelectProject(odxProject);
  
             std::vector<std::string> odxVehicles = rawOtxDiag->GetDiagConfiguration()->GetDbVehicleInformationList();
  
             std::string vehicleSetting = Setting::UserSettings::GetInstance().GetOdxVehicleInformation();
  
             for (size_t i = 0; i < odxVehicles.size(); i++)
             {
                 std::string odxVehicle = odxVehicles[i];
                 comboBoxODXVehicle->Items->Add(Util::Util::ToString(odxVehicle));
  
                 if (vehicleSetting._Equal(odxVehicle))
                 {
                     comboBoxODXVehicle->SelectedIndex = i;
                 }
             }
  
             if (comboBoxODXVehicle->SelectedIndex == -1)
             {
                 comboBoxODXVehicle->SelectedIndex = 0;
             }
         }
         else
         {
             comboBoxODXVehicle->Items->Add("");
             comboBoxODXVehicle->SelectedIndex = 0;
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::comboBoxODXVehicle_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     try
     {
         System::String^ stringOdxVehicle = comboBoxODXVehicle->SelectedItem->ToString()->Trim();
         std::shared_ptr<Otx::DiagManager::OtxDiagApi::IOtxDiag> rawOtxDiag = Util::OtxDiagUtil::RawOtxDiag();
         if (System::String::IsNullOrEmpty(stringOdxVehicle) == false && rawOtxDiag != nullptr)
         {
             rawOtxDiag->GetDiagConfiguration()->SelectVehicleInformation(Util::Util::ToString(stringOdxVehicle));
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::InitializeODXProject()
 {
     REFAPP_START_METHOD();
     comboBoxODXProject->Items->Clear();
  
     try
     {
         std::string licenseKey = Util::Util::ToString(textBoxDiagManagerLicenseKey->Text);
         std::shared_ptr<OpenTestSystem::Otx::DiagManager::OtxDiagApi::IOtxDiag> otxDiag = Util::OtxDiagUtil::RawOtxDiag(licenseKey);
  
         if (otxDiag == nullptr || otxDiag->GetDiagConfiguration() == nullptr)
         {
             REFAPP_END_METHOD();
             return;
         }
  
         std::vector<std::string> dbProjectList = otxDiag->GetDiagConfiguration()->GetDbProjectList();
  
         std::string odxProjectSetting = Setting::UserSettings::GetInstance().GetOdxProject();
         for (size_t i = 0; i < dbProjectList.size(); i++)
         {
             std::string dbProject = dbProjectList[i];
             comboBoxODXProject->Items->Add(Util::Util::ToString(dbProject));
  
             if (odxProjectSetting._Equal(dbProject))
             {
                 comboBoxODXProject->SelectedIndex = i;
             }
         }
  
         if (comboBoxODXProject->SelectedIndex == -1)
         {
             comboBoxODXProject->SelectedIndex = 0;
         }
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     REFAPP_END_METHOD();
 }
  
 void SampleForm::SetupDiagManagerControls()
 {
     REFAPP_START_METHOD();
     // move to line of diag ipc type
     portPipeLabel->Location = System::Drawing::Point(Width - 324, 65);
     textBoxDiagPortPipe->Location = System::Drawing::Point(Width - 221, 62);
     textBoxDiagPortPipe->Size = System::Drawing::Size(181, 22);
  
     // initialize default value of related controls
  
     if (comboBoxDiagIpcType->Items->Count == 0)
     {
         comboBoxDiagIpcType->Items->AddRange(Util::Util::ArrayIpcTypes2String());
         comboBoxDiagIpcType->SelectedItem = Util::Util::ToString(Setting::UserSettings::GetInstance().GetDiagIpcType());
     }
  
     if (comboBoxDiagManagerTraceLevel->Items->Count == 0)
     {
         comboBoxDiagManagerTraceLevel->Items->AddRange(Util::Util::ArrayDiagLoggerLevels2String());
         comboBoxDiagManagerTraceLevel->SelectedItem = Util::Util::ToString(Setting::UserSettings::GetInstance().GetDiagManagerTraceLevel());
     }
  
     if (comboBoxDiagLoggingTraceLevel->Items->Count == 0)
     {
         comboBoxDiagLoggingTraceLevel->Items->AddRange(Util::Util::ArrayDiagnosticLogLevels2String());
         comboBoxDiagLoggingTraceLevel->SelectedItem = Util::Util::ToString(Setting::UserSettings::GetInstance().GetDiagLoggingTraceLevel());
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::comboBoxDiagIpcType_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     labelOdxProject->Hide();
     comboBoxODXProject->Hide();
     labelODXVehicle->Hide();
     comboBoxODXVehicle->Hide();
  
     portPipeLabel->Hide();
     textBoxDiagPortPipe->Hide();
  
     textBoxDiagManagerLicenseKey->Enabled = false;
     comboBoxDiagManagerTraceLevel->Enabled = false;
     checkBoxIncludedDiagLogging->Enabled = false;
     comboBoxDiagLoggingTraceLevel->Enabled = false;
     textBoxDiagManagerTraceFolder->Enabled = false;
     buttonOpenDiagLoggingTraceFolder->Enabled = false;
     buttonBrowseDiagLoggingTraceFolder->Enabled = false;
  
     IpcTypes diagIpcType = Util::Util::ToIpcType(comboBoxDiagIpcType->SelectedItem->ToString());
     switch (diagIpcType)
     {
     case IpcTypes::Raw:
  
         labelOdxProject->Show();
         comboBoxODXProject->Show();
         labelODXVehicle->Show();
         comboBoxODXVehicle->Show();
  
         textBoxDiagManagerLicenseKey->Enabled = true;
         comboBoxDiagManagerTraceLevel->Enabled = true;
         checkBoxIncludedDiagLogging->Enabled = true;
         comboBoxDiagLoggingTraceLevel->Enabled = checkBoxIncludedDiagLogging->Checked;
         textBoxDiagManagerTraceFolder->Enabled = true;
         buttonOpenDiagLoggingTraceFolder->Enabled = true;
         buttonBrowseDiagLoggingTraceFolder->Enabled = true;
  
         InitializeODXProject();
         break;
  
     case IpcTypes::Socket:
  
         portPipeLabel->Show();
         portPipeLabel->Text = "DiagManager Ports";
  
         textBoxDiagPortPipe->Show();
         textBoxDiagPortPipe->Text = piml->DefaultDiagPort.ToString();
         textBoxDiagPortPipe->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxPortPipe_TextChanged);
  
         break;
  
     case IpcTypes::Pipe:
  
         portPipeLabel->Show();
         portPipeLabel->Text = "DiagManager Pipes";
  
         textBoxDiagPortPipe->Show();
         textBoxDiagPortPipe->Text = Util::Util::ToString(piml->DefaultDiagPipeName);
         textBoxDiagPortPipe->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxPortPipe_TextChanged);
  
         break;
  
     }
  
     piml->GlobalRuntimeManager = CreateRuntimeManager();
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::checkBoxIncludedDiagLogging_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     comboBoxDiagLoggingTraceLevel->Enabled = checkBoxIncludedDiagLogging->Checked;
  
     UpdateDiagLogging();
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonOpenDiagLoggingTraceFolder_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::String^ path = textBoxDiagManagerTraceFolder->Text;
     if (System::IO::Directory::Exists(path))
     {
         System::Diagnostics::Process::Start(path);
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::buttonBrowseDiagLoggingTraceFolder_Click(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     folderBrowserDialog1->SelectedPath = textBoxDiagManagerTraceFolder->Text;
     folderBrowserDialog1->ShowNewFolderButton = true;
  
     System::Windows::Forms::DialogResult result = folderBrowserDialog1->ShowDialog();
     if (result == System::Windows::Forms::DialogResult::OK)
     {
         textBoxDiagManagerTraceFolder->Text = folderBrowserDialog1->SelectedPath;
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxDiagManagerLicenseKey_KeyDown(System::Object^ sender, System::Windows::Forms::KeyEventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     if (e->KeyCode == System::Windows::Forms::Keys::Delete || e->KeyCode == System::Windows::Forms::Keys::Back)
     {
         textBoxDiagManagerLicenseKey->Clear();
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::textBoxDiagManagerLicenseKey_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     System::Windows::Forms::TextBox^ textBox = dynamic_cast<System::Windows::Forms::TextBox^>(sender);
     System::String^ inputRemoveHyphen = textBox->Text->Replace("-", "");
  
     System::Text::StringBuilder^ formattedLicenseKey = gcnew System::Text::StringBuilder();
     for (int i = 0; i < inputRemoveHyphen->Length; i++)
     {
         formattedLicenseKey->Append(inputRemoveHyphen[i]);
         if ((i + 1) % 5 == 0 && i + 1 < inputRemoveHyphen->Length)
         {
             formattedLicenseKey->Append("-");
         }
     }
  
     textBoxDiagManagerLicenseKey->Text = formattedLicenseKey->ToString();
     textBoxDiagManagerLicenseKey->SelectionStart = textBoxDiagManagerLicenseKey->Text->Length;
  
     std::string licenseKey = Util::Util::ToString(textBoxDiagManagerLicenseKey->Text);
     if (Util::LicenseUtil::CheckLicenseFormat(licenseKey))
     {
         this->piml->ErrorProvider->Clear();
         try
         {
             std::shared_ptr<OpenTestSystem::Otx::DiagManager::OtxDiagApi::IOtxDiag> otxDiag = Util::OtxDiagUtil::RawOtxDiag(licenseKey);
             InitializeODXProject();
  
             if (Util::OtxDiagUtil::RawOtxDiag() != nullptr)
             {
                 piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, "");
             }
         }
         catch (const std::exception& ex)
         {
             piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, Util::Util::ToString(ex.what()));
         }
         catch (System::Exception^ ex)
         {
             piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, ex->Message);
         }
         catch (...)
         {
             piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, "License key invalid.");
         }
  
         try
         {
             piml->GlobalRuntimeManager = CreateRuntimeManager();
         }
         catch (const std::exception& ex)
         {
             PrintException(ex);
         }
         catch (System::Exception^ ex)
         {
             PrintException(ex);
         }
     }
     else
     {
         this->piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, "License key does not match the desired format XXXXX-XXXXX-XXXXX-XXXXX-XXXXX.");
         this->comboBoxODXProject->Items->Clear();
         this->comboBoxODXProject->Items->Add("");
         this->comboBoxODXProject->SelectedIndex = 0;
     }
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::comboBoxDiagManagerTraceLevel_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false || Util::OtxDiagUtil::RawOtxDiag() == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     OpenTestSystem::Otx::DiagManager::Common::ILog::Level loggerLevel = Util::Util::ToLoggerLevel(comboBoxDiagManagerTraceLevel->SelectedItem->ToString());
  
     Util::OtxDiagUtil::SetLevelLogger(loggerLevel);
     PrintTextCallback("Updated trace level");
     REFAPP_END_METHOD();
 }
  
 void SampleForm::UpdateDiagLogging()
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false || Util::OtxDiagUtil::RawOtxDiag() == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     try
     {
         System::String^ stringDiagTraceFolder = textBoxDiagManagerTraceFolder->Text->Trim();
         std::string diagTraceFolder = System::String::IsNullOrEmpty(stringDiagTraceFolder) ? "" : Util::Util::ToString(stringDiagTraceFolder);
         int logLevel = Util::OtxDiagUtil::GetDiagnosticLogLevelDefault();
  
         if (checkBoxIncludedDiagLogging->Checked && comboBoxDiagLoggingTraceLevel->SelectedItem != nullptr)
         {
             logLevel = Util::Util::ToDiagDiagnosticsLogLevel(comboBoxDiagLoggingTraceLevel->SelectedItem->ToString());
         }
  
         Util::OtxDiagUtil::SetDiagDiagnosticLogging(logLevel, diagTraceFolder);
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     catch (...) {}
     REFAPP_END_METHOD();
 }
  
 System::Void SampleForm::comboBoxDiagLoggingTraceLevel_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
 {
     if (IsDiagIpcRaw() == false)
     {
         return;
     }
  
     UpdateDiagLogging();
 }
  
 System::Void SampleForm::textBoxDiagManagerTraceFolder_TextChanged(System::Object^ sender, System::EventArgs^ e)
 {
     REFAPP_START_METHOD();
     if (IsDiagIpcRaw() == false || Util::OtxDiagUtil::RawOtxDiag() == nullptr)
     {
         REFAPP_END_METHOD();
         return;
     }
  
     try
     {
         std::string diagTraceFolder = Util::Util::ToString(textBoxDiagManagerTraceFolder->Text);
  
         Util::OtxDiagUtil::SetPathLogger(diagTraceFolder);
         UpdateDiagLogging();
         PrintTextCallback("Updated DiagManager trace folder");
     }
     catch (const std::exception& ex)
     {
         PrintException(ex);
     }
     catch (System::Exception^ ex)
     {
         PrintException(ex);
     }
     catch (...) {}
     REFAPP_END_METHOD();
 }
  
 bool SampleForm::IsDiagIpcRaw()
 {
     REFAPP_START_METHOD();
     bool result = false;
     System::String^ ipcValue, ^ ipcDiagValue;
  
     try
     {
         if (Util::Util::IsInstance<System::Windows::Forms::ComboBox^>(comboBoxIpcType) &&
             Util::Util::IsInstance<System::Windows::Forms::ComboBox^>(comboBoxDiagIpcType) &&
             comboBoxIpcType->SelectedItem != nullptr &&
             comboBoxDiagIpcType->SelectedItem != nullptr)
         {
             ipcValue = comboBoxIpcType->SelectedItem->ToString();
             ipcDiagValue = comboBoxDiagIpcType->SelectedItem->ToString();
             result = Util::Util::ToIpcType(ipcValue) == IpcTypes::Raw && Util::Util::ToIpcType(ipcDiagValue) == IpcTypes::Raw;
         }
     }
     catch (...) {}
     REFAPP_END_METHOD();
     return result;
 }
 #pragma endregion

Code Example Header-File

Code example (.\otxruntime\ReferenceApplication\src\Gui\SampleForm.h) of the OTX-Runtime API Sample Program.

 #pragma once
  
 #include "CustomImplTypes.h"
 #include "IRuntimeManager.h"
 #include "CLRWrapper.h"
  
 #include <Project/IProject.h>
 #include <Otx/IPackage.h>
 #include <Otx/IDocument.h>
 #include <Otx/IProcedure.h>
 #include <KeyEventArgs.h>
 #include <Exceptions/Exception.h>
 using namespace OpenTestSystem::Otx::Runtime::Api;
  
 #include <memory>
  
 namespace OpenTestSystem { namespace Otx { namespace Runtime2 { namespace Api { namespace Sample {
  
     struct SampleFormImpl;
  
     public ref class SampleForm : public System::Windows::Forms::Form
     {
     public:
         SampleForm(void)
         {
             InitializeComponent();
             //
             //TODO: Add the constructor code here
             //
             InitializeInternalComponent();
         }
         SampleForm(System::String^ title, SampleForm^ createForm);
  
     protected:
         ~SampleForm()
         {
             if (components)
             {
                 delete components;
             }
  
             if (piml)
             {
                 delete piml;
             }
         }
  
     private: System::Windows::Forms::Panel^ panel1;
     private: System::Windows::Forms::Button^ buttonBrowseFile;
     private: System::Windows::Forms::ComboBox^ cbFilePath;
     private: System::Windows::Forms::Label^ label1;
     private: System::Windows::Forms::Panel^ panel2;
     private: System::Windows::Forms::OpenFileDialog^ openFileDialog1;
     private: System::Windows::Forms::TextBox^ txtPassword;
     private: System::Windows::Forms::Label^ passwordLabel;
     private: System::Windows::Forms::SplitContainer^ splitContainer1;
     private: System::Windows::Forms::TreeView^ treeViewOtxProject;
     private: System::Windows::Forms::Label^ label3;
     private: System::Windows::Forms::DataGridView^ gridViewParameter;
     private: System::Windows::Forms::Label^ labelAdjustProcedureParameters;
     private: System::Windows::Forms::Button^ buttonExecuteSelectedProcedure;
     private: System::Windows::Forms::Button^ buttonReload;
     private: System::Windows::Forms::SplitContainer^ splitContainer2;
     private: System::Windows::Forms::SplitContainer^ splitContainer3;
     private: System::Windows::Forms::Label^ label4;
     private: System::Windows::Forms::DataGridView^ gridViewContext;
     private: System::Windows::Forms::Label^ label5;
     private: System::Windows::Forms::DataGridView^ gridViewState;
     private: System::Windows::Forms::SplitContainer^ splitContainer4;
     private: System::Windows::Forms::ComboBox^ comboBoxTraceLevel;
     private: System::Windows::Forms::Label^ label8;
     private: System::Windows::Forms::Label^ label6;
     private: System::Windows::Forms::TextBox^ textBoxTraceFolder;
     private: System::Windows::Forms::Label^ label9;
     private: System::Windows::Forms::Button^ buttonBrowseTraceFolder;
     private: System::Windows::Forms::ComboBox^ comboBoxIpcType;
     private: System::Windows::Forms::Label^ label11;
     private: System::Windows::Forms::Label^ label10;
     private: System::Windows::Forms::Label^ portPipeLabel;
     private: System::Windows::Forms::TextBox^ textBoxRtPortPipe;
     private: System::Windows::Forms::Button^ buttonExecuteMain;
     private: System::Windows::Forms::Button^ buttonStop;
     private: System::Windows::Forms::CheckBox^ checkBoxCyclicExecution;
     private: System::Windows::Forms::CheckBox^ checkBoxAsyncExecution;
     private: System::Windows::Forms::Button^ buttonNewInstanceNewThread;
     private: System::Windows::Forms::Button^ buttonNewInstance;
     private: System::Windows::Forms::Label^ labelOutputOverflow;
     private: System::Windows::Forms::Button^ buttonCopyRow;
     private: System::Windows::Forms::Button^ buttonClearOutput;
     private: System::Windows::Forms::ListBox^ listBoxOuput;
     private: System::Windows::Forms::FolderBrowserDialog^ folderBrowserDialog1;
     private: System::Windows::Forms::ImageList^ imageList1;
     private: System::Windows::Forms::SplitContainer^ splitContainer5;
     private: System::Windows::Forms::GroupBox^ groupBox1;
     private: System::Windows::Forms::RadioButton^ radioButtonDefaultImplementation;
     private: System::Windows::Forms::RadioButton^ radioButtonOuputWindow;
     private: System::Windows::Forms::RadioButton^ radioButtonNoCustomImplementation;
     private: System::Windows::Forms::Panel^ panel3;
     private: System::Windows::Forms::Panel^ panel4;
     private: System::Windows::Forms::Button^ buttonWriteSettings;
     private: System::Windows::Forms::Button^ buttonReadSettings;
     private: System::Windows::Forms::DataGridView^ gridViewSettings;
     private: System::Windows::Forms::Label^ label12;
     private: System::Windows::Forms::CheckBox^ buttonHmi;
     private: System::Windows::Forms::CheckBox^ checkBoxCyclicReload;
     private: System::Windows::Forms::Label^ label13;
     private: System::Windows::Forms::Label^ label15;
     private: System::Windows::Forms::Label^ label14;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnSettingName;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnSettingValue;
     private: System::Windows::Forms::CheckBox^ checkBoxAdd2Output;
     private: System::Windows::Forms::CheckBox^ checkBoxNewRuntimeManager;
     private: System::Windows::Forms::TextBox^ textBoxRuntimeContextName;
     private: System::Windows::Forms::Label^ runtimeNameLabel;
     private: System::Windows::Forms::CheckBox^ buttonPause;
     private: System::Windows::Forms::CheckBox^ checkBoxIgnition;
     private: System::Windows::Forms::CheckBox^ checkBoxUseConnectionState;
     private: System::Windows::Forms::TextBox^ textBoxVoltageThreshold;
     private: System::Windows::Forms::Label^ labelVoltageThreshold;
     private: System::Windows::Forms::TextBox^ textBoxPollingTime;
     private: System::Windows::Forms::Label^ labelPollingTime;
     private: System::Windows::Forms::Label^ labelTimeout;
     private: System::Windows::Forms::TextBox^ textBoxTimeout;
     private: System::Windows::Forms::TextBox^ textBoxDiagPortPipe;
     private: System::Windows::Forms::Button^ buttonOpenTraceFolder;
     private: System::Windows::Forms::Label^ labelSeparator2;
     private: System::Windows::Forms::Label^ labelProcedureExecutionState;
     private: System::Windows::Forms::TableLayoutPanel^ tableLayoutPanelExecutionState;
     private: System::Windows::Forms::Label^ label18;
     private: System::Windows::Forms::Label^ labelExpectedState;
     private: System::Windows::Forms::Label^ labelSeparator3;
     private: System::Windows::Forms::Label^ labelSeparator4;
     private: System::Windows::Forms::Label^ labelSeparator1;
     private: System::Windows::Forms::Label^ labelBatteryState;
     private: System::Windows::Forms::Label^ labelIconProcedureExecutionState;
     private: System::Windows::Forms::Button^ buttonCheckBatteryIgnition;
     private: System::Windows::Forms::Label^ labelIgnitionState;
     private: System::Windows::Forms::CheckBox^ checkBoxStartAllParents;
     private: System::Windows::Forms::TextBox^ textBoxTraceFileMaxSize;
     private: System::Windows::Forms::TextBox^ textBoxTraceFileMaxCount;
     private: System::Windows::Forms::Label^ label2;
     private: System::Windows::Forms::Timer^ updateGuiTimer;
     private: System::Windows::Forms::Label^ labelSeparator5;
     private: System::Windows::Forms::Label^ labelProcedureExecutionTimes;
     private: System::Windows::Forms::ToolTip^ toolTip1;
     private: System::Windows::Forms::Button^ buttonStartStopWebServer;
     private: System::Windows::Forms::Button^ buttonLicense;
     private: System::ComponentModel::IContainer^ components;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnName;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnDirection;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnDataType;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnValue;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnDetails;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnContextName;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnContextDataType;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnContextValue;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnContextDetails;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnStateName;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnStateDataType;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnStateValue;
     private: System::Windows::Forms::DataGridViewTextBoxColumn^ dataGridViewTextBoxColumnStateDetails;
     private: System::Windows::Forms::ComboBox^ comboBoxODXProject;
     private: System::Windows::Forms::ComboBox^ comboBoxODXVehicle;
     private: System::Windows::Forms::Label^ labelDiagType;
     private: System::Windows::Forms::Label^ labelOdxProject;
     private: System::Windows::Forms::Label^ labelODXVehicle;
     private: System::Windows::Forms::Label^ label7;
     private: System::Windows::Forms::ComboBox^ comboBoxDiagIpcType;
     private: System::Windows::Forms::CheckBox^ checkBoxIncludedDiagLogging;
     private: System::Windows::Forms::ComboBox^ comboBoxDiagManagerTraceLevel;
     private: System::Windows::Forms::Label^ label16;
     private: System::Windows::Forms::TextBox^ textBoxDiagManagerLicenseKey;
     private: System::Windows::Forms::ComboBox^ comboBoxDiagLoggingTraceLevel;
     private: System::Windows::Forms::Label^ label17;
     private: System::Windows::Forms::TextBox^ textBoxDiagManagerTraceFolder;
     private: System::Windows::Forms::Label^ label19;
     private: System::Windows::Forms::Button^ buttonBrowseDiagLoggingTraceFolder;
     private: System::Windows::Forms::Button^ buttonOpenDiagLoggingTraceFolder;
     private: System::Windows::Forms::TextBox^ textBoxProfilingSize;
     private: System::Windows::Forms::CheckBox^ checkBoxProfiling;
  
     protected:
  
     private:
         SampleFormImpl* piml;
  
         void RegisterSettingsEvent();
         void InitializeInternalComponent();
         void CreateCustomImpl();
         void CreateDefaultCustomImpl();
         void CreateOutputWindowCustomImpl();
         void InitializeSampleDefaultValues();
         void LoadSetting();
         void AddComboBoxFileOrPath(System::Windows::Forms::ComboBox^ comboBox);
         void SetupTraceLevel();
         void SetupTraceFolder();
         void SetupTraceFileProfilerMaxCountAndSize();
         void SetupDefaultPortAndPipeName();
         void SetupCustomImplType();
         void SetupWindowSize();
         void SetupWindowLocation();
         bool CheckFormIsInBound(System::Drawing::Point location);
         void SetupTimeOut();
         void SetupPollingTime();
         void SetupVoltageThreshold();
         void UpdateWebServerButtonCallback();
         void SetRuntimeContextName();
         void SetTitle(System::String^ title);
         void SetLocation(SampleForm^ creatorForm);
         void PrintException(System::Exception^ ex);
         void PrintException(System::Exception^ ex, System::String^ additionalText);
         void PrintException(const std::exception& ex);
         void PrintException(const std::exception& ex, System::String^ additionalText);
         std::shared_ptr<IRuntimeManager> CreateRuntimeManager();
         std::shared_ptr<IRuntimeManager> CreateRawRuntimeManager();
         std::shared_ptr<IRuntimeManager> CreateSocketRuntimeManager();
         std::shared_ptr<IRuntimeManager> CreatePipeRuntimeManager();
         bool NoDiag();
         void InitializeRuntimeEvents(std::shared_ptr<IRuntimeManager> runtimeManager);
         void SetCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager);
         CustomImplTypes GetCurrentCustomImpl();
         void SetOutputWindowImplementation(std::shared_ptr<IRuntimeManager> runtimeManager);
         void SetDefaultCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager);
         void RemoveCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager);
         System::String^ GetTimeAndDurationStringSinceLastTimeAndUpdateLastTime();
         void EnableConnectionState();
         void SyncWithParent(System::Object^ parentControl);
         void SyncWithParent(System::Object^ parentControl, System::Object^ control);
         void SyncWithParent(System::Object^ parentControl, System::Object^ control, bool newThread);
         void ParentButtonClickCallback(System::Object^ state);
         void TextBoxSetTextCallback(cli::array<System::Object^>^ arr);
         void ParentTextBoxSetTextCallback(System::Object^ state);
         void CheckBoxSetCheckStateCallback(cli::array<System::Object^>^ arr);
         void ParentCheckBoxSetCheckStateCallback(System::Object^ state);
         void ComboBoxSetIndexCallback(cli::array<System::Object^>^ arr);        
         void ParentComboBoxSetIndexCallback(System::Object^ state);     
         void NumericUpDownSetValueCallback(cli::array<System::Object^>^ arr);
         void ParentNumericUpDownSetValueCallback(System::Object^ state);
         System::String^ IpcPortPipeString();
         void LoadContextFile(std::shared_ptr<IRuntimeManager> runtimeManager);
         void ReloadContextFileCallback(CLRWrapper<std::shared_ptr<IRuntimeManager>>^ clrRuntimeManager);
         void ClearSampleGUI();
         std::shared_ptr<Project::IProject> LoadPtx(std::shared_ptr<IRuntimeManager> runtimeManager);
         void ClearCustomImplemetationCaches();
         void LoadPackage(std::shared_ptr<Project::IProject> project);
         System::Windows::Forms::TreeNode^ CreatePackageNode(std::shared_ptr<IPackage> pack);
         System::Windows::Forms::TreeNode^ CreateDocumentNode(std::shared_ptr<IDocument> doc);
         System::Windows::Forms::TreeNode^ CreateProcedureName(std::shared_ptr<IProcedure> proc);
         void ReadSettings(std::map<std::string, std::string> settings);
         std::shared_ptr<Project::IPlayerProject> LoadPpx(std::shared_ptr<IRuntimeManager> runtimeManager);
         System::Void HmiWindow_FormClosing(System::Object^ sender, System::Windows::Forms::FormClosingEventArgs^ e);
         System::Void NewInstanceInThread();
         void ExecuteProcedure();
         void ExecuteProcedureSync(cli::array<System::Object^>^ args);
         void CheckBatteryIgnitionState(std::shared_ptr<IRuntimeManager> runtimeManager);
         void SetBatteryIgnitionState(ClampState batteryState, ClampState ignitionState);
         void UpdateGridView(std::shared_ptr<IProcedure> procedure);
         void UpdateGridviewParameter(std::shared_ptr<IProcedure> procedure);
         void UpdateGridviewParameter(std::shared_ptr<IProcedureParameter> parameter);
         System::String^ ConvertValue2String(std::shared_ptr<DataTypes::Object> value);
         System::String^ GetDetails(std::shared_ptr<DataTypes::Object> value);
         void UpdateGridViewContextVariable(std::shared_ptr<IDocument> document, bool withPrefix, std::vector<std::string>& listItemReviewed);
         void UpdateGridViewStateVariable(std::shared_ptr<IDocument> document, bool withPrefix, std::vector<std::string>& listItemReviewed);
         void DoCyclic(System::Object^ args);
         void CheckCyclicReloadOrNewRuntimeManager(std::shared_ptr<IRuntimeManager> runtimeManager);
         void CheckCyclicReloadOrNewRuntimeManager(std::shared_ptr<IRuntimeManager> runtimeManager, bool waitCyclic);
         void CheckCyclicReloadOrNewRuntimeManagerCallback(cli::array<System::Object^>^ arr);
         void WaitCyclicExecuteAsyncIsProcessing();
         void UpdateButtonStateAfterThrowException();
         void UpdateExecutionStateButtons(bool wasExecuted);
         void UpdatePauseButton(bool pauseAvailable);
         void UpdatePauseButton(bool pauseAvailable, bool enabled);
         void DisplayProcedureExecutionTimes();
         void SaveSettings();
         void SaveSocketPortOrPipeName();
         void SetExpectedState();
         std::shared_ptr<Project::IProject> GetProject(std::shared_ptr<IProcedure> procedure);
         void UpdateExecutionState(IRuntimeContext* context);
         void UpdateExecutionState(IRuntimeContext* context, ExecutionStateChangeReason reason);
         void AddRuntimeContext(IRuntimeContext* context);
         IRuntimeContext* GetRuntimeContext(long long runtimeId);
         void DisplayProcedureExecutionState(IRuntimeContext* context);
         void DisplayProcedureExecutionState(IRuntimeContext* context, System::String^ errorMessage);
         void RemoveRuntimeContext(IRuntimeContext* context);
         void StartStopUpdateGuiTimer();
         void ShowConnectionStateMessage(IRuntimeContext* context);
         std::string ShortenedValueString(std::shared_ptr<DataTypes::Object> value);
         bool IsPauseEnabled();
         bool IsContinueEnable();
  
         void StartStopWebServerCallback();
  
         void InitializeODXProject();
         void SetupDiagManagerControls();
         void UpdateDiagLogging();
         bool IsDiagIpcRaw();
  
     public:
         void PrintTextCallback(System::String^ text);
         void ReloadRuntimeManager();
         void SetInstanceName(System::String^ instanceName);
         void SetCreatorForm(SampleForm^ creatorForm);
  
         void ProcedurePendingCallback(CLRWrapper<IRuntimeContext*>^ clrContext);
         void ProcedureStartedCallback(CLRWrapper<IRuntimeContext*>^ clrContext);
         void ProcedurePaused(IRuntimeContext* context, ExecutionStateChangeReason reason);
         void ProcedurePausedCallback(cli::array<System::Object^>^ arr);
         void ProcedureContinuedCallback(CLRWrapper<IRuntimeContext*>^ clrContext);
         void ProcedureFinishedCallback(CLRWrapper<IRuntimeContext*>^ clrContext);
         void ProcedureStoppedCallback(CLRWrapper<IRuntimeContext*>^ clrContext);
         void ProcedureAbortedCallback(CLRWrapper<IRuntimeContext*>^ clrContext);
         void ProcedureTimeoutCallback(CLRWrapper<IRuntimeContext*>^ clrContext);
         void DiagConnectionStateChanged(ClampState batteryState, ClampState ignitionState);
         void DiagConnectionStateChangedCallback(cli::array<System::Object^>^ arr);
         void InOutParameterValueChanged(IRuntimeContext* context, IProcedureInOutParameter* parameter);
         void InOutParameterValueChangedCallback(cli::array<System::Object^>^ arr);
         void CustomScreenImplementation_KeyDown(std::shared_ptr<Custom::KeyEventArgs> eventArgs);
  
         void ContextVariableRead(std::shared_ptr<IContextVariable> contextVariable, std::shared_ptr<DataTypes::Object> value);
         void ContextVariableReadCallback(cli::array<System::Object^>^ arr);
         void StateVariableValueChanged(std::shared_ptr<IStateVariable> stateVariable, std::shared_ptr<DataTypes::Object> value);
         void StateVariableValueChangedCallback(cli::array<System::Object^>^ arr);
         void UpdateGridViewStateVariable(std::shared_ptr<IStateVariable> stateVariable);
  
     private:
 #pragma region Windows Form Designer generated code
         void InitializeComponent(void)
         {
             this->components = (gcnew System::ComponentModel::Container());
             System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(SampleForm::typeid));
             System::Windows::Forms::DataGridViewCellStyle^ dataGridViewCellStyle1 = (gcnew System::Windows::Forms::DataGridViewCellStyle());
             System::Windows::Forms::DataGridViewCellStyle^ dataGridViewCellStyle2 = (gcnew System::Windows::Forms::DataGridViewCellStyle());
             System::Windows::Forms::DataGridViewCellStyle^ dataGridViewCellStyle3 = (gcnew System::Windows::Forms::DataGridViewCellStyle());
             this->panel1 = (gcnew System::Windows::Forms::Panel());
             this->textBoxProfilingSize = (gcnew System::Windows::Forms::TextBox());
             this->checkBoxProfiling = (gcnew System::Windows::Forms::CheckBox());
             this->buttonBrowseDiagLoggingTraceFolder = (gcnew System::Windows::Forms::Button());
             this->buttonOpenDiagLoggingTraceFolder = (gcnew System::Windows::Forms::Button());
             this->textBoxDiagManagerTraceFolder = (gcnew System::Windows::Forms::TextBox());
             this->label19 = (gcnew System::Windows::Forms::Label());
             this->comboBoxDiagLoggingTraceLevel = (gcnew System::Windows::Forms::ComboBox());
             this->label17 = (gcnew System::Windows::Forms::Label());
             this->checkBoxIncludedDiagLogging = (gcnew System::Windows::Forms::CheckBox());
             this->comboBoxDiagManagerTraceLevel = (gcnew System::Windows::Forms::ComboBox());
             this->label16 = (gcnew System::Windows::Forms::Label());
             this->textBoxDiagManagerLicenseKey = (gcnew System::Windows::Forms::TextBox());
             this->label7 = (gcnew System::Windows::Forms::Label());
             this->comboBoxDiagIpcType = (gcnew System::Windows::Forms::ComboBox());
             this->labelDiagType = (gcnew System::Windows::Forms::Label());
             this->labelOdxProject = (gcnew System::Windows::Forms::Label());
             this->labelODXVehicle = (gcnew System::Windows::Forms::Label());
             this->comboBoxODXVehicle = (gcnew System::Windows::Forms::ComboBox());
             this->comboBoxODXProject = (gcnew System::Windows::Forms::ComboBox());
             this->label2 = (gcnew System::Windows::Forms::Label());
             this->textBoxTraceFileMaxSize = (gcnew System::Windows::Forms::TextBox());
             this->textBoxTraceFileMaxCount = (gcnew System::Windows::Forms::TextBox());
             this->buttonOpenTraceFolder = (gcnew System::Windows::Forms::Button());
             this->textBoxRuntimeContextName = (gcnew System::Windows::Forms::TextBox());
             this->runtimeNameLabel = (gcnew System::Windows::Forms::Label());
             this->textBoxDiagPortPipe = (gcnew System::Windows::Forms::TextBox());
             this->textBoxRtPortPipe = (gcnew System::Windows::Forms::TextBox());
             this->label13 = (gcnew System::Windows::Forms::Label());
             this->portPipeLabel = (gcnew System::Windows::Forms::Label());
             this->comboBoxIpcType = (gcnew System::Windows::Forms::ComboBox());
             this->label11 = (gcnew System::Windows::Forms::Label());
             this->label10 = (gcnew System::Windows::Forms::Label());
             this->buttonBrowseTraceFolder = (gcnew System::Windows::Forms::Button());
             this->textBoxTraceFolder = (gcnew System::Windows::Forms::TextBox());
             this->label9 = (gcnew System::Windows::Forms::Label());
             this->comboBoxTraceLevel = (gcnew System::Windows::Forms::ComboBox());
             this->label8 = (gcnew System::Windows::Forms::Label());
             this->label6 = (gcnew System::Windows::Forms::Label());
             this->buttonReload = (gcnew System::Windows::Forms::Button());
             this->txtPassword = (gcnew System::Windows::Forms::TextBox());
             this->passwordLabel = (gcnew System::Windows::Forms::Label());
             this->buttonBrowseFile = (gcnew System::Windows::Forms::Button());
             this->cbFilePath = (gcnew System::Windows::Forms::ComboBox());
             this->label1 = (gcnew System::Windows::Forms::Label());
             this->textBoxTimeout = (gcnew System::Windows::Forms::TextBox());
             this->labelTimeout = (gcnew System::Windows::Forms::Label());
             this->textBoxVoltageThreshold = (gcnew System::Windows::Forms::TextBox());
             this->labelVoltageThreshold = (gcnew System::Windows::Forms::Label());
             this->textBoxPollingTime = (gcnew System::Windows::Forms::TextBox());
             this->labelPollingTime = (gcnew System::Windows::Forms::Label());
             this->checkBoxIgnition = (gcnew System::Windows::Forms::CheckBox());
             this->checkBoxUseConnectionState = (gcnew System::Windows::Forms::CheckBox());
             this->panel2 = (gcnew System::Windows::Forms::Panel());
             this->buttonLicense = (gcnew System::Windows::Forms::Button());
             this->buttonStartStopWebServer = (gcnew System::Windows::Forms::Button());
             this->buttonHmi = (gcnew System::Windows::Forms::CheckBox());
             this->checkBoxNewRuntimeManager = (gcnew System::Windows::Forms::CheckBox());
             this->label15 = (gcnew System::Windows::Forms::Label());
             this->label14 = (gcnew System::Windows::Forms::Label());
             this->checkBoxCyclicReload = (gcnew System::Windows::Forms::CheckBox());
             this->listBoxOuput = (gcnew System::Windows::Forms::ListBox());
             this->labelOutputOverflow = (gcnew System::Windows::Forms::Label());
             this->buttonCopyRow = (gcnew System::Windows::Forms::Button());
             this->buttonClearOutput = (gcnew System::Windows::Forms::Button());
             this->buttonNewInstanceNewThread = (gcnew System::Windows::Forms::Button());
             this->buttonNewInstance = (gcnew System::Windows::Forms::Button());
             this->checkBoxStartAllParents = (gcnew System::Windows::Forms::CheckBox());
             this->checkBoxAdd2Output = (gcnew System::Windows::Forms::CheckBox());
             this->checkBoxCyclicExecution = (gcnew System::Windows::Forms::CheckBox());
             this->checkBoxAsyncExecution = (gcnew System::Windows::Forms::CheckBox());
             this->buttonPause = (gcnew System::Windows::Forms::CheckBox());
             this->buttonStop = (gcnew System::Windows::Forms::Button());
             this->buttonExecuteMain = (gcnew System::Windows::Forms::Button());
             this->buttonExecuteSelectedProcedure = (gcnew System::Windows::Forms::Button());
             this->openFileDialog1 = (gcnew System::Windows::Forms::OpenFileDialog());
             this->splitContainer1 = (gcnew System::Windows::Forms::SplitContainer());
             this->treeViewOtxProject = (gcnew System::Windows::Forms::TreeView());
             this->label3 = (gcnew System::Windows::Forms::Label());
             this->splitContainer5 = (gcnew System::Windows::Forms::SplitContainer());
             this->splitContainer2 = (gcnew System::Windows::Forms::SplitContainer());
             this->gridViewParameter = (gcnew System::Windows::Forms::DataGridView());
             this->dataGridViewTextBoxColumnName = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnDirection = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnDataType = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnValue = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnDetails = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->labelAdjustProcedureParameters = (gcnew System::Windows::Forms::Label());
             this->splitContainer3 = (gcnew System::Windows::Forms::SplitContainer());
             this->gridViewContext = (gcnew System::Windows::Forms::DataGridView());
             this->dataGridViewTextBoxColumnContextName = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnContextDataType = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnContextValue = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnContextDetails = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->label4 = (gcnew System::Windows::Forms::Label());
             this->gridViewState = (gcnew System::Windows::Forms::DataGridView());
             this->dataGridViewTextBoxColumnStateName = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnStateDataType = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnStateValue = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnStateDetails = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->label5 = (gcnew System::Windows::Forms::Label());
             this->panel3 = (gcnew System::Windows::Forms::Panel());
             this->gridViewSettings = (gcnew System::Windows::Forms::DataGridView());
             this->dataGridViewTextBoxColumnSettingName = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->dataGridViewTextBoxColumnSettingValue = (gcnew System::Windows::Forms::DataGridViewTextBoxColumn());
             this->panel4 = (gcnew System::Windows::Forms::Panel());
             this->label12 = (gcnew System::Windows::Forms::Label());
             this->buttonWriteSettings = (gcnew System::Windows::Forms::Button());
             this->buttonReadSettings = (gcnew System::Windows::Forms::Button());
             this->groupBox1 = (gcnew System::Windows::Forms::GroupBox());
             this->radioButtonNoCustomImplementation = (gcnew System::Windows::Forms::RadioButton());
             this->radioButtonDefaultImplementation = (gcnew System::Windows::Forms::RadioButton());
             this->radioButtonOuputWindow = (gcnew System::Windows::Forms::RadioButton());
             this->splitContainer4 = (gcnew System::Windows::Forms::SplitContainer());
             this->folderBrowserDialog1 = (gcnew System::Windows::Forms::FolderBrowserDialog());
             this->imageList1 = (gcnew System::Windows::Forms::ImageList(this->components));
             this->labelSeparator2 = (gcnew System::Windows::Forms::Label());
             this->labelProcedureExecutionState = (gcnew System::Windows::Forms::Label());
             this->tableLayoutPanelExecutionState = (gcnew System::Windows::Forms::TableLayoutPanel());
             this->labelIconProcedureExecutionState = (gcnew System::Windows::Forms::Label());
             this->labelBatteryState = (gcnew System::Windows::Forms::Label());
             this->labelExpectedState = (gcnew System::Windows::Forms::Label());
             this->labelSeparator3 = (gcnew System::Windows::Forms::Label());
             this->labelSeparator4 = (gcnew System::Windows::Forms::Label());
             this->labelSeparator1 = (gcnew System::Windows::Forms::Label());
             this->buttonCheckBatteryIgnition = (gcnew System::Windows::Forms::Button());
             this->labelIgnitionState = (gcnew System::Windows::Forms::Label());
             this->labelSeparator5 = (gcnew System::Windows::Forms::Label());
             this->labelProcedureExecutionTimes = (gcnew System::Windows::Forms::Label());
             this->label18 = (gcnew System::Windows::Forms::Label());
             this->updateGuiTimer = (gcnew System::Windows::Forms::Timer(this->components));
             this->toolTip1 = (gcnew System::Windows::Forms::ToolTip(this->components));
             this->panel1->SuspendLayout();
             this->panel2->SuspendLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer1))->BeginInit();
             this->splitContainer1->Panel1->SuspendLayout();
             this->splitContainer1->Panel2->SuspendLayout();
             this->splitContainer1->SuspendLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer5))->BeginInit();
             this->splitContainer5->Panel1->SuspendLayout();
             this->splitContainer5->Panel2->SuspendLayout();
             this->splitContainer5->SuspendLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer2))->BeginInit();
             this->splitContainer2->Panel1->SuspendLayout();
             this->splitContainer2->Panel2->SuspendLayout();
             this->splitContainer2->SuspendLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewParameter))->BeginInit();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer3))->BeginInit();
             this->splitContainer3->Panel1->SuspendLayout();
             this->splitContainer3->Panel2->SuspendLayout();
             this->splitContainer3->SuspendLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewContext))->BeginInit();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewState))->BeginInit();
             this->panel3->SuspendLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewSettings))->BeginInit();
             this->panel4->SuspendLayout();
             this->groupBox1->SuspendLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer4))->BeginInit();
             this->splitContainer4->Panel1->SuspendLayout();
             this->splitContainer4->Panel2->SuspendLayout();
             this->splitContainer4->SuspendLayout();
             this->tableLayoutPanelExecutionState->SuspendLayout();
             this->SuspendLayout();
             // 
             // panel1
             // 
             this->panel1->Controls->Add(this->textBoxProfilingSize);
             this->panel1->Controls->Add(this->checkBoxProfiling);
             this->panel1->Controls->Add(this->buttonBrowseDiagLoggingTraceFolder);
             this->panel1->Controls->Add(this->buttonOpenDiagLoggingTraceFolder);
             this->panel1->Controls->Add(this->textBoxDiagManagerTraceFolder);
             this->panel1->Controls->Add(this->label19);
             this->panel1->Controls->Add(this->comboBoxDiagLoggingTraceLevel);
             this->panel1->Controls->Add(this->label17);
             this->panel1->Controls->Add(this->checkBoxIncludedDiagLogging);
             this->panel1->Controls->Add(this->comboBoxDiagManagerTraceLevel);
             this->panel1->Controls->Add(this->label16);
             this->panel1->Controls->Add(this->textBoxDiagManagerLicenseKey);
             this->panel1->Controls->Add(this->label7);
             this->panel1->Controls->Add(this->comboBoxDiagIpcType);
             this->panel1->Controls->Add(this->labelDiagType);
             this->panel1->Controls->Add(this->labelOdxProject);
             this->panel1->Controls->Add(this->labelODXVehicle);
             this->panel1->Controls->Add(this->comboBoxODXVehicle);
             this->panel1->Controls->Add(this->comboBoxODXProject);
             this->panel1->Controls->Add(this->label2);
             this->panel1->Controls->Add(this->textBoxTraceFileMaxSize);
             this->panel1->Controls->Add(this->textBoxTraceFileMaxCount);
             this->panel1->Controls->Add(this->buttonOpenTraceFolder);
             this->panel1->Controls->Add(this->textBoxRuntimeContextName);
             this->panel1->Controls->Add(this->runtimeNameLabel);
             this->panel1->Controls->Add(this->textBoxDiagPortPipe);
             this->panel1->Controls->Add(this->textBoxRtPortPipe);
             this->panel1->Controls->Add(this->label13);
             this->panel1->Controls->Add(this->portPipeLabel);
             this->panel1->Controls->Add(this->comboBoxIpcType);
             this->panel1->Controls->Add(this->label11);
             this->panel1->Controls->Add(this->label10);
             this->panel1->Controls->Add(this->buttonBrowseTraceFolder);
             this->panel1->Controls->Add(this->textBoxTraceFolder);
             this->panel1->Controls->Add(this->label9);
             this->panel1->Controls->Add(this->comboBoxTraceLevel);
             this->panel1->Controls->Add(this->label8);
             this->panel1->Controls->Add(this->label6);
             this->panel1->Controls->Add(this->buttonReload);
             this->panel1->Controls->Add(this->txtPassword);
             this->panel1->Controls->Add(this->passwordLabel);
             this->panel1->Controls->Add(this->buttonBrowseFile);
             this->panel1->Controls->Add(this->cbFilePath);
             this->panel1->Controls->Add(this->label1);
             this->panel1->Dock = System::Windows::Forms::DockStyle::Top;
             this->panel1->Location = System::Drawing::Point(0, 0);
             this->panel1->Name = L"panel1";
             this->panel1->Padding = System::Windows::Forms::Padding(0, 0, 0, 6);
             this->panel1->Size = System::Drawing::Size(1328, 115);
             this->panel1->TabIndex = 0;
             // 
             // textBoxProfilingSize
             // 
             this->textBoxProfilingSize->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             this->textBoxProfilingSize->Location = System::Drawing::Point(391, 30);
             this->textBoxProfilingSize->Name = L"textBoxProfilingSize";
             this->textBoxProfilingSize->Size = System::Drawing::Size(32, 22);
             this->textBoxProfilingSize->TabIndex = 47;
             this->textBoxProfilingSize->Text = L"100";
             this->textBoxProfilingSize->TextAlign = System::Windows::Forms::HorizontalAlignment::Right;
             this->textBoxProfilingSize->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxProfilingSize_TextChanged);
             // 
             // checkBoxProfiling
             // 
             this->checkBoxProfiling->AutoSize = true;
             this->checkBoxProfiling->Location = System::Drawing::Point(296, 32);
             this->checkBoxProfiling->Name = L"checkBoxProfiling";
             this->checkBoxProfiling->RightToLeft = System::Windows::Forms::RightToLeft::Yes;
             this->checkBoxProfiling->Size = System::Drawing::Size(89, 17);
             this->checkBoxProfiling->TabIndex = 46;
             this->checkBoxProfiling->Tag = L"";
             this->checkBoxProfiling->Text = L"Profiling, Size";
             this->checkBoxProfiling->UseVisualStyleBackColor = true;
             this->checkBoxProfiling->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxProfiling_CheckedChanged);
             // 
             // buttonBrowseDiagLoggingTraceFolder
             // 
             this->buttonBrowseDiagLoggingTraceFolder->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonBrowseDiagLoggingTraceFolder->Location = System::Drawing::Point(1298, 86);
             this->buttonBrowseDiagLoggingTraceFolder->Name = L"buttonBrowseDiagLoggingTraceFolder";
             this->buttonBrowseDiagLoggingTraceFolder->Size = System::Drawing::Size(30, 23);
             this->buttonBrowseDiagLoggingTraceFolder->TabIndex = 45;
             this->buttonBrowseDiagLoggingTraceFolder->Text = L"...";
             this->buttonBrowseDiagLoggingTraceFolder->UseVisualStyleBackColor = true;
             this->buttonBrowseDiagLoggingTraceFolder->Click += gcnew System::EventHandler(this, &SampleForm::buttonBrowseDiagLoggingTraceFolder_Click);
             // 
             // buttonOpenDiagLoggingTraceFolder
             // 
             this->buttonOpenDiagLoggingTraceFolder->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonOpenDiagLoggingTraceFolder->Location = System::Drawing::Point(1210, 86);
             this->buttonOpenDiagLoggingTraceFolder->Name = L"buttonOpenDiagLoggingTraceFolder";
             this->buttonOpenDiagLoggingTraceFolder->Size = System::Drawing::Size(82, 23);
             this->buttonOpenDiagLoggingTraceFolder->TabIndex = 44;
             this->buttonOpenDiagLoggingTraceFolder->Text = L"Open Folder";
             this->buttonOpenDiagLoggingTraceFolder->UseVisualStyleBackColor = true;
             this->buttonOpenDiagLoggingTraceFolder->Click += gcnew System::EventHandler(this, &SampleForm::buttonOpenDiagLoggingTraceFolder_Click);
             // 
             // textBoxDiagManagerTraceFolder
             // 
             this->textBoxDiagManagerTraceFolder->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->textBoxDiagManagerTraceFolder->Location = System::Drawing::Point(1095, 88);
             this->textBoxDiagManagerTraceFolder->Name = L"textBoxDiagManagerTraceFolder";
             this->textBoxDiagManagerTraceFolder->Size = System::Drawing::Size(109, 20);
             this->textBoxDiagManagerTraceFolder->TabIndex = 43;
             this->textBoxDiagManagerTraceFolder->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxDiagManagerTraceFolder_TextChanged);
             // 
             // label19
             // 
             this->label19->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->label19->AutoSize = true;
             this->label19->Location = System::Drawing::Point(1073, 91);
             this->label19->Name = L"label19";
             this->label19->Size = System::Drawing::Size(15, 13);
             this->label19->TabIndex = 42;
             this->label19->Text = L"in";
             // 
             // comboBoxDiagLoggingTraceLevel
             // 
             this->comboBoxDiagLoggingTraceLevel->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->comboBoxDiagLoggingTraceLevel->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList;
             this->comboBoxDiagLoggingTraceLevel->Enabled = false;
             this->comboBoxDiagLoggingTraceLevel->FormattingEnabled = true;
             this->comboBoxDiagLoggingTraceLevel->Location = System::Drawing::Point(943, 88);
             this->comboBoxDiagLoggingTraceLevel->Name = L"comboBoxDiagLoggingTraceLevel";
             this->comboBoxDiagLoggingTraceLevel->Size = System::Drawing::Size(124, 21);
             this->comboBoxDiagLoggingTraceLevel->TabIndex = 41;
             this->comboBoxDiagLoggingTraceLevel->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxDiagLoggingTraceLevel_SelectedValueChanged);
             // 
             // label17
             // 
             this->label17->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->label17->AutoSize = true;
             this->label17->Location = System::Drawing::Point(893, 91);
             this->label17->Name = L"label17";
             this->label17->Size = System::Drawing::Size(44, 13);
             this->label17->TabIndex = 40;
             this->label17->Text = L"at level:";
             // 
             // checkBoxIncludedDiagLogging
             // 
             this->checkBoxIncludedDiagLogging->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->checkBoxIncludedDiagLogging->AutoSize = true;
             this->checkBoxIncludedDiagLogging->Location = System::Drawing::Point(760, 90);
             this->checkBoxIncludedDiagLogging->Name = L"checkBoxIncludedDiagLogging";
             this->checkBoxIncludedDiagLogging->Size = System::Drawing::Size(129, 17);
             this->checkBoxIncludedDiagLogging->TabIndex = 39;
             this->checkBoxIncludedDiagLogging->Text = L"included DiagLogging";
             this->checkBoxIncludedDiagLogging->UseVisualStyleBackColor = true;
             this->checkBoxIncludedDiagLogging->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxIncludedDiagLogging_CheckedChanged);
             // 
             // comboBoxDiagManagerTraceLevel
             // 
             this->comboBoxDiagManagerTraceLevel->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->comboBoxDiagManagerTraceLevel->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList;
             this->comboBoxDiagManagerTraceLevel->FormattingEnabled = true;
             this->comboBoxDiagManagerTraceLevel->Location = System::Drawing::Point(660, 88);
             this->comboBoxDiagManagerTraceLevel->Name = L"comboBoxDiagManagerTraceLevel";
             this->comboBoxDiagManagerTraceLevel->Size = System::Drawing::Size(94, 21);
             this->comboBoxDiagManagerTraceLevel->TabIndex = 38;
             this->comboBoxDiagManagerTraceLevel->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxDiagManagerTraceLevel_SelectedValueChanged);
             // 
             // label16
             // 
             this->label16->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->label16->AutoSize = true;
             this->label16->Location = System::Drawing::Point(598, 91);
             this->label16->Name = L"label16";
             this->label16->Size = System::Drawing::Size(59, 13);
             this->label16->TabIndex = 37;
             this->label16->Text = L"trace level:";
             // 
             // textBoxDiagManagerLicenseKey
             // 
             this->textBoxDiagManagerLicenseKey->Anchor = static_cast<System::Windows::Forms::AnchorStyles>(((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->textBoxDiagManagerLicenseKey->Location = System::Drawing::Point(128, 88);
             this->textBoxDiagManagerLicenseKey->Name = L"textBoxDiagManagerLicenseKey";
             this->textBoxDiagManagerLicenseKey->PasswordChar = '*';
             this->textBoxDiagManagerLicenseKey->Size = System::Drawing::Size(456, 20);
             this->textBoxDiagManagerLicenseKey->TabIndex = 36;
             this->textBoxDiagManagerLicenseKey->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxDiagManagerLicenseKey_TextChanged);
             this->textBoxDiagManagerLicenseKey->KeyDown += gcnew System::Windows::Forms::KeyEventHandler(this, &SampleForm::textBoxDiagManagerLicenseKey_KeyDown);
             // 
             // label7
             // 
             this->label7->AutoSize = true;
             this->label7->Location = System::Drawing::Point(-3, 91);
             this->label7->Name = L"label7";
             this->label7->Size = System::Drawing::Size(130, 13);
             this->label7->TabIndex = 35;
             this->label7->Text = L"DiagManager license key:";
             // 
             // comboBoxDiagIpcType
             // 
             this->comboBoxDiagIpcType->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->comboBoxDiagIpcType->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList;
             this->comboBoxDiagIpcType->FormattingEnabled = true;
             this->comboBoxDiagIpcType->Location = System::Drawing::Point(943, 61);
             this->comboBoxDiagIpcType->Name = L"comboBoxDiagIpcType";
             this->comboBoxDiagIpcType->Size = System::Drawing::Size(93, 21);
             this->comboBoxDiagIpcType->TabIndex = 34;
             this->comboBoxDiagIpcType->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxDiagIpcType_SelectedValueChanged);
             // 
             // labelDiagType
             // 
             this->labelDiagType->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->labelDiagType->AutoSize = true;
             this->labelDiagType->Location = System::Drawing::Point(878, 65);
             this->labelDiagType->Name = L"labelDiagType";
             this->labelDiagType->Size = System::Drawing::Size(59, 13);
             this->labelDiagType->TabIndex = 33;
             this->labelDiagType->Text = L"Diag Type:";
             // 
             // labelOdxProject
             // 
             this->labelOdxProject->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->labelOdxProject->AutoSize = true;
             this->labelOdxProject->Location = System::Drawing::Point(1046, 35);
             this->labelOdxProject->Name = L"labelOdxProject";
             this->labelOdxProject->Size = System::Drawing::Size(43, 13);
             this->labelOdxProject->TabIndex = 32;
             this->labelOdxProject->Text = L"Project:";
             // 
             // labelODXVehicle
             // 
             this->labelODXVehicle->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->labelODXVehicle->AutoSize = true;
             this->labelODXVehicle->Location = System::Drawing::Point(1044, 65);
             this->labelODXVehicle->Name = L"labelODXVehicle";
             this->labelODXVehicle->Size = System::Drawing::Size(45, 13);
             this->labelODXVehicle->TabIndex = 31;
             this->labelODXVehicle->Text = L"Vehicle:";
             // 
             // comboBoxODXVehicle
             // 
             this->comboBoxODXVehicle->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->comboBoxODXVehicle->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList;
             this->comboBoxODXVehicle->DropDownWidth = 120;
             this->comboBoxODXVehicle->FormattingEnabled = true;
             this->comboBoxODXVehicle->Location = System::Drawing::Point(1095, 61);
             this->comboBoxODXVehicle->Name = L"comboBoxODXVehicle";
             this->comboBoxODXVehicle->Size = System::Drawing::Size(233, 21);
             this->comboBoxODXVehicle->TabIndex = 3;
             this->comboBoxODXVehicle->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxODXVehicle_SelectedValueChanged);
             // 
             // comboBoxODXProject
             // 
             this->comboBoxODXProject->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->comboBoxODXProject->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList;
             this->comboBoxODXProject->DropDownWidth = 200;
             this->comboBoxODXProject->FormattingEnabled = true;
             this->comboBoxODXProject->Location = System::Drawing::Point(1095, 31);
             this->comboBoxODXProject->Name = L"comboBoxODXProject";
             this->comboBoxODXProject->Size = System::Drawing::Size(233, 21);
             this->comboBoxODXProject->TabIndex = 4;
             this->comboBoxODXProject->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxODXProject_SelectedValueChanged);
             // 
             // label2
             // 
             this->label2->AutoSize = true;
             this->label2->Location = System::Drawing::Point(165, 34);
             this->label2->Name = L"label2";
             this->label2->Size = System::Drawing::Size(54, 13);
             this->label2->TabIndex = 30;
             this->label2->Text = L"Files, Size";
             // 
             // textBoxTraceFileMaxSize
             // 
             this->textBoxTraceFileMaxSize->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             this->textBoxTraceFileMaxSize->Location = System::Drawing::Point(256, 30);
             this->textBoxTraceFileMaxSize->Name = L"textBoxTraceFileMaxSize";
             this->textBoxTraceFileMaxSize->Size = System::Drawing::Size(32, 22);
             this->textBoxTraceFileMaxSize->TabIndex = 29;
             this->textBoxTraceFileMaxSize->Text = L"100";
             this->textBoxTraceFileMaxSize->TextAlign = System::Windows::Forms::HorizontalAlignment::Right;
             this->textBoxTraceFileMaxSize->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxTraceFileMaxSize_TextChanged);
             // 
             // textBoxTraceFileMaxCount
             // 
             this->textBoxTraceFileMaxCount->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             this->textBoxTraceFileMaxCount->Location = System::Drawing::Point(225, 30);
             this->textBoxTraceFileMaxCount->Name = L"textBoxTraceFileMaxCount";
             this->textBoxTraceFileMaxCount->Size = System::Drawing::Size(25, 22);
             this->textBoxTraceFileMaxCount->TabIndex = 28;
             this->textBoxTraceFileMaxCount->Text = L"10";
             this->textBoxTraceFileMaxCount->TextAlign = System::Windows::Forms::HorizontalAlignment::Right;
             this->textBoxTraceFileMaxCount->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxTraceFileMaxCount_TextChanged);
             // 
             // buttonOpenTraceFolder
             // 
             this->buttonOpenTraceFolder->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonOpenTraceFolder->Location = System::Drawing::Point(833, 30);
             this->buttonOpenTraceFolder->Name = L"buttonOpenTraceFolder";
             this->buttonOpenTraceFolder->Size = System::Drawing::Size(49, 23);
             this->buttonOpenTraceFolder->TabIndex = 15;
             this->buttonOpenTraceFolder->Text = L"Open...";
             this->buttonOpenTraceFolder->UseVisualStyleBackColor = true;
             this->buttonOpenTraceFolder->Click += gcnew System::EventHandler(this, &SampleForm::buttonOpenTraceFolder_Click);
             // 
             // textBoxRuntimeContextName
             // 
             this->textBoxRuntimeContextName->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->textBoxRuntimeContextName->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             this->textBoxRuntimeContextName->Location = System::Drawing::Point(1124, 2);
             this->textBoxRuntimeContextName->Name = L"textBoxRuntimeContextName";
             this->textBoxRuntimeContextName->Size = System::Drawing::Size(123, 22);
             this->textBoxRuntimeContextName->TabIndex = 8;
             this->textBoxRuntimeContextName->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxRuntimeContextName_TextChanged);
             // 
             // runtimeNameLabel
             // 
             this->runtimeNameLabel->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->runtimeNameLabel->AutoSize = true;
             this->runtimeNameLabel->Location = System::Drawing::Point(1044, 5);
             this->runtimeNameLabel->Name = L"runtimeNameLabel";
             this->runtimeNameLabel->Size = System::Drawing::Size(75, 13);
             this->runtimeNameLabel->TabIndex = 7;
             this->runtimeNameLabel->Text = L"Runtime name";
             // 
             // textBoxDiagPortPipe
             // 
             this->textBoxDiagPortPipe->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->textBoxDiagPortPipe->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->textBoxDiagPortPipe->Location = System::Drawing::Point(1273, 31);
             this->textBoxDiagPortPipe->Name = L"textBoxDiagPortPipe";
             this->textBoxDiagPortPipe->Size = System::Drawing::Size(55, 22);
             this->textBoxDiagPortPipe->TabIndex = 22;
             this->textBoxDiagPortPipe->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxPortPipe_TextChanged);
             // 
             // textBoxRtPortPipe
             // 
             this->textBoxRtPortPipe->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->textBoxRtPortPipe->BackColor = System::Drawing::SystemColors::Window;
             this->textBoxRtPortPipe->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->textBoxRtPortPipe->Location = System::Drawing::Point(1192, 31);
             this->textBoxRtPortPipe->Name = L"textBoxRtPortPipe";
             this->textBoxRtPortPipe->Size = System::Drawing::Size(55, 22);
             this->textBoxRtPortPipe->TabIndex = 20;
             this->textBoxRtPortPipe->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxPortPipe_TextChanged);
             // 
             // label13
             // 
             this->label13->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->label13->AutoSize = true;
             this->label13->Location = System::Drawing::Point(1254, 34);
             this->label13->Name = L"label13";
             this->label13->Size = System::Drawing::Size(12, 13);
             this->label13->TabIndex = 21;
             this->label13->Text = L"/";
             // 
             // portPipeLabel
             // 
             this->portPipeLabel->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->portPipeLabel->AutoSize = true;
             this->portPipeLabel->Location = System::Drawing::Point(1044, 34);
             this->portPipeLabel->Name = L"portPipeLabel";
             this->portPipeLabel->Size = System::Drawing::Size(144, 13);
             this->portPipeLabel->TabIndex = 19;
             this->portPipeLabel->Text = L"Runner / DiagManager Ports";
             // 
             // comboBoxIpcType
             // 
             this->comboBoxIpcType->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->comboBoxIpcType->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList;
             this->comboBoxIpcType->DropDownWidth = 170;
             this->comboBoxIpcType->FormattingEnabled = true;
             this->comboBoxIpcType->Location = System::Drawing::Point(943, 31);
             this->comboBoxIpcType->Name = L"comboBoxIpcType";
             this->comboBoxIpcType->Size = System::Drawing::Size(93, 21);
             this->comboBoxIpcType->TabIndex = 18;
             this->comboBoxIpcType->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxIpcType_SelectedValueChanged);
             // 
             // label11
             // 
             this->label11->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->label11->AutoSize = true;
             this->label11->Location = System::Drawing::Point(895, 34);
             this->label11->Name = L"label11";
             this->label11->Size = System::Drawing::Size(24, 13);
             this->label11->TabIndex = 17;
             this->label11->Text = L"IPC";
             // 
             // label10
             // 
             this->label10->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->label10->BackColor = System::Drawing::SystemColors::ControlDark;
             this->label10->Location = System::Drawing::Point(888, 35);
             this->label10->Name = L"label10";
             this->label10->Size = System::Drawing::Size(1, 14);
             this->label10->TabIndex = 16;
             // 
             // buttonBrowseTraceFolder
             // 
             this->buttonBrowseTraceFolder->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonBrowseTraceFolder->Location = System::Drawing::Point(798, 30);
             this->buttonBrowseTraceFolder->Name = L"buttonBrowseTraceFolder";
             this->buttonBrowseTraceFolder->Size = System::Drawing::Size(29, 23);
             this->buttonBrowseTraceFolder->TabIndex = 14;
             this->buttonBrowseTraceFolder->Text = L"...";
             this->buttonBrowseTraceFolder->UseVisualStyleBackColor = true;
             this->buttonBrowseTraceFolder->Click += gcnew System::EventHandler(this, &SampleForm::buttonBrowseTraceFolder_Click);
             // 
             // textBoxTraceFolder
             // 
             this->textBoxTraceFolder->Anchor = static_cast<System::Windows::Forms::AnchorStyles>(((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->textBoxTraceFolder->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->textBoxTraceFolder->Location = System::Drawing::Point(450, 30);
             this->textBoxTraceFolder->Name = L"textBoxTraceFolder";
             this->textBoxTraceFolder->Size = System::Drawing::Size(342, 22);
             this->textBoxTraceFolder->TabIndex = 13;
             this->textBoxTraceFolder->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxTraceFolder_TextChanged);
             // 
             // label9
             // 
             this->label9->AutoSize = true;
             this->label9->Location = System::Drawing::Point(429, 33);
             this->label9->Name = L"label9";
             this->label9->Size = System::Drawing::Size(15, 13);
             this->label9->TabIndex = 12;
             this->label9->Text = L"in";
             // 
             // comboBoxTraceLevel
             // 
             this->comboBoxTraceLevel->DropDownStyle = System::Windows::Forms::ComboBoxStyle::DropDownList;
             this->comboBoxTraceLevel->FormattingEnabled = true;
             this->comboBoxTraceLevel->Location = System::Drawing::Point(90, 31);
             this->comboBoxTraceLevel->Name = L"comboBoxTraceLevel";
             this->comboBoxTraceLevel->Size = System::Drawing::Size(69, 21);
             this->comboBoxTraceLevel->TabIndex = 11;
             this->comboBoxTraceLevel->SelectedIndexChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxTraceLevel_SelectedIndexChanged);
             this->comboBoxTraceLevel->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::comboBoxTraceLevel_SelectedValueChanged);
             // 
             // label8
             // 
             this->label8->AutoSize = true;
             this->label8->Location = System::Drawing::Point(-3, 34);
             this->label8->Name = L"label8";
             this->label8->Size = System::Drawing::Size(83, 13);
             this->label8->TabIndex = 10;
             this->label8->Text = L"TraceFile: Level";
             // 
             // label6
             // 
             this->label6->Anchor = static_cast<System::Windows::Forms::AnchorStyles>(((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->label6->BackColor = System::Drawing::SystemColors::ControlDark;
             this->label6->Location = System::Drawing::Point(-3, 27);
             this->label6->Name = L"label6";
             this->label6->Size = System::Drawing::Size(1332, 1);
             this->label6->TabIndex = 9;
             // 
             // buttonReload
             // 
             this->buttonReload->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonReload->Enabled = false;
             this->buttonReload->Location = System::Drawing::Point(833, 1);
             this->buttonReload->Name = L"buttonReload";
             this->buttonReload->Size = System::Drawing::Size(49, 23);
             this->buttonReload->TabIndex = 3;
             this->buttonReload->Text = L"Reload";
             this->buttonReload->UseVisualStyleBackColor = true;
             this->buttonReload->Click += gcnew System::EventHandler(this, &SampleForm::buttonReload_Click);
             // 
             // txtPassword
             // 
             this->txtPassword->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->txtPassword->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->txtPassword->Location = System::Drawing::Point(943, 2);
             this->txtPassword->Name = L"txtPassword";
             this->txtPassword->PasswordChar = '*';
             this->txtPassword->Size = System::Drawing::Size(93, 22);
             this->txtPassword->TabIndex = 5;
             this->txtPassword->TextChanged += gcnew System::EventHandler(this, &SampleForm::txtPassword_TextChanged);
             // 
             // passwordLabel
             // 
             this->passwordLabel->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->passwordLabel->AutoSize = true;
             this->passwordLabel->Location = System::Drawing::Point(884, 6);
             this->passwordLabel->Name = L"passwordLabel";
             this->passwordLabel->Size = System::Drawing::Size(53, 13);
             this->passwordLabel->TabIndex = 4;
             this->passwordLabel->Text = L"Password";
             // 
             // buttonBrowseFile
             // 
             this->buttonBrowseFile->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonBrowseFile->Location = System::Drawing::Point(798, 1);
             this->buttonBrowseFile->Name = L"buttonBrowseFile";
             this->buttonBrowseFile->Size = System::Drawing::Size(29, 23);
             this->buttonBrowseFile->TabIndex = 2;
             this->buttonBrowseFile->Text = L"...";
             this->buttonBrowseFile->UseVisualStyleBackColor = true;
             this->buttonBrowseFile->Click += gcnew System::EventHandler(this, &SampleForm::buttonBrowseFile_Click);
             // 
             // cbFilePath
             // 
             this->cbFilePath->Anchor = static_cast<System::Windows::Forms::AnchorStyles>(((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->cbFilePath->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->cbFilePath->Location = System::Drawing::Point(90, 1);
             this->cbFilePath->Name = L"cbFilePath";
             this->cbFilePath->Size = System::Drawing::Size(702, 22);
             this->cbFilePath->TabIndex = 1;
             this->cbFilePath->SelectedValueChanged += gcnew System::EventHandler(this, &SampleForm::cbFilePath_SelectedValueChanged);
             this->cbFilePath->TextChanged += gcnew System::EventHandler(this, &SampleForm::cbFilePath_TextChanged);
             // 
             // label1
             // 
             this->label1->AutoSize = true;
             this->label1->Location = System::Drawing::Point(-3, 6);
             this->label1->Name = L"label1";
             this->label1->Size = System::Drawing::Size(87, 13);
             this->label1->TabIndex = 0;
             this->label1->Text = L"Select PTX/PPX";
             // 
             // textBoxTimeout
             // 
             this->textBoxTimeout->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             this->textBoxTimeout->Location = System::Drawing::Point(642, 3);
             this->textBoxTimeout->Name = L"textBoxTimeout";
             this->textBoxTimeout->RightToLeft = System::Windows::Forms::RightToLeft::Yes;
             this->textBoxTimeout->Size = System::Drawing::Size(45, 22);
             this->textBoxTimeout->TabIndex = 4;
             this->textBoxTimeout->Text = L"0";
             this->textBoxTimeout->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxTimeout_TextChanged);
             // 
             // labelTimeout
             // 
             this->labelTimeout->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->labelTimeout->AutoSize = true;
             this->labelTimeout->Location = System::Drawing::Point(591, 0);
             this->labelTimeout->Name = L"labelTimeout";
             this->labelTimeout->Padding = System::Windows::Forms::Padding(0, 7, 0, 0);
             this->labelTimeout->Size = System::Drawing::Size(45, 20);
             this->labelTimeout->TabIndex = 3;
             this->labelTimeout->Text = L"Timeout";
             // 
             // textBoxVoltageThreshold
             // 
             this->textBoxVoltageThreshold->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->textBoxVoltageThreshold->Location = System::Drawing::Point(1301, 3);
             this->textBoxVoltageThreshold->Name = L"textBoxVoltageThreshold";
             this->textBoxVoltageThreshold->RightToLeft = System::Windows::Forms::RightToLeft::Yes;
             this->textBoxVoltageThreshold->Size = System::Drawing::Size(45, 22);
             this->textBoxVoltageThreshold->TabIndex = 16;
             this->textBoxVoltageThreshold->Text = L"6000";
             this->textBoxVoltageThreshold->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxBatteryVoltageThreshold_TextChanged);
             // 
             // labelVoltageThreshold
             // 
             this->labelVoltageThreshold->AutoSize = true;
             this->labelVoltageThreshold->Location = System::Drawing::Point(1205, 0);
             this->labelVoltageThreshold->Name = L"labelVoltageThreshold";
             this->labelVoltageThreshold->Padding = System::Windows::Forms::Padding(0, 7, 0, 0);
             this->labelVoltageThreshold->Size = System::Drawing::Size(90, 20);
             this->labelVoltageThreshold->TabIndex = 15;
             this->labelVoltageThreshold->Text = L"VoltageThreshold";
             // 
             // textBoxPollingTime
             // 
             this->textBoxPollingTime->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->textBoxPollingTime->Location = System::Drawing::Point(1159, 3);
             this->textBoxPollingTime->Name = L"textBoxPollingTime";
             this->textBoxPollingTime->RightToLeft = System::Windows::Forms::RightToLeft::Yes;
             this->textBoxPollingTime->Size = System::Drawing::Size(40, 22);
             this->textBoxPollingTime->TabIndex = 14;
             this->textBoxPollingTime->Text = L"500";
             this->textBoxPollingTime->TextChanged += gcnew System::EventHandler(this, &SampleForm::textBoxPollingTime_TextChanged);
             // 
             // labelPollingTime
             // 
             this->labelPollingTime->AutoSize = true;
             this->labelPollingTime->Location = System::Drawing::Point(1092, 0);
             this->labelPollingTime->Name = L"labelPollingTime";
             this->labelPollingTime->Padding = System::Windows::Forms::Padding(0, 7, 0, 0);
             this->labelPollingTime->Size = System::Drawing::Size(61, 20);
             this->labelPollingTime->TabIndex = 13;
             this->labelPollingTime->Text = L"PollingTime";
             // 
             // checkBoxIgnition
             // 
             this->checkBoxIgnition->AutoSize = true;
             this->checkBoxIgnition->Checked = true;
             this->checkBoxIgnition->CheckState = System::Windows::Forms::CheckState::Indeterminate;
             this->checkBoxIgnition->Location = System::Drawing::Point(978, 3);
             this->checkBoxIgnition->Name = L"checkBoxIgnition";
             this->checkBoxIgnition->Padding = System::Windows::Forms::Padding(0, 3, 0, 0);
             this->checkBoxIgnition->Size = System::Drawing::Size(45, 20);
             this->checkBoxIgnition->TabIndex = 10;
             this->checkBoxIgnition->Text = L"IGN";
             this->checkBoxIgnition->TextImageRelation = System::Windows::Forms::TextImageRelation::TextBeforeImage;
             this->checkBoxIgnition->ThreeState = true;
             this->checkBoxIgnition->UseVisualStyleBackColor = true;
             this->checkBoxIgnition->CheckStateChanged += gcnew System::EventHandler(this, &SampleForm::CheckBoxKL15_CheckStateChanged);
             // 
             // checkBoxUseConnectionState
             // 
             this->checkBoxUseConnectionState->AutoSize = true;
             this->checkBoxUseConnectionState->CheckAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->checkBoxUseConnectionState->Location = System::Drawing::Point(700, 3);
             this->checkBoxUseConnectionState->Name = L"checkBoxUseConnectionState";
             this->checkBoxUseConnectionState->Padding = System::Windows::Forms::Padding(0, 3, 0, 0);
             this->checkBoxUseConnectionState->Size = System::Drawing::Size(139, 20);
             this->checkBoxUseConnectionState->TabIndex = 6;
             this->checkBoxUseConnectionState->Text = L"Check ConnectionState";
             this->checkBoxUseConnectionState->UseVisualStyleBackColor = true;
             this->checkBoxUseConnectionState->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxUseConnectionState_CheckedChanged);
             // 
             // panel2
             // 
             this->panel2->Controls->Add(this->buttonLicense);
             this->panel2->Controls->Add(this->buttonStartStopWebServer);
             this->panel2->Controls->Add(this->buttonHmi);
             this->panel2->Controls->Add(this->checkBoxNewRuntimeManager);
             this->panel2->Controls->Add(this->label15);
             this->panel2->Controls->Add(this->label14);
             this->panel2->Controls->Add(this->checkBoxCyclicReload);
             this->panel2->Controls->Add(this->listBoxOuput);
             this->panel2->Controls->Add(this->labelOutputOverflow);
             this->panel2->Controls->Add(this->buttonCopyRow);
             this->panel2->Controls->Add(this->buttonClearOutput);
             this->panel2->Controls->Add(this->buttonNewInstanceNewThread);
             this->panel2->Controls->Add(this->buttonNewInstance);
             this->panel2->Controls->Add(this->checkBoxStartAllParents);
             this->panel2->Controls->Add(this->checkBoxAdd2Output);
             this->panel2->Controls->Add(this->checkBoxCyclicExecution);
             this->panel2->Controls->Add(this->checkBoxAsyncExecution);
             this->panel2->Controls->Add(this->buttonPause);
             this->panel2->Controls->Add(this->buttonStop);
             this->panel2->Controls->Add(this->buttonExecuteMain);
             this->panel2->Controls->Add(this->buttonExecuteSelectedProcedure);
             this->panel2->Dock = System::Windows::Forms::DockStyle::Fill;
             this->panel2->Location = System::Drawing::Point(0, 0);
             this->panel2->Name = L"panel2";
             this->panel2->Size = System::Drawing::Size(1328, 305);
             this->panel2->TabIndex = 0;
             // 
             // buttonLicense
             // 
             this->buttonLicense->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonLicense->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonLicense.Image")));
             this->buttonLicense->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonLicense->Location = System::Drawing::Point(798, 5);
             this->buttonLicense->Name = L"buttonLicense";
             this->buttonLicense->Padding = System::Windows::Forms::Padding(10, 0, 5, 0);
             this->buttonLicense->Size = System::Drawing::Size(91, 35);
             this->buttonLicense->TabIndex = 19;
             this->buttonLicense->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/3333D311.htm";
             this->buttonLicense->Text = L"License";
             this->buttonLicense->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonLicense->UseVisualStyleBackColor = true;
             this->buttonLicense->Click += gcnew System::EventHandler(this, &SampleForm::buttonLicense_Click);
             // 
             // buttonStartStopWebServer
             // 
             this->buttonStartStopWebServer->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonStartStopWebServer->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonStartStopWebServer.Image")));
             this->buttonStartStopWebServer->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonStartStopWebServer->Location = System::Drawing::Point(676, 5);
             this->buttonStartStopWebServer->Name = L"buttonStartStopWebServer";
             this->buttonStartStopWebServer->Padding = System::Windows::Forms::Padding(10, 0, 5, 0);
             this->buttonStartStopWebServer->Size = System::Drawing::Size(116, 35);
             this->buttonStartStopWebServer->TabIndex = 18;
             this->buttonStartStopWebServer->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/3333D311.htm";
             this->buttonStartStopWebServer->Text = L"Web Server";
             this->buttonStartStopWebServer->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonStartStopWebServer->UseVisualStyleBackColor = true;
             this->buttonStartStopWebServer->Click += gcnew System::EventHandler(this, &SampleForm::buttonStartStopWebServer_Click);
             // 
             // buttonHmi
             // 
             this->buttonHmi->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonHmi->Appearance = System::Windows::Forms::Appearance::Button;
             this->buttonHmi->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonHmi.Image")));
             this->buttonHmi->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonHmi->Location = System::Drawing::Point(895, 5);
             this->buttonHmi->Name = L"buttonHmi";
             this->buttonHmi->Padding = System::Windows::Forms::Padding(10, 0, 10, 0);
             this->buttonHmi->Size = System::Drawing::Size(80, 35);
             this->buttonHmi->TabIndex = 9;
             this->buttonHmi->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/18FE2C39.htm";
             this->buttonHmi->Text = L"HMI";
             this->buttonHmi->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonHmi->UseVisualStyleBackColor = true;
             this->buttonHmi->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::buttonHmi_Click);
             // 
             // checkBoxNewRuntimeManager
             // 
             this->checkBoxNewRuntimeManager->AutoSize = true;
             this->checkBoxNewRuntimeManager->Enabled = false;
             this->checkBoxNewRuntimeManager->Location = System::Drawing::Point(481, 7);
             this->checkBoxNewRuntimeManager->Name = L"checkBoxNewRuntimeManager";
             this->checkBoxNewRuntimeManager->Size = System::Drawing::Size(89, 17);
             this->checkBoxNewRuntimeManager->TabIndex = 7;
             this->checkBoxNewRuntimeManager->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/A42F362A.htm";
             this->checkBoxNewRuntimeManager->Text = L"New RntMgr.";
             this->checkBoxNewRuntimeManager->UseVisualStyleBackColor = true;
             this->checkBoxNewRuntimeManager->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxNewRuntimeManager_CheckedChanged);
             // 
             // label15
             // 
             this->label15->Anchor = static_cast<System::Windows::Forms::AnchorStyles>(((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->label15->BackColor = System::Drawing::SystemColors::ControlDark;
             this->label15->Location = System::Drawing::Point(3, 43);
             this->label15->Name = L"label15";
             this->label15->Size = System::Drawing::Size(1328, 1);
             this->label15->TabIndex = 12;
             // 
             // label14
             // 
             this->label14->Anchor = static_cast<System::Windows::Forms::AnchorStyles>(((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->label14->BackColor = System::Drawing::SystemColors::ControlDark;
             this->label14->Location = System::Drawing::Point(1, 1);
             this->label14->Name = L"label14";
             this->label14->Size = System::Drawing::Size(1328, 1);
             this->label14->TabIndex = 0;
             // 
             // checkBoxCyclicReload
             // 
             this->checkBoxCyclicReload->AutoSize = true;
             this->checkBoxCyclicReload->Enabled = false;
             this->checkBoxCyclicReload->Location = System::Drawing::Point(481, 23);
             this->checkBoxCyclicReload->Name = L"checkBoxCyclicReload";
             this->checkBoxCyclicReload->Size = System::Drawing::Size(91, 17);
             this->checkBoxCyclicReload->TabIndex = 8;
             this->checkBoxCyclicReload->Text = L"Cyclic Reload";
             this->checkBoxCyclicReload->UseVisualStyleBackColor = true;
             this->checkBoxCyclicReload->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxCyclicReload_CheckedChanged);
             // 
             // listBoxOuput
             // 
             this->listBoxOuput->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Bottom)
                 | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->listBoxOuput->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             this->listBoxOuput->HorizontalScrollbar = true;
             this->listBoxOuput->IntegralHeight = false;
             this->listBoxOuput->ItemHeight = 14;
             this->listBoxOuput->Location = System::Drawing::Point(0, 76);
             this->listBoxOuput->Name = L"listBoxOuput";
             this->listBoxOuput->SelectionMode = System::Windows::Forms::SelectionMode::MultiExtended;
             this->listBoxOuput->Size = System::Drawing::Size(1328, 81);
             this->listBoxOuput->TabIndex = 17;
             this->listBoxOuput->SelectedIndexChanged += gcnew System::EventHandler(this, &SampleForm::listBoxOuput_SelectedIndexChanged);
             // 
             // labelOutputOverflow
             // 
             this->labelOutputOverflow->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->labelOutputOverflow->AutoSize = true;
             this->labelOutputOverflow->ForeColor = System::Drawing::Color::DarkRed;
             this->labelOutputOverflow->Location = System::Drawing::Point(781, 53);
             this->labelOutputOverflow->Name = L"labelOutputOverflow";
             this->labelOutputOverflow->Size = System::Drawing::Size(345, 13);
             this->labelOutputOverflow->TabIndex = 14;
             this->labelOutputOverflow->Text = L"More than 7,500 lines are in output! After 10,000 all lines will be cleared!";
             this->labelOutputOverflow->Visible = false;
             // 
             // buttonCopyRow
             // 
             this->buttonCopyRow->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonCopyRow->Enabled = false;
             this->buttonCopyRow->Location = System::Drawing::Point(1132, 48);
             this->buttonCopyRow->Name = L"buttonCopyRow";
             this->buttonCopyRow->Size = System::Drawing::Size(86, 23);
             this->buttonCopyRow->TabIndex = 15;
             this->buttonCopyRow->Text = L"Copy";
             this->buttonCopyRow->UseVisualStyleBackColor = true;
             this->buttonCopyRow->Click += gcnew System::EventHandler(this, &SampleForm::buttonCopyRow_Click);
             // 
             // buttonClearOutput
             // 
             this->buttonClearOutput->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonClearOutput->Location = System::Drawing::Point(1224, 48);
             this->buttonClearOutput->Name = L"buttonClearOutput";
             this->buttonClearOutput->Size = System::Drawing::Size(104, 23);
             this->buttonClearOutput->TabIndex = 16;
             this->buttonClearOutput->Text = L"Clear Output";
             this->buttonClearOutput->UseVisualStyleBackColor = true;
             this->buttonClearOutput->Click += gcnew System::EventHandler(this, &SampleForm::buttonClearOutput_Click);
             // 
             // buttonNewInstanceNewThread
             // 
             this->buttonNewInstanceNewThread->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonNewInstanceNewThread->AutoSize = true;
             this->buttonNewInstanceNewThread->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonNewInstanceNewThread.Image")));
             this->buttonNewInstanceNewThread->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonNewInstanceNewThread->Location = System::Drawing::Point(1116, 5);
             this->buttonNewInstanceNewThread->Name = L"buttonNewInstanceNewThread";
             this->buttonNewInstanceNewThread->Padding = System::Windows::Forms::Padding(10, 0, 10, 0);
             this->buttonNewInstanceNewThread->Size = System::Drawing::Size(212, 35);
             this->buttonNewInstanceNewThread->TabIndex = 11;
             this->buttonNewInstanceNewThread->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/18FE2C39.htm";
             this->buttonNewInstanceNewThread->Text = L"New Instance - New Thread";
             this->buttonNewInstanceNewThread->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonNewInstanceNewThread->UseVisualStyleBackColor = true;
             this->buttonNewInstanceNewThread->Click += gcnew System::EventHandler(this, &SampleForm::buttonNewInstanceNewThread_Click);
             // 
             // buttonNewInstance
             // 
             this->buttonNewInstance->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonNewInstance->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonNewInstance.Image")));
             this->buttonNewInstance->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonNewInstance->Location = System::Drawing::Point(981, 5);
             this->buttonNewInstance->Name = L"buttonNewInstance";
             this->buttonNewInstance->Padding = System::Windows::Forms::Padding(10, 0, 10, 0);
             this->buttonNewInstance->Size = System::Drawing::Size(129, 35);
             this->buttonNewInstance->TabIndex = 10;
             this->buttonNewInstance->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/18FE2C39.htm";
             this->buttonNewInstance->Text = L"New Instance";
             this->buttonNewInstance->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonNewInstance->UseVisualStyleBackColor = true;
             this->buttonNewInstance->Click += gcnew System::EventHandler(this, &SampleForm::buttonNewInstance_Click);
             // 
             // checkBoxStartAllParents
             // 
             this->checkBoxStartAllParents->AutoSize = true;
             this->checkBoxStartAllParents->Location = System::Drawing::Point(149, 51);
             this->checkBoxStartAllParents->Name = L"checkBoxStartAllParents";
             this->checkBoxStartAllParents->Size = System::Drawing::Size(106, 17);
             this->checkBoxStartAllParents->TabIndex = 12;
             this->checkBoxStartAllParents->Tag = L"";
             this->checkBoxStartAllParents->Text = L"Sync with Parent";
             this->checkBoxStartAllParents->UseVisualStyleBackColor = true;
             this->checkBoxStartAllParents->Visible = false;
             // 
             // checkBoxAdd2Output
             // 
             this->checkBoxAdd2Output->AutoSize = true;
             this->checkBoxAdd2Output->Checked = true;
             this->checkBoxAdd2Output->CheckState = System::Windows::Forms::CheckState::Checked;
             this->checkBoxAdd2Output->Location = System::Drawing::Point(0, 51);
             this->checkBoxAdd2Output->Name = L"checkBoxAdd2Output";
             this->checkBoxAdd2Output->Size = System::Drawing::Size(143, 17);
             this->checkBoxAdd2Output->TabIndex = 13;
             this->checkBoxAdd2Output->Tag = L"";
             this->checkBoxAdd2Output->Text = L"Add Messages to Output";
             this->checkBoxAdd2Output->UseVisualStyleBackColor = true;
             this->checkBoxAdd2Output->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxAdd2Output_CheckedChanged);
             // 
             // checkBoxCyclicExecution
             // 
             this->checkBoxCyclicExecution->AutoSize = true;
             this->checkBoxCyclicExecution->Location = System::Drawing::Point(405, 23);
             this->checkBoxCyclicExecution->Name = L"checkBoxCyclicExecution";
             this->checkBoxCyclicExecution->Size = System::Drawing::Size(54, 17);
             this->checkBoxCyclicExecution->TabIndex = 6;
             this->checkBoxCyclicExecution->Tag = L"";
             this->checkBoxCyclicExecution->Text = L"Cyclic";
             this->checkBoxCyclicExecution->UseVisualStyleBackColor = true;
             this->checkBoxCyclicExecution->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxCyclicExecution_CheckedChanged);
             // 
             // checkBoxAsyncExecution
             // 
             this->checkBoxAsyncExecution->AutoSize = true;
             this->checkBoxAsyncExecution->Checked = true;
             this->checkBoxAsyncExecution->CheckState = System::Windows::Forms::CheckState::Checked;
             this->checkBoxAsyncExecution->Location = System::Drawing::Point(405, 7);
             this->checkBoxAsyncExecution->Name = L"checkBoxAsyncExecution";
             this->checkBoxAsyncExecution->Size = System::Drawing::Size(76, 17);
             this->checkBoxAsyncExecution->TabIndex = 5;
             this->checkBoxAsyncExecution->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/A42F362A.htm";
             this->checkBoxAsyncExecution->Text = L"Asynchron";
             this->checkBoxAsyncExecution->UseVisualStyleBackColor = true;
             this->checkBoxAsyncExecution->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::checkBoxAsyncExecution_CheckedChanged);
             // 
             // buttonPause
             // 
             this->buttonPause->Appearance = System::Windows::Forms::Appearance::Button;
             this->buttonPause->Enabled = false;
             this->buttonPause->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonPause.Image")));
             this->buttonPause->Location = System::Drawing::Point(263, 5);
             this->buttonPause->Name = L"buttonPause";
             this->buttonPause->Padding = System::Windows::Forms::Padding(10, 0, 10, 0);
             this->buttonPause->Size = System::Drawing::Size(42, 35);
             this->buttonPause->TabIndex = 3;
             this->buttonPause->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/3333D311.htm";
             this->buttonPause->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonPause->UseVisualStyleBackColor = true;
             this->buttonPause->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::buttonPause_Click);
             // 
             // buttonStop
             // 
             this->buttonStop->Enabled = false;
             this->buttonStop->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonStop.Image")));
             this->buttonStop->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonStop->Location = System::Drawing::Point(311, 5);
             this->buttonStop->Name = L"buttonStop";
             this->buttonStop->Padding = System::Windows::Forms::Padding(10, 0, 10, 0);
             this->buttonStop->Size = System::Drawing::Size(88, 35);
             this->buttonStop->TabIndex = 4;
             this->buttonStop->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/3333D311.htm";
             this->buttonStop->Text = L"Stop";
             this->buttonStop->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonStop->UseVisualStyleBackColor = true;
             this->buttonStop->Click += gcnew System::EventHandler(this, &SampleForm::buttonStop_Click);
             // 
             // buttonExecuteMain
             // 
             this->buttonExecuteMain->Enabled = false;
             this->buttonExecuteMain->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonExecuteMain.Image")));
             this->buttonExecuteMain->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonExecuteMain->Location = System::Drawing::Point(0, 5);
             this->buttonExecuteMain->Name = L"buttonExecuteMain";
             this->buttonExecuteMain->Padding = System::Windows::Forms::Padding(10, 0, 10, 0);
             this->buttonExecuteMain->Size = System::Drawing::Size(91, 35);
             this->buttonExecuteMain->TabIndex = 1;
             this->buttonExecuteMain->Text = L"Main";
             this->buttonExecuteMain->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonExecuteMain->UseVisualStyleBackColor = true;
             this->buttonExecuteMain->Click += gcnew System::EventHandler(this, &SampleForm::buttonExecuteMain_Click);
             // 
             // buttonExecuteSelectedProcedure
             // 
             this->buttonExecuteSelectedProcedure->Enabled = false;
             this->buttonExecuteSelectedProcedure->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"buttonExecuteSelectedProcedure.Image")));
             this->buttonExecuteSelectedProcedure->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft;
             this->buttonExecuteSelectedProcedure->Location = System::Drawing::Point(97, 5);
             this->buttonExecuteSelectedProcedure->Name = L"buttonExecuteSelectedProcedure";
             this->buttonExecuteSelectedProcedure->Padding = System::Windows::Forms::Padding(10, 0, 10, 0);
             this->buttonExecuteSelectedProcedure->Size = System::Drawing::Size(160, 35);
             this->buttonExecuteSelectedProcedure->TabIndex = 2;
             this->buttonExecuteSelectedProcedure->Text = L"Selected Procedure";
             this->buttonExecuteSelectedProcedure->TextAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->buttonExecuteSelectedProcedure->UseVisualStyleBackColor = true;
             this->buttonExecuteSelectedProcedure->Click += gcnew System::EventHandler(this, &SampleForm::buttonExecuteSelectedProcedure_Click);
             // 
             // openFileDialog1
             // 
             this->openFileDialog1->Filter = L"All supported formats(*.ptx, *.ppx)|*.ptx;*.ppx|PTX Files(*.ptx)|*.ptx|PPX Files("
                 L"*->ppx)|*->ppx|All Files (*->*)|*->*";
             this->openFileDialog1->Title = L"Please select a PTX/PPX file";
             // 
             // splitContainer1
             // 
             this->splitContainer1->Dock = System::Windows::Forms::DockStyle::Fill;
             this->splitContainer1->FixedPanel = System::Windows::Forms::FixedPanel::Panel1;
             this->splitContainer1->Location = System::Drawing::Point(0, 115);
             this->splitContainer1->Name = L"splitContainer1";
             // 
             // splitContainer1.Panel1
             // 
             this->splitContainer1->Panel1->Controls->Add(this->treeViewOtxProject);
             this->splitContainer1->Panel1->Controls->Add(this->label3);
             // 
             // splitContainer1.Panel2
             // 
             this->splitContainer1->Panel2->Controls->Add(this->splitContainer5);
             this->splitContainer1->Size = System::Drawing::Size(1328, 290);
             this->splitContainer1->SplitterDistance = 307;
             this->splitContainer1->TabIndex = 5;
             // 
             // treeViewOtxProject
             // 
             this->treeViewOtxProject->Dock = System::Windows::Forms::DockStyle::Fill;
             this->treeViewOtxProject->Enabled = false;
             this->treeViewOtxProject->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             this->treeViewOtxProject->HideSelection = false;
             this->treeViewOtxProject->Location = System::Drawing::Point(0, 16);
             this->treeViewOtxProject->Name = L"treeViewOtxProject";
             this->treeViewOtxProject->Size = System::Drawing::Size(307, 274);
             this->treeViewOtxProject->TabIndex = 1;
             this->treeViewOtxProject->DrawNode += gcnew System::Windows::Forms::DrawTreeNodeEventHandler(this, &SampleForm::treeViewOtxProject_DrawNode);
             this->treeViewOtxProject->AfterSelect += gcnew System::Windows::Forms::TreeViewEventHandler(this, &SampleForm::treeViewOtxProject_AfterSelect);
             // 
             // label3
             // 
             this->label3->AutoSize = true;
             this->label3->Dock = System::Windows::Forms::DockStyle::Top;
             this->label3->Location = System::Drawing::Point(0, 0);
             this->label3->Name = L"label3";
             this->label3->Padding = System::Windows::Forms::Padding(0, 0, 0, 3);
             this->label3->Size = System::Drawing::Size(245, 16);
             this->label3->TabIndex = 0;
             this->label3->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/671A83F2.htm";
             this->label3->Text = L"OTX-Project Tree (To execute select a Procedure)";
             // 
             // splitContainer5
             // 
             this->splitContainer5->Dock = System::Windows::Forms::DockStyle::Fill;
             this->splitContainer5->FixedPanel = System::Windows::Forms::FixedPanel::Panel1;
             this->splitContainer5->Location = System::Drawing::Point(0, 0);
             this->splitContainer5->MinimumSize = System::Drawing::Size(0, 318);
             this->splitContainer5->Name = L"splitContainer5";
             // 
             // splitContainer5.Panel1
             // 
             this->splitContainer5->Panel1->Controls->Add(this->splitContainer2);
             // 
             // splitContainer5.Panel2
             // 
             this->splitContainer5->Panel2->Controls->Add(this->panel3);
             this->splitContainer5->Panel2->Controls->Add(this->groupBox1);
             this->splitContainer5->Size = System::Drawing::Size(1017, 318);
             this->splitContainer5->SplitterDistance = 311;
             this->splitContainer5->TabIndex = 4;
             // 
             // splitContainer2
             // 
             this->splitContainer2->Dock = System::Windows::Forms::DockStyle::Fill;
             this->splitContainer2->Location = System::Drawing::Point(0, 0);
             this->splitContainer2->Name = L"splitContainer2";
             this->splitContainer2->Orientation = System::Windows::Forms::Orientation::Horizontal;
             // 
             // splitContainer2.Panel1
             // 
             this->splitContainer2->Panel1->Controls->Add(this->gridViewParameter);
             this->splitContainer2->Panel1->Controls->Add(this->labelAdjustProcedureParameters);
             // 
             // splitContainer2.Panel2
             // 
             this->splitContainer2->Panel2->Controls->Add(this->splitContainer3);
             this->splitContainer2->Size = System::Drawing::Size(311, 318);
             this->splitContainer2->SplitterDistance = 95;
             this->splitContainer2->TabIndex = 3;
             // 
             // gridViewParameter
             // 
             this->gridViewParameter->AllowUserToAddRows = false;
             this->gridViewParameter->AllowUserToDeleteRows = false;
             this->gridViewParameter->AllowUserToResizeRows = false;
             this->gridViewParameter->BackgroundColor = System::Drawing::SystemColors::Window;
             this->gridViewParameter->BorderStyle = System::Windows::Forms::BorderStyle::Fixed3D;
             this->gridViewParameter->CellBorderStyle = System::Windows::Forms::DataGridViewCellBorderStyle::None;
             this->gridViewParameter->ColumnHeadersBorderStyle = System::Windows::Forms::DataGridViewHeaderBorderStyle::None;
             this->gridViewParameter->ColumnHeadersHeightSizeMode = System::Windows::Forms::DataGridViewColumnHeadersHeightSizeMode::AutoSize;
             this->gridViewParameter->Columns->AddRange(gcnew cli::array< System::Windows::Forms::DataGridViewColumn^  >(5) {
                 this->dataGridViewTextBoxColumnName,
                     this->dataGridViewTextBoxColumnDirection, this->dataGridViewTextBoxColumnDataType, this->dataGridViewTextBoxColumnValue, this->dataGridViewTextBoxColumnDetails
             });
             dataGridViewCellStyle1->Alignment = System::Windows::Forms::DataGridViewContentAlignment::MiddleLeft;
             dataGridViewCellStyle1->BackColor = System::Drawing::SystemColors::Window;
             dataGridViewCellStyle1->Font = (gcnew System::Drawing::Font(L"Consolas", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point,
                 static_cast<System::Byte>(0)));
             dataGridViewCellStyle1->ForeColor = System::Drawing::SystemColors::ControlText;
             dataGridViewCellStyle1->SelectionBackColor = System::Drawing::SystemColors::Highlight;
             dataGridViewCellStyle1->SelectionForeColor = System::Drawing::SystemColors::HighlightText;
             dataGridViewCellStyle1->WrapMode = System::Windows::Forms::DataGridViewTriState::False;
             this->gridViewParameter->DefaultCellStyle = dataGridViewCellStyle1;
             this->gridViewParameter->Dock = System::Windows::Forms::DockStyle::Fill;
             this->gridViewParameter->Enabled = false;
             this->gridViewParameter->EnableHeadersVisualStyles = false;
             this->gridViewParameter->Location = System::Drawing::Point(0, 16);
             this->gridViewParameter->MultiSelect = false;
             this->gridViewParameter->Name = L"gridViewParameter";
             this->gridViewParameter->RowHeadersVisible = false;
             this->gridViewParameter->RowHeadersWidth = 51;
             this->gridViewParameter->SelectionMode = System::Windows::Forms::DataGridViewSelectionMode::FullRowSelect;
             this->gridViewParameter->Size = System::Drawing::Size(311, 79);
             this->gridViewParameter->StandardTab = true;
             this->gridViewParameter->TabIndex = 1;
             this->gridViewParameter->CellContentClick += gcnew System::Windows::Forms::DataGridViewCellEventHandler(this, &SampleForm::gridView_CellContentClick);
             this->gridViewParameter->CellValidated += gcnew System::Windows::Forms::DataGridViewCellEventHandler(this, &SampleForm::gridViewParameter_CellValidated);
             this->gridViewParameter->CellValidating += gcnew System::Windows::Forms::DataGridViewCellValidatingEventHandler(this, &SampleForm::gridViewParameter_CellValidating);
             this->gridViewParameter->CellValueChanged += gcnew System::Windows::Forms::DataGridViewCellEventHandler(this, &SampleForm::gridView_CellValueChanged);
             // 
             // dataGridViewTextBoxColumnName
             // 
             this->dataGridViewTextBoxColumnName->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnName->HeaderText = L"Name";
             this->dataGridViewTextBoxColumnName->MinimumWidth = 6;
             this->dataGridViewTextBoxColumnName->Name = L"dataGridViewTextBoxColumnName";
             this->dataGridViewTextBoxColumnName->ReadOnly = true;
             this->dataGridViewTextBoxColumnName->Width = 58;
             // 
             // dataGridViewTextBoxColumnDirection
             // 
             this->dataGridViewTextBoxColumnDirection->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnDirection->HeaderText = L"Direction";
             this->dataGridViewTextBoxColumnDirection->Name = L"dataGridViewTextBoxColumnDirection";
             this->dataGridViewTextBoxColumnDirection->ReadOnly = true;
             this->dataGridViewTextBoxColumnDirection->Width = 72;
             // 
             // dataGridViewTextBoxColumnDataType
             // 
             this->dataGridViewTextBoxColumnDataType->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnDataType->HeaderText = L"DataType";
             this->dataGridViewTextBoxColumnDataType->MinimumWidth = 6;
             this->dataGridViewTextBoxColumnDataType->Name = L"dataGridViewTextBoxColumnDataType";
             this->dataGridViewTextBoxColumnDataType->ReadOnly = true;
             this->dataGridViewTextBoxColumnDataType->Width = 77;
             // 
             // dataGridViewTextBoxColumnValue
             // 
             this->dataGridViewTextBoxColumnValue->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnValue->HeaderText = L"Value";
             this->dataGridViewTextBoxColumnValue->MinimumWidth = 80;
             this->dataGridViewTextBoxColumnValue->Name = L"dataGridViewTextBoxColumnValue";
             this->dataGridViewTextBoxColumnValue->Width = 80;
             // 
             // dataGridViewTextBoxColumnDetails
             // 
             this->dataGridViewTextBoxColumnDetails->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnDetails->HeaderText = L"Details";
             this->dataGridViewTextBoxColumnDetails->Name = L"dataGridViewTextBoxColumnDetails";
             this->dataGridViewTextBoxColumnDetails->ReadOnly = true;
             this->dataGridViewTextBoxColumnDetails->Width = 62;
             // 
             // labelAdjustProcedureParameters
             // 
             this->labelAdjustProcedureParameters->AutoSize = true;
             this->labelAdjustProcedureParameters->Dock = System::Windows::Forms::DockStyle::Top;
             this->labelAdjustProcedureParameters->Location = System::Drawing::Point(0, 0);
             this->labelAdjustProcedureParameters->Name = L"labelAdjustProcedureParameters";
             this->labelAdjustProcedureParameters->Padding = System::Windows::Forms::Padding(0, 0, 0, 3);
             this->labelAdjustProcedureParameters->Size = System::Drawing::Size(188, 16);
             this->labelAdjustProcedureParameters->TabIndex = 0;
             this->labelAdjustProcedureParameters->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/94D3A64.htm";
             this->labelAdjustProcedureParameters->Text = L"Parameters of the selected Procedure:";
             // 
             // splitContainer3
             // 
             this->splitContainer3->Dock = System::Windows::Forms::DockStyle::Fill;
             this->splitContainer3->Location = System::Drawing::Point(0, 0);
             this->splitContainer3->Name = L"splitContainer3";
             this->splitContainer3->Orientation = System::Windows::Forms::Orientation::Horizontal;
             // 
             // splitContainer3.Panel1
             // 
             this->splitContainer3->Panel1->Controls->Add(this->gridViewContext);
             this->splitContainer3->Panel1->Controls->Add(this->label4);
             // 
             // splitContainer3.Panel2
             // 
             this->splitContainer3->Panel2->Controls->Add(this->gridViewState);
             this->splitContainer3->Panel2->Controls->Add(this->label5);
             this->splitContainer3->Size = System::Drawing::Size(311, 219);
             this->splitContainer3->SplitterDistance = 105;
             this->splitContainer3->TabIndex = 0;
             // 
             // gridViewContext
             // 
             this->gridViewContext->AllowUserToAddRows = false;
             this->gridViewContext->AllowUserToDeleteRows = false;
             this->gridViewContext->AllowUserToResizeRows = false;
             this->gridViewContext->BackgroundColor = System::Drawing::SystemColors::Window;
             this->gridViewContext->BorderStyle = System::Windows::Forms::BorderStyle::Fixed3D;
             this->gridViewContext->CellBorderStyle = System::Windows::Forms::DataGridViewCellBorderStyle::None;
             this->gridViewContext->ColumnHeadersBorderStyle = System::Windows::Forms::DataGridViewHeaderBorderStyle::None;
             this->gridViewContext->ColumnHeadersHeightSizeMode = System::Windows::Forms::DataGridViewColumnHeadersHeightSizeMode::AutoSize;
             this->gridViewContext->Columns->AddRange(gcnew cli::array< System::Windows::Forms::DataGridViewColumn^  >(4) {
                 this->dataGridViewTextBoxColumnContextName,
                     this->dataGridViewTextBoxColumnContextDataType, this->dataGridViewTextBoxColumnContextValue, this->dataGridViewTextBoxColumnContextDetails
             });
             dataGridViewCellStyle2->Alignment = System::Windows::Forms::DataGridViewContentAlignment::MiddleLeft;
             dataGridViewCellStyle2->BackColor = System::Drawing::SystemColors::Window;
             dataGridViewCellStyle2->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             dataGridViewCellStyle2->ForeColor = System::Drawing::SystemColors::ControlText;
             dataGridViewCellStyle2->SelectionBackColor = System::Drawing::SystemColors::Highlight;
             dataGridViewCellStyle2->SelectionForeColor = System::Drawing::SystemColors::HighlightText;
             dataGridViewCellStyle2->WrapMode = System::Windows::Forms::DataGridViewTriState::False;
             this->gridViewContext->DefaultCellStyle = dataGridViewCellStyle2;
             this->gridViewContext->Dock = System::Windows::Forms::DockStyle::Fill;
             this->gridViewContext->EnableHeadersVisualStyles = false;
             this->gridViewContext->Location = System::Drawing::Point(0, 16);
             this->gridViewContext->MultiSelect = false;
             this->gridViewContext->Name = L"gridViewContext";
             this->gridViewContext->RowHeadersVisible = false;
             this->gridViewContext->RowHeadersWidth = 51;
             this->gridViewContext->SelectionMode = System::Windows::Forms::DataGridViewSelectionMode::FullRowSelect;
             this->gridViewContext->Size = System::Drawing::Size(311, 89);
             this->gridViewContext->StandardTab = true;
             this->gridViewContext->TabIndex = 1;
             this->gridViewContext->CellContentClick += gcnew System::Windows::Forms::DataGridViewCellEventHandler(this, &SampleForm::gridView_CellContentClick);
             this->gridViewContext->CellValidated += gcnew System::Windows::Forms::DataGridViewCellEventHandler(this, &SampleForm::gridViewContextVariable_CellValidated);
             this->gridViewContext->CellValidating += gcnew System::Windows::Forms::DataGridViewCellValidatingEventHandler(this, &SampleForm::gridViewContextVariable_CellValidating);
             this->gridViewContext->CellValueChanged += gcnew System::Windows::Forms::DataGridViewCellEventHandler(this, &SampleForm::gridView_CellValueChanged);
             // 
             // dataGridViewTextBoxColumnContextName
             // 
             this->dataGridViewTextBoxColumnContextName->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnContextName->HeaderText = L"Name";
             this->dataGridViewTextBoxColumnContextName->MinimumWidth = 6;
             this->dataGridViewTextBoxColumnContextName->Name = L"dataGridViewTextBoxColumnContextName";
             this->dataGridViewTextBoxColumnContextName->ReadOnly = true;
             this->dataGridViewTextBoxColumnContextName->Width = 58;
             // 
             // dataGridViewTextBoxColumnContextDataType
             // 
             this->dataGridViewTextBoxColumnContextDataType->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnContextDataType->HeaderText = L"DataType";
             this->dataGridViewTextBoxColumnContextDataType->MinimumWidth = 6;
             this->dataGridViewTextBoxColumnContextDataType->Name = L"dataGridViewTextBoxColumnContextDataType";
             this->dataGridViewTextBoxColumnContextDataType->ReadOnly = true;
             this->dataGridViewTextBoxColumnContextDataType->Width = 77;
             // 
             // dataGridViewTextBoxColumnContextValue
             // 
             this->dataGridViewTextBoxColumnContextValue->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnContextValue->HeaderText = L"Value";
             this->dataGridViewTextBoxColumnContextValue->MinimumWidth = 80;
             this->dataGridViewTextBoxColumnContextValue->Name = L"dataGridViewTextBoxColumnContextValue";
             this->dataGridViewTextBoxColumnContextValue->Width = 80;
             // 
             // dataGridViewTextBoxColumnContextDetails
             // 
             this->dataGridViewTextBoxColumnContextDetails->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnContextDetails->HeaderText = L"Details";
             this->dataGridViewTextBoxColumnContextDetails->Name = L"dataGridViewTextBoxColumnContextDetails";
             this->dataGridViewTextBoxColumnContextDetails->Width = 62;
             // 
             // label4
             // 
             this->label4->AutoSize = true;
             this->label4->Dock = System::Windows::Forms::DockStyle::Top;
             this->label4->Location = System::Drawing::Point(0, 0);
             this->label4->Name = L"label4";
             this->label4->Padding = System::Windows::Forms::Padding(0, 0, 0, 3);
             this->label4->Size = System::Drawing::Size(277, 16);
             this->label4->TabIndex = 0;
             this->label4->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/A926ED83.htm";
             this->label4->Text = L"Set value for ContextVariables of the selected Document:";
             // 
             // gridViewState
             // 
             this->gridViewState->AllowUserToAddRows = false;
             this->gridViewState->AllowUserToDeleteRows = false;
             this->gridViewState->AllowUserToResizeRows = false;
             this->gridViewState->BackgroundColor = System::Drawing::SystemColors::Window;
             this->gridViewState->BorderStyle = System::Windows::Forms::BorderStyle::Fixed3D;
             this->gridViewState->CellBorderStyle = System::Windows::Forms::DataGridViewCellBorderStyle::None;
             this->gridViewState->ColumnHeadersBorderStyle = System::Windows::Forms::DataGridViewHeaderBorderStyle::None;
             this->gridViewState->ColumnHeadersHeightSizeMode = System::Windows::Forms::DataGridViewColumnHeadersHeightSizeMode::AutoSize;
             this->gridViewState->Columns->AddRange(gcnew cli::array< System::Windows::Forms::DataGridViewColumn^  >(4) {
                 this->dataGridViewTextBoxColumnStateName,
                     this->dataGridViewTextBoxColumnStateDataType, this->dataGridViewTextBoxColumnStateValue, this->dataGridViewTextBoxColumnStateDetails
             });
             dataGridViewCellStyle3->Alignment = System::Windows::Forms::DataGridViewContentAlignment::MiddleLeft;
             dataGridViewCellStyle3->BackColor = System::Drawing::SystemColors::Window;
             dataGridViewCellStyle3->Font = (gcnew System::Drawing::Font(L"Consolas", 9));
             dataGridViewCellStyle3->ForeColor = System::Drawing::SystemColors::ControlText;
             dataGridViewCellStyle3->SelectionBackColor = System::Drawing::SystemColors::Highlight;
             dataGridViewCellStyle3->SelectionForeColor = System::Drawing::SystemColors::HighlightText;
             dataGridViewCellStyle3->WrapMode = System::Windows::Forms::DataGridViewTriState::False;
             this->gridViewState->DefaultCellStyle = dataGridViewCellStyle3;
             this->gridViewState->Dock = System::Windows::Forms::DockStyle::Fill;
             this->gridViewState->EnableHeadersVisualStyles = false;
             this->gridViewState->Location = System::Drawing::Point(0, 16);
             this->gridViewState->MultiSelect = false;
             this->gridViewState->Name = L"gridViewState";
             this->gridViewState->RowHeadersVisible = false;
             this->gridViewState->RowHeadersWidth = 51;
             this->gridViewState->Size = System::Drawing::Size(311, 94);
             this->gridViewState->StandardTab = true;
             this->gridViewState->TabIndex = 1;
             // 
             // dataGridViewTextBoxColumnStateName
             // 
             this->dataGridViewTextBoxColumnStateName->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::DisplayedCells;
             this->dataGridViewTextBoxColumnStateName->HeaderText = L"Name";
             this->dataGridViewTextBoxColumnStateName->MinimumWidth = 6;
             this->dataGridViewTextBoxColumnStateName->Name = L"dataGridViewTextBoxColumnStateName";
             this->dataGridViewTextBoxColumnStateName->ReadOnly = true;
             this->dataGridViewTextBoxColumnStateName->Width = 58;
             // 
             // dataGridViewTextBoxColumnStateDataType
             // 
             this->dataGridViewTextBoxColumnStateDataType->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnStateDataType->HeaderText = L"DataType";
             this->dataGridViewTextBoxColumnStateDataType->MinimumWidth = 6;
             this->dataGridViewTextBoxColumnStateDataType->Name = L"dataGridViewTextBoxColumnStateDataType";
             this->dataGridViewTextBoxColumnStateDataType->ReadOnly = true;
             this->dataGridViewTextBoxColumnStateDataType->Width = 77;
             // 
             // dataGridViewTextBoxColumnStateValue
             // 
             this->dataGridViewTextBoxColumnStateValue->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnStateValue->HeaderText = L"Value";
             this->dataGridViewTextBoxColumnStateValue->MinimumWidth = 80;
             this->dataGridViewTextBoxColumnStateValue->Name = L"dataGridViewTextBoxColumnStateValue";
             this->dataGridViewTextBoxColumnStateValue->ReadOnly = true;
             this->dataGridViewTextBoxColumnStateValue->Width = 80;
             // 
             // dataGridViewTextBoxColumnStateDetails
             // 
             this->dataGridViewTextBoxColumnStateDetails->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::AllCells;
             this->dataGridViewTextBoxColumnStateDetails->HeaderText = L"Details";
             this->dataGridViewTextBoxColumnStateDetails->Name = L"dataGridViewTextBoxColumnStateDetails";
             this->dataGridViewTextBoxColumnStateDetails->ReadOnly = true;
             this->dataGridViewTextBoxColumnStateDetails->Width = 62;
             // 
             // label5
             // 
             this->label5->AutoSize = true;
             this->label5->Dock = System::Windows::Forms::DockStyle::Top;
             this->label5->Location = System::Drawing::Point(0, 0);
             this->label5->Name = L"label5";
             this->label5->Padding = System::Windows::Forms::Padding(0, 0, 0, 3);
             this->label5->Size = System::Drawing::Size(248, 16);
             this->label5->TabIndex = 0;
             this->label5->Tag = L"http://www.emotive.de/DeveloperReference/OtxRuntime/html/94D3A64.htm";
             this->label5->Text = L"Display Status Variables of the selected Document:";
             // 
             // panel3
             // 
             this->panel3->Controls->Add(this->gridViewSettings);
             this->panel3->Controls->Add(this->panel4);
             this->panel3->Dock = System::Windows::Forms::DockStyle::Fill;
             this->panel3->Location = System::Drawing::Point(0, 46);
             this->panel3->Name = L"panel3";
             this->panel3->Size = System::Drawing::Size(702, 272);
             this->panel3->TabIndex = 1;
             // 
             // gridViewSettings
             // 
             this->gridViewSettings->AllowUserToAddRows = false;
             this->gridViewSettings->AllowUserToDeleteRows = false;
             this->gridViewSettings->AllowUserToResizeRows = false;
             this->gridViewSettings->BackgroundColor = System::Drawing::SystemColors::Window;
             this->gridViewSettings->BorderStyle = System::Windows::Forms::BorderStyle::Fixed3D;
             this->gridViewSettings->CellBorderStyle = System::Windows::Forms::DataGridViewCellBorderStyle::None;
             this->gridViewSettings->ColumnHeadersBorderStyle = System::Windows::Forms::DataGridViewHeaderBorderStyle::None;
             this->gridViewSettings->ColumnHeadersHeightSizeMode = System::Windows::Forms::DataGridViewColumnHeadersHeightSizeMode::AutoSize;
             this->gridViewSettings->Columns->AddRange(gcnew cli::array< System::Windows::Forms::DataGridViewColumn^  >(2) {
                 this->dataGridViewTextBoxColumnSettingName,
                     this->dataGridViewTextBoxColumnSettingValue
             });
             this->gridViewSettings->Dock = System::Windows::Forms::DockStyle::Fill;
             this->gridViewSettings->Location = System::Drawing::Point(0, 28);
             this->gridViewSettings->MultiSelect = false;
             this->gridViewSettings->Name = L"gridViewSettings";
             this->gridViewSettings->RowHeadersVisible = false;
             this->gridViewSettings->RowHeadersWidth = 51;
             this->gridViewSettings->SelectionMode = System::Windows::Forms::DataGridViewSelectionMode::FullRowSelect;
             this->gridViewSettings->Size = System::Drawing::Size(702, 244);
             this->gridViewSettings->StandardTab = true;
             this->gridViewSettings->TabIndex = 1;
             // 
             // dataGridViewTextBoxColumnSettingName
             // 
             this->dataGridViewTextBoxColumnSettingName->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::Fill;
             this->dataGridViewTextBoxColumnSettingName->HeaderText = L"Name";
             this->dataGridViewTextBoxColumnSettingName->MinimumWidth = 100;
             this->dataGridViewTextBoxColumnSettingName->Name = L"dataGridViewTextBoxColumnSettingName";
             this->dataGridViewTextBoxColumnSettingName->ReadOnly = true;
             // 
             // dataGridViewTextBoxColumnSettingValue
             // 
             this->dataGridViewTextBoxColumnSettingValue->AutoSizeMode = System::Windows::Forms::DataGridViewAutoSizeColumnMode::Fill;
             this->dataGridViewTextBoxColumnSettingValue->HeaderText = L"Value";
             this->dataGridViewTextBoxColumnSettingValue->MinimumWidth = 160;
             this->dataGridViewTextBoxColumnSettingValue->Name = L"dataGridViewTextBoxColumnSettingValue";
             // 
             // panel4
             // 
             this->panel4->Controls->Add(this->label12);
             this->panel4->Controls->Add(this->buttonWriteSettings);
             this->panel4->Controls->Add(this->buttonReadSettings);
             this->panel4->Dock = System::Windows::Forms::DockStyle::Top;
             this->panel4->Location = System::Drawing::Point(0, 0);
             this->panel4->Name = L"panel4";
             this->panel4->Padding = System::Windows::Forms::Padding(20, 0, 20, 0);
             this->panel4->Size = System::Drawing::Size(702, 28);
             this->panel4->TabIndex = 0;
             // 
             // label12
             // 
             this->label12->AutoSize = true;
             this->label12->Location = System::Drawing::Point(2, 8);
             this->label12->Name = L"label12";
             this->label12->Padding = System::Windows::Forms::Padding(0, 3, 0, 3);
             this->label12->Size = System::Drawing::Size(81, 19);
             this->label12->TabIndex = 0;
             this->label12->Text = L"Project Settings";
             // 
             // buttonWriteSettings
             // 
             this->buttonWriteSettings->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonWriteSettings->Location = System::Drawing::Point(652, 3);
             this->buttonWriteSettings->Name = L"buttonWriteSettings";
             this->buttonWriteSettings->Size = System::Drawing::Size(50, 23);
             this->buttonWriteSettings->TabIndex = 2;
             this->buttonWriteSettings->Text = L"Write";
             this->buttonWriteSettings->UseVisualStyleBackColor = true;
             this->buttonWriteSettings->Click += gcnew System::EventHandler(this, &SampleForm::buttonWriteSettings_Click);
             // 
             // buttonReadSettings
             // 
             this->buttonReadSettings->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->buttonReadSettings->Location = System::Drawing::Point(598, 3);
             this->buttonReadSettings->Name = L"buttonReadSettings";
             this->buttonReadSettings->Size = System::Drawing::Size(50, 23);
             this->buttonReadSettings->TabIndex = 1;
             this->buttonReadSettings->Text = L"Read";
             this->buttonReadSettings->UseVisualStyleBackColor = true;
             this->buttonReadSettings->Click += gcnew System::EventHandler(this, &SampleForm::buttonReadSettings_Click);
             // 
             // groupBox1
             // 
             this->groupBox1->Controls->Add(this->radioButtonNoCustomImplementation);
             this->groupBox1->Controls->Add(this->radioButtonDefaultImplementation);
             this->groupBox1->Controls->Add(this->radioButtonOuputWindow);
             this->groupBox1->Dock = System::Windows::Forms::DockStyle::Top;
             this->groupBox1->Location = System::Drawing::Point(0, 0);
             this->groupBox1->MinimumSize = System::Drawing::Size(166, 0);
             this->groupBox1->Name = L"groupBox1";
             this->groupBox1->Size = System::Drawing::Size(702, 46);
             this->groupBox1->TabIndex = 0;
             this->groupBox1->TabStop = false;
             this->groupBox1->Text = L"Select Custom Implementation";
             // 
             // radioButtonNoCustomImplementation
             // 
             this->radioButtonNoCustomImplementation->AutoSize = true;
             this->radioButtonNoCustomImplementation->Location = System::Drawing::Point(250, 19);
             this->radioButtonNoCustomImplementation->Name = L"radioButtonNoCustomImplementation";
             this->radioButtonNoCustomImplementation->Size = System::Drawing::Size(51, 17);
             this->radioButtonNoCustomImplementation->TabIndex = 2;
             this->radioButtonNoCustomImplementation->TabStop = true;
             this->radioButtonNoCustomImplementation->Text = L"None";
             this->radioButtonNoCustomImplementation->UseVisualStyleBackColor = true;
             this->radioButtonNoCustomImplementation->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::radioButtonCustomImpl_CheckedChanged);
             // 
             // radioButtonDefaultImplementation
             // 
             this->radioButtonDefaultImplementation->AutoSize = true;
             this->radioButtonDefaultImplementation->Location = System::Drawing::Point(6, 19);
             this->radioButtonDefaultImplementation->Name = L"radioButtonDefaultImplementation";
             this->radioButtonDefaultImplementation->Size = System::Drawing::Size(133, 17);
             this->radioButtonDefaultImplementation->TabIndex = 0;
             this->radioButtonDefaultImplementation->TabStop = true;
             this->radioButtonDefaultImplementation->Text = L"Default Implementation";
             this->radioButtonDefaultImplementation->UseVisualStyleBackColor = true;
             this->radioButtonDefaultImplementation->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::radioButtonCustomImpl_CheckedChanged);
             // 
             // radioButtonOuputWindow
             // 
             this->radioButtonOuputWindow->AutoSize = true;
             this->radioButtonOuputWindow->Location = System::Drawing::Point(145, 19);
             this->radioButtonOuputWindow->Name = L"radioButtonOuputWindow";
             this->radioButtonOuputWindow->Size = System::Drawing::Size(99, 17);
             this->radioButtonOuputWindow->TabIndex = 1;
             this->radioButtonOuputWindow->TabStop = true;
             this->radioButtonOuputWindow->Text = L"Output Window";
             this->radioButtonOuputWindow->UseVisualStyleBackColor = true;
             this->radioButtonOuputWindow->CheckedChanged += gcnew System::EventHandler(this, &SampleForm::radioButtonCustomImpl_CheckedChanged);
             // 
             // splitContainer4
             // 
             this->splitContainer4->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Bottom)
                 | System::Windows::Forms::AnchorStyles::Left)
                 | System::Windows::Forms::AnchorStyles::Right));
             this->splitContainer4->FixedPanel = System::Windows::Forms::FixedPanel::Panel1;
             this->splitContainer4->Location = System::Drawing::Point(12, 12);
             this->splitContainer4->Name = L"splitContainer4";
             this->splitContainer4->Orientation = System::Windows::Forms::Orientation::Horizontal;
             // 
             // splitContainer4.Panel1
             // 
             this->splitContainer4->Panel1->Controls->Add(this->splitContainer1);
             this->splitContainer4->Panel1->Controls->Add(this->panel1);
             // 
             // splitContainer4.Panel2
             // 
             this->splitContainer4->Panel2->Controls->Add(this->panel2);
             this->splitContainer4->Size = System::Drawing::Size(1328, 714);
             this->splitContainer4->SplitterDistance = 405;
             this->splitContainer4->TabIndex = 9;
             // 
             // folderBrowserDialog1
             // 
             this->folderBrowserDialog1->Description = L"Browse for folder...";
             // 
             // imageList1
             // 
             this->imageList1->ImageStream = (cli::safe_cast<System::Windows::Forms::ImageListStreamer^>(resources->GetObject(L"imageList1.ImageStream")));
             this->imageList1->TransparentColor = System::Drawing::Color::Transparent;
             this->imageList1->Images->SetKeyName(0, L"ODFProject.bmp");
             this->imageList1->Images->SetKeyName(1, L"Package.bmp");
             this->imageList1->Images->SetKeyName(2, L"DocumentOTX16.bmp");
             this->imageList1->Images->SetKeyName(3, L"Procedure.bmp");
             // 
             // labelSeparator2
             // 
             this->labelSeparator2->BackColor = System::Drawing::SystemColors::ControlDark;
             this->labelSeparator2->Location = System::Drawing::Point(693, 5);
             this->labelSeparator2->Margin = System::Windows::Forms::Padding(3, 5, 3, 0);
             this->labelSeparator2->Name = L"labelSeparator2";
             this->labelSeparator2->Size = System::Drawing::Size(1, 16);
             this->labelSeparator2->TabIndex = 5;
             // 
             // labelProcedureExecutionState
             // 
             this->labelProcedureExecutionState->AutoEllipsis = true;
             this->labelProcedureExecutionState->Dock = System::Windows::Forms::DockStyle::Fill;
             this->labelProcedureExecutionState->Location = System::Drawing::Point(22, 0);
             this->labelProcedureExecutionState->Margin = System::Windows::Forms::Padding(0, 0, 3, 0);
             this->labelProcedureExecutionState->Name = L"labelProcedureExecutionState";
             this->labelProcedureExecutionState->Padding = System::Windows::Forms::Padding(0, 7, 0, 0);
             this->labelProcedureExecutionState->Size = System::Drawing::Size(385, 31);
             this->labelProcedureExecutionState->TabIndex = 1;
             this->labelProcedureExecutionState->Text = L"Select a procedure and click \"Start\"...";
             // 
             // tableLayoutPanelExecutionState
             // 
             this->tableLayoutPanelExecutionState->ColumnCount = 23;
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Percent,
                 100)));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle()));
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelIconProcedureExecutionState, 0, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelProcedureExecutionState, 1, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelSeparator2, 7, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->checkBoxUseConnectionState, 8, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelBatteryState, 11, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->checkBoxIgnition, 12, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelExpectedState, 10, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelSeparator3, 9, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->textBoxVoltageThreshold, 19, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelVoltageThreshold, 18, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->textBoxPollingTime, 17, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelPollingTime, 16, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelSeparator4, 15, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelSeparator1, 2, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelTimeout, 5, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->textBoxTimeout, 6, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->buttonCheckBatteryIgnition, 14, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelIgnitionState, 13, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelSeparator5, 4, 0);
             this->tableLayoutPanelExecutionState->Controls->Add(this->labelProcedureExecutionTimes, 3, 0);
             this->tableLayoutPanelExecutionState->Dock = System::Windows::Forms::DockStyle::Bottom;
             this->tableLayoutPanelExecutionState->Location = System::Drawing::Point(0, 593);
             this->tableLayoutPanelExecutionState->Name = L"tableLayoutPanelExecutionState";
             this->tableLayoutPanelExecutionState->Padding = System::Windows::Forms::Padding(0, 0, 3, 0);
             this->tableLayoutPanelExecutionState->RowCount = 1;
             this->tableLayoutPanelExecutionState->RowStyles->Add((gcnew System::Windows::Forms::RowStyle()));
             this->tableLayoutPanelExecutionState->Size = System::Drawing::Size(1352, 28);
             this->tableLayoutPanelExecutionState->TabIndex = 10;
             // 
             // labelIconProcedureExecutionState
             // 
             this->labelIconProcedureExecutionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"labelIconProcedureExecutionState.Image")));
             this->labelIconProcedureExecutionState->Location = System::Drawing::Point(4, 0);
             this->labelIconProcedureExecutionState->Margin = System::Windows::Forms::Padding(4, 0, 0, 0);
             this->labelIconProcedureExecutionState->Name = L"labelIconProcedureExecutionState";
             this->labelIconProcedureExecutionState->Padding = System::Windows::Forms::Padding(0, 6, 0, 0);
             this->labelIconProcedureExecutionState->Size = System::Drawing::Size(18, 22);
             this->labelIconProcedureExecutionState->TabIndex = 0;
             this->labelIconProcedureExecutionState->TextAlign = System::Drawing::ContentAlignment::MiddleLeft;
             // 
             // labelBatteryState
             // 
             this->labelBatteryState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"labelBatteryState.Image")));
             this->labelBatteryState->ImageAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->labelBatteryState->Location = System::Drawing::Point(952, 0);
             this->labelBatteryState->Name = L"labelBatteryState";
             this->labelBatteryState->Padding = System::Windows::Forms::Padding(0, 4, 0, 0);
             this->labelBatteryState->Size = System::Drawing::Size(20, 23);
             this->labelBatteryState->TabIndex = 9;
             // 
             // labelExpectedState
             // 
             this->labelExpectedState->AutoSize = true;
             this->labelExpectedState->Location = System::Drawing::Point(852, 0);
             this->labelExpectedState->Name = L"labelExpectedState";
             this->labelExpectedState->Padding = System::Windows::Forms::Padding(0, 7, 0, 0);
             this->labelExpectedState->Size = System::Drawing::Size(94, 20);
             this->labelExpectedState->TabIndex = 8;
             this->labelExpectedState->Text = L"Expected: BAT on";
             // 
             // labelSeparator3
             // 
             this->labelSeparator3->BackColor = System::Drawing::SystemColors::ControlDark;
             this->labelSeparator3->Location = System::Drawing::Point(845, 5);
             this->labelSeparator3->Margin = System::Windows::Forms::Padding(3, 5, 3, 0);
             this->labelSeparator3->Name = L"labelSeparator3";
             this->labelSeparator3->Size = System::Drawing::Size(1, 16);
             this->labelSeparator3->TabIndex = 7;
             // 
             // labelSeparator4
             // 
             this->labelSeparator4->BackColor = System::Drawing::SystemColors::ControlDark;
             this->labelSeparator4->Location = System::Drawing::Point(1085, 5);
             this->labelSeparator4->Margin = System::Windows::Forms::Padding(3, 5, 3, 0);
             this->labelSeparator4->Name = L"labelSeparator4";
             this->labelSeparator4->Size = System::Drawing::Size(1, 16);
             this->labelSeparator4->TabIndex = 12;
             // 
             // labelSeparator1
             // 
             this->labelSeparator1->BackColor = System::Drawing::SystemColors::ControlDark;
             this->labelSeparator1->Location = System::Drawing::Point(413, 5);
             this->labelSeparator1->Margin = System::Windows::Forms::Padding(3, 5, 3, 0);
             this->labelSeparator1->Name = L"labelSeparator1";
             this->labelSeparator1->Size = System::Drawing::Size(1, 16);
             this->labelSeparator1->TabIndex = 2;
             this->labelSeparator1->Visible = false;
             // 
             // buttonCheckBatteryIgnition
             // 
             this->buttonCheckBatteryIgnition->Location = System::Drawing::Point(1055, 3);
             this->buttonCheckBatteryIgnition->Name = L"buttonCheckBatteryIgnition";
             this->buttonCheckBatteryIgnition->Size = System::Drawing::Size(24, 20);
             this->buttonCheckBatteryIgnition->TabIndex = 11;
             this->buttonCheckBatteryIgnition->Text = L"...";
             this->buttonCheckBatteryIgnition->UseVisualStyleBackColor = true;
             this->buttonCheckBatteryIgnition->Click += gcnew System::EventHandler(this, &SampleForm::buttonCheckBatteryIgnition_Click);
             // 
             // labelIgnitionState
             // 
             this->labelIgnitionState->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"labelIgnitionState.Image")));
             this->labelIgnitionState->ImageAlign = System::Drawing::ContentAlignment::MiddleRight;
             this->labelIgnitionState->Location = System::Drawing::Point(1029, 0);
             this->labelIgnitionState->Name = L"labelIgnitionState";
             this->labelIgnitionState->Padding = System::Windows::Forms::Padding(0, 4, 0, 0);
             this->labelIgnitionState->Size = System::Drawing::Size(20, 23);
             this->labelIgnitionState->TabIndex = 9;
             // 
             // labelSeparator5
             // 
             this->labelSeparator5->BackColor = System::Drawing::SystemColors::ControlDark;
             this->labelSeparator5->Location = System::Drawing::Point(584, 5);
             this->labelSeparator5->Margin = System::Windows::Forms::Padding(3, 5, 3, 0);
             this->labelSeparator5->Name = L"labelSeparator5";
             this->labelSeparator5->Size = System::Drawing::Size(1, 16);
             this->labelSeparator5->TabIndex = 5;
             // 
             // labelProcedureExecutionTimes
             // 
             this->labelProcedureExecutionTimes->Anchor = static_cast<System::Windows::Forms::AnchorStyles>((System::Windows::Forms::AnchorStyles::Top | System::Windows::Forms::AnchorStyles::Right));
             this->labelProcedureExecutionTimes->AutoSize = true;
             this->labelProcedureExecutionTimes->Location = System::Drawing::Point(420, 0);
             this->labelProcedureExecutionTimes->Name = L"labelProcedureExecutionTimes";
             this->labelProcedureExecutionTimes->Padding = System::Windows::Forms::Padding(0, 7, 0, 0);
             this->labelProcedureExecutionTimes->Size = System::Drawing::Size(158, 20);
             this->labelProcedureExecutionTimes->TabIndex = 3;
             this->labelProcedureExecutionTimes->Text = L"main: 00:12 | Procedure1: 01:24";
             this->labelProcedureExecutionTimes->Visible = false;
             // 
             // label18
             // 
             this->label18->BackColor = System::Drawing::SystemColors::ControlDark;
             this->label18->Dock = System::Windows::Forms::DockStyle::Bottom;
             this->label18->Location = System::Drawing::Point(0, 592);
             this->label18->Name = L"label18";
             this->label18->Size = System::Drawing::Size(1352, 1);
             this->label18->TabIndex = 0;
             // 
             // updateGuiTimer
             // 
             this->updateGuiTimer->Interval = 500;
             this->updateGuiTimer->Tick += gcnew System::EventHandler(this, &SampleForm::updateGuiTimer_Tick);
             // 
             // SampleForm
             // 
             this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
             this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
             this->BackColor = System::Drawing::SystemColors::Window;
             this->ClientSize = System::Drawing::Size(1352, 621);
             this->Controls->Add(this->label18);
             this->Controls->Add(this->tableLayoutPanelExecutionState);
             this->Controls->Add(this->splitContainer4);
             this->DoubleBuffered = true;
             this->Icon = (cli::safe_cast<System::Drawing::Icon^>(resources->GetObject(L"$this.Icon")));
             this->MinimumSize = System::Drawing::Size(1260, 660);
             this->Name = L"SampleForm";
             this->FormClosing += gcnew System::Windows::Forms::FormClosingEventHandler(this, &SampleForm::SampleForm_FormClosing);
             this->Load += gcnew System::EventHandler(this, &SampleForm::SampleForm_Load);
             this->Shown += gcnew System::EventHandler(this, &SampleForm::SampleForm_Shown);
             this->panel1->ResumeLayout(false);
             this->panel1->PerformLayout();
             this->panel2->ResumeLayout(false);
             this->panel2->PerformLayout();
             this->splitContainer1->Panel1->ResumeLayout(false);
             this->splitContainer1->Panel1->PerformLayout();
             this->splitContainer1->Panel2->ResumeLayout(false);
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer1))->EndInit();
             this->splitContainer1->ResumeLayout(false);
             this->splitContainer5->Panel1->ResumeLayout(false);
             this->splitContainer5->Panel2->ResumeLayout(false);
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer5))->EndInit();
             this->splitContainer5->ResumeLayout(false);
             this->splitContainer2->Panel1->ResumeLayout(false);
             this->splitContainer2->Panel1->PerformLayout();
             this->splitContainer2->Panel2->ResumeLayout(false);
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer2))->EndInit();
             this->splitContainer2->ResumeLayout(false);
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewParameter))->EndInit();
             this->splitContainer3->Panel1->ResumeLayout(false);
             this->splitContainer3->Panel1->PerformLayout();
             this->splitContainer3->Panel2->ResumeLayout(false);
             this->splitContainer3->Panel2->PerformLayout();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer3))->EndInit();
             this->splitContainer3->ResumeLayout(false);
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewContext))->EndInit();
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewState))->EndInit();
             this->panel3->ResumeLayout(false);
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->gridViewSettings))->EndInit();
             this->panel4->ResumeLayout(false);
             this->panel4->PerformLayout();
             this->groupBox1->ResumeLayout(false);
             this->groupBox1->PerformLayout();
             this->splitContainer4->Panel1->ResumeLayout(false);
             this->splitContainer4->Panel2->ResumeLayout(false);
             (cli::safe_cast<System::ComponentModel::ISupportInitialize^>(this->splitContainer4))->EndInit();
             this->splitContainer4->ResumeLayout(false);
             this->tableLayoutPanelExecutionState->ResumeLayout(false);
             this->tableLayoutPanelExecutionState->PerformLayout();
             this->ResumeLayout(false);
  
         }
 #pragma endregion
     private: System::Void textBoxTraceFileMaxSize_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxTraceFileMaxCount_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonOpenTraceFolder_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxRuntimeContextName_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxPortPipe_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxIpcType_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonBrowseTraceFolder_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxTraceFolder_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxTraceLevel_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxTraceLevel_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonReload_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void txtPassword_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonBrowseFile_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void cbFilePath_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void cbFilePath_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxTimeout_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxBatteryVoltageThreshold_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxPollingTime_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void CheckBoxKL15_CheckStateChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxUseConnectionState_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonLicense_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonStartStopWebServer_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonHmi_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxNewRuntimeManager_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxCyclicReload_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void listBoxOuput_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonCopyRow_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonClearOutput_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonNewInstanceNewThread_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonNewInstance_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxAdd2Output_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxCyclicExecution_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxAsyncExecution_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonPause_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonStop_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonExecuteMain_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonExecuteSelectedProcedure_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonWriteSettings_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonReadSettings_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void radioButtonCustomImpl_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonCheckBatteryIgnition_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void treeViewOtxProject_DrawNode(System::Object^ sender, System::Windows::Forms::DrawTreeNodeEventArgs^ e);
     private: System::Void treeViewOtxProject_AfterSelect(System::Object^ sender, System::Windows::Forms::TreeViewEventArgs^ e);
     private: System::Void gridView_CellValueChanged(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e);
     private: System::Void gridView_CellContentClick(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e);
     private: System::Void gridViewParameter_CellValidated(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e);
     private: System::Void gridViewParameter_CellValidating(System::Object^ sender, System::Windows::Forms::DataGridViewCellValidatingEventArgs^ e);
     private: System::Void gridViewContextVariable_CellValidated(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e);
     private: System::Void gridViewContextVariable_CellValidating(System::Object^ sender, System::Windows::Forms::DataGridViewCellValidatingEventArgs^ e);
     private: System::Void updateGuiTimer_Tick(System::Object^ sender, System::EventArgs^ e);
     private: System::Void SampleForm_Load(System::Object^ sender, System::EventArgs^ e);
     private: System::Void SampleForm_Shown(System::Object^ sender, System::EventArgs^ e);
     private: System::Void SampleForm_FormClosing(System::Object^ sender, System::Windows::Forms::FormClosingEventArgs^ e);
     private: void WebServerTimer_Tick(System::Object^ sender, System::EventArgs^ e);
     void HmiWindow_SizeChanged(System::Object^ sender, System::EventArgs^ e);
     void HmiWindow_Activated(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxODXProject_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxODXVehicle_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxDiagIpcType_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxIncludedDiagLogging_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonOpenDiagLoggingTraceFolder_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void buttonBrowseDiagLoggingTraceFolder_Click(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxDiagManagerLicenseKey_KeyDown(System::Object^ sender, System::Windows::Forms::KeyEventArgs^ e);
     private: System::Void textBoxDiagManagerLicenseKey_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxDiagManagerTraceLevel_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void comboBoxDiagLoggingTraceLevel_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxDiagManagerTraceFolder_TextChanged(System::Object^ sender, System::EventArgs^ e);
     private: void SystemEvents_DisplaySettingsChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void checkBoxProfiling_CheckedChanged(System::Object^ sender, System::EventArgs^ e);
     private: System::Void textBoxProfilingSize_TextChanged(System::Object^ sender, System::EventArgs^ e);
 };
 }}}}}

Table of Contents

Code Example CPP-File

Code Example Header-File