EgtInterface/API_MachMgr.cpp

//----------------------------------------------------------------------------
//  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) ;
}

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

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

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

//-----------------------------------------------------------------------------
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() ;
}

//-----------------------------------------------------------------------------
//   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 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 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) ;
}

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

//-----------------------------------------------------------------------------
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 EgtGetTableRef1( double ptPos[3])
{
  // recupero il punto
   Point3d ptTemp ;
   if ( ! ExeGetTableRef1( ptTemp))
      return FALSE ;
  // ritorno il punto
   VEC_FROM_3D( ptPos, ptTemp)
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetTableArea1( int* pnAreaId)
{
  // recupero l'identificativo
   int nAreaId ;
   if ( ! ExeGetTableArea1( nAreaId))
      return FALSE ;
  // ritorno il dato
   if ( pnAreaId != nullptr)
      *pnAreaId = nAreaId ;
   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 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 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, wstrztoA( wsVal)) ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
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) ;
}

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

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSimMove( void)
{
   return ( ExeSimMove() ? TRUE : FALSE) ;
}

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

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

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