Runtime API Sample Program

Table of Contents

• Code Example CPP-File
• Code Example Header-File

The Sample program demonstrates the main functionality of the OTX-Runtime API. It can be used as a reference for the expected runtime behavior of the API and the source code below is like a reference guide about the proper programming of the API.

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;
 
    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)
    {
        if (runtimeManager == nullptr)
        {
            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);
    }
 
    void RemoveRuntimeEvents(std::shared_ptr<IRuntimeManager> runtimeManager)
    {
        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);
        }
    }
 
    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)
    {
        IRuntimeContext* pContext = const_cast<IRuntimeContext*>(&context);
        IProcedureInOutParameter* pParameter = const_cast<IProcedureInOutParameter*>(&parameter);
        Owner->InOutParameterValueChanged(pContext, pParameter);
    }
 
    void SetDefaultCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
    {
        if (runtimeManager == nullptr)
        {
            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);
    }
 
    void RemoveCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
    {
        if (runtimeManager == nullptr)
        {
            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);
    }
 
    void ClearCustomImplemetationCaches()
    {
        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)
    }
 
    void CreateDefaultCustomImpl()
    {
        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>();
    }
 
    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()
    {
        _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));
    }
 
    void RemoveOutputImplLogEventHandler()
    {
        if(_BasicScreenOutputImpl != nullptr)
            _BasicScreenOutputImpl->_logEventHandler = nullptr;
        if(_CustomScreenOutputImpl != nullptr)
            _CustomScreenOutputImpl->_logEventHandler = nullptr;
        if(_CustomScreenOutputImpl != nullptr)
            _LoggingOutputImpl->_logEventHandler = nullptr;
        if(_CustomScreenOutputImpl != nullptr)
            _ContextVariableOutputImpl->_logEventHandler = nullptr;
 
        if(_CustomScreenOutputImpl != nullptr)
            _StateVariableOutputImpl->_logEventHandler = nullptr;
        if(_CustomScreenOutputImpl != nullptr)
            _MeasureOutputImpl->_logEventHandler = nullptr;
        if(_CustomScreenOutputImpl != nullptr)
            _I18nOutputImpl->_logEventHandler = nullptr;
        if(_CustomScreenOutputImpl != nullptr)
            _ServiceProviderOutputImpl->_logEventHandler = nullptr;
 
        if(_CustomScreenOutputImpl != nullptr)
            _CommonDialogsOutputImpl->_logEventHandler = nullptr;
        if(_CustomScreenOutputImpl != nullptr)
            _SqlOutputImpl->_logEventHandler = nullptr;
 
        _BasicScreenOutputImpl = nullptr;
        _CustomScreenOutputImpl = nullptr;
        _LoggingOutputImpl = nullptr;
        _ContextVariableOutputImpl = nullptr;
 
        _StateVariableOutputImpl = nullptr;
        _MeasureOutputImpl = nullptr;
        _I18nOutputImpl = nullptr;
        _ServiceProviderOutputImpl = nullptr;
 
        _CommonDialogsOutputImpl = nullptr;
        _SqlOutputImpl = nullptr;
    }
 
    void WriteLogEvent(const std::string& text)
    {
        Owner->PrintTextCallback(Util::Util::ToString(text));
    }
 
    void SetOutputWindowImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
    {
        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);
    }
 
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()
{
    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);
    }
}
 
void SampleForm::SystemEvents_DisplaySettingsChanged(System::Object^ sender, System::EventArgs^ e)
{
    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 (...) {}
}
 
void SampleForm::InitializeInternalComponent()
{
    piml = new SampleFormImpl(this);
    RegisterSettingsEvent();
}
 
SampleForm::SampleForm(System::String^ title, SampleForm^ creatorForm)
{
    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");
}
 
System::Void SampleForm::SampleForm_Load(System::Object^ sender, System::EventArgs^ e)
{
    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
}
 
System::Void SampleForm::SampleForm_Shown(System::Object^ sender, System::EventArgs^ e)
{
    cbFilePath->SelectionLength = 0;
}
 
void SampleForm::SetRuntimeContextName()
{
    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++;
            textBoxRuntimeContextName->Text = Util::Util::ToString(piml->CreatorForm->piml->RuntimeContextName.substr(0, regExpMatch->Index) + std::to_string(number));
        }
    }
}
 
void SampleForm::SetTitle(System::String^ title)
{
    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 (!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;
    }
}
 
void SampleForm::SetLocation(SampleForm^ creatorForm)
{
    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;
    }
}
 
void SampleForm::CreateCustomImpl()
{
    CreateDefaultCustomImpl();
    CreateOutputWindowCustomImpl();
}
 
void SampleForm::CreateDefaultCustomImpl()
{
    PrintTextCallback("Create default custom implementation");
 
    piml->CreateDefaultCustomImpl();
}
 
void SampleForm::CreateOutputWindowCustomImpl()
{
    PrintTextCallback("Create output window custom implementation");
 
    piml->CreateOutputWindowCustomImpl();
}
 
void SampleForm::InitializeSampleDefaultValues()
{
    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();
}
 
void SampleForm::LoadSetting()
{
    Setting::UserSettings::GetInstance().Reload();
    try
    {
        SetupTraceLevel();
        SetupTraceFolder();
        SetupTraceFileMaxCountAndSize();
 
        // 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();
    }
}
 
void SampleForm::AddComboBoxFileOrPath(System::Windows::Forms::ComboBox^ comboBox)
{
    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;
    }
}
 
void SampleForm::SetupTraceFileMaxCountAndSize()
{
    textBoxTraceFileMaxCount->Text = Setting::UserSettings::GetInstance().GetTraceFileMaxCount().ToString();
    textBoxTraceFileMaxSize->Text = Setting::UserSettings::GetInstance().GetTraceFileMaxSize().ToString();
}
 
void SampleForm::SetupDefaultPortAndPipeName()
{
    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);
}
 
void SampleForm::SetupTraceLevel()
{
    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);
}
 
void SampleForm::SetupTraceFolder()
{
    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());
}
 
void SampleForm::SetupCustomImplType()
{
    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;
    }
}
 
void SampleForm::SetupWindowSize()
{
    int width = Setting::UserSettings::GetInstance().GetWindowWidth();
    int height = Setting::UserSettings::GetInstance().GetWindowHeight();
    Size = System::Drawing::Size(width, height);
}
 
void SampleForm::SetupWindowLocation()
{
    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;
        return;
    }
 
    CenterToScreen();
}
 
bool SampleForm::CheckFormIsInBound(System::Drawing::Point location)
{
    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))
            {
                return true;
            }
        }
 
        return false;
#pragma endregion
    }
    catch (...)
    {
        return false;
    }
}
 
void SampleForm::SetupTimeOut()
{
    System::String^ timeOutString = Setting::UserSettings::GetInstance().GetTimeOut().ToString();
    textBoxTimeout->Text = timeOutString;
}
 
void SampleForm::SetupPollingTime()
{
    std::string pollingTimeString = std::to_string(Setting::UserSettings::GetInstance().GetPollingTime());
    textBoxPollingTime->Text = Util::Util::ToString(pollingTimeString);
}
 
void SampleForm::SetupVoltageThreshold()
{
    std::string voltageThreshold = std::to_string(Setting::UserSettings::GetInstance().GetVoltageThreshold());
    textBoxVoltageThreshold->Text = Util::Util::ToString(voltageThreshold);
}
 
System::Void SampleForm::comboBoxIpcType_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
{
    // 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;
    }
}
 
System::Void SampleForm::textBoxPortPipe_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    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.");
    }
}
 
std::shared_ptr<IRuntimeManager> SampleForm::CreateRuntimeManager()
{
    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();
            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.");
 
        return runtimeManager;
    }
    catch (System::Exception^ ex)
    {
        PrintException(ex);
        PrintTextCallback("... No RuntimeManager created.");
 
        return runtimeManager;
    }
    catch (...)
    {
        PrintTextCallback("... No RuntimeManager created.");
 
        return runtimeManager;
    }
 
    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()
{
    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);
    }
}
 
std::shared_ptr<IRuntimeManager> SampleForm::CreatePipeRuntimeManager()
{
    if (NoDiag())
    {
        return RuntimeManagerFactory::CreatePipeRuntimeManager(Util::Util::ToString(textBoxRtPortPipe->Text));
    }
    else
    {
        return RuntimeManagerFactory::CreatePipeRuntimeManager(Util::Util::ToString(textBoxRtPortPipe->Text), Util::Util::ToString(textBoxDiagPortPipe->Text));
    }
}
 
bool SampleForm::NoDiag()
{
    return System::String::IsNullOrWhiteSpace(textBoxDiagPortPipe->Text);
}
 
void SampleForm::InitializeRuntimeEvents(std::shared_ptr<IRuntimeManager> runtimeManager)
{
    if (runtimeManager == nullptr)
    {
        return;
    }
 
    piml->InitializeRuntimeEvents(runtimeManager);
 
    PrintTextCallback("Initialization of runtime events finished");
}
 
System::Void SampleForm::radioButtonCustomImpl_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    if (piml->GlobalRuntimeManager == nullptr)
    {
        return;
    }
 
    if (sender != nullptr && (dynamic_cast<System::Windows::Forms::RadioButton^>(sender))->Checked == false)
    {
        return;
    }
 
    SetCustomImplementation(piml->GlobalRuntimeManager);
}
 
void SampleForm::SetCustomImplementation(std::shared_ptr<IRuntimeManager> runtimeManager)
{
    if (runtimeManager == nullptr)
    {
        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");
    }
}
 
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)
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action<CLRWrapper< IRuntimeContext*>^>(this, &SampleForm::ProcedurePendingCallback), clrContext);
        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);
    }
}
 
void SampleForm::ProcedureStartedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureStartedCallback), clrContext);
        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);
    }
}
 
void SampleForm::ProcedurePaused(IRuntimeContext* context, ExecutionStateChangeReason reason)
{
    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);
    }
}
 
void SampleForm::ProcedurePausedCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2)
    {
        return;
    }
 
    IRuntimeContext* context = Util::Util::CastTo<IRuntimeContext*>(arr[0]);
    ExecutionStateChangeReason reason = Util::Util::CastToEnum<ExecutionStateChangeReason>(arr[1]);
 
    if (context == nullptr)
    {
        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);
        }
    }
}
 
void SampleForm::ProcedureContinuedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureContinuedCallback), clrContext);
        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);
    }
}
 
void SampleForm::ProcedureStoppedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureStoppedCallback), clrContext);
        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);
    }
}
 
void SampleForm::ProcedureTimeoutCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureTimeoutCallback), clrContext);
        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);
    }
}
 
void SampleForm::DiagConnectionStateChanged(ClampState batteryState, ClampState ignitionState)
{
    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);
    }
}
 
void SampleForm::DiagConnectionStateChangedCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2)
    {
        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);
    }
}
 
// TODO: refactor. handle multithread?
void SampleForm::ProcedureFinishedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureFinishedCallback), clrContext);
        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());
        
        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"),
            System::TimeSpan::FromMilliseconds(context->GetExecutionTime()).ToString("hh':'mm':'ss','fff"),
            System::String::Format("{0:0,0} kB", context->GetProcessMemory() / 1024))
        );
 
        UpdateExecutionState(context);
 
        piml->CyclicExecuteAsyncIsProcessing = false;
    }
}
 
void SampleForm::ProcedureAbortedCallback(CLRWrapper<IRuntimeContext*>^ clrContext)
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action<CLRWrapper<IRuntimeContext*>^>(this, &SampleForm::ProcedureAbortedCallback), clrContext);
        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);
}
 
void SampleForm::UpdateExecutionState(IRuntimeContext* context, ExecutionStateChangeReason reason)
{
    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);
    }
}
 
void SampleForm::UpdateExecutionState(IRuntimeContext* context)
{   
    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();
    }
}
 
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()
{
    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("mm':'ss"));
        }
        text = text->TrimEnd(gcnew cli::array<wchar_t>{' ', '|'});
    }
 
    labelProcedureExecutionTimes->Text = text;
    labelSeparator1->Visible = true;
    labelProcedureExecutionTimes->Visible = true;
}
 
void SampleForm::InOutParameterValueChanged(IRuntimeContext* context, IProcedureInOutParameter* parameter)
{
    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);
    }
}
 
void SampleForm::InOutParameterValueChangedCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2)
    {
        return;
    }
 
    IRuntimeContext* context = Util::Util::CastTo<IRuntimeContext*>(arr[0]);
    IProcedureInOutParameter* parameter = Util::Util::CastTo<IProcedureInOutParameter*>(arr[1]);
 
    if (context == nullptr || parameter == nullptr)
    {
        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);
        }
    }
}
 
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)
{
#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")));
}
 
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)
{
#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;
    }
}
 
void SampleForm::SyncWithParent(System::Object^ parentControl)
{
    SyncWithParent(parentControl, nullptr);
}
 
void SampleForm::SyncWithParent(System::Object^ parentControl, System::Object^ control)
{
    SyncWithParent(parentControl, control, false);
}
 
void SampleForm::SyncWithParent(System::Object^ parentControl, System::Object^ control, bool newThread)
{
    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) && control != nullptr)
            {
                cli::array<System::Object^>^ state = gcnew cli::array<System::Object^>(2);
                state[0] = parentControl;
                state[1] = (dynamic_cast<System::Windows::Forms::Button^>(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) && control != nullptr)
            {
                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) && control != nullptr)
            {
                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) && control != nullptr)
            {
                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);
                }
            }
        }
    }
}
 
void SampleForm::ParentButtonClickCallback(System::Object^ state)
{
    System::Windows::Forms::Button^ parentButton = dynamic_cast<System::Windows::Forms::Button^> (state);
    if (parentButton == nullptr)
    {
        return;
    }
 
    if (parentButton->InvokeRequired)
    {
        piml->CreatorForm->Invoke(gcnew System::Action<System::Object^>(this, &SampleForm::ParentButtonClickCallback), parentButton);
    }
    else
    {
        parentButton->PerformClick();
    }
}
 
void SampleForm::TextBoxSetTextCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2) 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)
    {
        return;
    }
 
    parentTextBox->Text = textBox->Text;
}
 
void SampleForm::ParentTextBoxSetTextCallback(System::Object^ state)
{
    cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
    if (arr == nullptr || arr->Length != 2) 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)
    {
        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);
    }
}
 
void SampleForm::CheckBoxSetCheckStateCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2)
    {
        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)
    {
        return;
    }
 
    parentCheckBox->CheckState = checkBox->CheckState;
}
 
void SampleForm::ParentCheckBoxSetCheckStateCallback(System::Object^ state)
{
    cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
    if (arr == nullptr || arr->Length != 2) 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)
    {
        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);
    }
}
 
void SampleForm::ComboBoxSetIndexCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2) 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;
    }
 
    parentComboBox->SelectedIndex = comboBox->SelectedIndex;
}
 
void SampleForm::ParentComboBoxSetIndexCallback(System::Object^ state)
{
    cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
    if (arr == nullptr || arr->Length != 2) 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);
    }
}
 
System::Void SampleForm::buttonBrowseTraceFolder_Click(System::Object^ sender, System::EventArgs^ e)
{
    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;
    }
}
 
System::Void SampleForm::buttonOpenTraceFolder_Click(System::Object^ sender, System::EventArgs^ e)
{
    System::String^ path = textBoxTraceFolder->Text;
    if (System::IO::Directory::Exists(path))
    {
        System::Diagnostics::Process::Start(path);
    }
}
 
// This will not automatically update GUI if it is modified internally
System::Void SampleForm::textBoxTraceFolder_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    if (piml == nullptr || piml->GlobalRuntimeManager == nullptr)
    {
        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);
}
 
// This will not automatically update GUI if it is modified internally
System::Void SampleForm::comboBoxTraceLevel_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
{
    if (piml->GlobalRuntimeManager == nullptr)
    {
        return;
    }
 
    TraceLevels traceLevel = Util::Util::ToTraceLevel(comboBoxTraceLevel->SelectedItem->ToString());
    if (traceLevel == RuntimeConfig::GetInstance().GetTraceLevel())
    {
        return;
    }
 
    RuntimeConfig::GetInstance().SetTraceLevel(traceLevel);
    PrintTextCallback("Updated trace level");
}
 
System::Void SampleForm::buttonBrowseFile_Click(System::Object^ sender, System::EventArgs^ e)
{
    System::Windows::Forms::DialogResult result = openFileDialog1->ShowDialog();
    if (result == System::Windows::Forms::DialogResult::OK)
    {
        cbFilePath->Text = openFileDialog1->FileName;
 
        buttonReload->PerformClick();
    }
}
 
System::Void SampleForm::cbFilePath_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
System::Void SampleForm::cbFilePath_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
System::Void SampleForm::buttonReload_Click(System::Object^ sender, System::EventArgs^ e)
{
    LoadContextFile(piml->GlobalRuntimeManager);
 
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonReload : nullptr);
}
 
void SampleForm::LoadContextFile(std::shared_ptr<IRuntimeManager> runtimeManager)
{
    if(System::String::IsNullOrWhiteSpace(cbFilePath->Text))
    {
        return;
    }
 
    PrintTextCallback("Load '" + cbFilePath->Text + "'...");
 
    if (runtimeManager == nullptr)
    {
        PrintTextCallback("... No RuntimeManager exists!");
        return;
    }
 
    if (System::String::IsNullOrWhiteSpace(cbFilePath->Text->Trim()))
    {
        PrintTextCallback(".. wrong file name.");
        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;
                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;
                return;
            }
        }
    }
    catch (const std::exception& ex)
    {
        PrintException(ex);
    }
    catch (System::Exception^ ex)
    {
        PrintException(ex);
    }
 
    piml->IsLoadding = false;
}
 
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)
{
    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;
    }
 
    return project;
}
 
// TODO: refactor
std::shared_ptr<Project::IPlayerProject> SampleForm::LoadPpx(std::shared_ptr<IRuntimeManager> runtimeManager)
{
    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));
    }
 
    return playerProject;
}
 
// TODO: refactor
void SampleForm::LoadPackage(std::shared_ptr<Project::IProject> project)
{
    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.");
}
 
// TODO: refactor
System::Windows::Forms::TreeNode^ SampleForm::CreateDocumentNode(std::shared_ptr<Otx::Runtime::Api::Otx::IDocument> doc)
{
    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 (piml->StartUpNode.get() == nullptr)
        {
            piml->StartUpNode = procedureNode;
        }
    }
 
    return documentNode;
}
 
// TODO: refactor
System::Windows::Forms::TreeNode ^ SampleForm::CreateProcedureName(std::shared_ptr<Otx::Runtime::Api::Otx::IProcedure> proc)
{
    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);
    return procedureNode;
}
 
System::Windows::Forms::TreeNode^ SampleForm::CreatePackageNode(std::shared_ptr<Otx::Runtime::Api::Otx::IPackage> pack)
{
    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]));
    }
 
    return packageNode;
}
 
System::Void SampleForm::gridView_CellContentClick(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e)
{
    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;
                return;
            }
        }
    }
    catch (...) {}
 
    gridView_CellValueChanged(sender, e);
}
 
// 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)
{
    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
    {
        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);
    }
}
 
// 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)
{
    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());
        }
    }
}
 
// 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)
{
    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()))
        {
            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;
            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;
            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);
            }
        }
    }
}
 
System::Void SampleForm::gridViewContextVariable_CellValidated(System::Object^ sender, System::Windows::Forms::DataGridViewCellEventArgs^ e)
{
    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));
        }
    }
}
 
// TODO: refactor. consider update to use together with Parameter validating?
System::Void SampleForm::gridViewContextVariable_CellValidating(System::Object^ sender, System::Windows::Forms::DataGridViewCellValidatingEventArgs^ e)
{
    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)))
        {
            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;
            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
        }
    }
}
 
System::Void SampleForm::treeViewOtxProject_AfterSelect(System::Object^ sender, System::Windows::Forms::TreeViewEventArgs^ e)
{
    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???
            return;
        }
    }
 
    buttonExecuteSelectedProcedure->Enabled = false;
}
 
// TODO: refactor
std::shared_ptr<Project::IProject> SampleForm::GetProject(std::shared_ptr<IProcedure> procedure)
{
    if (procedure != nullptr)
    {
        std::shared_ptr<IPackage> package = procedure->GetDocument()->GetPackage();
        if (package != nullptr)
        {
            while(package->GetParent() != nullptr)
            {
                package = package->GetParent();
            }
            return package->GetProject();
        }
    }
    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)
{
    std::map<std::string, std::string> settings;
    if (piml->PlayerProject!=nullptr)
    {
        settings = piml->PlayerProject->GetSettings();
    }
    else
    {
        settings = piml->Project->GetSettings();
    }
    ReadSettings(settings);
}
 
void SampleForm::ReadSettings(std::map<std::string, std::string> settings)
{
    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);
    }
}
 
// TODO: refactor
System::Void SampleForm::buttonWriteSettings_Click(System::Object^ sender, System::EventArgs^ e)
{
    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);
    }
}
 
System::Void SampleForm::checkBoxCyclicExecution_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
System::Void SampleForm::checkBoxAsyncExecution_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxAsyncExecution : nullptr, checkBoxAsyncExecution);
}
 
System::Void SampleForm::checkBoxNewRuntimeManager_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    if (checkBoxNewRuntimeManager->Checked)
    {
        checkBoxCyclicReload->Checked = true;
    }
 
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxNewRuntimeManager : nullptr, checkBoxNewRuntimeManager);
}
 
System::Void SampleForm::checkBoxCyclicReload_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxCyclicReload : nullptr, checkBoxCyclicReload);
}
 
System::Void SampleForm::buttonExecuteSelectedProcedure_Click(System::Object^ sender, System::EventArgs^ e)
{
    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, NULL, true);
}
 
// TODO: refactor
System::Void SampleForm::buttonExecuteMain_Click(System::Object^ sender, System::EventArgs^ e)
{
    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, NULL, true);
}
 
// TODO: refactor
void SampleForm::ExecuteProcedure()
{
    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
            {
                //OtxDiagManager.OtxDiagApi.License.LicenseManager.SetLicenseKey(SampleConstants.LICENSE_KEY);
                if (checkBoxAsyncExecution->Checked)
                {
                    piml->GlobalRuntimeManager->ExecuteAsync(
                        Util::Util::ToString(textBoxRuntimeContextName->Text->Trim()),
                        piml->ProcedureToExecute,
                        piml->ExpectedConnectionState,
                        System::Convert::ToUInt64(textBoxTimeout->Text->Trim())
                    );
                }
                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] = System::Convert::ToUInt64(textBoxTimeout->Text->Trim());
 
                    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();
    }
}
 
void SampleForm::ExecuteProcedureSync(cli::array<System::Object^>^ args)
{
    if (args->Length != 4)
    {
        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)
    {
        return;
    }
 
    piml->GlobalRuntimeManager->Execute(
        Util::Util::ToString(runtimeContextName),
        procedureWrapper,
        (ExpectedState)expectedState,
        timeout);
}
 
void SampleForm::UpdateButtonStateAfterThrowException()
{
#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")));
}
 
// TODO: refactor
void SampleForm::DoCyclic(System::Object^ args)
{
    System::DateTime^ startTime = System::DateTime::Now;
 
    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 (checkBoxAsyncExecution->Checked)
            {
                runtimeContext = runtimeManager->ExecuteAsync(
                    Util::Util::ToString(textBoxRuntimeContextName->Text->Trim()),
                    piml->ProcedureToExecute,
                    piml->ExpectedConnectionState,
                    safe_cast<unsigned long long>(System::Convert::ToInt32(textBoxTimeout->Text))
                );
                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,
                    safe_cast<unsigned long long>(System::Convert::ToInt32(textBoxTimeout->Text))
                );
            }
 
            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);
    }
}
 
void SampleForm::WaitCyclicExecuteAsyncIsProcessing()
{
    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);
        }
    }
}
 
void SampleForm::CheckCyclicReloadOrNewRuntimeManager(std::shared_ptr<IRuntimeManager> runtimeManager)
{
    CheckCyclicReloadOrNewRuntimeManager(runtimeManager, true);
}
 
void SampleForm::CheckCyclicReloadOrNewRuntimeManager(std::shared_ptr<IRuntimeManager> runtimeManager, bool waitCyclic)
{
    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);
    }
}
 
void SampleForm::CheckCyclicReloadOrNewRuntimeManagerCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2)
    {
        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)
    {
        return;
    }
 
    if (checkBoxCyclicReload->Checked || checkBoxNewRuntimeManager->Checked)
    {
        LoadContextFile(runtimeManager);
    }
 
    if (checkBoxCyclicExecution->Checked)
    {
        checkBoxCyclicExecution->Text = "Cyclic (" + piml->CyclicExecutionCount.ToString() + ")";
    }
    else
    {
        checkBoxCyclicExecution->Text = "Cyclic";
    }
}
 
// TODO: refactor
System::Void SampleForm::buttonStop_Click(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
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)
{
    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);
    }
}
 
System::Void SampleForm::buttonClearOutput_Click(System::Object^ sender, System::EventArgs^ e)
{
    listBoxOuput->Items->Clear();
    labelOutputOverflow->Visible = false;
    buttonCopyRow->Enabled = false;
}
 
void SampleForm::UpdateGridView(std::shared_ptr<IProcedure> procedure)
{
    // || procedure->GetParameters() != nullptr
    if (procedure == nullptr)
    {
        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);
    }
}
 
void SampleForm::UpdateGridviewParameter(std::shared_ptr<IProcedure> procedure)
{
    std::vector<std::shared_ptr<IProcedureParameter>> parameters = procedure->GetParameters();
    for (int i = 0; i < parameters.size(); i++)
    {
        UpdateGridviewParameter(parameters[i]);
    }
}
 
// TODO: refactor
void SampleForm::UpdateGridviewParameter(std::shared_ptr<IProcedureParameter> parameter)
{
    if (IS_NOT_NULL(parameter) == false)
    {
        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());
    }
}
 
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)
{
    if (value == nullptr)
    {
        return System::String::Empty;
    }
 
    if (std::shared_ptr<DataTypes::TranslationKey> translationKey = std::dynamic_pointer_cast<DataTypes::TranslationKey>(value))
    {
        if (!translationKey->GetTextIdMappingName().empty())
        {
            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())
            {
                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())
            {
                return System::String::Format("TextId: {0}",
                                              Util::Util::ToString(enumerationElement->GetTranslationKey()->GetTextId()));
            }
 
            return System::String::Format("MappingName: {0}",
                                          Util::Util::ToString(enumerationElement->GetTranslationKey()->GetTextIdMappingName()));
        }
    }
 
    return System::String::Empty;
}
 
// TODO: refactor
void SampleForm::UpdateGridViewContextVariable(std::shared_ptr<IDocument> document, bool withPrefix, std::vector<std::string>& listItemReviewed)
{
    std::string documentFullName = document->GetPackage()->GetName() + "." + document->GetName();
    if (std::find(listItemReviewed.begin(), listItemReviewed.end(), documentFullName) != listItemReviewed.end())
    {
        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)
        {
            return;
        }
 
        bool bValueWasSet = false;
 
        // Update existing value
        for (int i = 0; i < gridViewContext->Rows->Count; i++)
        {
            System::Windows::Forms::DataGridViewRow^ row = gridViewContext->Rows[i];
 
            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);
    }
}
 
// TODO: refactor this
void SampleForm::StateVariableValueChanged(std::shared_ptr<IStateVariable> stateVariable, std::shared_ptr<DataTypes::Object> value)
{
    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);
    }
}
 
// TODO: refactor this
void SampleForm::StateVariableValueChangedCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2) 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)
    {
        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);
}
 
void SampleForm::ContextVariableRead(std::shared_ptr<IContextVariable> contextVariable, std::shared_ptr<DataTypes::Object> value)
{
    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);
    }
}
 
void SampleForm::ContextVariableReadCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2) 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)
    {
        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);
}
 
void SampleForm::UpdateGridViewStateVariable(std::shared_ptr<IDocument> document, bool withPrefix, std::vector<std::string>& listItemReviewed)
{
    std::string documentFullName = document->GetPackage()->GetName() + "." + document->GetName();
    if (std::find(listItemReviewed.begin(), listItemReviewed.end(), documentFullName) != listItemReviewed.end())
    {
        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);
    }
}
 
// TODO: refactor
void SampleForm::UpdateGridViewStateVariable(std::shared_ptr<IStateVariable> stateVariable)
{
    if (stateVariable == nullptr)
    {
        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();
}
 
System::Void SampleForm::buttonNewInstance_Click(System::Object^ sender, System::EventArgs^ e)
{
    SampleForm^ form = gcnew SampleForm();
    form->SetInstanceName(Util::Util::ToString(SampleConstants::CHILD_INSTANCE_NAME));
    form->SetCreatorForm(this);
    form->Show();
}
 
System::Void SampleForm::buttonNewInstanceNewThread_Click(System::Object^ sender, System::EventArgs^ e)
{
    System::Threading::Thread^ thread = gcnew System::Threading::Thread(gcnew System::Threading::ThreadStart(this, &SampleForm::NewInstanceInThread));
    thread->SetApartmentState(System::Threading::ApartmentState::STA);
    thread->Start();
}
 
System::Void SampleForm::NewInstanceInThread()
{
    SampleForm^ form = gcnew SampleForm();
    form->SetInstanceName(Util::Util::ToString(SampleConstants::CHILD_INSTANCE_NAME));
    form->SetCreatorForm(this);
    System::Windows::Forms::Application::Run(form);
}
 
System::Void SampleForm::buttonHmi_Click(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
System::Void SampleForm::HmiWindow_FormClosing(System::Object^ sender, System::Windows::Forms::FormClosingEventArgs^ e)
{
    piml->CustomScreenImplementation->SetHmiScreenHandle(NULL); 
    piml->HmiWindow = nullptr;
 
    buttonHmi->Checked = false;
}
 
void SampleForm::HmiWindow_Activated(System::Object^ sender, System::EventArgs^ e)
{
    if (piml->CustomScreenImplementation!=nullptr)
    {
        piml->CustomScreenImplementation->ActivateHmiScreen();
    }
}
 
void SampleForm::HmiWindow_SizeChanged(System::Object^ sender, System::EventArgs^ e)
{
    Setting::UserSettings::GetInstance().SetHmiWindowWidth(piml->HmiWindow->Width);
    Setting::UserSettings::GetInstance().SetHmiWindowHeight(piml->HmiWindow->Height);
 
    if (piml->CustomScreenImplementation != nullptr)
    {
        piml->CustomScreenImplementation->RefreshHmiScreen();
    }
}
 
void SampleForm::CustomScreenImplementation_KeyDown(std::shared_ptr<Custom::KeyEventArgs> eventArgs)
{
    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) + ")");
}
 
System::Void SampleForm::SampleForm_FormClosing(System::Object^ sender, System::Windows::Forms::FormClosingEventArgs^ e)
{
    // at C#: listForms.Remove(this)
    for (size_t i = 0; i < piml->ListForms.size(); i++)
    {
        if (piml->ListForms.at(i).get() == this)
        {
            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();
}
 
void SampleForm::SaveSettings()
{
    if (piml->CreatorForm.get() == nullptr)
    {
        // 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::Convert::ToInt32(textBoxTraceFileMaxCount->Text->Trim()));
        Setting::UserSettings::GetInstance().SetTraceFileMaxSize(System::Convert::ToInt32(textBoxTraceFileMaxSize->Text->Trim()));
        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::Convert::ToUInt64(textBoxTimeout->Text->Trim()));
        Setting::UserSettings::GetInstance().SetConnectionState(checkBoxUseConnectionState->Checked);
        Setting::UserSettings::GetInstance().SetIgnition((int)checkBoxIgnition->CheckState);
        Setting::UserSettings::GetInstance().SetPollingTime(System::Convert::ToInt32(textBoxPollingTime->Text->Trim()));
        Setting::UserSettings::GetInstance().SetVoltageThreshold(System::Convert::ToInt32(textBoxVoltageThreshold->Text->Trim()));
 
        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();
    }
}
 
void SampleForm::SaveSocketPortOrPipeName()
{
    IpcTypes ipcType = Util::Util::ToIpcType(comboBoxIpcType->SelectedItem->ToString());
 
    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::Convert::ToUInt16(textBoxDiagPortPipe->Text->Trim()));
            Setting::UserSettings::GetInstance().SetRuntimePort(System::Convert::ToUInt16(textBoxRtPortPipe->Text->Trim()));
            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;
    }
}
 
System::Void SampleForm::textBoxRuntimeContextName_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    textBoxRuntimeContextName->Text = textBoxRuntimeContextName->Text->Trim();
    piml->RuntimeContextName = Util::Util::ToString(textBoxRuntimeContextName->Text);
 
    SetTitle(Util::Util::ToString(piml->Title));
}
 
System::Void SampleForm::listBoxOuput_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e)
{
    buttonCopyRow->Enabled = listBoxOuput->SelectedItems->Count > 0;
}
 
System::Void SampleForm::buttonPause_Click(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
void SampleForm::AddRuntimeContext(IRuntimeContext* context)
{
    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});
        }
    }
}
 
void SampleForm::RemoveRuntimeContext(IRuntimeContext* context)
{
    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);
        }
    }
}
 
bool SampleForm::IsPauseEnabled()
{
    msclr::lock l(piml->LockRuntimeContexts.get());
    {
        for (int i = 0; i < piml->RuntimeContexts.size(); i++)
        {
            if (piml->RuntimeContexts[i]->GetExecutionState() == ExecutionState::Running)
            {
                return true;
            }
        }
 
        return false;
    }
}
 
bool SampleForm::IsContinueEnable()
{
    msclr::lock l(piml->LockRuntimeContexts.get());
    {
        for (int i = 0; i < piml->RuntimeContexts.size(); i++)
        {
            if (piml->RuntimeContexts[i]->GetExecutionState() == ExecutionState::Paused)
            {
                return true;
            }
        }
        return false;
    }
}
 
void SampleForm::SetExpectedState()
{
    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;
    }
}
 
System::Void SampleForm::checkBoxUseConnectionState_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
System::Void SampleForm::CheckBoxKL15_CheckStateChanged(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
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)
{
    CheckBatteryIgnitionState(piml->GlobalRuntimeManager);
 
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->buttonCheckBatteryIgnition : nullptr, buttonCheckBatteryIgnition);
}
 
System::Void SampleForm::textBoxPollingTime_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
System::Void SampleForm::textBoxBatteryVoltageThreshold_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    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);
}
 
void SampleForm::CheckBatteryIgnitionState(std::shared_ptr<IRuntimeManager> runtimeManager)
{
    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));
    }
}
 
void SampleForm::SetBatteryIgnitionState(ClampState batteryState, ClampState ignitionState)
{
#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;
    }
}
 
void SampleForm::ShowConnectionStateMessage(IRuntimeContext* runtimeContext)
{
    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;
        }
    }
}
 
System::Void SampleForm::checkBoxAdd2Output_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->checkBoxAdd2Output : nullptr, checkBoxAdd2Output);
}
 
void SampleForm::NumericUpDownSetValueCallback(cli::array<System::Object^>^ arr)
{
    if (arr == nullptr || arr->Length != 2) 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;
}
 
void SampleForm::ParentNumericUpDownSetValueCallback(System::Object^ state)
{
    cli::array<System::Object^>^ arr = dynamic_cast<cli::array<System::Object^>^>(state);
    if (arr == nullptr || arr->Length != 2) 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)
    {
        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);
    }
}
 
System::Void SampleForm::comboBoxTraceLevel_SelectedIndexChanged(System::Object^ sender, System::EventArgs^ e)
{
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->comboBoxTraceLevel : nullptr,
                   comboBoxTraceLevel);
}
 
System::Void SampleForm::txtPassword_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->txtPassword : nullptr, txtPassword);
}
 
System::Void SampleForm::textBoxTimeout_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    SyncWithParent(IS_NOT_NULL(piml->CreatorForm) ? piml->CreatorForm->textBoxTimeout : nullptr, textBoxTimeout);
}
 
System::Void SampleForm::textBoxTraceFileMaxSize_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    if (piml->GlobalRuntimeManager == nullptr)
    {
        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();
    }
}
 
System::Void SampleForm::textBoxTraceFileMaxCount_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    if (piml->GlobalRuntimeManager == nullptr)
    {
        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();
    }
}
 
void SampleForm::WebServerTimer_Tick(System::Object^ sender, System::EventArgs^ e)
{
    UpdateWebServerButtonCallback();
}
 
void SampleForm::UpdateWebServerButtonCallback()
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action(this, &SampleForm::UpdateWebServerButtonCallback));
        return;
    }
 
    if (piml->CustomScreenImplementation == nullptr)
    {
        buttonStartStopWebServer->Enabled = false;
        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)
        {
            return;
        }
 
        buttonStartStopWebServer->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"StopWebServer.image")));
        piml->IsStartWebSever = 1;
    }
    else
    {
        if (piml->IsStartWebSever == 0)
        {
            return;
        }
 
        buttonStartStopWebServer->Image = (cli::safe_cast<System::Drawing::Image^>(resources->GetObject(L"StartWebServer.image")));
        piml->IsStartWebSever = 0;
    }
}
 
System::Void SampleForm::buttonStartStopWebServer_Click(System::Object^ sender, System::EventArgs^ e)
{
    StartStopWebServerCallback();
}
 
void SampleForm::StartStopWebServerCallback()
{
    if (InvokeRequired)
    {
        Invoke(gcnew System::Action(this, &SampleForm::StartStopWebServerCallback));
        return;
    }
 
    if (piml->CustomScreenImplementation == nullptr)
    {
        return;
    }
 
    if (Custom::DefaultCustomScreenImplementation::IsStartedHtmlWebserver() == false) // No Start WebServer
    {
        piml->CustomScreenImplementation->StartHtmlWebServer();
    }
    else
    {
        piml->CustomScreenImplementation->StopHtmlWebServer();
    }
}
 
System::Void SampleForm::buttonLicense_Click(System::Object^ sender, System::EventArgs^ e)
{
    LicenseForm^ form = gcnew LicenseForm();
    form->SetParentForm(this);
    if (form != nullptr)
    {
        form->ShowDialog(this);
    }
}
 
void SampleForm::ReloadRuntimeManager()
{
    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->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");
    }
}
 
#pragma region C++ for Invoke inside DoCyclic
void SampleForm::ReloadContextFileCallback(CLRWrapper<std::shared_ptr<IRuntimeManager>>^ clrRuntimeManager)
{
    if (checkBoxNewRuntimeManager->Checked)
    {
        LoadContextFile(clrRuntimeManager->GetPtr());
    }
}
#pragma endregion
 
#pragma region C++
IRuntimeContext* SampleForm::GetRuntimeContext(long long runtimeId)
{
    for (int i = 0; i < piml->RuntimeContexts.size(); i++)
    {
        if (piml->RuntimeContexts[i]->GetRuntimeId() == runtimeId)
        {
            return piml->RuntimeContexts[i];
        }
    }
    return nullptr;
}
 
void SampleForm::SetInstanceName(System::String^ instanceName)
{
    if (System::String::IsNullOrEmpty(instanceName) == false)
    {
        piml->Title = Util::Util::ToString(instanceName);
    }
    else
    {
        piml->Title = SampleConstants::MAIN_INSTANCE_NAME;
    }
}
 
void SampleForm::SetCreatorForm(SampleForm^ creatorForm)
{
    piml->CreatorForm = creatorForm;
}
#pragma endregion
 
 
#pragma region C++ for RAW-mode
std::shared_ptr<IRuntimeManager> SampleForm::CreateRawRuntimeManager()
{
    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;
 
    switch (ipcType)
    {
    case OpenTestSystem::Otx::Runtime2::Api::Sample::Raw:
 
        comboBoxODXProject->Items->Clear();
        comboBoxODXVehicle->Items->Clear();
 
        licenseKey = Util::Util::ToString(textBoxDiagManagerLicenseKey->Text);
        rawOtxDiag = Util::OtxDiagUtil::RawOtxDiag(licenseKey);
        runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(rawOtxDiag);
 
        InitializeODXProject();
 
        break;
    case OpenTestSystem::Otx::Runtime2::Api::Sample::Socket:
 
        diagPort = System::Convert::ToUInt16(textBoxDiagPortPipe->Text);
        runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(diagPort);
 
        break;
    case OpenTestSystem::Otx::Runtime2::Api::Sample::Pipe:
 
        runtimeManager = RuntimeManagerFactory::CreateRawRuntimeManager(Util::Util::ToString(textBoxDiagPortPipe->Text));
 
        break;
    }
 
    return runtimeManager;
}
 
System::Void SampleForm::comboBoxODXProject_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
{
    try
    {
        std::shared_ptr<Otx::DiagManager::OtxDiagApi::IOtxDiag> rawOtxDiag = Util::OtxDiagUtil::RawOtxDiag();
        if (rawOtxDiag != nullptr && rawOtxDiag->GetDiagConfiguration() != nullptr)
        {
            std::string odxProject = Util::Util::ToString(comboBoxODXProject->SelectedItem->ToString());
            rawOtxDiag->GetDiagConfiguration()->SelectProject(odxProject);
 
            comboBoxODXVehicle->Items->Clear();
            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;
            }
        }
    }
    catch (const std::exception& ex)
    {
        PrintException(ex);
    }
    catch (System::Exception^ ex)
    {
        PrintException(ex);
    }
}
 
System::Void SampleForm::comboBoxODXVehicle_SelectedValueChanged(System::Object^ sender, System::EventArgs^ e)
{
    try
    {
        std::shared_ptr<Otx::DiagManager::OtxDiagApi::IOtxDiag> rawOtxDiag = Util::OtxDiagUtil::RawOtxDiag();
        rawOtxDiag->GetDiagConfiguration()->SelectVehicleInformation(Util::Util::ToString(comboBoxODXVehicle->SelectedItem->ToString()));
    }
    catch (const std::exception& ex)
    {
        PrintException(ex);
    }
    catch (System::Exception^ ex)
    {
        PrintException(ex);
    }
}
 
void SampleForm::InitializeODXProject()
{
    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)
        {
            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);
    }
}
 
void SampleForm::SetupDiagManagerControls()
{
    // 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());
    }
 
}
 
System::Void SampleForm::comboBoxDiagIpcType_SelectedValueChanged(System::Object ^ sender, System::EventArgs ^ e)
{
    labelOdxProject->Hide();
    comboBoxODXProject->Hide();
    labelODXVehicle->Hide();
    comboBoxODXVehicle->Hide();
 
    portPipeLabel->Hide();
    textBoxDiagPortPipe->Hide();
 
    IpcTypes diagIpcType = Util::Util::ToIpcType(comboBoxDiagIpcType->SelectedItem->ToString());
    switch (diagIpcType)
    {
    case IpcTypes::Raw:
 
        labelOdxProject->Show();
        comboBoxODXProject->Show();
        labelODXVehicle->Show();
        comboBoxODXVehicle->Show();
 
        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();
}
 
System::Void SampleForm::checkBoxIncludedDiagLogging_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
{
    comboBoxDiagLoggingTraceLevel->Enabled = checkBoxIncludedDiagLogging->Checked;
 
    UpdateDiagLogging();
}
 
System::Void SampleForm::buttonOpenDiagLoggingTraceFolder_Click(System::Object^ sender, System::EventArgs^ e)
{
    System::String^ path = textBoxDiagManagerTraceFolder->Text;
    if (System::IO::Directory::Exists(path))
    {
        System::Diagnostics::Process::Start(path);
    }
}
 
System::Void SampleForm::buttonBrowseDiagLoggingTraceFolder_Click(System::Object ^ sender, System::EventArgs ^ e)
{
    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;
    }
}
 
System::Void SampleForm::textBoxDiagManagerLicenseKey_KeyDown(System::Object ^ sender, System::Windows::Forms::KeyEventArgs ^ e)
{
    if (e->KeyCode == System::Windows::Forms::Keys::Delete || e->KeyCode == System::Windows::Forms::Keys::Back)
    {
        textBoxDiagManagerLicenseKey->Clear();
    }
}
 
System::Void SampleForm::textBoxDiagManagerLicenseKey_TextChanged(System::Object ^ sender, System::EventArgs ^ e)
{
    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("-");
        }
    }
 
    if (formattedLicenseKey->Length > 29)
    {
        formattedLicenseKey->Length = 29;
    }
 
    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);
        }
        catch (const std::exception& ex)
        {
            piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, Util::Util::ToString(ex.what()));
        }
        catch (System::Exception^ ex)
        {
            piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, ex->Message);
        }
 
        try
        {
            piml->GlobalRuntimeManager = CreateRuntimeManager();
        }
        catch (const std::exception& ex)
        {
            PrintException(ex);
        }
        catch (System::Exception^ ex)
        {
            PrintException(ex);
        }
    }
    else
    {
        if (System::String::IsNullOrEmpty(this->piml->ErrorProvider->GetError(textBoxDiagManagerLicenseKey)))
        {
            this->piml->ErrorProvider->SetError(textBoxDiagManagerLicenseKey, "License key does not match the desired format XXXXX-XXXXX-XXXXX-XXXXX-XXXXX.");
        }
    }
}
 
System::Void SampleForm::comboBoxDiagManagerTraceLevel_SelectedValueChanged(System::Object ^ sender, System::EventArgs ^ e)
{
    OpenTestSystem::Otx::DiagManager::Common::ILog::Level loggerLevel = Util::Util::ToLoggerLevel(comboBoxDiagManagerTraceLevel->SelectedItem->ToString());
    
    Util::OtxDiagUtil::SetLevelLogger(loggerLevel);
    PrintTextCallback("Updated trace level");
}
 
void SampleForm::UpdateDiagLogging()
{
    if (checkBoxIncludedDiagLogging->Checked && comboBoxDiagLoggingTraceLevel->SelectedItem != nullptr)
    {
        OpenTestSystem::Otx::DiagManager::NoneOtxDiagApi::INoneOtxDiag::LogLevels logLevel = Util::Util::ToDiagDiagnosticsLogLevel(comboBoxDiagLoggingTraceLevel->SelectedItem->ToString());
        std::string diagTraceFolder = Util::Util::ToString(textBoxDiagManagerTraceFolder->Text);
 
        Util::OtxDiagUtil::SetDiagDiagnosticLogging(logLevel, diagTraceFolder);
    }
    else
    {
        std::string traceFolder = Util::Util::ToString(textBoxDiagManagerTraceFolder->Text->Trim());
        Util::OtxDiagUtil::SetDiagDiagnosticLogging(Util::OtxDiagUtil::GetDiagnosticLogLevelDefault(), traceFolder);
    }
}
 
System::Void SampleForm::comboBoxDiagLoggingTraceLevel_SelectedValueChanged(System::Object ^ sender, System::EventArgs ^ e)
{
    UpdateDiagLogging();
}
 
System::Void SampleForm::textBoxDiagManagerTraceFolder_TextChanged(System::Object^ sender, System::EventArgs^ e)
{
    std::string diagTraceFolder = Util::Util::ToString(textBoxDiagManagerTraceFolder->Text);
 
    Util::OtxDiagUtil::SetPathLogger(diagTraceFolder);
    UpdateDiagLogging();
}
#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;
 
    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 SetupTraceFileMaxCountAndSize();
        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();
 
    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->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->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;
            // 
            // 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(306, 30);
            this->textBoxTraceFolder->Name = L"textBoxTraceFolder";
            this->textBoxTraceFolder->Size = System::Drawing::Size(486, 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(291, 35);
            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;
            this->dataGridViewTextBoxColumnDirection->ReadOnly = true;
            // 
            // 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