//---------------------------------------------------------------------------- // 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/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 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) { // 6 parametri : nRawId, nCrvId, dOverMat, dZmin, dHeight, cCol int nRawId ; LuaCheckParam( L, 1, nRawId) int nCrvId ; LuaCheckParam( L, 2, nCrvId) double dOverMat ; LuaCheckParam( L, 3, dOverMat) double dZmin ; LuaCheckParam( L, 4, dZmin) double dHeight ; LuaCheckParam( L, 5, dHeight) Color cCol ; LuaCheckParam( L, 6, cCol) LuaClearStack( L) ; // modifico le dimensioni del grezzo bool bOk = ExeModifyRawPart( nRawId, nCrvId, dOverMat, dZmin, 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 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) ; // metto l'asse nella nuova posizione 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 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 ; } //------------------------------------------------------------------------------- // 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 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 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 l'attrezzaggio della macchinata corrente bool bOk = ExeFindToolInCurrSetup( sTool) ; LuaSetParam( L, bOk) ; return 1 ; } //----------------------------------------------------------------------------- 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) { // nessun parametro LuaClearStack( L) ; // recupero la prima operazione attiva della macchinata corrente int nId = ExeGetFirstActiveOperation() ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetNextActiveOperation( lua_State* L) { // 1 parametro : nId int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero la successiva operazione attiva della macchinata corrente int nNextId = ExeGetNextActiveOperation( nId) ; // restituisco il risultato if ( nNextId != GDB_ID_NULL) LuaSetParam( L, nNextId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetLastActiveOperation( lua_State* L) { // nessun parametro LuaClearStack( L) ; // recupero l'ultima operazione attiva della macchinata corrente int nId = ExeGetLastActiveOperation() ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetPrevActiveOperation( lua_State* L) { // 1 parametro : nId int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero la precedente operazione attiva della macchinata corrente int nNextId = ExeGetPrevActiveOperation( nId) ; // 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 parametro : nId int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero lo stato della operazione indicata della macchinata corrente bool bOk = ExeIsOperationEmpty( nId) ; // 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 ; } //------------------------------------------------------------------------------- // 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 LuaIsMachiningEmpty( lua_State* L) { // nessun parametro LuaClearStack( L) ; // recupero lo stato della lavorazione corrente bool bEmpty = ExeIsMachiningEmpty() ; // 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 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 ; bool bOk = ExeGetClEntFlag( nEntId, nFlag) ; // restituisco il risultato if ( bOk) LuaSetParam( L, nFlag) ; else LuaSetParam( L) ; return 1 ; } //----------------------------------------------------------------------------- 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 ; } //------------------------------------------------------------------------------- // 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 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 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 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 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 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) ; // imposto la tavola corrente per il calcolo int nStat ; double dX ; double dY ; double dZ ; bool bOk = ExeGetCalcPositions( ptP, vAng, nStat, dX, dY, dZ) ; // restituisco il risultato if ( bOk) { LuaSetParam( L, bOk) ; LuaSetParam( L, nStat) ; LuaSetParam( L, dX) ; LuaSetParam( L, dY) ; LuaSetParam( L, dZ) ; return 5 ; } else { LuaSetParam( L, bOk) ; return 1 ; } } //------------------------------------------------------------------------------- static int LuaGetCalcTipFromPositions( lua_State* L) { // da 5 a 8 parametri : dX, dY, dZ, dAngA [, dAngB] [, dAngC] [, dAngD], 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 <= 7 ; ++ i) { double dAng ; if ( LuaGetParam( L, i, dAng)) vAng.emplace_back( dAng) ; else break ; } bool bBottom ; LuaCheckParam( 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 1 a 4 parametri : dAngA, dAngB, dAngC, dAngD DBLVECTOR vAng ; for ( int i = 1 ; i <= 4 ; ++ 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 1 a 4 parametri : dAngA, dAngB, dAngC, dAngD DBLVECTOR vAng ; for ( int i = 1 ; i <= 4 ; ++ 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 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 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 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( "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( "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( "EgtMoveFixtureMobile", LuaMoveFixtureMobile) ; // 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( "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( "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) ; // 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( "EgtIsMachiningEmpty", LuaIsMachiningEmpty) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningStartPoint", LuaGetMachiningStartPoint) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetMachiningEndPoint", LuaGetMachiningEndPoint) ; 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) ; // 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( "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( "EgtGetTcPosId", LuaGetTcPosId) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisToken", LuaGetAxisToken) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisType", LuaGetAxisType) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisInvert", LuaGetAxisInvert) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetAxisOffset", LuaGetAxisOffset) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetAllTablesNames", LuaGetAllTablesNames) ; 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( "EgtSetRotAxisBlock", LuaSetRotAxisBlock) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetRotAxisBlocked", LuaGetRotAxisBlocked) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcTool", LuaGetCalcTool) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcAngles", LuaGetCalcAngles) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcPositions", LuaGetCalcPositions) ; 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 ; }