//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : API_MachMgr.cpp       Data : 23.03.15        Versione : 1.6c8
// Contenuto : Funzioni Machining Manager per API.
//
//
//
// Modifiche : 23.03.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EgtStringConverter.h"

using namespace std ;


//-----------------------------------------------------------------------------
BOOL
__stdcall EgtInitMachMgr( const wchar_t* wsMachinesDir)
{
   return ( ExeInitMachMgr( wstrztoA( wsMachinesDir)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
//   Machines
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetCurrMachine( const wchar_t* wsMachineName)
{
   return ( ExeSetCurrMachine( wstrztoA( wsMachineName)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetCurrMachineName( wchar_t*& wsMachineName)
{
   if ( &wsMachineName == nullptr)
      return FALSE ;
   string sMachineName ;
   if ( ! ExeGetCurrMachineName( sMachineName))
      return FALSE ;
   wsMachineName = _wcsdup( stringtoW( sMachineName)) ;
   return  (( wsMachineName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
//   Machining Groups
//-----------------------------------------------------------------------------
int
__stdcall EgtGetMachGroupCount( void)
{
   return ExeGetMachGroupCount() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetFirstMachGroup( void)
{
   return ExeGetFirstMachGroup() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetNextMachGroup( int nId)
{
   return ExeGetNextMachGroup( nId) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachGroupNewName( const wchar_t* wsName, wchar_t*& wsNewName)
{
   if ( &wsNewName == nullptr)
      return FALSE ;
   string sNewName = wstrztoA( wsName) ;
   if ( ! ExeGetMachGroupNewName( sNewName))
      return FALSE ;
   wsNewName = _wcsdup( stringtoW( sNewName)) ;
   return  (( wsNewName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtAddMachGroup( const wchar_t* wsName, const wchar_t* wsMachineName)
{
   return ExeAddMachGroup( wstrztoA( wsName), wstrztoA( wsMachineName)) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveMachGroup( int nMGroupId)
{
   return ( ExeRemoveMachGroup( nMGroupId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachGroupName( int nMGroupInd, wchar_t*& wsName)
{
   if ( &wsName == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeGetMachGroupName( nMGroupInd, sName))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachGroupId( const wchar_t* wsName)
{
   return ExeGetMachGroupId( wstrztoA( wsName)) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetCurrMachGroup( int nMGroupId)
{
   return ( ExeSetCurrMachGroup( nMGroupId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtResetCurrMachGroup( void)
{
   return ( ExeResetCurrMachGroup() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetCurrMachGroup( void)
{
   return ExeGetCurrMachGroup() ;
}

//-----------------------------------------------------------------------------
//   Phases
//-----------------------------------------------------------------------------
int
__stdcall EgtAddPhase( void)
{
   return ExeAddPhase() ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetCurrPhase( int nPhase, BOOL bForced)
{
   return ( ExeSetCurrPhase( nPhase, ( bForced != FALSE)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetCurrPhase( void)
{
   return ExeGetCurrPhase() ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveLastPhase( void)
{
   return ( ExeRemoveLastPhase() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetPhaseCount( void)
{
   return ExeGetPhaseCount() ;
}

//-----------------------------------------------------------------------------
//   Raw Parts
//-----------------------------------------------------------------------------
int
__stdcall EgtGetRawPartCount( void)
{
   return ExeGetRawPartCount() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetFirstRawPart( void)
{
   return ExeGetFirstRawPart() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetNextRawPart( int nRawId)
{
   return ExeGetNextRawPart( nRawId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtAddRawPart( const double ptOrig[3],
                         double dLength, double dWidth, double dHeight, const int vCol[4])
{
   return ExeAddRawPart( ptOrig, dLength, dWidth, dHeight, vCol) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyRawPart( int nRawId, const double ptOrig[3],
                            double dLength, double dWidth, double dHeight, const int vCol[4])
{
   return ( ExeModifyRawPart( nRawId, ptOrig, dLength, dWidth, dHeight, vCol) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyRawPart2( int nRawId, int nCrvId,
                             double dOverMat, double dZmin, double dHeight, const int vCol[4])
{
   return ( ExeModifyRawPart( nRawId, nCrvId, dOverMat, dZmin, dHeight, vCol) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyRawPartSize( int nRawId, double dLength, double dWidth, double dHeight)
{
   return ( ExeModifyRawPartSize( nRawId, dLength, dWidth, dHeight) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyRawPartHeight( int nRawId, double dHeight)
{
   return ( ExeModifyRawPartHeight( nRawId, dHeight) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtKeepRawPart( int nRawId)
{
   return ( ExeKeepRawPart( nRawId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVerifyRawPartPhase( int nRawId, int nPhase)
{
   return ( ExeVerifyRawPartPhase( nRawId, nPhase) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveRawPartFromCurrPhase( int nRawId)
{
   return ( ExeRemoveRawPartFromCurrPhase( nRawId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveRawPart( int nRawId)
{
   return ( ExeRemoveRawPart( nRawId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMoveToCornerRawPart( int nRawId, const double ptCorner[3], int nFlag)
{
   return ( ExeMoveToCornerRawPart( nRawId, ptCorner, nFlag) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMoveRawPart( int nRawId, const double vtMove[3])
{
   return ( ExeMoveRawPart( nRawId, vtMove) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSplitFlatRawPartWithMachinings( int nRawId, int nNumMchId, const int nMchIds[])
{
   INTVECTOR vMchIds ;
   vMchIds.reserve( nNumMchId) ;
   for ( int i = 0 ; i < nNumMchId ; ++i) {
      vMchIds.push_back( nMchIds[i]) ;
   }
   return ExeSplitFlatRawPartWithMachinings( nRawId, vMchIds) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetPartInRawPartCount( int nRawId)
{
   return ExeGetPartInRawPartCount( nRawId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetFirstPartInRawPart( int nRawId)
{
   return ExeGetFirstPartInRawPart( nRawId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetNextPartInRawPart( int nPartId)
{
   return ExeGetNextPartInRawPart( nPartId) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtAddPartToRawPart( int nPartId, const double ptPos[3], int nRawId)
{
   return ( ExeAddPartToRawPart( nPartId, ptPos, nRawId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetRawPartFromPart( int nPartId)
{
   return ExeGetRawPartFromPart( nPartId) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemovePartFromRawPart( int nPartId)
{
   return ( ExeRemovePartFromRawPart( nPartId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
// Table & Fixtures
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetTable( const wchar_t* wsTable)
{
   return ( ExeSetTable( wstrztoA( wsTable)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetTableName( wchar_t*& wsTableName)
{
   if ( &wsTableName == nullptr)
      return FALSE ;
   string sTableName ;
   if ( ! ExeGetTable( sTableName))
      return FALSE ;
   wsTableName = _wcsdup( stringtoW( sTableName)) ;
   return  (( wsTableName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetTableRef( int nInd, double ptPos[3])
{
  // recupero il punto
   Point3d ptTemp ;
   if ( ! ExeGetTableRef( nInd, ptTemp))
      return FALSE ;
  // ritorno il punto
   VEC_FROM_3D( ptPos, ptTemp)
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetTableArea( int nInd, double ptMin[3], double ptMax[3])
{
  // recupero l'identificativo
   BBox3d b3Area ;
   if ( ! ExeGetTableArea( nInd, b3Area))
      return FALSE ;
  // ritorno i dati
   if ( ptMin != nullptr)
      VEC_FROM_3D( ptMin, b3Area.GetMin()) ;
   if ( ptMax != nullptr)
      VEC_FROM_3D( ptMax, b3Area.GetMax()) ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtShowOnlyTable( bool bVal)
{
   return ( ExeShowOnlyTable( bVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
// Tools DataBase
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetToolNewName( const wchar_t* wsName, wchar_t*& wsNewName)
{
   if ( &wsNewName == nullptr)
      return FALSE ;
   string sNewName = wstrztoA( wsName) ;
   if ( ! ExeTdbGetToolNewName( sNewName))
      return FALSE ;
   wsNewName = _wcsdup( stringtoW( sNewName)) ;
   return  (( wsNewName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbAddTool( const wchar_t* wsName, int nType)
{
   return ( ExeTdbAddTool( wstrztoA( wsName), nType) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbCopyTool( const wchar_t* wsSource, const wchar_t* wsName)
{
   return ( ExeTdbCopyTool( wstrztoA( wsSource), wstrztoA( wsName)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbRemoveTool( const wchar_t* wsName)
{
   return ( ExeTdbRemoveTool( wstrztoA( wsName)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetFirstTool( int nFamily, wchar_t*& wsName, int* pnType)
{
   if ( &wsName == nullptr  ||  pnType == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeTdbGetFirstTool( nFamily, sName, *pnType))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetNextTool( int nFamily, wchar_t*& wsName, int* pnType)
{
   if ( &wsName == nullptr  ||  pnType == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeTdbGetNextTool( nFamily, sName, *pnType))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetToolFromUUID( const wchar_t* wsTuuid, wchar_t*& wsName)
{
   if ( &wsName == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeTdbGetToolFromUUID( wstrztoA( wsTuuid), sName))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbSetCurrTool( const wchar_t* wsName)
{
   return ( ExeTdbSetCurrTool( wstrztoA( wsName)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbSaveCurrTool( void)
{
   return ( ExeTdbSaveCurrTool() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbIsCurrToolModified( void)
{
   return ( ExeTdbIsCurrToolModified() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbSetCurrToolParamBool( int nType, BOOL bVal)
{
   return ( ExeTdbSetCurrToolParam( nType, ( bVal != FALSE)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbSetCurrToolParamInt( int nType, int nVal)
{
   return ( ExeTdbSetCurrToolParam( nType, nVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbSetCurrToolParamDouble( int nType, double dVal)
{
   return ( ExeTdbSetCurrToolParam( nType, dVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbSetCurrToolParamString( int nType, const wchar_t* wsVal)
{
   return ( ExeTdbSetCurrToolParam( nType, string( wstrztoA( wsVal))) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetCurrToolParamBool( int nType, BOOL* pbVal)
{
   if ( pbVal == nullptr)
      return FALSE ;
   bool bVal ;
   if ( ! ExeTdbGetCurrToolParam( nType, bVal))
      return FALSE ;
   *pbVal = ( bVal ? TRUE : FALSE) ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetCurrToolParamInt( int nType, int* pnVal)
{
   if ( pnVal == nullptr)
      return FALSE ;
   return ( ExeTdbGetCurrToolParam( nType, *pnVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetCurrToolParamDouble( int nType, double* pdVal)
{
   if ( pdVal == nullptr)
      return FALSE ;
   return ( ExeTdbGetCurrToolParam( nType, *pdVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetCurrToolParamString( int nType, wchar_t*& wsVal)
{
   if ( &wsVal == nullptr)
      return FALSE ;
   string sVal ;
   if ( ! ExeTdbGetCurrToolParam( nType, sVal))
      return FALSE ;
   wsVal = _wcsdup( stringtoW( sVal)) ;
   return  (( wsVal == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbSave( void)
{
   return ( ExeTdbSave() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetToolDir( wchar_t*& wsToolDir)
{
   if ( &wsToolDir == nullptr)
      return FALSE ;
   string sToolDir ;
   if ( ! ExeTdbGetToolDir( sToolDir))
      return FALSE ;
   wsToolDir = _wcsdup( stringtoW( sToolDir)) ;
   return  (( wsToolDir == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtTdbGetToolHolderDir( wchar_t*& wsTHolderDir)
{
   if ( &wsTHolderDir == nullptr)
      return FALSE ;
   string sTHolderDir ;
   if ( ! ExeTdbGetToolHolderDir( sTHolderDir))
      return FALSE ;
   wsTHolderDir = _wcsdup( stringtoW( sTHolderDir)) ;
   return  (( wsTHolderDir == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
// Machiningss DataBase
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetMachiningNewName( const wchar_t* wsName, wchar_t*& wsNewName)
{
   if ( &wsNewName == nullptr)
      return FALSE ;
   string sNewName = wstrztoA( wsName) ;
   if ( ! ExeMdbGetMachiningNewName( sNewName))
      return FALSE ;
   wsNewName = _wcsdup( stringtoW( sNewName)) ;
   return  (( wsNewName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbAddMachining( const wchar_t* wsName, int nType)
{
   return ( ExeMdbAddMachining( wstrztoA( wsName), nType) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbCopyMachining( const wchar_t* wsSource, const wchar_t* wsName)
{
   return ( ExeMdbCopyMachining( wstrztoA( wsSource), wstrztoA( wsName)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbRemoveMachining( const wchar_t* wsName)
{
   return ( ExeMdbRemoveMachining( wstrztoA( wsName)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetFirstMachining( int nType, wchar_t*& wsName)
{
   if ( &wsName == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeMdbGetFirstMachining( nType, sName))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetNextMachining( int nType, wchar_t*& wsName)
{
   if ( &wsName == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeMdbGetNextMachining( nType, sName))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetMachiningFromUUID( const wchar_t* wsMuuid, wchar_t*& wsName)
{
   if ( &wsName == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeMdbGetMachiningFromUUID( wstrztoA( wsMuuid), sName))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSetCurrMachining( const wchar_t* wsName)
{
   return ( ExeMdbSetCurrMachining( wstrztoA( wsName)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSaveCurrMachining( void)
{
   return ( ExeMdbSaveCurrMachining() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbIsCurrMachiningModified( void)
{
   return ( ExeMdbIsCurrMachiningModified() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSetCurrMachiningParamBool( int nType, BOOL bVal)
{
   return ( ExeMdbSetCurrMachiningParam( nType, ( bVal != FALSE)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSetCurrMachiningParamInt( int nType, int nVal)
{
   return ( ExeMdbSetCurrMachiningParam( nType, nVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSetCurrMachiningParamDouble( int nType, double dVal)
{
   return ( ExeMdbSetCurrMachiningParam( nType, dVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSetCurrMachiningParamString( int nType, const wchar_t* wsVal)
{
   return ( ExeMdbSetCurrMachiningParam( nType, string( wstrztoA( wsVal))) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetCurrMachiningParamBool( int nType, BOOL* pbVal)
{
   if ( pbVal == nullptr)
      return FALSE ;
   bool bVal ;
   if ( ! ExeMdbGetCurrMachiningParam( nType, bVal))
      return FALSE ;
   *pbVal = ( bVal ? TRUE : FALSE) ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetCurrMachiningParamInt( int nType, int* pnVal)
{
   if ( pnVal == nullptr)
      return FALSE ;
   return ( ExeMdbGetCurrMachiningParam( nType, *pnVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetCurrMachiningParamDouble( int nType, double* pdVal)
{
   if ( pdVal == nullptr)
      return FALSE ;
   return ( ExeMdbGetCurrMachiningParam( nType, *pdVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetCurrMachiningParamString( int nType, wchar_t*& wsVal)
{
   if ( &wsVal == nullptr)
      return FALSE ;
   string sVal ;
   if ( ! ExeMdbGetCurrMachiningParam( nType, sVal))
      return FALSE ;
   wsVal = _wcsdup( stringtoW( sVal)) ;
   return  (( wsVal == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSetGeneralParamDouble( int nType, double dVal)
{
   return ( ExeMdbSetGeneralParam( nType, dVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetGeneralParamDouble( int nType, double* pdVal)
{
   if ( pdVal == nullptr)
      return FALSE ;
   return ( ExeMdbGetGeneralParam( nType, *pdVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbSave( void)
{
   return ( ExeMdbSave() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtMdbGetMachiningDir( wchar_t*& wsMchDir)
{
   if ( &wsMchDir == nullptr)
      return FALSE ;
   string sMchDir ;
   if ( ! ExeTdbGetToolDir( sMchDir))
      return FALSE ;
   wsMchDir = _wcsdup( stringtoW( sMchDir)) ;
   return  (( wsMchDir == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
// Operations
//-----------------------------------------------------------------------------
int
__stdcall EgtGetFirstOperation( void)
{
   return ExeGetFirstOperation() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetNextOperation( int nId)
{
   return ExeGetNextOperation( nId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetLastOperation( void)
{
   return ExeGetLastOperation() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetPrevOperation( int nId)
{
   return ExeGetPrevOperation( nId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetFirstActiveOperation( void)
{
   return ExeGetFirstActiveOperation() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetNextActiveOperation( int nId)
{
   return ExeGetNextActiveOperation( nId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetLastActiveOperation( void)
{
   return ExeGetLastActiveOperation() ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetPrevActiveOperation( int nId)
{
   return ExeGetPrevActiveOperation( nId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetOperationType( int nId)
{
   return ExeGetOperationType( nId) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetOperationPhase( int nId)
{
   return ExeGetOperationPhase( nId) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetOperationName( int nId, wchar_t*& wsName)
{
   if ( &wsName == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeGetOperationName( nId, sName))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetOperationId( const wchar_t* wsName)
{
   return ExeGetOperationId( wstrztoA( wsName)) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveOperation( int nId)
{
   return ( ExeRemoveOperation( nId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveAllPhaseOperations( int nPhase)
{
   return ( ExeRemoveAllPhaseOperations( nPhase) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveAllOperations( void)
{
   return ( ExeRemoveAllOperations() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetOperationMode( int nId, BOOL bActive)
{
   return ( ExeSetOperationMode( nId, bActive!= FALSE) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetOperationMode( int nId)
{
   bool bActive ;
   if ( ! ExeGetOperationMode( nId, bActive))
      return FALSE ;
   return ( bActive ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetAllOperationsMode( BOOL bActive)
{
   return ( ExeSetAllOperationsMode( bActive!= FALSE) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetOperationStatus( int nId, BOOL bShow)
{
   return ( ExeSetOperationStatus( nId, ( bShow != FALSE)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetOperationStatus( int nId)
{
   bool bShow ;
   if ( ! ExeGetOperationStatus( nId, bShow))
      return FALSE ;
   return ( bShow ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetAllOperationsStatus( BOOL bShow)
{
   return ( ExeSetAllOperationsStatus( bShow != FALSE) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtChangeOperationPhase( int nId, int nNewPhase)
{
   return ( ExeChangeOperationPhase( nId, nNewPhase) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtRemoveOperationHome( int nId)
{
   return ( ExeRemoveOperationHome( nId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
// Dispositions
//-----------------------------------------------------------------------------
int
__stdcall EgtGetPhaseDisposition( int nPhase)
{
   return ExeGetPhaseDisposition( nPhase) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSpecialApplyDisposition( int nId, BOOL bRecalc)
{
   return ( ExeSpecialApplyDisposition( nId, ( bRecalc != FALSE)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
// Machinings
//-----------------------------------------------------------------------------
int
__stdcall EgtAddMachining( const wchar_t* wsName, const wchar_t* wsMachining)
{
   return ExeAddMachining( wstrztoA( wsName), wstrztoA( wsMachining)) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtCreateMachining( const wchar_t* wsName, int nMchType, const wchar_t* wsTool)
{
   return ExeAddMachining( wstrztoA( wsName), nMchType, wstrztoA( wsTool)) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetCurrMachining( int nId)
{
   return ( ExeSetCurrMachining( nId) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetCurrMachining( void)
{
   return ExeGetCurrMachining() ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetMachiningParamBool( int nType, BOOL bVal)
{
   return ( ExeSetMachiningParam( nType, ( bVal != FALSE)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetMachiningParamInt( int nType, int nVal)
{
   return ( ExeSetMachiningParam( nType, nVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetMachiningParamDouble( int nType, double dVal)
{
   return ( ExeSetMachiningParam( nType, dVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetMachiningParamString( int nType, const wchar_t* wsVal)
{
   return ( ExeSetMachiningParam( nType, string( wstrztoA( wsVal))) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetMachiningGeometry( int nNumId, const int nIds[], const int nSubs[])
{
   if ( nIds == nullptr  ||  nSubs == nullptr)
      return FALSE ;
  // creo elenco identificativi
   SELVECTOR vIds ;
   vIds.reserve( nNumId) ;
   for ( int i = 0 ; i < nNumId ; ++ i)
      vIds.emplace_back( nIds[i], nSubs[i]) ;
   return ( ExeSetMachiningGeometry( vIds) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPreviewMachining( BOOL bRecalc)
{
   return ( ExePreviewMachining( bRecalc != FALSE) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtApplyMachining( BOOL bRecalc)
{
   return ( ExeApplyMachining( bRecalc != FALSE) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachiningParamBool( int nType, BOOL* pbVal)
{
   if ( pbVal == nullptr)
      return FALSE ;
   bool bVal ;
   if ( ! ExeGetMachiningParam( nType, bVal))
      return FALSE ;
   *pbVal = bVal ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachiningParamInt( int nType, int* pnVal)
{
   if ( pnVal == nullptr)
      return FALSE ;
   return ( ExeGetMachiningParam( nType, *pnVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachiningParamDouble( int nType, double* pdVal)
{
   if ( pdVal == nullptr)
      return FALSE ;
   return ( ExeGetMachiningParam( nType, *pdVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachiningParamString( int nType, wchar_t*& wsVal)
{
   if ( &wsVal == nullptr)
      return FALSE ;
   string sVal ;
   if ( ! ExeGetMachiningParam( nType, sVal))
      return FALSE ;
   wsVal = _wcsdup( stringtoW( sVal)) ;
   return  (( wsVal == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetMachiningGeometry( int nInd, int* pnId, int* pnSub)
{
   if ( pnId == nullptr  ||  pnSub == nullptr)
      return FALSE ;
  // recupero elenco identificativi
   SELVECTOR vIds ;
   if ( ! ExeGetMachiningGeometry( vIds))
      return FALSE ;
  // verifico indice
   if ( nInd < 0  ||  nInd >= int( vIds.size()))
      return FALSE ;
  // assegno il risultato
   *pnId = vIds[nInd].nId ;
   *pnSub = vIds[nInd].nSub ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtIsMachiningEmpty( void)
{
   return ( ExeIsMachiningEmpty() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
// Simulation
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimStart( void)
{
   return ( ExeSimStart() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimMove( int* pnStatus)
{
   int nStatus ;
   bool bOk = ExeSimMove( nStatus) ;
   if ( pnStatus != nullptr)
      *pnStatus = nStatus ;
   return ( bOk ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimHome( void)
{
   return ( ExeSimHome() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimGetAxisInfoPos( int nI, wchar_t*& wsName, double* pdVal)
{
   if ( &wsName == nullptr  ||  pdVal == nullptr)
      return FALSE ;
   string sName ;
   if ( ! ExeSimGetAxisInfoPos( nI, sName, *pdVal))
      return FALSE ;
   wsName = _wcsdup( stringtoW( sName)) ;
   return  (( wsName == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimGetToolInfo( wchar_t*& wsTool, double* pdSpeed)
{
   if ( &wsTool == nullptr  ||  pdSpeed == nullptr)
      return FALSE ;
   string sTool ;
   if ( ! ExeSimGetToolInfo( sTool, *pdSpeed))
      return FALSE ;
   wsTool = _wcsdup( stringtoW( sTool)) ;
   return  (( wsTool == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimGetMoveInfo( int* pnGmove, double* pdFeed)
{
   if ( pnGmove == nullptr  ||  pdFeed == nullptr)
      return FALSE ;
   return ( ExeSimGetMoveInfo( *pnGmove, *pdFeed) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimSetStep( double dStep)
{
   return ( ExeSimSetStep( dStep) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimStop( void)
{
   return ( ExeSimStop() ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
// Generation
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGenerate( const wchar_t* wsCncFile, const wchar_t* wsInfo)
{
   return ( ExeGenerate( wstrztoA( wsCncFile), wstrztoA( wsInfo)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
// Machine
//-----------------------------------------------------------------------------
int
__stdcall EgtGetBaseId( const wchar_t* wsBase)
{
   return ExeGetBaseId( wstrztoA( wsBase)) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetTableId( const wchar_t* wsTable)
{
   return ExeGetTableId( wstrztoA( wsTable)) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetAxisId( const wchar_t* wsAxis)
{
   return ExeGetAxisId( wstrztoA( wsAxis)) ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetHeadId( const wchar_t* wsHead)
{
   return ExeGetHeadId( wstrztoA( wsHead)) ;
}

//-----------------------------------------------------------------------------
// Machine Calc
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetCalcTool( const wchar_t* wsTool, const wchar_t* wsHead, int nExit)
{
   return ( ExeSetCalcTool( wstrztoA( wsTool), wstrztoA( wsHead), nExit) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
                                      BOOL bBottom, double ptTip[3])
{
   Point3d ptTmp ;
   if ( ! ExeGetCalcTipFromPositions( dX, dY, dZ, dAngA, dAngB, ( bBottom != FALSE), ptTmp))
      return FALSE ;
  // ritorno i dati
   if ( ptTip != nullptr)
      VEC_FROM_3D( ptTip, ptTmp) ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetCalcToolDirFromAngles( double dAngA, double dAngB, double vtDir[3])
{
   Vector3d vtTmp ;
   if ( ! ExeGetCalcToolDirFromAngles( dAngA, dAngB, vtTmp))
      return FALSE ;
  // ritorno i dati
   if ( vtDir != nullptr)
      VEC_FROM_3D( vtDir, vtTmp) ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVerifyOutstroke( double dX, double dY, double dZ, double dAngA, double dAngB, int* pnStat)
{
   int nStat ;
   if ( ! ExeVerifyOutstroke( dX, dY, dZ, dAngA, dAngB, nStat))
      return FALSE ;
   if ( pnStat != nullptr)
      *pnStat = nStat ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetOutstrokeInfo( wchar_t*& wsInfo)
{
   string sInfo ;
   if ( ! ExeGetOutstrokeInfo( sInfo))
      return false ;
   wsInfo = _wcsdup( stringtoW( sInfo)) ;
   return  (( wsInfo == nullptr) ? FALSE : TRUE) ;
}

//-----------------------------------------------------------------------------
// Machine Move
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetAxisPos( const wchar_t* wsAxis, double dVal)
{
   return ( ExeSetAxisPos( wstrztoA( wsAxis), dVal) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtLoadTool( const wchar_t* wsHead, int nExit, const wchar_t* wsTool)
{
   return ( ExeLoadTool( wstrztoA( wsHead), nExit, wstrztoA( wsTool)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtResetHeadSet( const wchar_t* wsHead)
{
   return ( ExeResetHeadSet( wstrztoA( wsHead)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetMachineLook( int nFlag)
{
   return ( ExeSetMachineLook( nFlag) ? TRUE : FALSE) ;
}