//---------------------------------------------------------------------------- // EgalTech 2014-2014 //---------------------------------------------------------------------------- // File : LUA_GdbObjAttribs.cpp Data : 30.09.14 Versione : 1.5i5 // Contenuto : Funzioni di trasformazione geometrica per LUA. // // // // Modifiche : 30.09.14 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "API.h" #include "LUA.h" #include "LUA_Base.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EGkLuaAux.h" #include "/EgtDev/Include/EGnStringUtils.h" using namespace std ; //------------------------------------------------------------------------------- static int LuaSetLevel( lua_State* L) { // 2 parametri : nId, nLevel int nId ; LuaCheckParam( L, 1, nId) int nLevel ; LuaCheckParam( L, 2, nLevel) // imposto lo stato bool bOk = ( EgtSetLevel( nId, nLevel) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaRevertLevel( lua_State* L) { // 1 parametro : nId int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // porto il livello al valore precedente bool bOk = ( EgtRevertLevel( nId) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetLevel( lua_State* L) { // 1 parametro : nId int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero il livello int nLevel ; bool bOk = ( EgtGetLevel( nId, &nLevel) != FALSE) ; // restituisco il risultato if ( bOk) LuaSetReturn( L, nLevel) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetCalcLevel( lua_State* L) { // 1 parametro : nId int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero il livello int nLevel ; bool bOk = ( EgtGetCalcLevel( nId, &nLevel) != FALSE) ; // restituisco il risultato if ( bOk) LuaSetReturn( L, nLevel) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetMode( lua_State* L) { // 2 parametri : nId, nMode int nId ; LuaCheckParam( L, 1, nId) int nMode ; LuaCheckParam( L, 2, nMode) LuaClearStack( L) ; // imposto il modo bool bOk = ( EgtSetMode( nId, nMode) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaRevertMode( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // porto il modo al valore precedente bool bOk = ( EgtRevertMode( nId) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetMode( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero il modo int nMode ; if ( EgtGetMode( nId, &nMode) != FALSE) // restituisco il risultato LuaSetReturn( L, nMode) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetCalcMode( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero il modo calcolato (ovvero proprio ed ereditato) int nMode ; if ( EgtGetCalcMode( nId, &nMode) != FALSE) // restituisco il risultato LuaSetReturn( L, nMode) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetStatus( lua_State* L) { // 2 parametri : Id, nStatus INTVECTOR vId ; LuaCheckParam( L, 1, vId) int nStatus ; LuaCheckParam( L, 2, nStatus) LuaClearStack( L) ; // imposto lo stato bool bOk = EgtSetStatus( vId, nStatus) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaRevertStatus( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // porto lo stato al valore precedente bool bOk = ( EgtRevertStatus( nId) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetStatus( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero lo stato int nStatus ; if ( EgtGetStatus( nId, &nStatus) != FALSE) // restituisco il risultato LuaSetReturn( L, nStatus) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetCalcStatus( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero lo stato int nStatus ; if ( EgtGetCalcStatus( nId, &nStatus) != FALSE) // restituisco il risultato LuaSetReturn( L, nStatus) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetMark( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // imposto l'evidenziazione bool bOk = ( EgtSetMark( nId) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaResetMark( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // cancello l'evidenziazione bool bOk = ( EgtResetMark( nId) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetMark( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero lo stato di evidenziazione BOOL nMark ; if ( EgtGetMark( nId, &nMark) != FALSE) // restituisco il risultato LuaSetReturn( L, ( nMark != FALSE)) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetCalcMark( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero lo stato calcolato di evidenziazione BOOL nMark ; if ( EgtGetCalcMark( nId, &nMark) != FALSE) // restituisco il risultato LuaSetReturn( L, ( nMark != FALSE)) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaStdColor( lua_State* L) { // 1 parametro : Nome string sName ; LuaCheckParam( L, 1, sName) LuaClearStack( L) ; // recupero il colore con il nome indicato Color cCol ; if ( GetStdColor( sName, cCol)) { // restituisco il risultato LuaSetReturn( L, cCol) ; } else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetColor( lua_State* L) { // 2 o 3 parametri : Id/s, Colore [, bSetAlpha] INTVECTOR vId ; LuaCheckParam( L, 1, vId) Color cCol ; LuaCheckParam( L, 2, cCol) bool bSetAlpha = true ; LuaGetParam( L, 3, bSetAlpha) ; LuaClearStack( L) ; // assegno il colore bool bOk = EgtSetColor( vId, cCol, bSetAlpha) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetAlpha( lua_State* L) { // 2 : Id/s, nAlpha INTVECTOR vId ; LuaCheckParam( L, 1, vId) int nAlpha ; LuaCheckParam( L, 2, nAlpha) LuaClearStack( L) ; // assegno la trasparenza bool bOk = EgtSetAlpha( vId, nAlpha) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaResetColor( lua_State* L) { // 1 parametro : Id/s INTVECTOR vId ; LuaCheckParam( L, 1, vId) LuaClearStack( L) ; // tolgo il colore bool bOk = EgtResetColor( vId) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetColor( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero il colore int vCol[4] ; if ( EgtGetColor( nId, vCol) != FALSE) { Color cCol( vCol) ; // restituisco il risultato LuaSetReturn( L, cCol) ; } else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetCalcColor( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero il colore int vCol[4] ; if ( EgtGetCalcColor( nId, vCol) != FALSE) { Color cCol( vCol) ; // restituisco il risultato LuaSetReturn( L, cCol) ; } else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetName( lua_State* L) { // 2 parametri : Id, Name int nId ; LuaCheckParam( L, 1, nId) string sName ; LuaCheckParam( L, 2, sName) LuaClearStack( L) ; // assegno il nome bool bOk = EgtSetName( nId, sName) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetName( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // recupero il nome string sName ; bool bOk = EgtGetName( nId, sName) ; // restituisco il risultato if ( bOk) LuaSetReturn( L, sName) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaExistsName( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // verifico esistenza nome bool bOk = ( EgtExistsName( nId) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaRemoveName( lua_State* L) { // 1 parametro : Id int nId ; LuaCheckParam( L, 1, nId) LuaClearStack( L) ; // verifico esistenza nome bool bOk = ( EgtRemoveName( nId) != FALSE) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaSetInfo( lua_State* L) { // 3 parametri : Id, Key, Info int nId ; LuaCheckParam( L, 1, nId) string sKey ; LuaCheckParam( L, 2, sKey) string sInfo ; LuaCheckParam( L, 3, sInfo) LuaClearStack( L) ; // assegno la info bool bOk = EgtSetInfo( nId, sKey, sInfo) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaGetInfo( lua_State* L) { // 2 parametri : Id, Key int nId ; LuaCheckParam( L, 1, nId) string sKey ; LuaCheckParam( L, 2, sKey) LuaClearStack( L) ; // recupero l'info string sInfo ; bool bOk = EgtGetInfo( nId, sKey, sInfo) ; // restituisco il risultato if ( bOk) LuaSetReturn( L, sInfo) ; else LuaSetReturn( L) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaExistsInfo( lua_State* L) { // 2 parametri : Id, Key int nId ; LuaCheckParam( L, 1, nId) string sKey ; LuaCheckParam( L, 2, sKey) LuaClearStack( L) ; // verifico esistenza info bool bOk = EgtExistsInfo( nId, sKey) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- static int LuaRemoveInfo( lua_State* L) { // 2 parametri : Id, Key int nId ; LuaCheckParam( L, 1, nId) string sKey ; LuaCheckParam( L, 2, sKey) LuaClearStack( L) ; // rimuovo info bool bOk = EgtRemoveInfo( nId, sKey) ; // restituisco il risultato LuaSetReturn( L, bOk) ; return 1 ; } //------------------------------------------------------------------------------- bool LuaInstallGdbObjAttribs( void) { bool bOk = true ; bOk = bOk && LuaRegisterFunction( "EgtSetLevel", LuaSetLevel) ; bOk = bOk && LuaRegisterFunction( "EgtRevertLevel", LuaRevertLevel) ; bOk = bOk && LuaRegisterFunction( "EgtGetLevel", LuaGetLevel) ; bOk = bOk && LuaRegisterFunction( "EgtGetCalcLevel", LuaGetCalcLevel) ; bOk = bOk && LuaRegisterFunction( "EgtSetMode", LuaSetMode) ; bOk = bOk && LuaRegisterFunction( "EgtRevertMode", LuaRevertMode) ; bOk = bOk && LuaRegisterFunction( "EgtGetMode", LuaGetMode) ; bOk = bOk && LuaRegisterFunction( "EgtGetCalcMode", LuaGetCalcMode) ; bOk = bOk && LuaRegisterFunction( "EgtSetStatus", LuaSetStatus) ; bOk = bOk && LuaRegisterFunction( "EgtRevertStatus", LuaRevertStatus) ; bOk = bOk && LuaRegisterFunction( "EgtGetStatus", LuaGetStatus) ; bOk = bOk && LuaRegisterFunction( "EgtGetCalcStatus", LuaGetCalcStatus) ; bOk = bOk && LuaRegisterFunction( "EgtSetMark", LuaSetMark) ; bOk = bOk && LuaRegisterFunction( "EgtResetMark", LuaResetMark) ; bOk = bOk && LuaRegisterFunction( "EgtGetMark", LuaGetMark) ; bOk = bOk && LuaRegisterFunction( "EgtGetCalcMark", LuaGetCalcMark) ; bOk = bOk && LuaRegisterFunction( "EgtStdColor", LuaStdColor) ; bOk = bOk && LuaRegisterFunction( "EgtSetColor", LuaSetColor) ; bOk = bOk && LuaRegisterFunction( "EgtSetAlpha", LuaSetAlpha) ; bOk = bOk && LuaRegisterFunction( "EgtResetColor", LuaResetColor) ; bOk = bOk && LuaRegisterFunction( "EgtGetColor", LuaGetColor) ; bOk = bOk && LuaRegisterFunction( "EgtGetCalcColor", LuaGetCalcColor) ; bOk = bOk && LuaRegisterFunction( "EgtSetName", LuaSetName) ; bOk = bOk && LuaRegisterFunction( "EgtGetName", LuaGetName) ; bOk = bOk && LuaRegisterFunction( "EgtExistsName", LuaExistsName) ; bOk = bOk && LuaRegisterFunction( "EgtRemoveName", LuaRemoveName) ; bOk = bOk && LuaRegisterFunction( "EgtSetInfo", LuaSetInfo) ; bOk = bOk && LuaRegisterFunction( "EgtGetInfo", LuaGetInfo) ; bOk = bOk && LuaRegisterFunction( "EgtExistsInfo", LuaExistsInfo) ; bOk = bOk && LuaRegisterFunction( "EgtRemoveInfo", LuaRemoveInfo) ; return bOk ; }