tgm_comm_int_ii_dll.h

Go to the documentation of this file.

/*
*-----------------------------------------------------------------------------+
* **************************** tgm_comm_int_ii_dll.h ************************ |
*-----------------------------------------------------------------------------+
*                      Copyright 2017 by TG Drives s.r.o.                     |
*                                                                             |
*                      TG Drives s.r.o.                                       |
*                      Olomoucka 1290/79                                      |
*                      CZ-627 00 Brno                                         |
*                      Czech Republic                                         |
*                                                                             |
*-----------------------------------------------------------------------------+
* Description:                                                                |
*  wrapper for TGM_Comm_Int_2.dll or libTGM_Comm_Int_2.so (dynamic load)      |
*  uses plain Win32 API on Windows                                            |
*  uses Qt functions on Linux                                                 |
*                                                                             |
*-----------------------------------------------------------------------------+
* - rewritten according to comments of Frantisek Mikulu
* - added assertions to almost all function
*   (mainly pointer check against nullptr)
*/

/*
 * Note: some helper function are not yet documented.
 *
*/

#ifndef TGMCOMMINT2_DLL_H
#define TGMCOMMINT2_DLL_H

#ifdef __linux__
#define COM_CALLTYPE
#else
#define COM_CALLTYPE _cdecl
#endif

#define MAX_OFFLINE_COUNT 100

#include <stdint.h>
#include <assert.h>

#if defined WIN32
# include <Windows.h>
# include <tchar.h>
# include <stdio.h>
#elif !defined UNDER_RTSS
# include <QLibrary>
# include <QDebug>
# include <QFileInfo>
#endif

// windows specific data types
#ifdef WIN32

// prevent multiple typedefs by #define trick
# ifndef TGM_HWND
#  define TGM_HWND TGM_HWND
   typedef HWND   TGM_HWND;
# endif

# if !defined _UNICODE
#  error "_UNICODE must be defined for WIN32"
# endif

# ifndef TGM_TCHAR
#  define TGM_TCHAR TGM_TCHAR
   typedef wchar_t TGM_TCHAR;
# endif

# ifndef TGM_WCHAR
#  define TGM_WCHAR TGM_WCHAR
   typedef wchar_t TGM_WCHAR; // wchar_t on Windows is 16bits wide
# endif

# ifndef TGM_TEXT
#  define TGM_TEXT(a) TEXT(a)
# endif

#else // linux or rtss

# ifndef TGM_HWND
#  define TGM_HWND TGM_HWND
   typedef intptr_t TGM_HWND;
# endif

# ifndef TGM_TCHAR
#  define TGM_TCHAR TGM_TCHAR
   typedef char TGM_TCHAR;
# endif

# ifndef TGM_WCHAR
#  define TGM_WCHAR TGM_WCHAR
   typedef uint16_t TGM_WCHAR; // to keep the TGM structures the same on Windows and Linux
                            // we must use UTF-16 coding on Linux as well, thus WCHAR is 16bits
                            // (naturally, the wchar_t on Linux can be 32bits and is 
                            // platform dependent)
# endif

# ifndef TGM_TEXT
#  define TGM_TEXT(a) (a)
# endif

#endif

// by default none of the wrapper function is declared as virtual
// but if the default error output is to be changed
// it can be done by declaring the respective functions
// as virtual and redefine them in a derived class
#define TGM_COMM_INT_VIRTUAL
//#define TGM_COMM_INT_VIRTUAL virtual


#ifdef WIN32
# if _MSC_VER < 1800 // below Visual Studio 2013
#  pragma warning(push)
#  pragma warning(disable : 4480) // VS2010: disable warning: non-standard extension used
# endif // Visual Studio 2013+
#endif

#ifndef ENUM_CLASS_DEFINED
# ifdef __GNUC__
#  define ENUM_CLASS class
# elif _MSC_VER < 1800 // below Visual Studio 2013
#  define ENUM_CLASS
# else // Visual Studio 2013+
#  define ENUM_CLASS class
# endif // _MSC_VER < 1800
# define ENUM_CLASS_DEFINED
#endif // !ENUM_CLASS_DEFINED

class CTGM_COMM_INT_2
{
public:
  // constants - declared as enum class - strongly typed enums increase safety and readability of code
  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  enum ENUM_CLASS error_code : int32_t
  {
    Success = 0,                        
    Device_Type = 1,               
    Interface_Not_Create = 2,      
    Connection_Not_Open = 3,       
    Not_Detect_Comm_DLL = 4,       
    Interface_Already_Exists = 5,  
    Interface_Create_Off_Mem = 6,  
    Connection_Already_Exists = 7, 
    Connection_Create_Thread = 8,  
    Invalid_Data = 9,              
  };

  // conversion - for interfacing with C or Deplhi
  static int32_t errorCodeToInt(error_code errorCode)
  {
    return static_cast<int32_t>(errorCode);
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  enum ENUM_CLASS device : uint32_t
  {
    Local_TGM = 0,  
    TGM_Mini = 1,   
    TGM_REMOTE = 2, 
  };

  // conversion - for interfacing with C or Deplhi
  static uint32_t deviceToInt(device deviceType)
  {
    return static_cast<uint32_t>(deviceType);
  }
  static device intToDevice(uint32_t deviceType)
  {
    switch (deviceType)
    {
    case static_cast<uint32_t>(device::Local_TGM) :
      return device::Local_TGM;
    case static_cast<uint32_t>(device::TGM_Mini) :
      return device::TGM_Mini;
    case static_cast<uint32_t>(device::TGM_REMOTE) :
      return device::TGM_REMOTE;
    default: 
      return device::Local_TGM;
    }
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  enum ENUM_CLASS connected_memory : int32_t
  {
    None = 0,               
    Local_Offline = 1,      
    Local_TGM_Online = 2,   
    TGM_Mini_Offline = 3,   
    TGM_Mini_Online = 4,    
    REM_Client_Offline = 5, 
    REM_Server_Offline = 6, 
    REM_Server = 7,         
  };

  // conversion - for interfacing with C or Deplhi
  static int32_t connectedMemoryToInt(connected_memory mem)
  {
    return static_cast<int32_t>(mem);
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  enum ENUM_CLASS compatibility : int32_t
  {
    App_ID_None = -1,     // do not test App ID compatibility
    App_Mem_ID_None = -1, // do not test App Mem ID compatibility
  };

  // conversion - for interfacing with C or Deplhi
  static int32_t compatibilityToInt(compatibility comp)
  {
    return static_cast<int32_t>(comp);
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  enum ENUM_CLASS status : int32_t
  {
    Simulation_Mode_TGM = 2,                 
    Online = 1,                              
    Offline_Connection_Proceeds = 0,         
    Offline_Device_Offline = -1,             
    Offline_Incompatible_DLL_ID = -2,        
    Offline_Incompatible_DLL_Mem_ID = -3,    
    Offline_Incompatible_DEVICE_ID = -4,     
    Offline_Incompatible_DEVICE_Mem_ID = -5, 
    Offline_Not_Detect_Comm_DLL = -6,        
    Offline_Open_Connection_Failed = -7,     
    Offline_Init_Connection_Failed = -8,     
    Offline_Connection_Not_Opened = -9,      
    Offline_Interface_Not_Create = -10,      
  };
  // conversion - for interfacing with C or Deplhi
  static int32_t statusToInt(status statusCode)
  {
    return static_cast<int32_t>(statusCode);
  }

  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  enum ENUM_CLASS read_write : int32_t
  {
    OK = 0,                        
    OK_Offline_Data = -1,          
    ERR_Invalid_Data = -2,         
    ERR_Device_Busy = -3,          
    ERR_Interface_Not_Create = -8, 
    ERR_Unsupported_Function = -9, 

    // must be the same values as in ERR enum
    ERR_Connection_Not_Open = 3,       
    ERR_Not_Detect_Comm_DLL = 4,       
  };
  // conversion - for interfacing with C or Deplhi
  static int32_t readWriteToInt(read_write rwCode)
  {
    return static_cast<int32_t>(rwCode);
  }

  // Shared memory numbers ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  enum ENUM_CLASS shared_memory : uint32_t
  {
    SYSTEM = 0,       
    DATA = 1,         
    CAM = 2,          
    OSC = 3,          
    SERVO = 4,        
    DIO = 5,          
    INTERP = 6,       
    INTERP_W = 7,     
    INTERP_R = 8,     
    ODS = 9,          
    CNC_EX = 10,      
    G_CODE = 11,      
    CNC_EX_LOCAL = 12,
    CNC_INI = 13,     
    UNIVERSAL = 14,   
    NMemories = 15,   
  };

  // converions functions - for interfacing with C or Deplhi
  static uint32_t memoryTypeToInt(shared_memory memoryType)
  {
    return static_cast<uint32_t>(memoryType);
  }

  static shared_memory intToMemoryType(uint32_t memoryType)
  {
    switch (memoryType)
    {
    case 0:  return shared_memory::SYSTEM;
    case 1:  return shared_memory::DATA;
    case 2:  return shared_memory::CAM;
    case 3:  return shared_memory::OSC;
    case 4:  return shared_memory::SERVO;
    case 5:  return shared_memory::DIO;
    case 6:  return shared_memory::INTERP;
    case 7:  return shared_memory::INTERP_W;
    case 8:  return shared_memory::INTERP_R;
    case 9:  return shared_memory::ODS;
    case 10: return shared_memory::CNC_EX;
    case 11: return shared_memory::G_CODE;
    case 12: return shared_memory::CNC_EX_LOCAL;
    case 13: return shared_memory::CNC_INI;
    case 14: return shared_memory::UNIVERSAL;
    default:
      // check if the enum class shared_memory has not been changed
      // if so, this static_assert must be changed accordingly
      static_assert(static_cast<uint32_t>(shared_memory::NMemories) == 15, "Number of shared memories must be 15");
      return shared_memory::NMemories;
    }
  }

  // real-time process (RTSS or Zynq) needs only enums above
  // so rest of code will not be used for it
#ifndef UNDER_RTSS

public:
  CTGM_COMM_INT_2() {}
  TGM_COMM_INT_VIRTUAL ~CTGM_COMM_INT_2()
  {
    Close_Connection();
    Destroy_Interface();
  }


public:
  error_code LoadDll(const char * fileName)
  {
    assert(fileName != nullptr);
    error_code rv = preLoadDll(fileName);
    if (rv != error_code::Success)
      return rv;
    m_pCREATE_INTERFACE_2 = reinterpret_cast<TGM_CREATE_INTERFACE_2 *>(getFuncAddress(fileName, "Create_Interface_2"));
    m_pDESTROY_INTERFACE = reinterpret_cast<TGM_DESTROY_INTERFACE *>(getFuncAddress(fileName, "Destroy_Interface"));
    m_pOPEN_CONNECTION = reinterpret_cast<TGM_OPEN_CONNECTION *>(getFuncAddress(fileName, "Open_Connection"));
    m_pCHANGE_CONNECTION = reinterpret_cast<TGM_CHANGE_CONNECTION *>(getFuncAddress(fileName, "Change_Connection"));
    m_pCLOSE_CONNECTION = reinterpret_cast<TGM_CLOSE_CONNECTION *>(getFuncAddress(fileName, "Close_Connection"));
    m_pGET_DLL_INFO = reinterpret_cast<TGM_GET_DLL_INFO *>(getFuncAddress(fileName, "Get_DLL_Info"));
    m_pSET_APP_COMPATIBILITY_VN = reinterpret_cast<TGM_SET_APP_COMPATIBILITY_VN *>(getFuncAddress(fileName, "Set_App_Compatibility_VN"));
    m_pGET_STATUS = reinterpret_cast<TGM_GET_STATUS *>(getFuncAddress(fileName, "Get_Status"));
    m_pGET_STATUS_GRAPHICS = reinterpret_cast<TGM_GET_STATUS_GRAPHICS *>(getFuncAddress(fileName, "Get_Status_Graphics"));
    m_pGET_CONNECTIONS_INFO_2 = reinterpret_cast<TGM_GET_CONNECTIONS_INFO_2 *>(getFuncAddress(fileName, "Get_Connections_Info_2"));
    m_pGET_SERVER_INFO = reinterpret_cast<TGM_GET_SERVER_INFO *>(getFuncAddress(fileName, "Get_Server_Info"));

    m_pSHOW_CONNECTIONS_INFO_WIN = reinterpret_cast<TGM_SHOW_CONNECTIONS_INFO_WIN *>(getFuncAddress(fileName, "Show_Connections_Info_Win"));
    m_pCLOSE_CONNECTIONS_INFO_WIN = reinterpret_cast<TGM_CLOSE_CONNECTIONS_INFO_WIN *>(getFuncAddress(fileName, "Close_Connections_Info_Win"));
    m_pGET_CONNECTIONS_INFO_WIN_DIMENSION = reinterpret_cast<TGM_GET_CONNECTIONS_INFO_WIN_DIMENSION *>(getFuncAddress(fileName, "Get_Connections_Info_Win_Dimension"));

    m_pREAD_I32 = reinterpret_cast<TGM_READ_I32 *>(getFuncAddress(fileName, "Read_I32"));
    m_pREAD_I64 = reinterpret_cast<TGM_READ_I64 *>(getFuncAddress(fileName, "Read_I64"));
    m_pREAD_double = reinterpret_cast<TGM_READ_double *>(getFuncAddress(fileName, "Read_Double"));
    m_pREAD_BLOCK = reinterpret_cast<TGM_READ_BLOCK *>(getFuncAddress(fileName, "Read_Block"));
    m_pREAD_LPSTR = reinterpret_cast<TGM_READ_LPSTR *>(getFuncAddress(fileName, "Read_LPSTR"));
    m_pREAD_LPWSTR = reinterpret_cast<TGM_READ_LPWSTR *>(getFuncAddress(fileName, "Read_LPWSTR"));
    m_pWRITE_I32 = reinterpret_cast<TGM_WRITE_I32 *>(getFuncAddress(fileName, "Write_I32"));
    m_pWRITE_I64 = reinterpret_cast<TGM_WRITE_I64 *>(getFuncAddress(fileName, "Write_I64"));
    m_pWRITE_double = reinterpret_cast<TGM_WRITE_double *>(getFuncAddress(fileName, "Write_Double"));
    m_pWRITE_BLOCK = reinterpret_cast<TGM_WRITE_BLOCK *>(getFuncAddress(fileName, "Write_Block"));
    m_pWRITE_LPSTR = reinterpret_cast<TGM_WRITE_LPSTR *>(getFuncAddress(fileName, "Write_LPSTR"));
    m_pWRITE_LPWSTR = reinterpret_cast<TGM_WRITE_LPWSTR *>(getFuncAddress(fileName, "Write_LPWSTR"));
    m_pSET_BIT_I32 = reinterpret_cast<TGM_SET_BIT_I32 *>(getFuncAddress(fileName, "SetB_I32"));
    m_pSET_BIT_I64 = reinterpret_cast<TGM_SET_BIT_I64 *>(getFuncAddress(fileName, "SetB_I64"));
    m_pCLR_BIT_I32 = reinterpret_cast<TGM_CLR_BIT_I32 *>(getFuncAddress(fileName, "ClrB_I32"));
    m_pCLR_BIT_I64 = reinterpret_cast<TGM_CLR_BIT_I64 *>(getFuncAddress(fileName, "ClrB_I64"));
    m_pTGL_BIT_I32 = reinterpret_cast<TGM_TGL_BIT_I32 *>(getFuncAddress(fileName, "TglB_I32"));
    m_pTGL_BIT_I64 = reinterpret_cast<TGM_TGL_BIT_I64 *>(getFuncAddress(fileName, "TglB_I64"));
    m_pREAD_I32_DIRECT = reinterpret_cast<TGM_READ_I32_DIRECT *>(getFuncAddress(fileName, "Read_I32_Direct"));
    m_pREAD_I64_DIRECT = reinterpret_cast<TGM_READ_I64_DIRECT *>(getFuncAddress(fileName, "Read_I64_Direct"));
    m_pREAD_double_DIRECT = reinterpret_cast<TGM_READ_double_DIRECT *>(getFuncAddress(fileName, "Read_Double_Direct"));
    m_pREAD_BLOCK_DIRECT = reinterpret_cast<TGM_READ_BLOCK_DIRECT *>(getFuncAddress(fileName, "Read_Block_Direct"));
    m_pREAD_LPSTR_DIRECT = reinterpret_cast<TGM_READ_LPSTR_DIRECT *>(getFuncAddress(fileName, "Read_LPSTR_Direct"));
    m_pREAD_LPWSTR_DIRECT = reinterpret_cast<TGM_READ_LPWSTR_DIRECT *>(getFuncAddress(fileName, "Read_LPWSTR_Direct"));
    m_pWRITE_I32_DIRECT = reinterpret_cast<TGM_WRITE_I32_DIRECT *>(getFuncAddress(fileName, "Write_I32_Direct"));
    m_pWRITE_I64_DIRECT = reinterpret_cast<TGM_WRITE_I64_DIRECT *>(getFuncAddress(fileName, "Write_I64_Direct"));
    m_pWRITE_double_DIRECT = reinterpret_cast<TGM_WRITE_double_DIRECT *>(getFuncAddress(fileName, "Write_Double_Direct"));
    m_pWRITE_BLOCK_DIRECT = reinterpret_cast<TGM_WRITE_BLOCK_DIRECT *>(getFuncAddress(fileName, "Write_Block_Direct"));
    m_pWRITE_LPSTR_DIRECT = reinterpret_cast<TGM_WRITE_LPSTR_DIRECT *>(getFuncAddress(fileName, "Write_LPSTR_Direct"));
    m_pWRITE_LPWSTR_DIRECT = reinterpret_cast<TGM_WRITE_LPWSTR_DIRECT *>(getFuncAddress(fileName, "Write_LPWSTR_Direct"));
    m_pSET_BIT_I32_DIRECT = reinterpret_cast<TGM_SET_BIT_I32_DIRECT *>(getFuncAddress(fileName, "SetB_I32_Direct"));
    m_pSET_BIT_I64_DIRECT = reinterpret_cast<TGM_SET_BIT_I64_DIRECT *>(getFuncAddress(fileName, "SetB_I64_Direct"));
    m_pCLR_BIT_I32_DIRECT = reinterpret_cast<TGM_CLR_BIT_I32_DIRECT *>(getFuncAddress(fileName, "ClrB_I32_Direct"));
    m_pCLR_BIT_I64_DIRECT = reinterpret_cast<TGM_CLR_BIT_I64_DIRECT *>(getFuncAddress(fileName, "ClrB_I64_Direct"));
    m_pTGL_BIT_I32_DIRECT = reinterpret_cast<TGM_TGL_BIT_I32_DIRECT *>(getFuncAddress(fileName, "TglB_I32_Direct"));
    m_pTGL_BIT_I64_DIRECT = reinterpret_cast<TGM_TGL_BIT_I64_DIRECT *>(getFuncAddress(fileName, "TglB_I64_Direct"));
    m_pFLUSH_BUFFER = reinterpret_cast<TGM_FLUSH_BUFFER *>(getFuncAddress(fileName, "Fluh_Buffer"));

#if defined __linux__
    QFileInfo dirAndPath(fileName);
    return Create_Interface_2(qPrintable(dirAndPath.absolutePath()));
#else
    // convert ANSI to UNICODE
    wchar_t dirAndPath[_MAX_DIR + _MAX_PATH], path[_MAX_PATH];
    int wchars_num = MultiByteToWideChar(CP_UTF8, 0, fileName, -1, NULL, 0);
    if (wchars_num <= 0)
    {
      return error_code::Invalid_Data;
    }
    WCHAR* fileNameW = new WCHAR[static_cast<size_t>(wchars_num)];
    MultiByteToWideChar(CP_UTF8, 0, fileName, -1, fileNameW, wchars_num);

    _wsplitpath_s(fileNameW, dirAndPath, _countof(dirAndPath), path, _countof(path), nullptr, 0, nullptr, 0);
    delete[] fileNameW;

    wcscat_s(dirAndPath, path);
    return Create_Interface_2(dirAndPath);
#endif
  }
  error_code Create_Interface_2(const TGM_TCHAR *DLL_Directory)
  {
    assert(DLL_Directory != nullptr);
    if (m_nCreateInterfaceCalled > 0)
      return error_code::Interface_Already_Exists;

    if (m_pCREATE_INTERFACE_2)
    {
      status statusCode = Get_Status();
      if (statusCode == status::Offline_Interface_Not_Create)
      {
        m_offlineCounter = 0;
        error_code code = dispErrorCode(("Create_Interface_2"), m_pCREATE_INTERFACE_2(DLL_Directory));
        if (code == error_code::Success)
        {
          m_nCreateInterfaceCalled++;
          m_bCreateInterfaceAlreadyCalledByApplication = false;
        }
        return code;
      }
      else
      {
        m_nCreateInterfaceCalled++;
        // interface has been created by parent application
        // so we cannot destroy it - protect by this flag
        m_bCreateInterfaceAlreadyCalledByApplication = true;
        return error_code::Success;
      }
    }
    return error_code::Not_Detect_Comm_DLL;
  }
  void Destroy_Interface()
  {
    m_nCreateInterfaceCalled--;
    if(m_nCreateInterfaceCalled != 0)
      return;

    if (m_pDESTROY_INTERFACE)
    {
      // if the create interface was called before this wrapper, e.g. by application
      // we cannot destroy it, since the subsequent call of Destroy_Interface
      // would fail
      if (m_bCreateInterfaceAlreadyCalledByApplication == false)
        m_pDESTROY_INTERFACE();
    }
    m_hModule.unload();
  }
  error_code Open_Connection(int32_t keepOnline, int32_t commTimeout, device deviceType, uint32_t IPAddress)
  {
    // exactly one call of Create_Interface is needed to open an connection
    if (m_nCreateInterfaceCalled != 1)
      return error_code::Interface_Not_Create;

    // another check inside TGM_Comm_Int_2.dll
    status statusCode = Get_Status();
    if (statusCode == status::Offline_Interface_Not_Create)
      return error_code::Interface_Not_Create;

    // cannot call Open_Connection multiple times without Close_Connection
    if (m_nOpenConnectionCalled > 0)
      return error_code::Connection_Already_Exists;

    m_nOpenConnectionCalled++;

    error_code rv = error_code::Not_Detect_Comm_DLL;
    if (statusCode == status::Offline_Connection_Not_Opened)
    {
      m_offlineCounter = 0;
      if (m_pOPEN_CONNECTION)
      {
        m_bOpenConnectionAlreadyCalledByApplication = false;
        rv = dispErrorCode(("Open_Connection"), m_pOPEN_CONNECTION(keepOnline, commTimeout, deviceType, IPAddress));
      }
    }
    else
    {
      // OpenConnection was already called by parent application
      // therefore we cannot CloseConnection
      m_bOpenConnectionAlreadyCalledByApplication = true;
    }

    return rv;
  }
  error_code Close_Connection()
  {
    if (m_nCreateInterfaceCalled != 1)
      return error_code::Interface_Not_Create;

    // another check inside TGM_Comm_Int_2.dll
    status statusCode = Get_Status();
    if (statusCode == status::Offline_Interface_Not_Create)
      return error_code::Interface_Not_Create;

    m_nOpenConnectionCalled--;
    if(m_nOpenConnectionCalled != 0)
    {
      return error_code::Connection_Not_Open;
    }

    // we can close connection only if it is opened by the wrapper
    if (m_bOpenConnectionAlreadyCalledByApplication == false)
    {
      if (m_pCLOSE_CONNECTION)
        return dispErrorCode(("Close_Connection"), m_pCLOSE_CONNECTION());
      return error_code::Not_Detect_Comm_DLL;
    }
    return error_code::Success;
  }
  error_code Change_Connection(device deviceType, uint32_t IPAddress)
  {
    if (m_nCreateInterfaceCalled != 1)
      return error_code::Interface_Not_Create;

    // another check inside TGM_Comm_Int_2.dll
    status statusCode = Get_Status();
    if (statusCode == status::Offline_Interface_Not_Create)
      return error_code::Interface_Not_Create;

    // only one OpenConnection can be called
    if(m_nOpenConnectionCalled != 1)
    {
      return error_code::Connection_Not_Open;
    }

    return dispErrorCode(("CHANGE_CONNECTION"), m_pCHANGE_CONNECTION(deviceType, IPAddress));
  }
  error_code Get_Dll_Info(device deviceType, int32_t *pVersion, int32_t *pCompatibilityID, int32_t *pCompatibilityMemID)
  {
    assert(pVersion != nullptr);
    assert(pCompatibilityID != nullptr);
    assert(pCompatibilityMemID != nullptr);
    if (m_pGET_DLL_INFO)
      return dispErrorCode(("GET_DLL_INFO"), m_pGET_DLL_INFO(deviceType, pVersion, pCompatibilityID, pCompatibilityMemID));
    return error_code::Not_Detect_Comm_DLL;
  }

  void Set_App_Compatibility_VN(int32_t compatibilityID, int32_t compatibilityMemID, int32_t version, const TGM_TCHAR *appName)
  {
    assert(appName != nullptr);
    if (m_pSET_APP_COMPATIBILITY_VN)
      m_pSET_APP_COMPATIBILITY_VN(compatibilityID, compatibilityMemID, version, appName);
  }
  status Get_Status()
  {
    if (m_pGET_STATUS)
      return m_pGET_STATUS();
    return status::Offline_Not_Detect_Comm_DLL;
  }

  status Get_Status_Graphics(int32_t *pBackgroundColor, int32_t *pTextColor, TGM_TCHAR *statusText)
  {
    if (m_pGET_STATUS_GRAPHICS)
      return m_pGET_STATUS_GRAPHICS(pBackgroundColor, pTextColor, statusText);
    return status::Offline_Not_Detect_Comm_DLL;
  }

  error_code Show_Connections_Info_Win(TGM_HWND parent, int32_t enableChangeConnection)
  {
    if (m_pSHOW_CONNECTIONS_INFO_WIN)
      return m_pSHOW_CONNECTIONS_INFO_WIN(parent, enableChangeConnection);
    return error_code::Not_Detect_Comm_DLL;
  }

  error_code Close_Connections_Info_Win()
  {
    if (m_pCLOSE_CONNECTIONS_INFO_WIN)
      return m_pCLOSE_CONNECTIONS_INFO_WIN();
    return error_code::Not_Detect_Comm_DLL;
  }

  void Get_Connections_Info_Win_Dimension(int32_t *pWidth, int32_t *pHeight)
  {
    assert(pWidth != nullptr);
    assert(pHeight != nullptr);
    if (m_pGET_CONNECTIONS_INFO_WIN_DIMENSION)
      m_pGET_CONNECTIONS_INFO_WIN_DIMENSION(pWidth, pHeight);
  }

  error_code Get_Connections_Info_2(device *pDeviceType, uint32_t *IPAddress, connected_memory *pConnectedMemory)
  {
    assert(pDeviceType != nullptr);
    assert(IPAddress != nullptr);
    assert(pConnectedMemory != nullptr);
    if (m_pGET_CONNECTIONS_INFO_2)
      return dispErrorCode(("GET_CONNECTIONS_INFO_2"), m_pGET_CONNECTIONS_INFO_2(pDeviceType, IPAddress, pConnectedMemory));
    return error_code::Not_Detect_Comm_DLL;
  }

  error_code Get_Server_Info(device deviceType,
                             int32_t *pCompatibilityID, 
                             int32_t *pCompatibilityMemID, 
                             status *pConnectionStatus)
  {
    assert(pCompatibilityID != nullptr);
    assert(pCompatibilityMemID != nullptr);
    assert(pConnectionStatus != nullptr);
    if (m_pGET_SERVER_INFO)
      return dispErrorCode(("GET_SERVER_INFO"), m_pGET_SERVER_INFO(deviceType, pCompatibilityID, pCompatibilityMemID, pConnectionStatus));
    return error_code::Not_Detect_Comm_DLL;
  }
  // access functions
  read_write Read_I32(shared_memory memoryType, uint32_t offset, int32_t *pValue)
  {
    assert(pValue != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_I32)
      return dispErrorCode(("READ_I32"), m_pREAD_I32(memoryType, offset, pValue));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_I64(shared_memory memoryType, uint32_t offset, int64_t *pValue)
  {
    assert(pValue != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_I64)
      return dispErrorCode(("READ_I64"), m_pREAD_I64(memoryType, offset, pValue));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_Double(shared_memory memoryType, uint32_t offset, double *pValue)
  {
    assert(pValue != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_double)
      return dispErrorCode(("READ_double"), m_pREAD_double(memoryType, offset, pValue));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_BLOCK(shared_memory memoryType, uint32_t offset, void *buffer, uint32_t bufferLength)
  {
    assert(buffer != nullptr);
    assert(bufferLength > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_BLOCK)
      return dispErrorCode(("READ_BLOCK"), m_pREAD_BLOCK(memoryType, offset, buffer, bufferLength));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_LPSTR(shared_memory memoryType, uint32_t offset, char *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count)
  {
    assert(buffer != nullptr);
    assert(buffer_Char_Len > 0);
    assert(pRead_Char_Count != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_LPSTR)
      return dispErrorCode(("Read_LPSTR"), m_pREAD_LPSTR(memoryType, offset, buffer, buffer_Char_Len, pRead_Char_Count));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_LPWSTR(shared_memory memoryType, uint32_t offset, TGM_WCHAR *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count)
  {
    assert(buffer != nullptr);
    assert(buffer_Char_Len > 0);
    assert(pRead_Char_Count != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_LPWSTR)
      return dispErrorCode(("Read_LPWSTR"), m_pREAD_LPWSTR(memoryType, offset, buffer, buffer_Char_Len, pRead_Char_Count));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_I32(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_I32)
      return dispErrorCode(("WRITE_I32"), m_pWRITE_I32(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_I64(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_I64)
      return dispErrorCode(("WRITE_I64"), m_pWRITE_I64(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_Double(shared_memory memoryType, uint32_t offset, double Value)
  {
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_double)
      return dispErrorCode(("WRITE_double"), m_pWRITE_double(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_BLOCK(shared_memory memoryType, uint32_t offset, const void *buffer, uint32_t bufferLength)
  {
    assert(buffer != nullptr);
    assert(bufferLength > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_BLOCK)
      return dispErrorCode(("WRITE_BLOCK"), m_pWRITE_BLOCK(memoryType, offset, buffer, bufferLength));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }

  read_write Write_LPSTR(shared_memory memoryType, uint32_t offset, const char *buffer, uint32_t Write_Char_Len)
  {
    assert(buffer != nullptr);
    assert(Write_Char_Len > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_LPSTR)
      return dispErrorCode(("Write_LPSTR"), m_pWRITE_LPSTR(memoryType, offset, buffer, Write_Char_Len));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }

  read_write Write_LPWSTR(shared_memory memoryType, uint32_t offset, const TGM_WCHAR *buffer, uint32_t Write_Char_Len)
  {
    assert(buffer != nullptr);
    assert(Write_Char_Len > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_LPWSTR)
      return dispErrorCode(("Write_LPWSTR"), m_pWRITE_LPWSTR(memoryType, offset, buffer, Write_Char_Len));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Set_Bit_I32(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    assert((offset & 0x3) == 0); // offset must be aligned to 4 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pSET_BIT_I32)
      return dispErrorCode(("SET_BIT_I32"), m_pSET_BIT_I32(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Set_Bit_I64(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    assert((offset & 0x7) == 0); // offset must be aligned to 8 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pSET_BIT_I64)
      return dispErrorCode(("SET_BIT_I64"), m_pSET_BIT_I64(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Clr_Bit_I32(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    assert((offset & 0x3) == 0); // offset must be aligned to 4 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pCLR_BIT_I32)
      return dispErrorCode(("CLR_BIT_I32"), m_pCLR_BIT_I32(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Clr_Bit_I64(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    assert((offset & 0x7) == 0); // offset must be aligned to 8 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pCLR_BIT_I64)
      return dispErrorCode(("CLR_BIT_I64"), m_pCLR_BIT_I64(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Tgl_Bit_I32(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    assert((offset & 0x3) == 0); // offset must be aligned to 4 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pTGL_BIT_I32)
      return dispErrorCode(("TGL_BIT_I32"), m_pTGL_BIT_I32(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Tgl_Bit_I64(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    assert((offset & 0x7) == 0); // offset must be aligned to 8 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pTGL_BIT_I64)
      return dispErrorCode(("TGL_BIT_I64"), m_pTGL_BIT_I64(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }

  read_write Read_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t *pValue)
  {
    assert(pValue != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_I32_DIRECT)
      return dispErrorCode(("READ_I32_DIRECT"), m_pREAD_I32_DIRECT(memoryType, offset, pValue));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t *pValue)
  {
    assert(pValue != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_I64_DIRECT)
      return dispErrorCode(("READ_I64_DIRECT"), m_pREAD_I64_DIRECT(memoryType, offset, pValue));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_Double_DIRECT(shared_memory memoryType, uint32_t offset, double *pValue)
  {
    assert(pValue != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_double_DIRECT)
      return dispErrorCode(("READ_double_DIRECT"), m_pREAD_double_DIRECT(memoryType, offset, pValue));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_BLOCK_DIRECT(shared_memory memoryType, uint32_t offset, void *buffer, uint32_t bufferLength)
  {
    assert(buffer != nullptr);
    assert(bufferLength > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_BLOCK_DIRECT)
      return dispErrorCode(("READ_BLOCK_DIRECT"), m_pREAD_BLOCK_DIRECT(memoryType, offset, buffer, bufferLength));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_LPSTR_DIRECT(shared_memory memoryType, uint32_t offset, char *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count)
  {
    assert(buffer != nullptr);
    assert(buffer_Char_Len > 0);
    assert(pRead_Char_Count != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_LPSTR)
      return dispErrorCode(("Read_LPSTR_DIRECT"), m_pREAD_LPSTR(memoryType, offset, buffer, buffer_Char_Len, pRead_Char_Count));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Read_LPWSTR_DIRECT(shared_memory memoryType, uint32_t offset, TGM_WCHAR *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count)
  {
    assert(buffer != nullptr);
    assert(buffer_Char_Len > 0);
    assert(pRead_Char_Count != nullptr);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pREAD_LPWSTR)
      return dispErrorCode(("Read_LPWSTR_DRIECT"), m_pREAD_LPWSTR(memoryType, offset, buffer, buffer_Char_Len, pRead_Char_Count));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_I32_DIRECT)
      return dispErrorCode(("WRITE_I32_DIRECT"), m_pWRITE_I32_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_I64_DIRECT)
      return dispErrorCode(("WRITE_I64_DIRECT"), m_pWRITE_I64_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_Double_DIRECT(shared_memory memoryType, uint32_t offset, double Value)
  {
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_double_DIRECT)
      return dispErrorCode(("WRITE_double_DIRECT"), m_pWRITE_double_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }

  read_write Write_BLOCK_DIRECT(shared_memory memoryType, uint32_t offset, const void *buffer, uint32_t bufferLength)
  {
    assert(buffer != nullptr);
    assert(bufferLength > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_BLOCK_DIRECT)
      return dispErrorCode(("WRITE_BLOCK_DIRECT"), m_pWRITE_BLOCK_DIRECT(memoryType, offset, buffer, bufferLength));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Write_LPSTR_DIRECT(shared_memory memoryType, uint32_t offset, const char *buffer, uint32_t Write_Char_Len)
  {
    assert(buffer != nullptr);
    assert(Write_Char_Len > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_LPSTR_DIRECT)
      return dispErrorCode(("Write_LPSTR_Direct"), m_pWRITE_LPSTR_DIRECT(memoryType, offset, buffer, Write_Char_Len));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }

  read_write Write_LPWSTR_DIRECT(shared_memory memoryType, uint32_t offset, const TGM_WCHAR *buffer, uint32_t Write_Char_Len)
  {
    assert(buffer != nullptr);
    assert(Write_Char_Len > 0);
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pWRITE_LPWSTR_DIRECT)
      return dispErrorCode(("Write_LPWSTR_Direct"), m_pWRITE_LPWSTR_DIRECT(memoryType, offset, buffer, Write_Char_Len));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Set_Bit_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    assert((offset & 0x3) == 0); // offset must be aligned to 4 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pSET_BIT_I32_DIRECT)
      return dispErrorCode(("SET_BIT_I32_DIRECT"), m_pSET_BIT_I32_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Set_Bit_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    assert((offset & 0x7) == 0); // offset must be aligned to 8 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pSET_BIT_I64_DIRECT)
      return dispErrorCode(("SET_BIT_I64_DIRECT"), m_pSET_BIT_I64_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Clr_Bit_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    assert((offset & 0x3) == 0); // offset must be aligned to 4 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pCLR_BIT_I32_DIRECT)
      return dispErrorCode(("CLR_BIT_I32_DIRECT"), m_pCLR_BIT_I32_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Clr_Bit_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    assert((offset & 0x7) == 0); // offset must be aligned to 8 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pCLR_BIT_I64_DIRECT)
      return dispErrorCode(("CLR_BIT_I64_DIRECT"), m_pCLR_BIT_I64_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Tgl_Bit_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value)
  {
    assert((offset & 0x3) == 0); // offset must be aligned to 4 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pTGL_BIT_I32_DIRECT)
      return dispErrorCode(("TGL_BIT_I32_DIRECT"), m_pTGL_BIT_I32_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Tgl_Bit_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value)
  {
    assert((offset & 0x7) == 0); // offset must be aligned to 8 bytes
    if (m_offlineCounter >= MAX_OFFLINE_COUNT)
      return read_write::ERR_Device_Busy;
    if (m_pTGL_BIT_I64_DIRECT)
      return dispErrorCode(("TGL_BIT_I64_DIRECT"), m_pTGL_BIT_I64_DIRECT(memoryType, offset, Value));
    return read_write::ERR_Not_Detect_Comm_DLL;
  }
  read_write Flush_Buffer()
  {
    if (m_pFLUSH_BUFFER)
      return dispErrorCode(("FLUSH_BUFFER"), m_pFLUSH_BUFFER());
    return read_write::ERR_Interface_Not_Create;
  }

  // suplemental helpers: convert enum classes to strings
  // UNICODE/ANSI versions
  static const TGM_TCHAR * DeviceToString(device deviceType)
  {
    switch (deviceType)
    {
    case device::Local_TGM:
      return TGM_TEXT("Device_Local_TGM");
    case device::TGM_Mini:
      return TGM_TEXT("Device_TGM_Mini");
    case device::TGM_REMOTE:
      return TGM_TEXT("Device_TGM_REMOTE");
    }
    // to satisfy Visual C++ compiler
    return TGM_TEXT("<Unknown device>");
  }

  static const TGM_TCHAR * StatusToString(status code)
  {
    switch (code)
    {
    case status::Simulation_Mode_TGM:
      return TGM_TEXT("Status_Simulation_Mode_TGM");
    case status::Online:
      return TGM_TEXT("Status_Online");
    case status::Offline_Connection_Proceeds:
      return TGM_TEXT("Status_Offline_Connection_Proceeds");
    case status::Offline_Device_Offline:
      return TGM_TEXT("Status_Offline_Device_Offline");
    case status::Offline_Incompatible_DLL_ID:
      return TGM_TEXT("Status_Offline_Incompatible_DLL_ID");
    case status::Offline_Incompatible_DLL_Mem_ID:
      return TGM_TEXT("Status_Offline_Incompatible_DLL_Mem_ID");
    case status::Offline_Incompatible_DEVICE_ID:
      return TGM_TEXT("Status_Offline_Incompatible_DEVICE_ID");
    case status::Offline_Incompatible_DEVICE_Mem_ID:
      return TGM_TEXT("Status_Offline_Incompatible_DEVICE_Mem_ID");
    case status::Offline_Not_Detect_Comm_DLL:
      return TGM_TEXT("Status_Offline_Not_Detect_Comm_DLL");
    case status::Offline_Open_Connection_Failed:
      return TGM_TEXT("Status_Offline_Open_Connection_Failed");
    case status::Offline_Init_Connection_Failed:
      return TGM_TEXT("Status_Offline_Init_Connection_Failed");
    case status::Offline_Connection_Not_Opened:
      return TGM_TEXT("Status_Offline_Connection_Not_Opened");
    case status::Offline_Interface_Not_Create:
      return TGM_TEXT("Status_Offline_Interface_Not_Create");
    }
    // to satisfy Visual C++ compiler
    return TGM_TEXT("<Unknown status>");
  }

  static const TGM_TCHAR * ReadWriteCodeToString(read_write code)
  {
    switch (code)
    {
    case read_write::OK:
      return TGM_TEXT("RW_OK");
    case read_write::OK_Offline_Data:
      return TGM_TEXT("RW_OK_Offline_Data");
    case read_write::ERR_Invalid_Data:
      return TGM_TEXT("RW_ERR_Invalid_Data");
    case read_write::ERR_Device_Busy:
      return TGM_TEXT("RW_ERR_Device_Busy");
    case read_write::ERR_Interface_Not_Create:
      return TGM_TEXT("RW_ERR_Interface_Not_Create");
    case read_write::ERR_Unsupported_Function:
      return TGM_TEXT("RW_ERR_Unsupported_Function");
    case read_write::ERR_Connection_Not_Open:
      return TGM_TEXT("RW_ERR_Connection_Not_Open");
    case read_write::ERR_Not_Detect_Comm_DLL:
      return TGM_TEXT("RW_ERR_Not_Detect_Comm_DLL");
    }
    // to satisfy Visual C++ compiler
    return TGM_TEXT("<Unknown RW_ERR>");
  }

  // ANSI only versions
  static const char * DeviceToStringA(device deviceType)
  {
    switch (deviceType)
    {
    case device::Local_TGM:
      return ("Device_Local_TGM");
    case device::TGM_Mini:
      return ("Device_TGM_Mini");
    case device::TGM_REMOTE:
      return ("Device_TGM_REMOTE");
    }
    // to satisfy Visual C++ compiler
    return ("<Unknown device>");
  }

  static const char * StatusToStringA(status code)
  {
    switch (code)
    {
    case status::Simulation_Mode_TGM:
      return ("Status_Simulation_Mode_TGM");
    case status::Online:
      return ("Status_Online");
    case status::Offline_Connection_Proceeds:
      return ("Status_Offline_Connection_Proceeds");
    case status::Offline_Device_Offline:
      return ("Status_Offline_Device_Offline");
    case status::Offline_Incompatible_DLL_ID:
      return ("Status_Offline_Incompatible_DLL_ID");
    case status::Offline_Incompatible_DLL_Mem_ID:
      return ("Status_Offline_Incompatible_DLL_Mem_ID");
    case status::Offline_Incompatible_DEVICE_ID:
      return ("Status_Offline_Incompatible_DEVICE_ID");
    case status::Offline_Incompatible_DEVICE_Mem_ID:
      return ("Status_Offline_Incompatible_DEVICE_Mem_ID");
    case status::Offline_Not_Detect_Comm_DLL:
      return ("Status_Offline_Not_Detect_Comm_DLL");
    case status::Offline_Open_Connection_Failed:
      return ("Status_Offline_Open_Connection_Failed");
    case status::Offline_Init_Connection_Failed:
      return ("Status_Offline_Init_Connection_Failed");
    case status::Offline_Connection_Not_Opened:
      return ("Status_Offline_Connection_Not_Opened");
    case status::Offline_Interface_Not_Create:
      return ("Status_Offline_Interface_Not_Create");
    }
    // to satisfy Visual C++ compiler
    return ("<Unknown status>");
  }

  static const char * ReadWriteCodeToStringA(read_write code)
  {
    switch (code)
    {
    case read_write::OK:
      return "RW_OK";
    case read_write::OK_Offline_Data:
      return "RW_OK_Offline_Data";
    case read_write::ERR_Invalid_Data:
      return "RW_ERR_Invalid_Data";
    case read_write::ERR_Device_Busy:
      return "RW_ERR_Device_Busy";
    case read_write::ERR_Interface_Not_Create:
      return "RW_ERR_Interface_Not_Create";
    case read_write::ERR_Unsupported_Function:
      return "RW_ERR_Unsupported_Function";
    case read_write::ERR_Connection_Not_Open:
      return "RW_ERR_Connection_Not_Open";
    case read_write::ERR_Not_Detect_Comm_DLL:
      return "RW_ERR_Not_Detect_Comm_DLL";
    }
    // to satisfy Visual C++ compiler
    return ("<Unknown RW_ERR>");
  }

  static const char * ErrorCodeToStringA(error_code code)
  {
    switch (code)
    {
    case error_code::Success:
      return "OK";
    case error_code::Device_Type:
      return "ERR_Device_Type";
    case error_code::Interface_Not_Create:
      return "ERR_Interface_Not_Create";
    case error_code::Connection_Not_Open:
      return "ERR_Connection_Not_Open";
    case error_code::Not_Detect_Comm_DLL:
      return "ERR_Not_Detect_Comm_DLL";
    case error_code::Interface_Already_Exists:
      return "ERR_Interface_Already_Exists";
    case error_code::Interface_Create_Off_Mem:
      return "ERR_Interface_Create_Off_Mem";
    case error_code::Connection_Already_Exists:
      return "ERR_Connection_Already_Exists";
    case error_code::Connection_Create_Thread:
      return "ERR_Connection_Create_Thread";
    case error_code::Invalid_Data:
      return "ERR_Invalid_Data";
    }
    // to satisfy Visual C++ compiler
    return ("<Unknown error code>");
  }

  static const char * MemoryTypeToStringA(shared_memory memory)
  {
    switch (memory)
    {
    case CTGM_COMM_INT_2::shared_memory::SYSTEM:
      return "TGM_System";
    case CTGM_COMM_INT_2::shared_memory::DATA:
      return "TGM_Data";
    case CTGM_COMM_INT_2::shared_memory::CAM:
      return "TGM_Cam_Profile";
    case CTGM_COMM_INT_2::shared_memory::OSC:
      return "TGM_Oscilloscope";
    case CTGM_COMM_INT_2::shared_memory::SERVO:
      return "TGM_Servo";
    case CTGM_COMM_INT_2::shared_memory::DIO:
      return "TGM_Dio";
    case CTGM_COMM_INT_2::shared_memory::INTERP:
      return "TGM_interpolator";
    case CTGM_COMM_INT_2::shared_memory::INTERP_W:
      return "InterpolatorWriteMemory";
    case CTGM_COMM_INT_2::shared_memory::INTERP_R:
      return "InterpolatorReadMemory";
    case CTGM_COMM_INT_2::shared_memory::ODS:
      return "TGM_ODS";
    case CTGM_COMM_INT_2::shared_memory::CNC_EX:
      return "TGM_CNCEX";
    case CTGM_COMM_INT_2::shared_memory::G_CODE:
      return "TGM_GCODE";
    case CTGM_COMM_INT_2::shared_memory::CNC_INI:
      return "TGM_CNCINI";
    case CTGM_COMM_INT_2::shared_memory::UNIVERSAL:
      return "TGM_Universal";
    case CTGM_COMM_INT_2::shared_memory::CNC_EX_LOCAL:
      return "<TGM_CNCEX_Local>";
    case CTGM_COMM_INT_2::shared_memory::NMemories:
      return "<Unknown memory type>";
    }
    // to satisfy Visual C++ compiler
    return "<Unknown memory type>";
  }

private:
  // portability code (Windows & linux with Qt)
  // loading library - xLibrary class
  // native Windows code uses Qt functions syntax
  #ifdef WIN32
    // misc. typedefs
    typedef void _xFunctionPointer();
    typedef _xFunctionPointer *x_FunctionPointer;

    class x_Library
    {
    public:
      x_Library() : m_hModule(NULL) { m_fileName[0] = '\0'; }

      ~x_Library()
      {
        unload();
      }

      x_FunctionPointer resolve(const char * funcName) const
      {
        assert(funcName != nullptr);
        if (m_hModule != NULL)
          return reinterpret_cast<x_FunctionPointer>(GetProcAddress(m_hModule, funcName));
        return NULL;
      }
      void setFileName(const char * fileName) { strcpy_s(m_fileName, fileName); }
      void load() { m_hModule = LoadLibraryA(m_fileName); }
      bool isLoaded() { return m_hModule == NULL ? false : true; }
      HMODULE GetHModule() const { return m_hModule; }
      bool unload()
      {
        bool rv = false;
        if (m_hModule != NULL)
        {
          if(FreeLibrary(m_hModule) != FALSE)
            rv = true;
        }
        m_hModule = nullptr;
        return rv;
      }

    protected:
      char    m_fileName[_MAX_PATH];
      HMODULE m_hModule;
    };
  #else  // !WIN32
    typedef QLibrary x_Library;
    typedef QFunctionPointer x_FunctionPointer;
  #endif // !WIN32

  // display warning or error string to standard debug output
#ifdef WIN32
    // ANSI version
    void x_warning(const char * pszFormat, ...)
    {
      assert(pszFormat != nullptr);
      va_list args;
      va_start(args, pszFormat);

      char out[256];
      const int outLastIndex = static_cast<int>(_countof(out) - 1);
      // print out the text
      int nChars = vsnprintf_s(out, _TRUNCATE, pszFormat, args);
      if (nChars < 0)
      {
        out[outLastIndex] = '\0';
        nChars = static_cast<int>(strlen(out));
      }

      // implemet Qt functionality -> auto append \n if necessary
      if (nChars > 0 && nChars < outLastIndex)
      {
        if (out[nChars - 1] != '\n')
        {
          out[nChars] = '\n';
          out[nChars + 1] = '\0';
        }
      }

      OutputDebugStringA(out);
      va_end(args);
    }
#else // !WIN32
#   define x_warning(strFormat, ...) qWarning(strFormat, ##__VA_ARGS__)
#endif // !WIN32

protected:
  x_Library m_hModule;
  // for simplicity with UNICODE vs ANSI version, do not print file name, which can be UNICODE or ANSI
  // depending on platform
  // function can be virtual for easy replacement in derived platform specific class
  TGM_COMM_INT_VIRTUAL void errDllNotFound(const char *aFileName)
  {
    x_warning("CTGM_COMM_INT_2: Dynamic library %s not found", aFileName);
#ifdef __linux__
    perror("Additional info:");
#endif // __linux__
  }
  TGM_COMM_INT_VIRTUAL void errFuncNotFound(const char *aFileName, const char *funcName)
  {
    x_warning("CTGM_COMM_INT_2: Function %s not found in library %s", funcName, aFileName);
#ifdef __linux__
    perror("Additional info:");
#endif // __linux__
  }

  x_FunctionPointer getFuncAddress(const char *aFileName, const char *funcName)
  {
    assert(aFileName != nullptr);
    assert(funcName != nullptr);
    x_FunctionPointer func = m_hModule.resolve(funcName);
    if (!func)
    {
      errFuncNotFound(aFileName, funcName);
    }
    return func;
  }
  error_code preLoadDll(const char *aFileName)
  {
    assert(aFileName != nullptr);
    m_hModule.setFileName(aFileName);
    m_hModule.load();
    if (m_hModule.isLoaded() == false)
    {
      errDllNotFound(aFileName);
      return error_code::Not_Detect_Comm_DLL;
    }
    return error_code::Success;
  }

  TGM_COMM_INT_VIRTUAL error_code dispErrorCode(const char *funcName, error_code code)
  {
    assert(funcName != nullptr);
    switch (code)
    {
    case error_code::Success:
      m_offlineCounter = 0;
      break;
    case error_code::Device_Type:
      x_warning("%s ERR_Device_Type", funcName);
      break;
    case error_code::Interface_Not_Create:
      x_warning("%s ERR_Interface_Not_Create", funcName);
      break;
    case error_code::Connection_Not_Open:
      x_warning("%s ERR_Connection_Not_Open", funcName);
      break;
    case error_code::Not_Detect_Comm_DLL:
      x_warning("%s ERR_Not_Detect_Comm_DLL", funcName);
      break;
    case error_code::Interface_Already_Exists:
      x_warning("%s ERR_Interface_Already_Exists", funcName);
      break;
    case error_code::Interface_Create_Off_Mem:
      x_warning("%s ERR_Interface_Create_Off_Mem", funcName);
      break;
    case error_code::Connection_Already_Exists:
      x_warning("%s ERR_Connection_Already_Exists", funcName);
      break;
    case error_code::Connection_Create_Thread:
      x_warning("%s ERR_Connection_Create_Thread", funcName);
      break;
    case error_code::Invalid_Data:
      x_warning("%s ERR_Invalid_Data", funcName);
      break;
    }
    return code;
  }

  TGM_COMM_INT_VIRTUAL read_write dispErrorCode(const char *funcName, read_write code)
  {
    assert(funcName != nullptr);
    switch (code)
    {
    case read_write::OK:
      m_offlineCounter = 0;
      break;
    case read_write::OK_Offline_Data:
      m_offlineCounter = 0;
      break;
    case read_write::ERR_Invalid_Data:
      x_warning("%s RW_ERR_Invalid_Data", funcName);
      break;
    case read_write::ERR_Device_Busy:
      if (m_offlineCounter < MAX_OFFLINE_COUNT)
        m_offlineCounter++;
      x_warning("%s RW_ERR_Device_Busy", funcName);
      break;
    case read_write::ERR_Interface_Not_Create:
      x_warning("%s RW_ERR_Interface_Not_Create", funcName);
      break;
    case read_write::ERR_Unsupported_Function:
      x_warning("%s RW_ERR_Unsupported_Function", funcName);
      break;
    case read_write::ERR_Connection_Not_Open:
      x_warning("%s RW_ERR_Connection_Not_Open", funcName);
      break;
    case read_write::ERR_Not_Detect_Comm_DLL:
      x_warning("%s RW_ERR_Not_Detect_Comm_DLL", funcName);
      break;
    }
    return code;
  }

protected:
  // functions declaration
  typedef error_code COM_CALLTYPE TGM_CREATE_INTERFACE_2(const TGM_TCHAR *DLL_Directory);
  typedef void COM_CALLTYPE TGM_SET_APP_COMPATIBILITY_VN(int32_t compatibilityID, int32_t compatibilityMemID, int32_t version, const TGM_TCHAR *appName);
  typedef void COM_CALLTYPE TGM_DESTROY_INTERFACE();
  typedef error_code COM_CALLTYPE TGM_OPEN_CONNECTION(int32_t keepOnline, int32_t commTimeout, device deviceType, uint32_t IPAddress);
  typedef error_code COM_CALLTYPE TGM_CHANGE_CONNECTION(device deviceType, uint32_t IPAddress);
  typedef error_code COM_CALLTYPE TGM_CLOSE_CONNECTION();
  typedef error_code COM_CALLTYPE TGM_GET_DLL_INFO(device deviceType, int32_t *pVersion, int32_t *pCompatibilityID, int32_t *pCompatibilityMemID);
  typedef status COM_CALLTYPE TGM_GET_STATUS();
  typedef status COM_CALLTYPE TGM_GET_STATUS_GRAPHICS(int32_t *pBackColor, int32_t *pTextColor, TGM_TCHAR *buffer); // min 128 characters

  typedef error_code COM_CALLTYPE TGM_GET_CONNECTIONS_INFO_2(device *pDeviceType, uint32_t *pIPAddress, connected_memory *pConnectedMemory);
  typedef error_code COM_CALLTYPE TGM_GET_SERVER_INFO(device deviceType, int32_t *pCompatibilityID, int32_t *pCompatibilityMemID, status *pConnectionStatus);
  typedef error_code COM_CALLTYPE TGM_SHOW_CONNECTIONS_INFO_WIN(TGM_HWND parent, int32_t enableChangeConnection);
  typedef error_code COM_CALLTYPE TGM_CLOSE_CONNECTIONS_INFO_WIN();
  typedef void COM_CALLTYPE TGM_GET_CONNECTIONS_INFO_WIN_DIMENSION(int32_t *Width, int32_t *Height); // not yet implemented in the wrapper and Linux version
  // access functions
  typedef read_write COM_CALLTYPE TGM_READ_I32(shared_memory memoryType, uint32_t offset, int32_t *pValue);
  typedef read_write COM_CALLTYPE TGM_READ_I64(shared_memory memoryType, uint32_t offset, int64_t *pValue);
  typedef read_write COM_CALLTYPE TGM_READ_double(shared_memory memoryType, uint32_t offset, double *pValue);
  typedef read_write COM_CALLTYPE TGM_READ_BLOCK(shared_memory memoryType, uint32_t offset, void *buffer, uint32_t bufferLength);
  typedef read_write COM_CALLTYPE TGM_READ_LPSTR(shared_memory memoryType, uint32_t offset, char *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count);
  typedef read_write COM_CALLTYPE TGM_READ_LPWSTR(shared_memory memoryType, uint32_t offset, TGM_WCHAR *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count);
  typedef read_write COM_CALLTYPE TGM_WRITE_I32(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_WRITE_I64(shared_memory memoryType, uint32_t offset, int64_t Value);
  typedef read_write COM_CALLTYPE TGM_WRITE_double(shared_memory memoryType, uint32_t offset, double Value);
  typedef read_write COM_CALLTYPE TGM_WRITE_BLOCK(shared_memory memoryType, uint32_t offset, const void *buffer, uint32_t bufferLength);
  typedef read_write COM_CALLTYPE TGM_WRITE_LPSTR(shared_memory memoryType, uint32_t offset, const char *Buffer, uint32_t Write_Char_Len);
  typedef read_write COM_CALLTYPE TGM_WRITE_LPWSTR(shared_memory memoryType, uint32_t offset, const TGM_WCHAR *Buffer, uint32_t Write_Char_Len);
  typedef read_write COM_CALLTYPE TGM_SET_BIT_I32(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_SET_BIT_I64(shared_memory memoryType, uint32_t offset, int64_t Value);
  typedef read_write COM_CALLTYPE TGM_CLR_BIT_I32(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_CLR_BIT_I64(shared_memory memoryType, uint32_t offset, int64_t Value);
  typedef read_write COM_CALLTYPE TGM_TGL_BIT_I32(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_TGL_BIT_I64(shared_memory memoryType, uint32_t offset, int64_t Value);
  // direct access functions -> wait for a response
  typedef read_write COM_CALLTYPE TGM_READ_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t *pValue);
  typedef read_write COM_CALLTYPE TGM_READ_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t *pValue);
  typedef read_write COM_CALLTYPE TGM_READ_double_DIRECT(shared_memory memoryType, uint32_t offset, double *pValue);
  typedef read_write COM_CALLTYPE TGM_READ_BLOCK_DIRECT(shared_memory memoryType, uint32_t offset, void *buffer, uint32_t bufferLength);
  typedef read_write COM_CALLTYPE TGM_READ_LPSTR_DIRECT(shared_memory memoryType, uint32_t offset, char *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count);
  typedef read_write COM_CALLTYPE TGM_READ_LPWSTR_DIRECT(shared_memory memoryType, uint32_t offset, TGM_WCHAR *buffer, uint32_t buffer_Char_Len, uint32_t *pRead_Char_Count);

  typedef read_write COM_CALLTYPE TGM_WRITE_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_WRITE_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value);
  typedef read_write COM_CALLTYPE TGM_WRITE_double_DIRECT(shared_memory memoryType, uint32_t offset, double Value);
  typedef read_write COM_CALLTYPE TGM_WRITE_BLOCK_DIRECT(shared_memory memoryType, uint32_t offset, const void *buffer, uint32_t bufferLength);
  typedef read_write COM_CALLTYPE TGM_WRITE_LPSTR_DIRECT(shared_memory memoryType, uint32_t offset, const char *Buffer, uint32_t Write_Char_Len);
  typedef read_write COM_CALLTYPE TGM_WRITE_LPWSTR_DIRECT(shared_memory memoryType, uint32_t offset, const TGM_WCHAR *Buffer, uint32_t Write_Char_Len);

  typedef read_write COM_CALLTYPE TGM_SET_BIT_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_SET_BIT_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value);
  typedef read_write COM_CALLTYPE TGM_CLR_BIT_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_CLR_BIT_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value);
  typedef read_write COM_CALLTYPE TGM_TGL_BIT_I32_DIRECT(shared_memory memoryType, uint32_t offset, int32_t Value);
  typedef read_write COM_CALLTYPE TGM_TGL_BIT_I64_DIRECT(shared_memory memoryType, uint32_t offset, int64_t Value);

  typedef read_write COM_CALLTYPE TGM_FLUSH_BUFFER();

  TGM_CREATE_INTERFACE_2 *m_pCREATE_INTERFACE_2 = nullptr;
  TGM_DESTROY_INTERFACE *m_pDESTROY_INTERFACE = nullptr;
  TGM_OPEN_CONNECTION *m_pOPEN_CONNECTION = nullptr;
  TGM_CHANGE_CONNECTION *m_pCHANGE_CONNECTION = nullptr;
  TGM_CLOSE_CONNECTION *m_pCLOSE_CONNECTION = nullptr;
  TGM_GET_DLL_INFO *m_pGET_DLL_INFO = nullptr;
  TGM_SET_APP_COMPATIBILITY_VN *m_pSET_APP_COMPATIBILITY_VN = nullptr;
  TGM_GET_STATUS *m_pGET_STATUS = nullptr;
  TGM_GET_STATUS_GRAPHICS *m_pGET_STATUS_GRAPHICS = nullptr;
  TGM_GET_CONNECTIONS_INFO_2 *m_pGET_CONNECTIONS_INFO_2 = nullptr;
  TGM_GET_SERVER_INFO *m_pGET_SERVER_INFO = nullptr;
  TGM_SHOW_CONNECTIONS_INFO_WIN *m_pSHOW_CONNECTIONS_INFO_WIN = nullptr;
  TGM_CLOSE_CONNECTIONS_INFO_WIN *m_pCLOSE_CONNECTIONS_INFO_WIN = nullptr;
  TGM_GET_CONNECTIONS_INFO_WIN_DIMENSION *m_pGET_CONNECTIONS_INFO_WIN_DIMENSION = nullptr;
  TGM_READ_I32 *m_pREAD_I32 = nullptr;
  TGM_READ_I64 *m_pREAD_I64 = nullptr;
  TGM_READ_double *m_pREAD_double = nullptr;
  TGM_READ_BLOCK *m_pREAD_BLOCK = nullptr;
  TGM_READ_LPSTR  *m_pREAD_LPSTR = nullptr;
  TGM_READ_LPWSTR *m_pREAD_LPWSTR = nullptr;
  TGM_WRITE_I32 *m_pWRITE_I32 = nullptr;
  TGM_WRITE_I64 *m_pWRITE_I64 = nullptr;
  TGM_WRITE_double *m_pWRITE_double = nullptr;
  TGM_WRITE_BLOCK *m_pWRITE_BLOCK = nullptr;
  TGM_WRITE_LPSTR  *m_pWRITE_LPSTR = nullptr;
  TGM_WRITE_LPWSTR *m_pWRITE_LPWSTR = nullptr;
  TGM_SET_BIT_I32 *m_pSET_BIT_I32 = nullptr;
  TGM_SET_BIT_I64 *m_pSET_BIT_I64 = nullptr;
  TGM_CLR_BIT_I32 *m_pCLR_BIT_I32 = nullptr;
  TGM_CLR_BIT_I64 *m_pCLR_BIT_I64 = nullptr;
  TGM_TGL_BIT_I32 *m_pTGL_BIT_I32 = nullptr;
  TGM_TGL_BIT_I64 *m_pTGL_BIT_I64 = nullptr;
  TGM_READ_I32_DIRECT *m_pREAD_I32_DIRECT = nullptr;
  TGM_READ_I64_DIRECT *m_pREAD_I64_DIRECT = nullptr;
  TGM_READ_double_DIRECT *m_pREAD_double_DIRECT = nullptr;
  TGM_READ_BLOCK_DIRECT *m_pREAD_BLOCK_DIRECT = nullptr;
  TGM_READ_LPSTR_DIRECT  *m_pREAD_LPSTR_DIRECT = nullptr;
  TGM_READ_LPWSTR_DIRECT *m_pREAD_LPWSTR_DIRECT = nullptr;
  TGM_WRITE_I32_DIRECT *m_pWRITE_I32_DIRECT = nullptr;
  TGM_WRITE_I64_DIRECT *m_pWRITE_I64_DIRECT = nullptr;
  TGM_WRITE_double_DIRECT *m_pWRITE_double_DIRECT = nullptr;
  TGM_WRITE_BLOCK_DIRECT *m_pWRITE_BLOCK_DIRECT = nullptr;
  TGM_WRITE_LPSTR_DIRECT  *m_pWRITE_LPSTR_DIRECT = nullptr;
  TGM_WRITE_LPWSTR_DIRECT *m_pWRITE_LPWSTR_DIRECT = nullptr;
  TGM_SET_BIT_I32_DIRECT *m_pSET_BIT_I32_DIRECT = nullptr;
  TGM_SET_BIT_I64_DIRECT *m_pSET_BIT_I64_DIRECT = nullptr;
  TGM_CLR_BIT_I32_DIRECT *m_pCLR_BIT_I32_DIRECT = nullptr;
  TGM_CLR_BIT_I64_DIRECT *m_pCLR_BIT_I64_DIRECT = nullptr;
  TGM_TGL_BIT_I32_DIRECT *m_pTGL_BIT_I32_DIRECT = nullptr;
  TGM_TGL_BIT_I64_DIRECT *m_pTGL_BIT_I64_DIRECT = nullptr;
  TGM_FLUSH_BUFFER *m_pFLUSH_BUFFER = nullptr;

  size_t m_offlineCounter = 0;

  int32_t m_nCreateInterfaceCalled = 0; // protect incorrect CreatInterface/DestroyInterface call order
  int32_t m_nOpenConnectionCalled  = 0; // protect incorrect OpenConnection/CloseConnection call order

  // protect multiple call to CreateInterface and OpenConnection
  // if parent application already calls these functions, the wrapper must ignore them
  // usable if the wrapper is used in sub-DLL, which uses TGM_Comm_Int_2.dll
  // independently on the parent application
  // For example: Qt_CNC_Tester.exe uses this wrapper for working with TGM_Comm_Int_2.dll
  // directly. But Qt_CNC_Tester.exe also uses SF_TCh.dll, which in turn internally also uses
  // TGM_Comm_Int_2.dll (by this wrapper).
  // Therefore by using these flags, multiple call to CreateInterface/OpenConnection
  // will be avoided without an error.
  bool m_bCreateInterfaceAlreadyCalledByApplication = false;
  bool m_bOpenConnectionAlreadyCalledByApplication = false;

#endif // UNDER_RTSS

private:
  // prevent from copying
  CTGM_COMM_INT_2(const CTGM_COMM_INT_2 &other);
  CTGM_COMM_INT_2 &operator=(const CTGM_COMM_INT_2 &other);

};

// useful typedefs - abbreviations of enum classes inside CTGM_COMM_INT_2
// TGM_IF = TGMotion interface
typedef CTGM_COMM_INT_2::error_code       TGM_IF_ERR;

typedef CTGM_COMM_INT_2::read_write       TGM_IF_RW;

typedef CTGM_COMM_INT_2::status           TGM_IF_STAT;

typedef CTGM_COMM_INT_2::device           TGM_IF_DEV;

typedef CTGM_COMM_INT_2::shared_memory    TGM_IF_MEM;

typedef CTGM_COMM_INT_2::connected_memory TGM_IF_CONN_MEM;

#ifdef WIN32
# if _MSC_VER < 1800 // below Visual Studio 2013
#  pragma warning(pop)
# endif
#endif

#endif // TGMCOMMINT2_DLL_H