//---------------------------------------------------------------------------- // EgalTech 2015-2015 //---------------------------------------------------------------------------- // File : LUA_GdbPartLayers.cpp Data : 29.01.15 Versione : 1.6a7 // Contenuto : Funzioni di gestione pezzi e layer relativi per LUA. // // // // Modifiche : 29.01.15 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "LUA.h" #include "/EgtDev/Include/EXeExecutor.h" #include "/EgtDev/Include/EGkGdbConst.h" #include "/EgtDev/Include/EGkLuaAux.h" using namespace std ; //------------------------------------------------------------------------------- static int LuaIsPart( lua_State* L) { // 1 parametro : nIdPart int nIdPart ; LuaCheckParam( L, 1, nIdPart) LuaClearStack( L) ; // verifico sia un pezzo bool bOk = ExeIsPart( nIdPart) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaIsLayer( lua_State* L) { // 1 parametro : nIdLayer int nIdLayer ; LuaCheckParam( L, 1, nIdLayer) LuaClearStack( L) ; // verifico sia un layer bool bOk = ExeIsLayer( nIdLayer) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetCurrPart( lua_State* L) { // nessun parametro LuaClearStack( L) ; // recupero il pezzo corrente int nId = ExeGetCurrPart() ; // restituisco il risultato LuaSetParam( L, nId) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetCurrLayer( lua_State* L) { // nessun parametro LuaClearStack( L) ; // recupero il layer corrente int nId = ExeGetCurrLayer() ; // restituisco il risultato LuaSetParam( L, nId) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetCurrPartLayer( lua_State* L) { // 2 parametri : nPartId, nLayerId int nPartId ; LuaCheckParam( L, 1, nPartId) int nLayerId ; LuaCheckParam( L, 2, nLayerId) LuaClearStack( L) ; // imposto pezzo e layer correnti bool bOk = ExeSetCurrPartLayer( nPartId, nLayerId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaResetCurrPartLayer( lua_State* L) { // nessun parametro LuaClearStack( L) ; // cerco primo pezzo e layer validi per essere dichiarati correnti bool bOk = ExeResetCurrPartLayer() ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetPartCount( lua_State* L) { // nessuno o 1 parametro : [bOnlyVisible] bool bOnlyVisible = false ; LuaGetParam( L, 1, bOnlyVisible) ; LuaClearStack( L) ; // recupero numero pezzi int nNbr = ExeGetPartCount( bOnlyVisible) ; // restituisco il risultato LuaSetParam( L, nNbr) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetFirstPart( lua_State* L) { // nessuno o 1 parametro : [bOnlyVisible] bool bOnlyVisible = false ; LuaGetParam( L, 1, bOnlyVisible) ; LuaClearStack( L) ; // cerco primo pezzo int nId = ExeGetFirstPart( bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetNextPart( lua_State* L) { // 1 o 2 parametri : nPartId [, bOnlyVisible] int nPartId ; LuaCheckParam( L, 1, nPartId) bool bOnlyVisible = false ; LuaGetParam( L, 2, bOnlyVisible) ; LuaClearStack( L) ; // cerco pezzo successivo int nId = ExeGetNextPart( nPartId, bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetLastPart( lua_State* L) { // nessuno o 1 parametro : [bOnlyVisible] bool bOnlyVisible = false ; LuaGetParam( L, 1, bOnlyVisible) ; LuaClearStack( L) ; // cerco ultimo pezzo int nId = ExeGetLastPart( bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetPrevPart( lua_State* L) { // 1 o 2 parametri : nPartId [, bOnlyVisible] int nPartId ; LuaCheckParam( L, 1, nPartId) bool bOnlyVisible = false ; LuaGetParam( L, 2, bOnlyVisible) ; LuaClearStack( L) ; // cerco pezzo precedente int nId = ExeGetPrevPart( nPartId, bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetFirstLayer( lua_State* L) { // 1 o 2 parametri : nPartId [, bOnlyVisible] int nPartId ; LuaCheckParam( L, 1, nPartId) bool bOnlyVisible = false ; LuaGetParam( L, 2, bOnlyVisible) ; LuaClearStack( L) ; // cerco il primo layer del pezzo int nId = ExeGetFirstLayer( nPartId, bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetNextLayer( lua_State* L) { // 1 o 2 parametri : nLayerId [, bOnlyVisible] int nLayerId ; LuaCheckParam( L, 1, nLayerId) bool bOnlyVisible = false ; LuaGetParam( L, 2, bOnlyVisible) ; LuaClearStack( L) ; // cerco il prossimo layer (ovviamente dello stesso pezzo) int nId = ExeGetNextLayer( nLayerId, bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetLastLayer( lua_State* L) { // 1 o 2 parametri : nPartId [, bOnlyVisible] int nPartId ; LuaCheckParam( L, 1, nPartId) bool bOnlyVisible = false ; LuaGetParam( L, 2, bOnlyVisible) ; LuaClearStack( L) ; // cerco l'ultimo layer del pezzo int nId = ExeGetLastLayer( nPartId, bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetPrevLayer( lua_State* L) { // 1 o 2 parametri : nLayerId [, bOnlyVisible] int nLayerId ; LuaCheckParam( L, 1, nLayerId) bool bOnlyVisible = false ; LuaGetParam( L, 2, bOnlyVisible) ; LuaClearStack( L) ; // cerco il precedente layer (ovviamente dello stesso pezzo) int nId = ExeGetPrevLayer( nLayerId, bOnlyVisible) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaIsGhostPart( lua_State* L) { // 1 parametro : nGhostId int nGhostId ; LuaCheckParam( L, 1, nGhostId) LuaClearStack( L) ; // verifico sia un segnaposto di pezzo messo in grezzo bool bOk = ExeIsGhostPart( nGhostId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetFirstGhostPart( lua_State* L) { // nessuno parametro LuaClearStack( L) ; // cerco primo pezzo messo in grezzo int nId = ExeGetFirstGhostPart() ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetNextGhostPart( lua_State* L) { // 1 parametro : nGhostPartId int nGhostPartId ; LuaCheckParam( L, 1, nGhostPartId) LuaClearStack( L) ; // cerco pezzo successivo messo in grezzo int nId = ExeGetNextGhostPart( nGhostPartId) ; // restituisco il risultato if ( nId != GDB_ID_NULL) LuaSetParam( L, nId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaEraseEmptyParts( lua_State* L) { // nessun parametro LuaClearStack( L) ; // cancello i pezzi vuoti bool bOk = ExeEraseEmptyParts() ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSelectPartObjs( lua_State* L) { // 1 parametro : PartId int nPartId ; LuaCheckParam( L, 1, nPartId) LuaClearStack( L) ; // eseguo la selezione bool bOk = ExeSelectPartObjs( nPartId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDeselectPartObjs( lua_State* L) { // 1 parametro : PartId int nPartId ; LuaCheckParam( L, 1, nPartId) LuaClearStack( L) ; // eseguo la selezione bool bOk = ExeDeselectPartObjs( nPartId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSelectLayerObjs( lua_State* L) { // 1 parametro : LayerId int nLayerId ; LuaCheckParam( L, 1, nLayerId) LuaClearStack( L) ; // eseguo la selezione bool bOk = ExeSelectLayerObjs( nLayerId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDeselectLayerObjs( lua_State* L) { // 1 parametro : LayerId int nLayerId ; LuaCheckParam( L, 1, nLayerId) LuaClearStack( L) ; // eseguo la selezione bool bOk = ExeDeselectLayerObjs( nLayerId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSelectPathObjs( lua_State* L) { // 2 parametri : nId, bHaltOnFork int nId ; LuaCheckParam( L, 1, nId) bool bHaltOnFork ; LuaCheckParam( L, 2, bHaltOnFork) LuaClearStack( L) ; // eseguo la selezione bool bOk = ExeSelectPathObjs( nId, bHaltOnFork) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploNew( lua_State* L) { // 1 parametro : nSouId int nSouId ; LuaCheckParam( L, 1, nSouId) LuaClearStack( L) ; // creo il duplicato int nNewId = ExeDuploNew( nSouId) ; // restituisco il risultato LuaSetParam( L, nNewId) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploCount( lua_State* L) { // 1 parametro : nSouId int nSouId ; LuaCheckParam( L, 1, nSouId) LuaClearStack( L) ; // recupero il numero di duplicati int nCount ; bool bOk = ExeDuploCount( nSouId, nCount) ; // restituisco il risultato if ( bOk) LuaSetParam( L, nCount) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploList( lua_State* L) { // 1 parametro : nSouId int nSouId ; LuaCheckParam( L, 1, nSouId) LuaClearStack( L) ; // recupero l'elenco dei duplicati INTVECTOR vnRef ; bool bOk = ExeDuploList( nSouId, vnRef) ; // restituisco il risultato if ( bOk) LuaSetParam( L, vnRef) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploInRawCount( lua_State* L) { // 1 parametro : nSouId int nSouId ; LuaCheckParam( L, 1, nSouId) LuaClearStack( L) ; // recupero il numero di duplicati che sono riferiti da grezzi nei vari gruppi di lavoro del progetto int nCount ; bool bOk = ExeDuploInRawCount( nSouId, nCount) ; // restituisco il risultato if ( bOk) LuaSetParam( L, nCount) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploWithoutRawList( lua_State* L) { // nessun parametro LuaClearStack( L) ; // recupero l'elenco dei duplicati INTVECTOR vnDup ; bool bOk = ExeDuploWithoutRawList( vnDup) ; // restituisco il risultato if ( bOk) LuaSetParam( L, vnDup) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploSetModified( lua_State* L) { // 1 parametro : nSouId int nSouId ; LuaCheckParam( L, 1, nSouId) LuaClearStack( L) ; // dichiaro che il pezzo è modificato bool bOk = ExeDuploSetModified( nSouId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploGetModified( lua_State* L) { // 1 parametro : nSouId int nSouId ; LuaCheckParam( L, 1, nSouId) LuaClearStack( L) ; // recupero lo stato di modifica del pezzo bool bModif ; bool bOk = ExeDuploGetModified( nSouId, bModif) ; // restituisco il risultato if ( bOk) LuaSetParam( L, bModif) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploSetLocked( lua_State* L) { // 1 parametro : nDupId int nDupId ; LuaCheckParam( L, 1, nDupId) LuaClearStack( L) ; // blocco il duplicato (non modificabile) bool bOk = ExeDuploSetLocked( nDupId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploResetLocked( lua_State* L) { // 1 parametro : nDupId int nDupId ; LuaCheckParam( L, 1, nDupId) LuaClearStack( L) ; // sblocco il duplicato (ritorna copia esatta dell'originale) bool bOk = ExeDuploResetLocked( nDupId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploGetLocked( lua_State* L) { // 1 parametro : nDupId int nDupId ; LuaCheckParam( L, 1, nDupId) LuaClearStack( L) ; // recupero lo stato di blocco del duplicato bool bLocked ; bool bOk = ExeDuploGetLocked( nDupId, bLocked) ; // restituisco il risultato if ( bOk) LuaSetParam( L, bLocked) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploUpdate( lua_State* L) { // 1 parametro : nSouId int nSouId ; LuaCheckParam( L, 1, nSouId) LuaClearStack( L) ; // aggiorno i duplicati del pezzo bool bOk = ExeDuploUpdate( nSouId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaIsDuplo( lua_State* L) { // 1 parametro : nDouId int nDouId ; LuaCheckParam( L, 1, nDouId) LuaClearStack( L) ; // verifico se è un duplicato bool bOk = ExeIsDuplo( nDouId) ; // restituisco il risultato LuaSetParam( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaDuploGetOriginal( lua_State* L) { // 1 parametro : nDouId int nDouId ; LuaCheckParam( L, 1, nDouId) LuaClearStack( L) ; // verifico se è un duplicato int nOrigId = ExeDuploGetOriginal( nDouId) ; // restituisco il risultato if ( nOrigId != GDB_ID_NULL) LuaSetParam( L, nOrigId) ; else LuaSetParam( L) ; return 1 ; } //------------------------------------------------------------------------------- bool LuaInstallGdbPartLayer( LuaMgr& luaMgr) { bool bOk = ( &luaMgr != nullptr) ; bOk = bOk && luaMgr.RegisterFunction( "EgtIsPart", LuaIsPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtIsLayer", LuaIsLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrPart", LuaGetCurrPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrLayer", LuaGetCurrLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrPartLayer", LuaSetCurrPartLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtResetCurrPartLayer", LuaResetCurrPartLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetPartCount", LuaGetPartCount) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstPart", LuaGetFirstPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextPart", LuaGetNextPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastPart", LuaGetLastPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevPart", LuaGetPrevPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstLayer", LuaGetFirstLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextLayer", LuaGetNextLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastLayer", LuaGetLastLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevLayer", LuaGetPrevLayer) ; bOk = bOk && luaMgr.RegisterFunction( "EgtIsGhostPart", LuaIsGhostPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstGhostPart", LuaGetFirstGhostPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextGhostPart", LuaGetNextGhostPart) ; bOk = bOk && luaMgr.RegisterFunction( "EgtEraseEmptyParts", LuaEraseEmptyParts) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSelectPartObjs", LuaSelectPartObjs) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDeselectPartObjs", LuaDeselectPartObjs) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSelectLayerObjs", LuaSelectLayerObjs) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDeselectLayerObjs", LuaDeselectLayerObjs) ; bOk = bOk && luaMgr.RegisterFunction( "EgtSelectPathObjs", LuaSelectPathObjs) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploNew", LuaDuploNew) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploCount", LuaDuploCount) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploList", LuaDuploList) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploInRawCount", LuaDuploInRawCount) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploWithoutRawList", LuaDuploWithoutRawList) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploSetModified", LuaDuploSetModified) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploGetModified", LuaDuploGetModified) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploSetLocked", LuaDuploSetLocked) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploResetLocked", LuaDuploResetLocked) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploGetLocked", LuaDuploGetLocked) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploUpdate", LuaDuploUpdate) ; bOk = bOk && luaMgr.RegisterFunction( "EgtIsDuplo", LuaIsDuplo) ; bOk = bOk && luaMgr.RegisterFunction( "EgtDuploGetOriginal", LuaDuploGetOriginal) ; return bOk ; }