Dario Sassi
4722 lines
141 KiB
C++
4722 lines
141 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2018
|
|
//----------------------------------------------------------------------------
|
|
// File : LUA_MachMgr.cpp Data : 27.11.18 Versione : 1.9k2
|
|
// Contenuto : Funzioni Machining Manager per LUA.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 24.03.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "LUA.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EXeConst.h"
|
|
#include "/EgtDev/Include/EMkToolConst.h"
|
|
#include "/EgtDev/Include/EMkMachiningConst.h"
|
|
#include "/EgtDev/Include/EGkGdbConst.h"
|
|
#include "/EgtDev/Include/EGkLuaAux.h"
|
|
|
|
using namespace std ;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Errors & Warnings
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetLastMachMgrError( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero identificativo e stringa dell'errore
|
|
int nErr = ExeGetLastMachMgrErrorId() ;
|
|
string sErr = ( nErr != 0 ? ExeGetLastMachMgrErrorString() : "") ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nErr) ;
|
|
LuaSetParam( L, sErr) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachMgrWarning( lua_State* L)
|
|
{
|
|
// 1 para parametro
|
|
int nInd ;
|
|
LuaCheckParam( L, 1, nInd)
|
|
LuaClearStack( L) ;
|
|
// recupero identificativo e stringa dell'avviso
|
|
int nWarn = ExeGetMachMgrWarningId( nInd) ;
|
|
string sWarn = ( nWarn != 0 ? ExeGetMachMgrWarningString( nInd) : "") ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nWarn) ;
|
|
LuaSetParam( L, sWarn) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Machines
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetCurrMachine( lua_State* L)
|
|
{
|
|
// 1 parametro : nome della macchina
|
|
string sMachineName ;
|
|
LuaCheckParam( L, 1, sMachineName)
|
|
LuaClearStack( L) ;
|
|
// rendo corrente la macchina
|
|
bool bOk = ExeSetCurrMachine( sMachineName) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCurrMachineName( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il nome della macchina
|
|
string sMachineName ;
|
|
bool bOk = ExeGetCurrMachineName( sMachineName) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sMachineName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCurrMachineDir( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il direttorio della macchina
|
|
string sMachineDir ;
|
|
bool bOk = ExeGetCurrMachineDir( sMachineDir) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sMachineDir) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Mach Groups
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachGroupCount( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il numero di macchinate
|
|
int nTot = ExeGetMachGroupCount() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nTot) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetFirstMachGroup( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della prima macchinata
|
|
int nId = ExeGetFirstMachGroup() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetNextMachGroup( lua_State* L)
|
|
{
|
|
// 1 parametro : identificativo di una macchinata
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della successiva macchinata
|
|
int nNextId = ExeGetNextMachGroup( nId) ;
|
|
// restituisco il risultato
|
|
if ( nNextId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNextId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetLastMachGroup( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo dell'ultima macchinata
|
|
int nId = ExeGetLastMachGroup() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetPrevMachGroup( lua_State* L)
|
|
{
|
|
// 1 parametro : identificativo di una macchinata
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della precedente macchinata
|
|
int nNextId = ExeGetPrevMachGroup( nId) ;
|
|
// restituisco il risultato
|
|
if ( nNextId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNextId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachGroupNewName( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// verifico nome e se necessario lo modifico per renderlo nuovo
|
|
bool bOk = ExeGetMachGroupNewName( sName) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAddMachGroup( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nome del gruppo [, nome della macchina da utilizzare]
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
string sMachineName ;
|
|
LuaGetParam( L, 2, sMachineName) ;
|
|
LuaClearStack( L) ;
|
|
// aggiungo la macchinata
|
|
int nId = ExeAddMachGroup( sName, sMachineName) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCopyMachGroup( lua_State* L)
|
|
{
|
|
// 2 parametri : nome del gruppo sorgente, nome del nuovo gruppo
|
|
string sSouName ;
|
|
LuaCheckParam( L, 1, sSouName)
|
|
string sName ;
|
|
LuaCheckParam( L, 2, sName) ;
|
|
LuaClearStack( L) ;
|
|
// copio la macchinata
|
|
int nId = ExeCopyMachGroup( sSouName, sName) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveMachGroup( lua_State* L)
|
|
{
|
|
// 1 parametro : identificativo del gruppo
|
|
int nMGroupInd ;
|
|
LuaCheckParam( L, 1, nMGroupInd)
|
|
LuaClearStack( L) ;
|
|
// rimuovo la macchinata
|
|
bool bOk = ExeRemoveMachGroup( nMGroupInd) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaChangeMachGroupName( lua_State* L)
|
|
{
|
|
// 2 parametri : identificativo del gruppo, nuovo nome
|
|
int nMGroupInd ;
|
|
LuaCheckParam( L, 1, nMGroupInd)
|
|
string sNewName ;
|
|
LuaCheckParam( L, 2, sNewName)
|
|
LuaClearStack( L) ;
|
|
// cambio il nome della macchinata
|
|
string sName ;
|
|
bool bOk = ExeChangeMachGroupName( nMGroupInd, sNewName) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachGroupName( lua_State* L)
|
|
{
|
|
// 1 parametro : identificativo del gruppo
|
|
int nMGroupInd ;
|
|
LuaCheckParam( L, 1, nMGroupInd)
|
|
LuaClearStack( L) ;
|
|
// recupero il nome della macchinata
|
|
string sName ;
|
|
bool bOk = ExeGetMachGroupName( nMGroupInd, sName) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachGroupMachineName( lua_State* L)
|
|
{
|
|
// 1 parametro : identificativo del gruppo
|
|
int nMGroupInd ;
|
|
LuaCheckParam( L, 1, nMGroupInd)
|
|
LuaClearStack( L) ;
|
|
// recupero il nome della macchinata
|
|
string sMachineName ;
|
|
bool bOk = ExeGetMachGroupMachineName( nMGroupInd, sMachineName) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sMachineName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachGroupId( lua_State* L)
|
|
{
|
|
// 1 parametro : nome del gruppo
|
|
string sGroupName ;
|
|
LuaCheckParam( L, 1, sGroupName)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della macchinata
|
|
int nId = ExeGetMachGroupId( sGroupName) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetCurrMachGroup( lua_State* L)
|
|
{
|
|
// nessuno o 1 parametro : [identificativo del gruppo]
|
|
int nMGroupInd ;
|
|
if ( ! LuaGetParam( L, 1, nMGroupInd))
|
|
nMGroupInd = ExeGetFirstMachGroup() ;
|
|
LuaClearStack( L) ;
|
|
// imposto il gruppo corrente
|
|
bool bOk = ExeSetCurrMachGroup( nMGroupInd) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaResetCurrMachGroup( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// imposto il gruppo corrente
|
|
bool bOk = ExeResetCurrMachGroup() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCurrMachGroup( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo del gruppo corrente
|
|
int nId = ExeGetCurrMachGroup() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Phases
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAddPhase( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// aggiungo una nuova fase di lavorazione alla macchinata corrente
|
|
int nPhase = ExeAddPhase() ;
|
|
// restituisco il risultato
|
|
if ( nPhase > 0)
|
|
LuaSetParam( L, nPhase) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetCurrPhase( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nPhase [, bForced = false]
|
|
int nPhase ;
|
|
LuaCheckParam( L, 1, nPhase)
|
|
bool bForced = false ;
|
|
LuaGetParam( L, 2, bForced) ;
|
|
LuaClearStack( L) ;
|
|
// imposto la fase di lavorazione corrente nella macchinata corrente
|
|
bool bOk = ExeSetCurrPhase( nPhase, bForced) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCurrPhase( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero la fase di lavorazione corrente nella macchinata corrente
|
|
int nPhase = ExeGetCurrPhase() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nPhase) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveLastPhase( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// elimina l'ultima fase di lavorazione dalla macchinata corrente
|
|
bool bOk = ExeRemoveLastPhase() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetPhaseCount( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il numero totale di fasi di lavorazione nella macchinata corrente
|
|
int nCount = ExeGetPhaseCount() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nCount) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Raw Parts & Parts
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetRawPartCount( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il numero di grezzi nella macchinata corrente
|
|
int nCount = ExeGetRawPartCount() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nCount) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetFirstRawPart( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero identificativo primo grezzo nella macchinata corrente
|
|
int nId = ExeGetFirstRawPart() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetNextRawPart( lua_State* L)
|
|
{
|
|
// 1 parametro : nRawId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
LuaClearStack( L) ;
|
|
// recupero identificativo successivo grezzo nella macchinata corrente
|
|
int nId = ExeGetNextRawPart( nRawId) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAddRawPart( lua_State* L)
|
|
{
|
|
// 5 parametri : Pto origine, dLen, dWidth, dH, Color
|
|
Point3d ptOrig ;
|
|
LuaCheckParam( L, 1, ptOrig)
|
|
double dLength ;
|
|
LuaCheckParam( L, 2, dLength)
|
|
double dWidth ;
|
|
LuaCheckParam( L, 3, dWidth)
|
|
double dHeight ;
|
|
LuaCheckParam( L, 4, dHeight)
|
|
Color cCol ;
|
|
LuaCheckParam( L, 5, cCol)
|
|
LuaClearStack( L) ;
|
|
// inserisco il grezzo nella macchinata corrente
|
|
int nInd = ExeAddRawPart( ptOrig, dLength, dWidth, dHeight, cCol) ;
|
|
// restituisco il risultato
|
|
if ( nInd != GDB_ID_NULL)
|
|
LuaSetParam( L, nInd) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAddRawPartWithPart( lua_State* L)
|
|
{
|
|
// 4 parametri : nPartId, nCrvId, dOverMat, Color
|
|
int nPartId ;
|
|
LuaCheckParam( L, 1, nPartId)
|
|
int nCrvId = GDB_ID_NULL ;
|
|
LuaGetParam( L, 2, nCrvId) ;
|
|
double dOverMat ;
|
|
LuaCheckParam( L, 3, dOverMat)
|
|
Color cCol ;
|
|
LuaCheckParam( L, 4, cCol)
|
|
LuaClearStack( L) ;
|
|
// inserisco il grezzo nella macchinata corrente
|
|
int nInd = ExeAddRawPartWithPart( nPartId, nCrvId, dOverMat, cCol) ;
|
|
// restituisco il risultato
|
|
if ( nInd != GDB_ID_NULL)
|
|
LuaSetParam( L, nInd) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaModifyRawPart( lua_State* L)
|
|
{
|
|
// 5 parametri : nRawId, nCrvId, dOverMat, dHeight, cCol
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
int nCrvId ;
|
|
LuaCheckParam( L, 2, nCrvId)
|
|
double dOverMat ;
|
|
LuaCheckParam( L, 3, dOverMat)
|
|
double dHeight ;
|
|
LuaCheckParam( L, 4, dHeight)
|
|
Color cCol ;
|
|
LuaCheckParam( L, 5, cCol)
|
|
LuaClearStack( L) ;
|
|
// modifico le dimensioni del grezzo
|
|
bool bOk = ExeModifyRawPart( nRawId, nCrvId, dOverMat, dHeight, cCol) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaModifyRawPartSize( lua_State* L)
|
|
{
|
|
// 4 parametri : nRawId, dLength, dWidth, dHeight
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
double dLength ;
|
|
LuaCheckParam( L, 2, dLength)
|
|
double dWidth ;
|
|
LuaCheckParam( L, 3, dWidth)
|
|
double dHeight ;
|
|
LuaCheckParam( L, 4, dHeight)
|
|
LuaClearStack( L) ;
|
|
// modifico le dimensioni del grezzo
|
|
bool bOk = ExeModifyRawPartSize( nRawId, dLength, dWidth, dHeight) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaModifyRawPartHeight( lua_State* L)
|
|
{
|
|
// 2 parametri : nRawId, dHeight
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
double dHeight ;
|
|
LuaCheckParam( L, 2, dHeight)
|
|
LuaClearStack( L) ;
|
|
// modifico lo spessore del grezzo
|
|
bool bOk = ExeModifyRawPartHeight( nRawId, dHeight) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaKeepRawPart( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nRawId [, nSouPhase]
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
int nSouPhase = 0 ;
|
|
LuaGetParam( L, 2, nSouPhase) ;
|
|
LuaClearStack( L) ;
|
|
// confermo il grezzo nella fase corrente della macchinata corrente
|
|
bool bOk = ExeKeepRawPart( nRawId, nSouPhase) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaVerifyRawPartPhase( lua_State* L)
|
|
{
|
|
// 2 parametri : nRawId, nPhase
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
int nPhase ;
|
|
LuaCheckParam( L, 2, nPhase)
|
|
LuaClearStack( L) ;
|
|
// verifico che il grezzo sia valido ed appartenga alla fase di lavorazione indicata
|
|
bool bOk = ExeVerifyRawPartPhase( nRawId, nPhase) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveRawPartFromCurrPhase( lua_State* L)
|
|
{
|
|
// 1 parametro : nRawId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
LuaClearStack( L) ;
|
|
// elimino il grezzo dalla fase corrente della macchinata corrente
|
|
bool bOk = ExeRemoveRawPartFromCurrPhase( nRawId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveRawPart( lua_State* L)
|
|
{
|
|
// 1 parametro : nRawId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
LuaClearStack( L) ;
|
|
// elimino il grezzo dalla macchinata corrente
|
|
bool bOk = ExeRemoveRawPart( nRawId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMoveRawPart( lua_State* L)
|
|
{
|
|
// 2 parametri : nRawId, vtMove
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
Vector3d vtMove ;
|
|
LuaCheckParam( L, 2, vtMove)
|
|
LuaClearStack( L) ;
|
|
// traslo il grezzo
|
|
bool bOk = ExeMoveRawPart( nRawId, vtMove) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetRawPartCenter( lua_State* L)
|
|
{
|
|
// 1 parametro : nRawId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
LuaClearStack( L) ;
|
|
// recupero il centro del grezzo
|
|
Point3d ptCen ;
|
|
bool bOk = ExeGetRawPartCenter( nRawId, ptCen) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, ptCen) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetRawPartBBox( lua_State* L)
|
|
{
|
|
// 1 parametro : nRawId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
LuaClearStack( L) ;
|
|
// recupero il bounding box del grezzo
|
|
BBox3d b3Raw ;
|
|
bool bOk = ExeGetRawPartBBox( nRawId, b3Raw) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, b3Raw) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSplitFlatRawPartWithMachinings( lua_State* L)
|
|
{
|
|
// 2 parametri : nRawId, vMchId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
INTVECTOR vMchId ;
|
|
LuaCheckParam( L, 2, vMchId)
|
|
LuaClearStack( L) ;
|
|
// divido il grezzo in parti in base ai tagli delle lavorazioni
|
|
int nId = ExeSplitFlatRawPartWithMachinings( nRawId, vMchId) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRotateRawPart( lua_State* L)
|
|
{
|
|
// 3 parametri : nRawId, vtAx, dAngRotDeg
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
Vector3d vtAx ;
|
|
LuaCheckParam( L, 2, vtAx)
|
|
double dAngRotDeg ;
|
|
LuaCheckParam( L, 3, dAngRotDeg)
|
|
LuaClearStack( L) ;
|
|
// ruoto il grezzo
|
|
bool bOk = ExeRotateRawPart( nRawId, vtAx, dAngRotDeg) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMoveToCornerRawPart( lua_State* L)
|
|
{
|
|
// 3 parametri : nRawId, ptCorner, nFlag
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
Point3d ptCorner ;
|
|
LuaCheckParam( L, 2, ptCorner)
|
|
int nFlag ;
|
|
LuaCheckParam( L, 3, nFlag)
|
|
LuaClearStack( L) ;
|
|
// sposto il grezzo nel corner
|
|
bool bOk = ExeMoveToCornerRawPart( nRawId, ptCorner, nFlag) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMoveToCenterRawPart( lua_State* L)
|
|
{
|
|
// 3 parametri : nRawId, ptCenter, nFlag
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
Point3d ptCenter ;
|
|
LuaCheckParam( L, 2, ptCenter)
|
|
int nFlag ;
|
|
LuaCheckParam( L, 3, nFlag)
|
|
LuaClearStack( L) ;
|
|
// sposto il grezzo nel corner
|
|
bool bOk = ExeMoveToCenterRawPart( nRawId, ptCenter, nFlag) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetPartInRawPartCount( lua_State* L)
|
|
{
|
|
// 1 parametro : nRawId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
LuaClearStack( L) ;
|
|
// recupero il numero di pezzi nel grezzo
|
|
int nCount = ExeGetPartInRawPartCount( nRawId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nCount) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetFirstPartInRawPart( lua_State* L)
|
|
{
|
|
// 1 parametro : nRawId
|
|
int nRawId ;
|
|
LuaCheckParam( L, 1, nRawId)
|
|
LuaClearStack( L) ;
|
|
// recupero identificativo primo pezzo nel grezzo
|
|
int nId = ExeGetFirstPartInRawPart( nRawId) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetNextPartInRawPart( lua_State* L)
|
|
{
|
|
// 1 parametro : nPartId
|
|
int nPartId ;
|
|
LuaCheckParam( L, 1, nPartId)
|
|
LuaClearStack( L) ;
|
|
// recupero identificativo successivo pezzo nello stesso grezzo
|
|
int nId = ExeGetNextPartInRawPart( nPartId) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAddPartToRawPart( lua_State* L)
|
|
{
|
|
// 3 parametri : nPartId, ptPos, nRawId
|
|
int nPartId ;
|
|
LuaCheckParam( L, 1, nPartId)
|
|
Point3d ptPos ;
|
|
LuaCheckParam( L, 2, ptPos)
|
|
int nRawId ;
|
|
LuaCheckParam( L, 3, nRawId)
|
|
LuaClearStack( L) ;
|
|
// inserisco il grezzo nella macchinata corrente
|
|
bool bOk = ExeAddPartToRawPart( nPartId, ptPos, nRawId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetRawPartFromPart( lua_State* L)
|
|
{
|
|
// 1 parametro : nPartId
|
|
int nPartId ;
|
|
LuaCheckParam( L, 1, nPartId)
|
|
LuaClearStack( L) ;
|
|
// cerco il grezzo della fase corrente della macchinata corrente cui appartiene il pezzo
|
|
int nRawId = ExeGetRawPartFromPart( nPartId) ;
|
|
// restituisco il risultato
|
|
if ( nRawId != GDB_ID_NULL)
|
|
LuaSetParam( L, nRawId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemovePartFromRawPart( lua_State* L)
|
|
{
|
|
// 1 parametro : nPartId
|
|
int nPartId ;
|
|
LuaCheckParam( L, 1, nPartId)
|
|
LuaClearStack( L) ;
|
|
// elimino il grezzo dalla macchinata corrente
|
|
bool bOk = ExeRemovePartFromRawPart( nPartId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTranslatePartInRawPart( lua_State* L)
|
|
{
|
|
// 2 parametri : nPartId, vtMove
|
|
int nPartId ;
|
|
LuaCheckParam( L, 1, nPartId)
|
|
Vector3d vtMove ;
|
|
LuaCheckParam( L, 2, vtMove)
|
|
LuaClearStack( L) ;
|
|
// traslo il pezzo nel grezzo
|
|
bool bOk = ExeTranslatePartInRawPart( nPartId, vtMove) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRotatePartInRawPart( lua_State* L)
|
|
{
|
|
// 3 parametri : nPartId, vtAx, dAngRotDeg
|
|
int nPartId ;
|
|
LuaCheckParam( L, 1, nPartId)
|
|
Vector3d vtAx ;
|
|
LuaCheckParam( L, 2, vtAx)
|
|
double dAngRotDeg ;
|
|
LuaCheckParam( L, 3, dAngRotDeg)
|
|
LuaClearStack( L) ;
|
|
// ruoto il pezzo nel grezzo
|
|
bool bOk = ExeRotatePartInRawPart( nPartId, vtAx, dAngRotDeg) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Table & Fixtures
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetTable( lua_State* L)
|
|
{
|
|
// 1 parametro : sTable
|
|
string sTable ;
|
|
LuaCheckParam( L, 1, sTable)
|
|
LuaClearStack( L) ;
|
|
// imposto la tavola corrente
|
|
bool bOk = ExeSetTable( sTable) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetTableAreaOffset( lua_State* L)
|
|
{
|
|
// 4 parametri : dOffsXP, dOffsYP, dOffsXM, dOffsYM
|
|
double dOffsXP ;
|
|
LuaCheckParam( L, 1, dOffsXP)
|
|
double dOffsYP ;
|
|
LuaCheckParam( L, 2, dOffsYP)
|
|
double dOffsXM ;
|
|
LuaCheckParam( L, 3, dOffsXM)
|
|
double dOffsYM ;
|
|
LuaCheckParam( L, 4, dOffsYM)
|
|
LuaClearStack( L) ;
|
|
// imposto l'offset dell'area della tavola corrente
|
|
bool bOk = ExeSetTableAreaOffset( dOffsXP, dOffsYP, dOffsXM, dOffsYM) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetTableName( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il nome della tavola corrente
|
|
string sTable ;
|
|
bool bOk = ExeGetTable( sTable) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sTable) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetTableRef( lua_State* L)
|
|
{
|
|
// 1 parametro opzionale : [nInd]
|
|
int nInd = 1 ;
|
|
LuaGetParam( L, 1, nInd) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il riferimento nInd-esimo della tavola corrente
|
|
Point3d ptPos ;
|
|
bool bOk = ExeGetTableRef( nInd, ptPos) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, ptPos) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetTableArea( lua_State* L)
|
|
{
|
|
// 1 parametro opzionale : [nInd]
|
|
int nInd = 1 ;
|
|
LuaGetParam( L, 1, nInd) ;
|
|
LuaClearStack( L) ;
|
|
// recupero la area utile nInd-esima della tavola corrente
|
|
BBox3d b3Area ;
|
|
bool bOk = ExeGetTableArea( nInd, b3Area) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, b3Area) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetTableAreaOffset( lua_State* L)
|
|
{
|
|
// 1 parametro opzionale : [nInd]
|
|
int nInd = 1 ;
|
|
LuaGetParam( L, 1, nInd) ;
|
|
LuaClearStack( L) ;
|
|
// recupero la area utile offsettata nInd-esima della tavola corrente
|
|
BBox3d b3AreaOffs ;
|
|
bool bOk = ExeGetTableAreaOffset( nInd, b3AreaOffs) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, b3AreaOffs) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaChangeTable( lua_State* L)
|
|
{
|
|
// 2 parametri : sTable, bUpdateDisp
|
|
string sTable ;
|
|
LuaCheckParam( L, 1, sTable)
|
|
bool bUpdateDisp ;
|
|
LuaCheckParam( L, 2, bUpdateDisp)
|
|
LuaClearStack( L) ;
|
|
// cambio la tavola corrente
|
|
bool bOk = ExeChangeTable( sTable, bUpdateDisp) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMoveDispAxis( lua_State* L)
|
|
{
|
|
// 2 parametri : sName, dPos
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
double dPos ;
|
|
LuaCheckParam( L, 2, dPos)
|
|
LuaClearStack( L) ;
|
|
// muovo l'asse nella nuova posizione
|
|
bool bOk = ExeMoveDispAxis( sName, dPos) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveDispAxis( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// rimuovo il movimento dell'asse
|
|
bool bOk = ExeRemoveDispAxis( sName) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaKeepAllDispAxes( lua_State* L)
|
|
{
|
|
// 1 parametro : nSouPhase
|
|
int nSouPhase ;
|
|
LuaCheckParam( L, 1, nSouPhase) ;
|
|
LuaClearStack( L) ;
|
|
// confermo i movimenti degli assi di disposizione nella fase corrente della macchinata corrente
|
|
bool bOk = ExeKeepAllDispAxes( nSouPhase) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAddFixture( lua_State* L)
|
|
{
|
|
// 2 o 3 o 4 parametri : sName, ptPos [, dAngRotDeg [, dMov]]
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
Point3d ptPos ;
|
|
LuaCheckParam( L, 2, ptPos)
|
|
double dAngRotDeg = 0 ;
|
|
double dMov = 0 ;
|
|
if ( LuaGetParam( L, 3, dAngRotDeg))
|
|
LuaGetParam( L, 4, dMov) ;
|
|
LuaClearStack( L) ;
|
|
// aggiungo la ventosa nella posizione indicata
|
|
int nId = ExeAddFixture( sName, ptPos, dAngRotDeg, dMov) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaKeepFixture( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nFxtId [, nSouPhase]
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
int nSouPhase = 0 ;
|
|
LuaGetParam( L, 2, nSouPhase) ;
|
|
LuaClearStack( L) ;
|
|
// confermo il bloccaggio nella fase corrente della macchinata corrente
|
|
bool bOk = ExeKeepFixture( nFxtId, nSouPhase) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveFixture( lua_State* L)
|
|
{
|
|
// 1 parametro : nFxtId
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
LuaClearStack( L) ;
|
|
// rimuovo il bloccaggio
|
|
bool bOk = ExeRemoveFixture( nFxtId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetFirstFixture( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// cerco il primo bloccaggio
|
|
int nId = ExeGetFirstFixture() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetNextFixture( lua_State* L)
|
|
{
|
|
// 1 parametro : nFxtId
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
LuaClearStack( L) ;
|
|
// cerco il successivo bloccaggio
|
|
int nId = ExeGetNextFixture( nFxtId) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMoveFixture( lua_State* L)
|
|
{
|
|
// 2 parametri : nFxtId, vtMove
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
Vector3d vtMove ;
|
|
LuaCheckParam( L, 2, vtMove)
|
|
LuaClearStack( L) ;
|
|
// muovo il bloccaggio
|
|
bool bOk= ExeMoveFixture( nFxtId, vtMove) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRotateFixture( lua_State* L)
|
|
{
|
|
// 2 parametri : nFxtId, dDeltaAngDeg
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
double dDeltaAngDeg ;
|
|
LuaCheckParam( L, 2, dDeltaAngDeg)
|
|
LuaClearStack( L) ;
|
|
// ruoto il bloccaggio
|
|
bool bOk= ExeRotateFixture( nFxtId, dDeltaAngDeg) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetFixtureLink( lua_State* L)
|
|
{
|
|
// 2 parametri : nFxtId, sTaLink
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
string sTaLink ;
|
|
LuaCheckParam( L, 2, sTaLink)
|
|
LuaClearStack( L) ;
|
|
// aggancio il bloccaggio ad asse tavola
|
|
bool bOk= ExeSetFixtureLink( nFxtId, sTaLink) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMoveFixtureMobile( lua_State* L)
|
|
{
|
|
// 2 parametri : nFxtId, dDeltaMov
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
double dDeltaMov ;
|
|
LuaCheckParam( L, 2, dDeltaMov)
|
|
LuaClearStack( L) ;
|
|
// muovo di delta la parte mobile del bloccaggio
|
|
bool bOk= ExeMoveFixtureMobile( nFxtId, dDeltaMov) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetFixtureMobile( lua_State* L)
|
|
{
|
|
// 2 parametri : nFxtId, dMov
|
|
int nFxtId ;
|
|
LuaCheckParam( L, 1, nFxtId)
|
|
double dMov ;
|
|
LuaCheckParam( L, 2, dMov)
|
|
LuaClearStack( L) ;
|
|
// imposto il movimento della parte mobile del bloccaggio
|
|
bool bOk= ExeSetFixtureMobile( nFxtId, dMov) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Tools database
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetToolNewName( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// verifico nome e se necessario lo modifico per renderlo nuovo nel DB
|
|
bool bOk = ExeTdbGetToolNewName( sName) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbAddTool( lua_State* L)
|
|
{
|
|
// 2 parametri : sName, nType
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
int nType ;
|
|
LuaCheckParam( L, 2, nType)
|
|
LuaClearStack( L) ;
|
|
// aggiungo l'utensile
|
|
bool bOk = ExeTdbAddTool( sName, nType) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbCopyTool( lua_State* L)
|
|
{
|
|
// 2 parametri : sSource, sName
|
|
string sSource ;
|
|
LuaCheckParam( L, 1, sSource)
|
|
string sName ;
|
|
LuaCheckParam( L, 2, sName)
|
|
LuaClearStack( L) ;
|
|
// aggiungo l'utensile
|
|
bool bOk = ExeTdbCopyTool( sSource, sName) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbRemoveTool( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// aggiungo l'utensile
|
|
bool bOk = ExeTdbRemoveTool( sName) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetFirstTool( lua_State* L)
|
|
{
|
|
// 1 parametro : nFamily
|
|
int nFamily ;
|
|
LuaCheckParam( L, 1, nFamily)
|
|
// cerco il primo utensile della famiglia
|
|
string sName ;
|
|
int nType ;
|
|
bool bOk = ExeTdbGetFirstTool( nFamily, sName, nType) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sName) ;
|
|
LuaSetParam( L, nType) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, "") ;
|
|
LuaSetParam( L, TT_NONE) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetNextTool( lua_State* L)
|
|
{
|
|
// 1 parametro : nFamily
|
|
int nFamily ;
|
|
LuaCheckParam( L, 1, nFamily)
|
|
// cerco il prossimo utensile della famiglia
|
|
string sName ;
|
|
int nType ;
|
|
bool bOk = ExeTdbGetNextTool( nFamily, sName, nType) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sName) ;
|
|
LuaSetParam( L, nType) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, "") ;
|
|
LuaSetParam( L, TT_NONE) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetToolFromUUID( lua_State* L)
|
|
{
|
|
// 1 parametro : sTuuid
|
|
string sTuuid ;
|
|
LuaCheckParam( L, 1, sTuuid)
|
|
LuaClearStack( L) ;
|
|
string sName ;
|
|
bool bOk = ExeTdbGetToolFromUUID( sTuuid, sName) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbSetCurrTool( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// imposto l'utensile corrente
|
|
bool bOk = ExeTdbSetCurrTool( sName) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbSaveCurrTool( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// salvo l'utensile corrente
|
|
bool bOk = ExeTdbSaveCurrTool() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbIsCurrToolModified( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// verifico se l'utensile corrente � stato modificato
|
|
bool bOk = ExeTdbIsCurrToolModified() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbSetCurrToolParam( lua_State* L)
|
|
{
|
|
// 2 parametri : nType, Val
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
// leggo opportunamente il valore da assegnare
|
|
if ( ( nType & TPA_BOOL) != 0) {
|
|
bool bVal ;
|
|
LuaCheckParam( L, 2, bVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolParam( nType, bVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & TPA_INT) != 0) {
|
|
int nVal ;
|
|
LuaCheckParam( L, 2, nVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolParam( nType, nVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & TPA_DOU) != 0) {
|
|
double dVal ;
|
|
LuaCheckParam( L, 2, dVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolParam( nType, dVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & TPA_STR) != 0) {
|
|
string sVal ;
|
|
LuaCheckParam( L, 2, sVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolParam( nType, sVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else {
|
|
LuaClearStack( L) ;
|
|
LuaSetParam( L, false) ;
|
|
}
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbSetCurrToolValInNotes( lua_State* L)
|
|
{
|
|
// 3 parametri : nType, sKey, Val
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
string sKey ;
|
|
LuaCheckParam( L, 2, sKey)
|
|
// leggo opportunamente il valore da assegnare
|
|
if ( lua_isboolean( L, 3)) {
|
|
bool bVal ;
|
|
LuaCheckParam( L, 3, bVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolValInNotes( nType, sKey, bVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( lua_isinteger( L, 3)) {
|
|
int nVal ;
|
|
LuaCheckParam( L, 3, nVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolValInNotes( nType, sKey, nVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( lua_isnumber( L, 3)) {
|
|
double dVal ;
|
|
LuaCheckParam( L, 3, dVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolValInNotes( nType, sKey, dVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( lua_isstring( L, 3)) {
|
|
string sVal ;
|
|
LuaCheckParam( L, 3, sVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeTdbSetCurrToolValInNotes( nType, sKey, sVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else {
|
|
LuaClearStack( L) ;
|
|
LuaSetParam( L, false) ;
|
|
}
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbRemoveCurrToolValInNotes(lua_State* L)
|
|
{
|
|
// 2 parametri : nType, sKey
|
|
int nType ;
|
|
LuaCheckParam(L, 1, nType)
|
|
string sKey ;
|
|
LuaCheckParam(L, 2, sKey)
|
|
LuaClearStack(L) ;
|
|
bool bOk = ExeTdbRemoveCurrToolValInNotes(nType, sKey) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetCurrToolParam( lua_State* L)
|
|
{
|
|
// 1 parametro : nType
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
LuaClearStack( L) ;
|
|
// recupero il parametro voluto dell'utensile corrente
|
|
if ( ( nType & TPA_BOOL) != 0) {
|
|
bool bVal ;
|
|
bool bOk = ExeTdbGetCurrToolParam( nType, bVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, bVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & TPA_INT) != 0) {
|
|
int nVal ;
|
|
bool bOk = ExeTdbGetCurrToolParam( nType, nVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, nVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & TPA_DOU) != 0) {
|
|
double dVal ;
|
|
bool bOk = ExeTdbGetCurrToolParam( nType, dVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & TPA_STR) != 0) {
|
|
string sVal ;
|
|
bool bOk = ExeTdbGetCurrToolParam( nType, sVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetCurrToolValInNotes( lua_State* L)
|
|
{
|
|
// 2 o 3 parametri : nType, sKey, sType
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
string sKey ;
|
|
LuaCheckParam( L, 2, sKey)
|
|
string sType = "s" ;
|
|
LuaGetParam( L, 3, sType) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il parametro voluto dell'utensile corrente
|
|
if ( sType == "b" || sType == "B") {
|
|
bool bVal ;
|
|
if ( ExeTdbGetCurrToolValInNotes( nType, sKey, bVal))
|
|
LuaSetParam( L, bVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( sType == "i" || sType == "I") {
|
|
int nVal ;
|
|
if ( ExeTdbGetCurrToolValInNotes( nType, sKey, nVal))
|
|
LuaSetParam( L, nVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( sType == "d" || sType == "D") {
|
|
double dVal ;
|
|
if ( ExeTdbGetCurrToolValInNotes( nType, sKey, dVal))
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else { // "s" "S"
|
|
string sVal ;
|
|
if ( ExeTdbGetCurrToolValInNotes( nType, sKey, sVal))
|
|
LuaSetParam( L, sVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetCurrToolMaxDepth( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il massimo affondamento dell'utensile corrente
|
|
double dVal ;
|
|
bool bOk = ExeTdbGetCurrToolMaxDepth( dVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetCurrToolThDiam( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il diametro del portautensili
|
|
double dVal ;
|
|
bool bOk = ExeTdbGetCurrToolThDiam( dVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetCurrToolThLength( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero la lunghezza del portautensili
|
|
double dVal ;
|
|
bool bOk = ExeTdbGetCurrToolThLength( dVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbIsCurrToolStandardDraw( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero lo stato
|
|
bool bStandard ;
|
|
bool bOk = ExeTdbCurrToolIsStandardDraw( bStandard) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, bStandard) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbGetCurrToolDraw( lua_State* L)
|
|
{
|
|
// 1 o nessun parametro
|
|
string sDraw ;
|
|
LuaGetParam( L, 1, sDraw) ;
|
|
LuaClearStack( L) ;
|
|
// creo contesto per disegno utensile
|
|
int nGenCtx = ExeGetCurrentContext() ;
|
|
int nToolCtx = ExeInitContext() ;
|
|
// eseguo disegno
|
|
int nErr = ExeTdbCurrToolDraw( nGenCtx, nToolCtx) ;
|
|
// se richiesto salvo il disegno
|
|
if ( nErr == 0 && ! sDraw.empty()) {
|
|
if ( ! ExeSaveFile( sDraw, GDB_SV_CMPTXT))
|
|
nErr = 1000 ;
|
|
}
|
|
// ripristino contesto originale e distruggo quello per l'utensile
|
|
ExeSetCurrentContext( nGenCtx) ;
|
|
ExeDeleteContext( nToolCtx) ;
|
|
// parametro di ritorno
|
|
LuaSetParam( L, nErr) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbReload( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// ricarico il DB utensili (eventuali modifiche dopo l'ultimo salvataggio vengono perse)
|
|
bool bOk = ExeTdbReload() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaTdbSave( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// lancio salvataggio DB utensili
|
|
bool bOk = ExeTdbSave() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Setup
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCurrSetup( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo del gruppo di attrezzaggio della macchinata corrente
|
|
int nSetupId = ExeGetCurrSetup() ;
|
|
// restituisco il risultato
|
|
if ( nSetupId != GDB_ID_NULL)
|
|
LuaSetParam( L, nSetupId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetDefaultSetupName( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il nome dell'attrezzaggio di default
|
|
string sName ;
|
|
bool bOk = ExeGetDefaultSetupName( sName) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaImportSetup( lua_State* L)
|
|
{
|
|
// 1 o nessun parametro : [sName]
|
|
string sName ;
|
|
LuaGetParam( L, 1, sName) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo importazione
|
|
bool bOk = ExeImportSetup( sName) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaExistsCurrSetup( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// verifico l'esistenza dell'attrezzaggio della macchinata corrente
|
|
bool bOk = ExeExistsCurrSetup() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaVerifyCurrSetup( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// verifico l'attrezzaggio della macchinata corrente
|
|
STRVECTOR vsErrors ;
|
|
bool bOk = ExeVerifyCurrSetup( vsErrors) ;
|
|
LuaSetParam( L, bOk) ;
|
|
if ( bOk)
|
|
LuaSetParam( L) ;
|
|
else
|
|
LuaSetParam( L, vsErrors) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaFindToolInCurrSetup( lua_State* L)
|
|
{
|
|
// 1 parametro : sTool
|
|
string sTool ;
|
|
LuaGetParam( L, 1, sTool) ;
|
|
LuaClearStack( L) ;
|
|
// verifico attrezzaggio utensile e ne recupero l'eventuale posizione
|
|
string sTcPos ;
|
|
bool bOk = ExeGetToolSetupPosInCurrSetup( sTool, sTcPos) ;
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, sTcPos) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetToolsInCurrSetupPos( lua_State* L)
|
|
{
|
|
// 1 parametro : sTcPos
|
|
string sTcPos ;
|
|
LuaGetParam( L, 1, sTcPos) ;
|
|
LuaClearStack( L) ;
|
|
// recupero gli utensili nella posizione indicata dell'attrezzaggio della macchinata corrente
|
|
STRVECTOR vsTools ;
|
|
bool bOk = ExeGetToolsInCurrSetupPos( sTcPos, vsTools) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, vsTools) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Machinings database
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbGetMachiningNewName( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// verifico nome e se necessario lo modifico per renderlo nuovo nel DB
|
|
bool bOk = ExeMdbGetMachiningNewName( sName) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbAddMachining( lua_State* L)
|
|
{
|
|
// 2 parametri : sName, nType
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
int nType ;
|
|
LuaCheckParam( L, 2, nType)
|
|
LuaClearStack( L) ;
|
|
// aggiungo la lavorazione
|
|
bool bOk = ExeMdbAddMachining( sName, nType) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbCopyMachining( lua_State* L)
|
|
{
|
|
// 2 parametri : sSource, sName
|
|
string sSource ;
|
|
LuaCheckParam( L, 1, sSource)
|
|
string sName ;
|
|
LuaCheckParam( L, 2, sName)
|
|
LuaClearStack( L) ;
|
|
// aggiungo la lavorazione
|
|
bool bOk = ExeMdbCopyMachining( sSource, sName) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbRemoveMachining( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// aggiungo la lavorazione
|
|
bool bOk = ExeMdbRemoveMachining( sName) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbGetFirstMachining( lua_State* L)
|
|
{
|
|
// 1 parametro : nType
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
LuaClearStack( L) ;
|
|
// cerco la prima lavorazione
|
|
string sName ;
|
|
bool bOk = ExeMdbGetFirstMachining( nType, sName) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbGetNextMachining( lua_State* L)
|
|
{
|
|
// 1 parametro : nType
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
LuaClearStack( L) ;
|
|
// cerco la successiva lavorazione
|
|
string sName ;
|
|
bool bOk = ExeMdbGetNextMachining( nType, sName) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbGetMachiningFromUUID( lua_State* L)
|
|
{
|
|
// 1 parametro : sMuuid
|
|
string sMuuid ;
|
|
LuaCheckParam( L, 1, sMuuid)
|
|
LuaClearStack( L) ;
|
|
string sName ;
|
|
bool bOk = ExeMdbGetMachiningFromUUID( sMuuid, sName) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbSetCurrMachining( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// imposto la lavorazione corrente
|
|
bool bOk = ExeMdbSetCurrMachining( sName) ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbSaveCurrMachining( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// salvo la lavorazione corrente
|
|
bool bOk = ExeMdbSaveCurrMachining() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbIsCurrMachiningModified( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// verifico se la lavorazione corrente � stata modificata
|
|
bool bOk = ExeMdbIsCurrMachiningModified() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbSetCurrMachiningParam( lua_State* L)
|
|
{
|
|
// 2 parametri : nType, Val
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
// leggo opportunamente il valore da assegnare
|
|
if ( ( nType & MPA_BOOL) != 0) {
|
|
bool bVal ;
|
|
LuaCheckParam( L, 2, bVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeMdbSetCurrMachiningParam( nType, bVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & MPA_INT) != 0) {
|
|
int nVal ;
|
|
LuaCheckParam( L, 2, nVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeMdbSetCurrMachiningParam( nType, nVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & MPA_DOU) != 0) {
|
|
double dVal ;
|
|
LuaCheckParam( L, 2, dVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeMdbSetCurrMachiningParam( nType, dVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & MPA_STR) != 0) {
|
|
string sVal ;
|
|
LuaCheckParam( L, 2, sVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeMdbSetCurrMachiningParam( nType, sVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbGetCurrMachiningParam( lua_State* L)
|
|
{
|
|
// 1 parametro : nType
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
LuaClearStack( L) ;
|
|
// recupero il parametro della lavorazione nel DB
|
|
if ( ( nType & MPA_BOOL) != 0) {
|
|
bool bVal ;
|
|
bool bOk = ExeMdbGetCurrMachiningParam( nType, bVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, bVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MPA_INT) != 0) {
|
|
int nVal ;
|
|
bool bOk = ExeMdbGetCurrMachiningParam( nType, nVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, nVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MPA_DOU) != 0) {
|
|
double dVal ;
|
|
bool bOk = ExeMdbGetCurrMachiningParam( nType, dVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MPA_STR) != 0) {
|
|
string sVal ;
|
|
bool bOk = ExeMdbGetCurrMachiningParam( nType, sVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbSetGeneralParam( lua_State* L)
|
|
{
|
|
// 2 parametri : nType, dVal
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
// leggo opportunamente il valore da assegnare
|
|
if ( ( nType & MGP_BOOL) != 0) {
|
|
bool bVal ;
|
|
LuaCheckParam( L, 2, bVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeMdbSetGeneralParam( nType, bVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & MGP_INT) != 0) {
|
|
int nVal ;
|
|
LuaCheckParam( L, 2, nVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeMdbSetGeneralParam( nType, nVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
else if ( ( nType & MGP_DOU) != 0) {
|
|
double dVal ;
|
|
LuaCheckParam( L, 2, dVal)
|
|
LuaClearStack( L) ;
|
|
bool bOk = ExeMdbSetGeneralParam( nType, dVal) ;
|
|
LuaSetParam( L, bOk) ;
|
|
}
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbGetGeneralParam( lua_State* L)
|
|
{
|
|
// 1 parametro : nType
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
LuaClearStack( L) ;
|
|
// recupero il parametro della lavorazione nel DB
|
|
if ( ( nType & MGP_BOOL) != 0) {
|
|
bool bVal ;
|
|
bool bOk = ExeMdbGetGeneralParam( nType, bVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, bVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MGP_INT) != 0) {
|
|
int nVal ;
|
|
bool bOk = ExeMdbGetGeneralParam( nType, nVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, nVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MGP_DOU) != 0) {
|
|
double dVal ;
|
|
bool bOk = ExeMdbGetGeneralParam( nType, dVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbReload( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// ricarico il DB lavorazioni (eventuali modifiche dopo l'ultimo salvataggio vengono perse)
|
|
bool bOk = ExeMdbReload() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaMdbSave( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// lancio salvataggio
|
|
bool bOk = ExeMdbSave() ;
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Operations
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetFirstOperation( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero la prima operazione della macchinata corrente
|
|
int nId = ExeGetFirstOperation() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetNextOperation( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero la successiva operazione della macchinata corrente
|
|
int nNextId = ExeGetNextOperation( nId) ;
|
|
// restituisco il risultato
|
|
if ( nNextId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNextId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetLastOperation( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'ultima operazione della macchinata corrente
|
|
int nId = ExeGetLastOperation() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetPrevOperation( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero la precedente operazione della macchinata corrente
|
|
int nNextId = ExeGetPrevOperation( nId) ;
|
|
// restituisco il risultato
|
|
if ( nNextId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNextId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetFirstActiveOperation( lua_State* L)
|
|
{
|
|
// nessuno o 1 parametro : [bNeedMachNotEmpty]
|
|
bool bNeedMachNotEmpty = false ;
|
|
LuaGetParam( L, 1, bNeedMachNotEmpty) ;
|
|
LuaClearStack( L) ;
|
|
// recupero la prima operazione attiva della macchinata corrente
|
|
int nId = ExeGetFirstActiveOperation( bNeedMachNotEmpty) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetNextActiveOperation( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nId [, bNeedMachNotEmpty]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
bool bNeedMachNotEmpty = false ;
|
|
LuaGetParam( L, 2, bNeedMachNotEmpty) ;
|
|
LuaClearStack( L) ;
|
|
// recupero la successiva operazione attiva della macchinata corrente
|
|
int nNextId = ExeGetNextActiveOperation( nId, bNeedMachNotEmpty) ;
|
|
// restituisco il risultato
|
|
if ( nNextId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNextId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetLastActiveOperation( lua_State* L)
|
|
{
|
|
// nessuno o 1 parametro : [bNeedMachNotEmpty]
|
|
bool bNeedMachNotEmpty = false ;
|
|
LuaGetParam( L, 1, bNeedMachNotEmpty) ;
|
|
LuaClearStack( L) ;
|
|
// recupero l'ultima operazione attiva della macchinata corrente
|
|
int nId = ExeGetLastActiveOperation( bNeedMachNotEmpty) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetPrevActiveOperation( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nId [, bNeedMachNotEmpty]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
bool bNeedMachNotEmpty = false ;
|
|
LuaGetParam( L, 2, bNeedMachNotEmpty) ;
|
|
LuaClearStack( L) ;
|
|
// recupero la precedente operazione attiva della macchinata corrente
|
|
int nNextId = ExeGetPrevActiveOperation( nId, bNeedMachNotEmpty) ;
|
|
// restituisco il risultato
|
|
if ( nNextId != GDB_ID_NULL)
|
|
LuaSetParam( L, nNextId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetOperationType( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// restituisco il tipo dell'operazione indicata della macchinata corrente
|
|
int nType = ExeGetOperationType( nId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nType) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetOperationPhase( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// restituisco la fase di appartenenza dell'operazione indicata della macchinata corrente
|
|
int nPhase = ExeGetOperationPhase( nId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nPhase) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetOperationName( lua_State* L)
|
|
{
|
|
// 2 parametri : nId, sName
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
string sName ;
|
|
LuaCheckParam( L, 2, sName)
|
|
LuaClearStack( L) ;
|
|
// assegno il nuovo nome all'operazione indicata della macchinata corrente
|
|
bool bOk = ExeSetOperationName( nId, sName) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetOperationName( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// restituisco il nome dell'operazione indicata della macchinata corrente
|
|
string sName ;
|
|
bool bOk = ExeGetOperationName( nId, sName) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetOperationId( lua_State* L)
|
|
{
|
|
// 1 parametro : sName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
LuaClearStack( L) ;
|
|
// restituisco l'identificativo dell'operazione nominata della macchinata corrente
|
|
int nId = ExeGetOperationId( sName) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaIsOperationEmpty( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nId [, nEmptyType]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nEmptyType = EMP_NEED_GEOM ;
|
|
LuaGetParam( L, 2, nEmptyType) ;
|
|
LuaClearStack( L) ;
|
|
// recupero lo stato della operazione indicata della macchinata corrente
|
|
bool bOk = ExeIsOperationEmpty( nId, nEmptyType) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveOperation( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// elimino l'operazione indicata della macchinata corrente
|
|
bool bOk = ExeRemoveOperation( nId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveAllPhaseOperations( lua_State* L)
|
|
{
|
|
// 1 parametro : nPhase
|
|
int nPhase ;
|
|
LuaCheckParam( L, 1, nPhase)
|
|
LuaClearStack( L) ;
|
|
// elimino tutte le operazioni (tranne la disposizione) della fase indicata della macchinata corrente
|
|
bool bOk = ExeRemoveAllPhaseOperations( nPhase) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveAllOperations( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// elimino tutte le operazioni della macchinata corrente tranne la prima disposizione
|
|
bool bOk = ExeRemoveAllOperations() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetOperationMode( lua_State* L)
|
|
{
|
|
// 2 parametro : nId, bActive
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
bool bActive ;
|
|
LuaCheckParam( L, 2, bActive)
|
|
LuaClearStack( L) ;
|
|
// imposto l'attivazione dell'operazione
|
|
bool bOk = ExeSetOperationMode( nId, bActive) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetOperationMode( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero l'attivazione dell'operazione
|
|
bool bActive ;
|
|
bool bOk = ExeGetOperationMode( nId, bActive) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, bActive) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetAllOperationsMode( lua_State* L)
|
|
{
|
|
// 1 parametro : bActive
|
|
bool bActive ;
|
|
LuaCheckParam( L, 1, bActive)
|
|
LuaClearStack( L) ;
|
|
// imposto l'attivazione di tutte le operazioni
|
|
bool bOk = ExeSetAllOperationsMode( bActive) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetOperationStatus( lua_State* L)
|
|
{
|
|
// 2 parametro : nId, bShow
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
bool bShow ;
|
|
LuaCheckParam( L, 2, bShow)
|
|
LuaClearStack( L) ;
|
|
// imposto lo stato di visualizzazione dell'operazione
|
|
bool bOk = ExeSetOperationStatus( nId, bShow) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetOperationStatus( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero lo stato di visualizzazione dell'operazione
|
|
bool bShow ;
|
|
bool bOk = ExeGetOperationStatus( nId, bShow) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, bShow) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetAllOperationsStatus( lua_State* L)
|
|
{
|
|
// 1 parametro : bShow
|
|
bool bShow ;
|
|
LuaCheckParam( L, 1, bShow)
|
|
LuaClearStack( L) ;
|
|
// imposto lo stato di visualizzazione di tutte le operazioni
|
|
bool bOk = ExeSetAllOperationsStatus( bShow) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAdjustOperationPhase( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// imposta la fase della lavorazione in base alla sua posizione nella lista
|
|
bool bOk = ExeAdjustOperationPhase( nId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaChangeOperationPhase( lua_State* L)
|
|
{
|
|
// 2 parametri : nId, nNewPhase
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
int nNewPhase ;
|
|
LuaCheckParam( L, 2, nNewPhase)
|
|
LuaClearStack( L) ;
|
|
// cambio la fase dell'operazione e la sposto in fondo alle lavorazioni della stessa fase
|
|
bool bOk = ExeChangeOperationPhase( nId, nNewPhase) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRemoveOperationHome( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// elimino eventuale posizionamento finale in home dalla operazione
|
|
bool bOk = ExeRemoveOperationHome( nId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Dispositions
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetPhaseDisposition( lua_State* L)
|
|
{
|
|
// 1 parametro : nPhase
|
|
int nPhase ;
|
|
LuaCheckParam( L, 1, nPhase)
|
|
LuaClearStack( L) ;
|
|
// recupero la disposizione della fase indicata
|
|
int nId = ExeGetPhaseDisposition( nPhase) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSpecialApplyDisposition( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nId [, bRecalc]
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
bool bRecalc = false ;
|
|
LuaGetParam( L, 2, bRecalc) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo azione speciale su disposizione indicata
|
|
bool bOk = ExeSpecialApplyDisposition( nId, bRecalc) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSpecialUpdateDisposition( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// aggiorno assi macchina e collegamento con precedente della disposizione indicata
|
|
bool bOk = ExeSpecialUpdateDisposition( nId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetDispositionToolData( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero dati dell'eventuale utensile associato alla disposizione
|
|
string sName ;
|
|
string sHead ;
|
|
int nExit ;
|
|
string sTcPos ;
|
|
bool bOk = ExeGetDispositionToolData( nId, sName, sHead, nExit, sTcPos) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sName) ;
|
|
LuaSetParam( L, sHead) ;
|
|
LuaSetParam( L, nExit) ;
|
|
LuaSetParam( L, sTcPos) ;
|
|
return 4 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Machinings
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaAddMachining( lua_State* L)
|
|
{
|
|
// 2 parametri : sName, sMachining
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
string sMachining ;
|
|
LuaCheckParam( L, 2, sMachining)
|
|
LuaClearStack( L) ;
|
|
// aggiungo la lavorazione
|
|
int nId = ExeAddMachining( sName, sMachining) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL) {
|
|
LuaSetParam( L, nId) ;
|
|
// recupero il nome effettivo
|
|
ExeGetOperationName( nId, sName) ;
|
|
LuaSetParam( L, sName) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCreateMachining( lua_State* L)
|
|
{
|
|
// 3 parametri : sName, nMchType, sTool
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
int nMchType ;
|
|
LuaCheckParam( L, 2, nMchType)
|
|
string sTool ;
|
|
LuaCheckParam( L, 3, sTool)
|
|
LuaClearStack( L) ;
|
|
// aggiungo la lavorazione (creandola al momento)
|
|
int nId = ExeAddMachining( sName, nMchType, sTool) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL) {
|
|
LuaSetParam( L, nId) ;
|
|
// recupero il nome effettivo
|
|
ExeGetOperationName( nId, sName) ;
|
|
LuaSetParam( L, sName) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaCopyMachining( lua_State* L)
|
|
{
|
|
// 2 parametri : sName, sSouName
|
|
string sName ;
|
|
LuaCheckParam( L, 1, sName)
|
|
string sSouName ;
|
|
LuaCheckParam( L, 2, sSouName)
|
|
LuaClearStack( L) ;
|
|
// copio la lavorazione
|
|
int nId = ExeCopyMachining( sName, sSouName) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetCurrMachining( lua_State* L)
|
|
{
|
|
// 1 parametro : nId
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// imposto la lavorazione come corrente
|
|
bool bOk = ExeSetCurrMachining( nId) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCurrMachining( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// restituisco identificativo della lavorazione corrente
|
|
int nId = ExeGetCurrMachining() ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaResetCurrMachining( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// reset della lavorazione come corrente
|
|
bool bOk = ExeResetCurrMachining() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetMachiningParam( lua_State* L)
|
|
{
|
|
// 2 parametri : nType, xVal
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
bool bOk = false ;
|
|
if ( ( nType & MPA_BOOL) != 0) {
|
|
bool bVal ;
|
|
LuaCheckParam( L, 2, bVal)
|
|
// imposto il parametro alla lavorazione corrente
|
|
bOk = ExeSetMachiningParam( nType, bVal) ;
|
|
}
|
|
else if ( ( nType & MPA_INT) != 0) {
|
|
int nVal ;
|
|
LuaCheckParam( L, 2, nVal)
|
|
// imposto il parametro alla lavorazione corrente
|
|
bOk = ExeSetMachiningParam( nType, nVal) ;
|
|
}
|
|
else if ( ( nType & MPA_DOU) != 0) {
|
|
double dVal ;
|
|
LuaCheckParam( L, 2, dVal)
|
|
// imposto il parametro alla lavorazione corrente
|
|
bOk = ExeSetMachiningParam( nType, dVal) ;
|
|
}
|
|
else if ( ( nType & MPA_STR) != 0) {
|
|
string sVal ;
|
|
LuaCheckParam( L, 2, sVal)
|
|
// imposto il parametro alla lavorazione corrente
|
|
bOk = ExeSetMachiningParam( nType, sVal) ;
|
|
}
|
|
LuaClearStack( L) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachiningParam( lua_State* L)
|
|
{
|
|
// 1 parametr : nType
|
|
int nType ;
|
|
LuaCheckParam( L, 1, nType)
|
|
LuaClearStack( L) ;
|
|
if ( ( nType & MPA_BOOL) != 0) {
|
|
bool bVal ;
|
|
// recupero il parametro dalla lavorazione corrente
|
|
bool bOk = ExeGetMachiningParam( nType, bVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, bVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MPA_INT) != 0) {
|
|
int nVal ;
|
|
// recupero il parametro dalla lavorazione corrente
|
|
bool bOk = ExeGetMachiningParam( nType, nVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, nVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MPA_DOU) != 0) {
|
|
double dVal ;
|
|
// recupero il parametro dalla lavorazione corrente
|
|
bool bOk = ExeGetMachiningParam( nType, dVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else if ( ( nType & MPA_STR) != 0) {
|
|
string sVal ;
|
|
// recupero il parametro dalla lavorazione corrente
|
|
bool bOk = ExeGetMachiningParam( nType, sVal) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
}
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetMachiningGeometry( lua_State* L)
|
|
{
|
|
// 1 parametro : vSel
|
|
SELVECTOR vSel ;
|
|
LuaCheckParam( L, 1, vSel)
|
|
LuaClearStack( L) ;
|
|
// imposto la geometria alla lavorazione corrente
|
|
bool bOk = ExeSetMachiningGeometry( vSel) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaPreviewMachining( lua_State* L)
|
|
{
|
|
// 1 o nessun parametro : [bRecalc]
|
|
bool bRecalc = false ;
|
|
LuaGetParam( L, 1, bRecalc) ;
|
|
LuaClearStack( L) ;
|
|
// calcolo l'anteprima (se prevista) della lavorazione corrente
|
|
bool bOk = ExePreviewMachining( bRecalc) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaApplyMachining( lua_State* L)
|
|
{
|
|
// 2 o 1 o nessun parametro : [bRecalc] [, bPostApply]
|
|
bool bRecalc = false ;
|
|
bool bPostApply = true ;
|
|
if ( LuaGetParam( L, 1, bRecalc))
|
|
LuaGetParam( L, 2, bPostApply) ;
|
|
LuaClearStack( L) ;
|
|
// calcolo la lavorazione corrente
|
|
bool bOk = ExeApplyMachining( bRecalc, bPostApply) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaUpdateMachining( lua_State* L)
|
|
{
|
|
// 1 o nessun parametro : bPostApply
|
|
bool bPostApply = true ;
|
|
LuaGetParam( L, 1, bPostApply) ;
|
|
LuaClearStack( L) ;
|
|
// aggiorno assi macchina e collegamento con operazione precedente per la lavorazione corrente
|
|
bool bOk = ExeUpdateMachining( bPostApply) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachiningGeometry( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero gli indici della geometria della lavorazione corrente
|
|
SELVECTOR vSel ;
|
|
bool bOk = ExeGetMachiningGeometry( vSel) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vSel) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachiningSkippedGeometry( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero gli indici della geometria non lavorata della lavorazione corrente
|
|
SELVECTOR vSel ;
|
|
bool bOk = ExeGetMachiningSkippedGeometry( vSel) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vSel) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaIsMachiningEmpty( lua_State* L)
|
|
{
|
|
// nessuno o 1 parametro : [nEmptyType]
|
|
int nEmptyType = EMP_NEED_GEOM ;
|
|
LuaGetParam( L, 1, nEmptyType) ;
|
|
LuaClearStack( L) ;
|
|
// recupero lo stato della lavorazione corrente
|
|
bool bEmpty = ExeIsMachiningEmpty( nEmptyType) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bEmpty) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachiningStartPoint( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il punto iniziale del primo percorso della lavorazione corrente
|
|
Point3d ptStart ;
|
|
bool bOk = ExeGetMachiningStartPoint( ptStart) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, ptStart) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachiningEndPoint( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il punto finale dell'ultimo percorso della lavorazione corrente
|
|
Point3d ptEnd ;
|
|
bool bOk = ExeGetMachiningEndPoint( ptEnd) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, ptEnd) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachiningStartAxes( lua_State* L)
|
|
{
|
|
// 0 o 1 parametro : [bSkipClimb]
|
|
bool bSkipClimb = true ;
|
|
LuaGetParam( L, 1, bSkipClimb) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il valore iniziale degli assi del primo percorso della lavorazione corrente
|
|
DBLVECTOR vAxVal ;
|
|
bool bOk = ExeGetMachiningStartAxes( bSkipClimb, vAxVal) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vAxVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetMachiningEndAxes( lua_State* L)
|
|
{
|
|
// 0 o 1 parametro : [bSkipRise]
|
|
bool bSkipRise = true ;
|
|
LuaGetParam( L, 1, bSkipRise) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il valore finale degli assi dell'ultimo percorso della lavorazione corrente
|
|
DBLVECTOR vAxVal ;
|
|
bool bOk = ExeGetMachiningEndAxes( bSkipRise, vAxVal) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vAxVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaApplyAllMachinings( lua_State* L)
|
|
{
|
|
// 1 o 2 o nessun parametro : [ bRecalc [, bStopOnFirstErr]]
|
|
bool bRecalc = true ;
|
|
bool bStopOnFirstErr = false ;
|
|
if ( LuaGetParam( L, 1, bRecalc))
|
|
LuaGetParam( L, 2, bStopOnFirstErr) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo ricalcolo delle lavorazioni
|
|
string sErrList, sWarnList ;
|
|
bool bOk = ExeApplyAllMachiningsEx( bRecalc, bStopOnFirstErr, sErrList, sWarnList) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, sErrList) ;
|
|
LuaSetParam( L, sWarnList) ;
|
|
return 3 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaUpdateAllMachinings( lua_State* L)
|
|
{
|
|
// 1 o nessun parametro : [bStopOnFirstErr]
|
|
bool bStopOnFirstErr = false ;
|
|
LuaGetParam( L, 1, bStopOnFirstErr) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo aggiornamento delle lavorazioni
|
|
string sErrList, sWarnList ;
|
|
bool bOk = ExeUpdateAllMachiningsEx( bStopOnFirstErr, sErrList, sWarnList) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, sErrList) ;
|
|
LuaSetParam( L, sWarnList) ;
|
|
return 3 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CL Entities Interrogations
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetClEntMove( lua_State* L)
|
|
{
|
|
// 1 parametro : nEntId
|
|
int nEntId ;
|
|
LuaGetParam( L, 1, nEntId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il tipo di movimento
|
|
int nMove ;
|
|
bool bOk = ExeGetClEntMove( nEntId, nMove) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, nMove) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetClEntFlag( lua_State* L)
|
|
{
|
|
// 1 parametro : nEntId
|
|
int nEntId ;
|
|
LuaGetParam( L, 1, nEntId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il flag
|
|
int nFlag, nFlag2 ;
|
|
bool bOk = ExeGetClEntFlag( nEntId, nFlag, nFlag2) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, nFlag) ;
|
|
LuaSetParam( L, nFlag2) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetClEntIndex( lua_State* L)
|
|
{
|
|
// 1 parametro : nEntId
|
|
int nEntId ;
|
|
LuaGetParam( L, 1, nEntId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero l'indice
|
|
int nIndex ;
|
|
bool bOk = ExeGetClEntIndex( nEntId, nIndex) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, nIndex) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetClEntFeed( lua_State* L)
|
|
{
|
|
// 1 parametro : nEntId
|
|
int nEntId ;
|
|
LuaGetParam( L, 1, nEntId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero la feed
|
|
double dFeed ;
|
|
bool bOk = ExeGetClEntFeed( nEntId, dFeed) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, dFeed) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetClEntAxesStatus( lua_State* L)
|
|
{
|
|
// 1 parametro : nEntId
|
|
int nEntId ;
|
|
LuaGetParam( L, 1, nEntId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero lo stato del movimento assi
|
|
int nStatus ;
|
|
bool bOk = ExeGetClEntAxesStatus( nEntId, nStatus) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, nStatus) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetClEntAxesMask( lua_State* L)
|
|
{
|
|
// 1 parametro : nEntId
|
|
int nEntId ;
|
|
LuaGetParam( L, 1, nEntId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero la mascheratura del movimento assi (valida solo in rapido)
|
|
int nMask ;
|
|
bool bOk = ExeGetClEntAxesMask( nEntId, nMask) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, nMask) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
LuaGetClEntAxesVal( lua_State* L)
|
|
{
|
|
// 1 parametro : nEntId
|
|
int nEntId ;
|
|
LuaGetParam( L, 1, nEntId) ;
|
|
LuaClearStack( L) ;
|
|
// recupero il valore degli assi
|
|
DBLVECTOR vAxes ;
|
|
bool bOk = ExeGetClEntAxesVal( nEntId, vAxes) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vAxes) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Simulation
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimInit( lua_State* L)
|
|
{
|
|
// nessuno
|
|
LuaClearStack( L) ;
|
|
// avvio la simulazione
|
|
bool bOk = ExeSimInit() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimStart( lua_State* L)
|
|
{
|
|
// nessuno o 1 parametro : [bStart]
|
|
bool bStart = true ;
|
|
LuaGetParam( L, 1, bStart) ;
|
|
LuaClearStack( L) ;
|
|
// avvio la simulazione
|
|
bool bOk = ExeSimStart( bStart) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimMove( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// eseguo movimento di simulazione
|
|
int nStatus ;
|
|
bool bOk = ExeSimMove( nStatus) ;
|
|
// restituisco i risultati
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nStatus) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimHome( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// porto la macchina in posizione home
|
|
bool bOk = ExeSimHome() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimSetStep( lua_State* L)
|
|
{
|
|
// 1 parametro : dStep
|
|
double dStep ;
|
|
LuaCheckParam( L, 1, dStep)
|
|
LuaClearStack( L) ;
|
|
// imposto lo step di riferimento per la simulazione
|
|
bool bOk = ExeSimSetStep( dStep) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimSetUiStatus( lua_State* L)
|
|
{
|
|
// 1 parametro : nUiStatus
|
|
int nUiStatus ;
|
|
LuaCheckParam( L, 1, nUiStatus)
|
|
LuaClearStack( L) ;
|
|
// imposto lo step di riferimento per la simulazione
|
|
bool bOk = ExeSimSetUiStatus( nUiStatus) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimEnableToolTipTrace( lua_State* L)
|
|
{
|
|
// 1 parametro : bEnable
|
|
bool bEnable ;
|
|
LuaCheckParam( L, 1, bEnable)
|
|
LuaClearStack( L) ;
|
|
// imposto abilitazione disegno traccia della punta utensile
|
|
bool bOk = ExeSimEnableToolTipTrace( bEnable) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimGetAxisInfoPos( lua_State* L)
|
|
{
|
|
// 1 parametro : nInd
|
|
int nInd ;
|
|
LuaCheckParam( L, 1, nInd)
|
|
LuaClearStack( L) ;
|
|
// calcolo nome e posizione dell'asse
|
|
string sName ;
|
|
string sToken ;
|
|
bool bLinear ;
|
|
double dVal ;
|
|
bool bOk = ExeSimGetAxisInfoPos( nInd, sName, sToken, bLinear, dVal) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sName) ;
|
|
LuaSetParam( L, sToken) ;
|
|
LuaSetParam( L, bLinear) ;
|
|
LuaSetParam( L, dVal) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 4 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimGetToolInfo( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero nome e speed dell'utensile corrente
|
|
string sName ;
|
|
double dSpeed ;
|
|
bool bOk = ExeSimGetToolInfo( sName, dSpeed) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sName) ;
|
|
LuaSetParam( L, dSpeed) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimGetOperationInfo( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero nome e tipo dell'operazione corrente
|
|
string sName ;
|
|
int nType ;
|
|
bool bOk = ExeSimGetOperationInfo( sName, nType) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sName) ;
|
|
LuaSetParam( L, nType) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimGetMoveInfo( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero tipo e veolcit� del movimento corrente
|
|
int nGmove ;
|
|
double dFeed ;
|
|
bool bOk = ExeSimGetMoveInfo( nGmove, dFeed) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, nGmove) ;
|
|
LuaSetParam( L, dFeed) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimExit( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// termino la simulazione
|
|
bool bOk = ExeSimExit() ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Generation & T&L estimation
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGenerate( lua_State* L)
|
|
{
|
|
// 1 o 2 parametro : sCncFile [, sInfo]
|
|
string sCncFile ;
|
|
LuaCheckParam( L, 1, sCncFile)
|
|
string sInfo ;
|
|
LuaGetParam( L, 2, sInfo) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo la generazione del part-program
|
|
bool bOk = ExeGenerate( sCncFile, sInfo) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaEstimate( lua_State* L)
|
|
{
|
|
// 1 o 2 parametro : sEstFile [, sInfo]
|
|
string sEstFile ;
|
|
LuaCheckParam( L, 1, sEstFile)
|
|
string sInfo ;
|
|
LuaGetParam( L, 2, sInfo) ;
|
|
LuaClearStack( L) ;
|
|
// eseguo la stima dei tempi e delle lunghezze di lavorazione
|
|
bool bOk = ExeEstimate( sEstFile, sInfo) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSimulate( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// eseguo la simulazione
|
|
int nErr ;
|
|
string sErr ;
|
|
bool bOk = ExeSimulate( nErr, sErr) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nErr) ;
|
|
LuaSetParam( L, sErr) ;
|
|
return 3 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Machine Calc
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetCalcTable( lua_State* L)
|
|
{
|
|
// 1 parametro : sTable
|
|
string sTable ;
|
|
LuaCheckParam( L, 1, sTable)
|
|
LuaClearStack( L) ;
|
|
// imposto la tavola corrente per i calcoli macchina
|
|
bool bOk = ExeSetCalcTable( sTable) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetCalcTool( lua_State* L)
|
|
{
|
|
// 3 parametro : sTool, sHead, nExit
|
|
string sTool ;
|
|
LuaCheckParam( L, 1, sTool)
|
|
string sHead ;
|
|
LuaCheckParam( L, 2, sHead)
|
|
int nExit ;
|
|
LuaCheckParam( L, 3, nExit)
|
|
LuaClearStack( L) ;
|
|
// imposto l'utensile corrente per il calcolo
|
|
bool bOk = ExeSetCalcTool( sTool, sHead, nExit) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetCalcSolCh( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : nScc [, bExact]
|
|
int nScc ;
|
|
LuaCheckParam( L, 1, nScc)
|
|
bool bExact = false ;
|
|
LuaGetParam( L, 2, bExact) ;
|
|
LuaClearStack( L) ;
|
|
// imposto il criterio di scelta della soluzione e se deve essere rispettato esattamente
|
|
bool bOk = ExeSetCalcSolCh( nScc, bExact) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetRotAxisBlock( lua_State* L)
|
|
{
|
|
// 2 parametri : sAxis, dVal
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
double dVal ;
|
|
LuaCheckParam( L, 2, dVal)
|
|
LuaClearStack( L) ;
|
|
// imposto asse da bloccare con il suo valore
|
|
bool bOk = ExeSetRotAxisBlock( sAxis, dVal) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcTable( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero la tavola correnti
|
|
string sTable ;
|
|
bool bOk = ExeGetCalcTable( sTable) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sTable) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcTool( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'utensile, la testa e l'uscita correnti
|
|
string sTool ;
|
|
string sHead ;
|
|
int nExit ;
|
|
bool bOk = ExeGetCalcTool( sTool, sHead, nExit) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sTool) ;
|
|
LuaSetParam( L, sHead) ;
|
|
LuaSetParam( L, nExit) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 3 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcSolCh( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero il criterio di scelta della soluzione e se deve essere rispettato esattamente
|
|
int nScc ;
|
|
bool bExact ;
|
|
bool bOk = ExeGetCalcSolCh( nScc, bExact) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, nScc) ;
|
|
LuaSetParam( L, bExact) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAllCurrAxesNames( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// imposto l'utensile corrente per il calcolo
|
|
STRVECTOR vAxName ;
|
|
bool bOk = ExeGetAllCurrAxesNames( vAxName) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vAxName) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetRotAxisBlocked( lua_State* L)
|
|
{
|
|
// 1 parametro : nInd ( 0-based)
|
|
int nInd ;
|
|
LuaCheckParam( L, 1, nInd)
|
|
LuaClearStack( L) ;
|
|
// recupero dati bloccaggio asse in posizione nInd
|
|
string sAxis ;
|
|
double dVal ;
|
|
bool bOk = ExeGetRotAxisBlocked( nInd, sAxis, dVal) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, sAxis) ;
|
|
LuaSetParam( L, dVal) ;
|
|
}
|
|
else {
|
|
LuaSetParam( L) ;
|
|
LuaSetParam( L) ;
|
|
}
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcAngles( lua_State* L)
|
|
{
|
|
// 1 o 2 parametri : vtDirT, vtDirA
|
|
Vector3d vtDirT ;
|
|
LuaCheckParam( L, 1, vtDirT)
|
|
Vector3d vtDirA ;
|
|
LuaGetParam( L, 2, vtDirA) ;
|
|
LuaClearStack( L) ;
|
|
// calcolo gli angoli macchina dalle direzioni fresa e ausiliaria
|
|
int nStat ; double dAngA1 ; double dAngB1 ; double dAngA2 ; double dAngB2 ;
|
|
bool bOk = ExeGetCalcAngles( vtDirT, vtDirA, nStat, dAngA1, dAngB1, dAngA2, dAngB2) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, nStat) ;
|
|
LuaSetParam( L, dAngA1) ;
|
|
LuaSetParam( L, dAngB1) ;
|
|
LuaSetParam( L, dAngA2) ;
|
|
LuaSetParam( L, dAngB2) ;
|
|
return 6 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcPositions( lua_State* L)
|
|
{
|
|
// da 2 a 5 parametri : ptP, dAngA [, dAngB] [, dAngC] [, dAngD]
|
|
Point3d ptP ;
|
|
LuaCheckParam( L, 1, ptP)
|
|
DBLVECTOR vAng ;
|
|
for ( int i = 2 ; i <= 5 ; ++ i) {
|
|
double dAng ;
|
|
if ( LuaGetParam( L, i, dAng))
|
|
vAng.emplace_back( dAng) ;
|
|
else
|
|
break ;
|
|
}
|
|
LuaClearStack( L) ;
|
|
// calcolo gli assi lineari dalla posizione e dagli angoli
|
|
double dX ; double dY ; double dZ ;
|
|
bool bOk = ExeGetCalcPositions( ptP, vAng, dX, dY, dZ) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, 0) ; // assegnato per compatibilit�
|
|
LuaSetParam( L, dX) ;
|
|
LuaSetParam( L, dY) ;
|
|
LuaSetParam( L, dZ) ;
|
|
return 5 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetRobotAngles( lua_State* L)
|
|
{
|
|
// da 3 parametri : ptP, vtTool, vtAux
|
|
Point3d ptP ;
|
|
LuaCheckParam( L, 1, ptP)
|
|
Vector3d vtTool ;
|
|
LuaCheckParam( L, 2, vtTool)
|
|
Vector3d vtAux ;
|
|
LuaCheckParam( L, 3, vtAux)
|
|
LuaClearStack( L) ;
|
|
// imposto la tavola corrente per il calcolo
|
|
DBLVECTOR vAng1, vAng2 ;
|
|
bool bOk = ExeGetRobotAngles( ptP, vtTool, vtAux, vAng1, vAng2) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, vAng1) ;
|
|
LuaSetParam( L, vAng2) ;
|
|
return 3 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcTipFromPositions( lua_State* L)
|
|
{
|
|
// da 3 a 10 parametri : dX, dY, dZ [, dAngR1] [, dAngR2] [, dAngR3] [, dAngR4] [, dAngR5] [, dAngR6] [, bBottom]
|
|
double dX ;
|
|
LuaCheckParam( L, 1, dX)
|
|
double dY ;
|
|
LuaCheckParam( L, 2, dY)
|
|
double dZ ;
|
|
LuaCheckParam( L, 3, dZ)
|
|
DBLVECTOR vAng ;
|
|
int i ;
|
|
for ( i = 4 ; i <= 9 ; ++ i) {
|
|
double dAng ;
|
|
if ( LuaGetParam( L, i, dAng))
|
|
vAng.emplace_back( dAng) ;
|
|
else
|
|
break ;
|
|
}
|
|
bool bBottom = false ;
|
|
LuaGetParam( L, i, bBottom) ;
|
|
LuaClearStack( L) ;
|
|
// calcolo il tip utensile dagli assi macchina
|
|
Point3d ptTip ;
|
|
bool bOk = ExeGetCalcTipFromPositions( dX, dY, dZ, vAng, bBottom, ptTip) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, ptTip) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcToolDirFromAngles( lua_State* L)
|
|
{
|
|
// da 0 a 6 parametri : [dAngR1] [, dAngR2] [, dAngR3] [, dAngR4] [, dAngR5] [, dAngR6]
|
|
DBLVECTOR vAng ;
|
|
for ( int i = 1 ; i <= 6 ; ++ i) {
|
|
double dAng ;
|
|
if ( LuaGetParam( L, i, dAng))
|
|
vAng.emplace_back( dAng) ;
|
|
else
|
|
break ;
|
|
}
|
|
LuaClearStack( L) ;
|
|
// Calcolo la direzione utensile dagli angoli macchina
|
|
Vector3d vtDir ;
|
|
bool bOk = ExeGetCalcToolDirFromAngles( vAng, vtDir) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vtDir) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcAuxDirFromAngles( lua_State* L)
|
|
{
|
|
// da 0 a 6 parametri : [dAngR1] [, dAngR2] [, dAngR3] [, dAngR4] [, dAngR5] [, dAngR6]
|
|
DBLVECTOR vAng ;
|
|
for ( int i = 1 ; i <= 6 ; ++ i) {
|
|
double dAng ;
|
|
if ( LuaGetParam( L, i, dAng))
|
|
vAng.emplace_back( dAng) ;
|
|
else
|
|
break ;
|
|
}
|
|
LuaClearStack( L) ;
|
|
// Calcolo la direzione ausiliaria dagli angoli macchina
|
|
Vector3d vtDir ;
|
|
bool bOk = ExeGetCalcAuxDirFromAngles( vAng, vtDir) ;
|
|
// restituisco il risultato
|
|
if ( bOk && ! vtDir.IsSmall())
|
|
LuaSetParam( L, vtDir) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaVerifyOutstroke( lua_State* L)
|
|
{
|
|
// 5 parametri : dX, dY, dZ, dAngA, dAngB
|
|
double dX ;
|
|
LuaCheckParam( L, 1, dX)
|
|
double dY ;
|
|
LuaCheckParam( L, 2, dY)
|
|
double dZ ;
|
|
LuaCheckParam( L, 3, dZ)
|
|
double dAngA ;
|
|
LuaCheckParam( L, 4, dAngA)
|
|
double dAngB ;
|
|
LuaCheckParam( L, 5, dAngB)
|
|
LuaClearStack( L) ;
|
|
// imposto la tavola corrente per il calcolo
|
|
int nStat ;
|
|
bool bOk = ExeVerifyOutstroke( dX, dY, dZ, dAngA, dAngB, nStat) ;
|
|
// restituisco il risultato
|
|
if ( bOk) {
|
|
LuaSetParam( L, ( nStat == 0)) ;
|
|
LuaSetParam( L, nStat) ;
|
|
return 2 ;
|
|
}
|
|
else {
|
|
LuaSetParam( L, false) ;
|
|
return 1 ;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetOutstrokeInfo( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero le info sull'ultima extracorsa
|
|
string sInfo ;
|
|
bool bOk = ExeGetOutstrokeInfo( sInfo) ;
|
|
if ( bOk)
|
|
LuaSetParam( L, sInfo) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Machine
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetBaseId( lua_State* L)
|
|
{
|
|
// 1 parametro : sBase
|
|
string sBase ;
|
|
LuaCheckParam( L, 1, sBase)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della Base indicata della macchina
|
|
int nId = ExeGetBaseId( sBase) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetTableId( lua_State* L)
|
|
{
|
|
// 1 parametro : sTable
|
|
string sTable ;
|
|
LuaCheckParam( L, 1, sTable)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della Tavola indicata della macchina
|
|
int nId = ExeGetTableId( sTable) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisId( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo dell'Asse indicato della macchina
|
|
int nId = ExeGetAxisId( sAxis) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetHeadId( lua_State* L)
|
|
{
|
|
// 1 parametro : sHead
|
|
string sHead ;
|
|
LuaCheckParam( L, 1, sHead)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della Testa indicata della macchina
|
|
int nId = ExeGetHeadId( sHead) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetHeadExitCount( lua_State* L)
|
|
{
|
|
// 1 parametro : sHead
|
|
string sHead ;
|
|
LuaCheckParam( L, 1, sHead)
|
|
LuaClearStack( L) ;
|
|
// recupero il numero di uscite della Testa indicata della macchina
|
|
int nCount = ExeGetHeadExitCount( sHead) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, nCount) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetExitId( lua_State* L)
|
|
{
|
|
// 2 parametri : sHead, nExit
|
|
string sHead ;
|
|
LuaCheckParam( L, 1, sHead)
|
|
int nExit ;
|
|
LuaCheckParam( L, 2, nExit)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo dell'Uscita della Testa indicata della macchina
|
|
int nId = ExeGetExitId( sHead, nExit) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetTcPosId( lua_State* L)
|
|
{
|
|
// 1 parametro : sTcPos
|
|
string sTcPos ;
|
|
LuaCheckParam( L, 1, sTcPos)
|
|
LuaClearStack( L) ;
|
|
// recupero l'identificativo della posizione di cambio utensile indicata della macchina
|
|
int nId = ExeGetTcPosId( sTcPos) ;
|
|
// restituisco il risultato
|
|
if ( nId != GDB_ID_NULL)
|
|
LuaSetParam( L, nId) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisToken( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero il token dell'asse
|
|
string sToken ;
|
|
bool bOk = ExeGetAxisToken( sAxis, sToken) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sToken) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisType( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero il tipo dell'asse
|
|
bool bLinear ;
|
|
bool bOk = ExeGetAxisType( sAxis, bLinear) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, bLinear) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisDir( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero la direzione dell'asse
|
|
Vector3d vtDir ;
|
|
bool bOk = ExeGetAxisDir( sAxis, vtDir) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vtDir) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisInvert( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero il flag di inversione per visualizzazione dell'asse
|
|
bool bInvert ;
|
|
bool bOk = ExeGetAxisInvert( sAxis, bInvert) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, bInvert) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisOffset( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero il valore di offset per visualizzazione dell'asse
|
|
double dOffset ;
|
|
bool bOk = ExeGetAxisOffset( sAxis, dOffset) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, dOffset) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAllTablesNames( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'elenco delle tavole della macchina corrente
|
|
STRVECTOR vNames ;
|
|
bool bOk = ExeGetAllTablesNames( vNames) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vNames) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAllAxesNames( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'elenco degli assi della macchina corrente
|
|
STRVECTOR vNames ;
|
|
bool bOk = ExeGetAllAxesNames( vNames) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vNames) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAllHeadsNames( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'elenco delle teste della macchina corrente
|
|
STRVECTOR vNames ;
|
|
bool bOk = ExeGetAllHeadsNames( vNames) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vNames) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAllTcPosNames( lua_State* L)
|
|
{
|
|
// nessun parametro
|
|
LuaClearStack( L) ;
|
|
// recupero l'elenco delle posizioni di cambio utensile della macchina corrente
|
|
STRVECTOR vNames ;
|
|
bool bOk = ExeGetAllTcPosNames( vNames) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, vNames) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetAxisPos( lua_State* L)
|
|
{
|
|
// 2 parametri : sAxis, dVal
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
double dVal ;
|
|
LuaCheckParam( L, 2, dVal)
|
|
LuaClearStack( L) ;
|
|
// metto l'asse nella nuova posizione
|
|
double dNewVal = dVal ;
|
|
bool bOk = ExeSetAxisPos( sAxis, dVal, &dNewVal) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
LuaSetParam( L, dNewVal) ;
|
|
return 2 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisPos( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero la posizione dell'asse
|
|
double dVal ;
|
|
bool bOk = ExeGetAxisPos( sAxis, &dVal) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, dVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisMin( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero il minimo dell'asse
|
|
double dMin ;
|
|
bool bOk = ExeGetAxisMin( sAxis, &dMin) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, dMin) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisMax( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero il massimo dell'asse
|
|
double dMax ;
|
|
bool bOk = ExeGetAxisMax( sAxis, &dMax) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, dMax) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetAxisHomePos( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// recupero la posizione home dell'asse
|
|
double dHomeVal ;
|
|
bool bOk = ExeGetAxisHomePos( sAxis, &dHomeVal) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, dHomeVal) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaResetAxisPos( lua_State* L)
|
|
{
|
|
// 1 parametro : sAxis
|
|
string sAxis ;
|
|
LuaCheckParam( L, 1, sAxis)
|
|
LuaClearStack( L) ;
|
|
// metto l'asse nella posizione home
|
|
bool bOk = ExeResetAxisPos( sAxis) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaLoadTool( lua_State* L)
|
|
{
|
|
// 3 parametri : sHead, nExit, sTool
|
|
string sHead ;
|
|
LuaCheckParam( L, 1, sHead)
|
|
int nExit ;
|
|
LuaCheckParam( L, 2, nExit)
|
|
string sTool ;
|
|
LuaCheckParam( L, 3, sTool)
|
|
LuaClearStack( L) ;
|
|
// carico l'utensile
|
|
bool bOk = ExeLoadTool( sHead, nExit, sTool) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetLoadedTool( lua_State* L)
|
|
{
|
|
// 2 parametri : sHead, nExit
|
|
string sHead ;
|
|
LuaCheckParam( L, 1, sHead)
|
|
int nExit ;
|
|
LuaCheckParam( L, 2, nExit)
|
|
LuaClearStack( L) ;
|
|
// recupero l'utensile caricato su testa e uscita indicate
|
|
string sTool ;
|
|
bool bOk = ExeGetLoadedTool( sHead, nExit, sTool) ;
|
|
// restituisco il risultato
|
|
if ( bOk)
|
|
LuaSetParam( L, sTool) ;
|
|
else
|
|
LuaSetParam( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaUnloadTool( lua_State* L)
|
|
{
|
|
// 2 parametri : sHead, nExit
|
|
string sHead ;
|
|
LuaCheckParam( L, 1, sHead)
|
|
int nExit ;
|
|
LuaCheckParam( L, 2, nExit)
|
|
LuaClearStack( L) ;
|
|
// scarico l'utensile
|
|
bool bOk = ExeUnloadTool( sHead, nExit) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaResetHeadSet( lua_State* L)
|
|
{
|
|
// 1 parametro : sHead
|
|
string sHead ;
|
|
LuaCheckParam( L, 1, sHead)
|
|
LuaClearStack( L) ;
|
|
// carico l'utensile
|
|
bool bOk = ExeResetHeadSet( sHead) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetMachineLook( lua_State* L)
|
|
{
|
|
// 1 parametro : nFlag
|
|
int nFlag ;
|
|
LuaCheckParam( L, 1, nFlag)
|
|
LuaClearStack( L) ;
|
|
// imposto lo stato di visualizzazione della macchina
|
|
bool bOk = ExeSetMachineLook( nFlag) ;
|
|
// restituisco il risultato
|
|
LuaSetParam( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallMachMgr( LuaMgr& luaMgr)
|
|
{
|
|
bool bOk = ( &luaMgr != nullptr) ;
|
|
// Errors & Warnings
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastMachMgrError", LuaGetLastMachMgrError) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachMgrWarning", LuaGetMachMgrWarning) ;
|
|
// Machines
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrMachine", LuaSetCurrMachine) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrMachineName", LuaGetCurrMachineName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrMachineDir", LuaGetCurrMachineDir) ;
|
|
// Mach Groups
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupCount", LuaGetMachGroupCount) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstMachGroup", LuaGetFirstMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextMachGroup", LuaGetNextMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastMachGroup", LuaGetLastMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevMachGroup", LuaGetPrevMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupNewName", LuaGetMachGroupNewName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAddMachGroup", LuaAddMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCopyMachGroup", LuaCopyMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveMachGroup", LuaRemoveMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtChangeMachGroupName", LuaChangeMachGroupName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupName", LuaGetMachGroupName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupMachineName", LuaGetMachGroupMachineName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachGroupId", LuaGetMachGroupId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrMachGroup", LuaSetCurrMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtResetCurrMachGroup", LuaResetCurrMachGroup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrMachGroup", LuaGetCurrMachGroup) ;
|
|
// Phases
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAddPhase", LuaAddPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrPhase", LuaSetCurrPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrPhase", LuaGetCurrPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveLastPhase", LuaRemoveLastPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetPhaseCount", LuaGetPhaseCount) ;
|
|
// Raw Parts & Parts
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetRawPartCount", LuaGetRawPartCount) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstRawPart", LuaGetFirstRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextRawPart", LuaGetNextRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAddRawPart", LuaAddRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAddRawPartWithPart", LuaAddRawPartWithPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtModifyRawPart", LuaModifyRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtModifyRawPartSize", LuaModifyRawPartSize) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtModifyRawPartHeight", LuaModifyRawPartHeight) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtKeepRawPart", LuaKeepRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyRawPartPhase", LuaVerifyRawPartPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveRawPartFromCurrPhase", LuaRemoveRawPartFromCurrPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveRawPart", LuaRemoveRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRotateRawPart", LuaRotateRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMoveToCornerRawPart", LuaMoveToCornerRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMoveToCenterRawPart", LuaMoveToCenterRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMoveRawPart", LuaMoveRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetRawPartCenter", LuaGetRawPartCenter) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetRawPartBBox", LuaGetRawPartBBox) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSplitFlatRawPartWithMachinings", LuaSplitFlatRawPartWithMachinings) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetPartInRawPartCount", LuaGetPartInRawPartCount) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstPartInRawPart", LuaGetFirstPartInRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextPartInRawPart", LuaGetNextPartInRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAddPartToRawPart", LuaAddPartToRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetRawPartFromPart", LuaGetRawPartFromPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemovePartFromRawPart", LuaRemovePartFromRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMovePartInRawPart", LuaTranslatePartInRawPart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRotatePartInRawPart", LuaRotatePartInRawPart) ;
|
|
// Table & Fixtures
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetTable", LuaSetTable) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetTableAreaOffset", LuaSetTableAreaOffset) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableName", LuaGetTableName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableRef", LuaGetTableRef) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableArea", LuaGetTableArea) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableAreaOffset", LuaGetTableAreaOffset) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtChangeTable", LuaChangeTable) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMoveDispAxis", LuaMoveDispAxis) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveDispAxis", LuaRemoveDispAxis) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtKeepAllDispAxes", LuaKeepAllDispAxes) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAddFixture", LuaAddFixture) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtKeepFixture", LuaKeepFixture) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveFixture", LuaRemoveFixture) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstFixture", LuaGetFirstFixture) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextFixture", LuaGetNextFixture) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMoveFixture", LuaMoveFixture) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRotateFixture", LuaRotateFixture) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetFixtureLink", LuaSetFixtureLink) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMoveFixtureMobile", LuaMoveFixtureMobile) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetFixtureMobile", LuaSetFixtureMobile) ;
|
|
// Tools database
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetToolNewName", LuaTdbGetToolNewName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbAddTool", LuaTdbAddTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbCopyTool", LuaTdbCopyTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbRemoveTool", LuaTdbRemoveTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetFirstTool", LuaTdbGetFirstTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetNextTool", LuaTdbGetNextTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetToolFromUUID", LuaTdbGetToolFromUUID) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSetCurrTool", LuaTdbSetCurrTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSaveCurrTool", LuaTdbSaveCurrTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbIsCurrToolModified", LuaTdbIsCurrToolModified) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSetCurrToolParam", LuaTdbSetCurrToolParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSetCurrToolValInNotes", LuaTdbSetCurrToolValInNotes) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbRemoveCurrToolValInNotes", LuaTdbRemoveCurrToolValInNotes) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolParam", LuaTdbGetCurrToolParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolValInNotes", LuaTdbGetCurrToolValInNotes) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolMaxDepth", LuaTdbGetCurrToolMaxDepth) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolThDiam", LuaTdbGetCurrToolThDiam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolThLength", LuaTdbGetCurrToolThLength) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbIsCurrToolStandardDraw", LuaTdbIsCurrToolStandardDraw) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbGetCurrToolDraw", LuaTdbGetCurrToolDraw) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbReload", LuaTdbReload) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtTdbSave", LuaTdbSave) ;
|
|
// Setup
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrSetup", LuaGetCurrSetup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetDefaultSetupName", LuaGetDefaultSetupName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtImportSetup", LuaImportSetup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtExistsCurrSetup", LuaExistsCurrSetup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyCurrSetup", LuaVerifyCurrSetup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtFindToolInCurrSetup", LuaFindToolInCurrSetup) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetToolsInCurrSetupPos", LuaGetToolsInCurrSetupPos) ;
|
|
// Machinings database
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetMachiningNewName", LuaMdbGetMachiningNewName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbAddMachining", LuaMdbAddMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbCopyMachining", LuaMdbCopyMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbRemoveMachining", LuaMdbRemoveMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetFirstMachining", LuaMdbGetFirstMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetNextMachining", LuaMdbGetNextMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetMachiningFromUUID", LuaMdbGetMachiningFromUUID) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSetCurrMachining", LuaMdbSetCurrMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSaveCurrMachining", LuaMdbSaveCurrMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbIsCurrMachiningModified", LuaMdbIsCurrMachiningModified) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSetCurrMachiningParam", LuaMdbSetCurrMachiningParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetCurrMachiningParam", LuaMdbGetCurrMachiningParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSetGeneralParam", LuaMdbSetGeneralParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbGetGeneralParam", LuaMdbGetGeneralParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbReload", LuaMdbReload) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtMdbSave", LuaMdbSave) ;
|
|
// Operations
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstOperation", LuaGetFirstOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextOperation", LuaGetNextOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastOperation", LuaGetLastOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevOperation", LuaGetPrevOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstActiveOperation", LuaGetFirstActiveOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextActiveOperation", LuaGetNextActiveOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastActiveOperation", LuaGetLastActiveOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevActiveOperation", LuaGetPrevActiveOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationType", LuaGetOperationType) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationPhase", LuaGetOperationPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetOperationName", LuaSetOperationName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationName", LuaGetOperationName) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationId", LuaGetOperationId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtIsOperationEmpty", LuaIsOperationEmpty) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveOperation", LuaRemoveOperation) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveAllPhaseOperations", LuaRemoveAllPhaseOperations) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveAllOperations", LuaRemoveAllOperations) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetOperationMode", LuaSetOperationMode) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationMode", LuaGetOperationMode) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetAllOperationsMode", LuaSetAllOperationsMode) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetOperationStatus", LuaSetOperationStatus) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetOperationStatus", LuaGetOperationStatus) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetAllOperationsStatus", LuaSetAllOperationsStatus) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAdjustOperationPhase", LuaAdjustOperationPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtChangeOperationPhase", LuaChangeOperationPhase) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveOperationHome", LuaRemoveOperationHome) ;
|
|
// Dispositions
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetPhaseDisposition", LuaGetPhaseDisposition) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSpecialApplyDisposition", LuaSpecialApplyDisposition) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSpecialUpdateDisposition", LuaSpecialUpdateDisposition) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetDispositionToolData", LuaGetDispositionToolData) ;
|
|
// Machinings
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtAddMachining", LuaAddMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCreateMachining", LuaCreateMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtCopyMachining", LuaCopyMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrMachining", LuaSetCurrMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrMachining", LuaGetCurrMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtResetCurrMachining", LuaResetCurrMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetMachiningParam", LuaSetMachiningParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetMachiningGeometry", LuaSetMachiningGeometry) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtPreviewMachining", LuaPreviewMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtApplyMachining", LuaApplyMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtUpdateMachining", LuaUpdateMachining) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningParam", LuaGetMachiningParam) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningGeometry", LuaGetMachiningGeometry) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningSkippedGeometry", LuaGetMachiningSkippedGeometry) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtIsMachiningEmpty", LuaIsMachiningEmpty) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningStartPoint", LuaGetMachiningStartPoint) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningEndPoint", LuaGetMachiningEndPoint) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningStartAxes", LuaGetMachiningStartAxes) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningEndAxes", LuaGetMachiningEndAxes) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtApplyAllMachinings", LuaApplyAllMachinings) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtUpdateAllMachinings", LuaUpdateAllMachinings) ;
|
|
// CL Entities Interrogations
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntMove", LuaGetClEntMove) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntFlag", LuaGetClEntFlag) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntIndex", LuaGetClEntIndex) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntFeed", LuaGetClEntFeed) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesStatus", LuaGetClEntAxesStatus) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesMask", LuaGetClEntAxesMask) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetClEntAxesVal", LuaGetClEntAxesVal) ;
|
|
// Simulation
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimInit", LuaSimInit) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimStart", LuaSimStart) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimMove", LuaSimMove) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimHome", LuaSimHome) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimSetStep", LuaSimSetStep) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimSetUiStatus", LuaSimSetUiStatus) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimEnableToolTipTrace", LuaSimEnableToolTipTrace) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimGetAxisInfoPos", LuaSimGetAxisInfoPos) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimGetToolInfo", LuaSimGetToolInfo) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimGetOperationInfo", LuaSimGetOperationInfo) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimGetMoveInfo", LuaSimGetMoveInfo) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimExit", LuaSimExit) ;
|
|
// Generation, T&L estimation e Simulazione
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGenerate", LuaGenerate) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtEstimate", LuaEstimate) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSimulate", LuaSimulate) ;
|
|
// Machine
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetBaseId", LuaGetBaseId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetTableId", LuaGetTableId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisId", LuaGetAxisId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetHeadId", LuaGetHeadId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetHeadExitCount", LuaGetHeadExitCount) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetExitId", LuaGetExitId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetTcPosId", LuaGetTcPosId) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisToken", LuaGetAxisToken) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisType", LuaGetAxisType) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisDir", LuaGetAxisDir) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisInvert", LuaGetAxisInvert) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisOffset", LuaGetAxisOffset) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllTablesNames", LuaGetAllTablesNames) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllAxesNames", LuaGetAllAxesNames) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllHeadsNames", LuaGetAllHeadsNames) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllTcPosNames", LuaGetAllTcPosNames) ;
|
|
// Machine Calc
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetCalcTable", LuaSetCalcTable) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetCalcTool", LuaSetCalcTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetCalcSolCh", LuaSetCalcSolCh) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetRotAxisBlock", LuaSetRotAxisBlock) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTable", LuaGetCalcTable) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTool", LuaGetCalcTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcSolCh", LuaGetCalcSolCh) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllCurrAxesNames", LuaGetAllCurrAxesNames) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetRotAxisBlocked", LuaGetRotAxisBlocked) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcAngles", LuaGetCalcAngles) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcPositions", LuaGetCalcPositions) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetRobotAngles", LuaGetRobotAngles) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTipFromPositions", LuaGetCalcTipFromPositions) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcToolDirFromAngles", LuaGetCalcToolDirFromAngles) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcAuxDirFromAngles", LuaGetCalcAuxDirFromAngles) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyOutstroke", LuaVerifyOutstroke) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetOutstrokeInfo", LuaGetOutstrokeInfo) ;
|
|
// Machine Move
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetAxisPos", LuaSetAxisPos) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisPos", LuaGetAxisPos) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisMin", LuaGetAxisMin) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisMax", LuaGetAxisMax) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisHomePos", LuaGetAxisHomePos) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtResetAxisPos", LuaResetAxisPos) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtLoadTool", LuaLoadTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtGetLoadedTool", LuaGetLoadedTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtUnloadTool", LuaUnloadTool) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtResetHeadSet", LuaResetHeadSet) ;
|
|
bOk = bOk && luaMgr.RegisterFunction( "EgtSetMachineLook", LuaSetMachineLook) ;
|
|
|
|
return bOk ;
|
|
}
|