diff --git a/API_General.cpp b/API_General.cpp index 80956d7..c56579e 100644 --- a/API_General.cpp +++ b/API_General.cpp @@ -14,7 +14,7 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "API.h" -#include "LUA.h" +#include "LUA_Base.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInDllMain.h" #include "/EgtDev/Include/EGkDllMain.h" diff --git a/API_Lua.cpp b/API_Lua.cpp index 18dd5e4..be9438b 100644 --- a/API_Lua.cpp +++ b/API_Lua.cpp @@ -14,7 +14,7 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "API.h" -#include "LUA.h" +#include "LUA_Base.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EGnStringUtils.h" #include "/EgtDev/Include/EGnStringConverter.h" diff --git a/EgtInterface.rc b/EgtInterface.rc index fa1303d..1420cf0 100644 Binary files a/EgtInterface.rc and b/EgtInterface.rc differ diff --git a/EgtInterface.vcxproj b/EgtInterface.vcxproj index 9aad807..cfdc797 100644 --- a/EgtInterface.vcxproj +++ b/EgtInterface.vcxproj @@ -214,6 +214,8 @@ copy $(TargetPath) \EgtProg\Dll64 + + @@ -243,6 +245,7 @@ copy $(TargetPath) \EgtProg\Dll64 + diff --git a/EgtInterface.vcxproj.filters b/EgtInterface.vcxproj.filters index 10d33a3..a7cc255 100644 --- a/EgtInterface.vcxproj.filters +++ b/EgtInterface.vcxproj.filters @@ -66,6 +66,12 @@ File di intestazione + + File di intestazione + + + File di intestazione + @@ -197,6 +203,9 @@ File di origine\LUA + + File di origine\LUA + diff --git a/LUA.h b/LUA.h index 8313ee9..a3a8344 100644 --- a/LUA.h +++ b/LUA.h @@ -13,99 +13,53 @@ #pragma once -#include -#include "/EgtDev/Include/EgkGeoCollection.h" - -struct lua_State ; -class Vector3d ; -class Point3d ; -class Frame3d ; -class Color ; - //-------------------------- General ----------------------------------------- -bool LuaInit( void) ; -bool LuaExit( void) ; -bool LuaSetLuaLibsDir( const std::string& sDir) ; -bool LuaEvalNumExpr( const std::string& sExpr, double& dVal) ; -bool LuaEvalStringExpr( const std::string& sExpr, std::string& sVal) ; -bool LuaExecLine( const std::string& sLine) ; -bool LuaExecFile( const std::string& sFile) ; -bool LuaRequire( const std::string& sFile) ; -const std::string& LuaGetLastError( void) ; -bool LuaInstallGeneral( lua_State* L) ; - -//-------------------------- Aux --------------------------------------------- -#define LuaCheckParam(L,I,P) { if ( ! LuaGetParam(L,I,P)) return luaL_error( L, " Invalid Parameter # " #I) ;} -bool LuaGetParam( lua_State* L, int nInd, bool& bPar) ; -bool LuaGetParam( lua_State* L, int nInd, int& nPar) ; -bool LuaGetParam( lua_State* L, int nInd, double& dPar) ; -bool LuaGetParam( lua_State* L, int nInd, std::string& sPar) ; -bool LuaGetParam( lua_State* L, int nInd, Vector3d& vtPar) ; -bool LuaGetParam( lua_State* L, int nInd, Point3d& ptPar) ; -bool LuaGetParam( lua_State* L, int nInd, POINTU& ptParW) ; -bool LuaGetParam( lua_State* L, int nInd, Frame3d& frPar) ; -bool LuaGetParam( lua_State* L, int nInd, Color& colPar) ; -bool LuaGetParam( lua_State* L, int nInd, INTVECTOR& vPar) ; -bool LuaGetParam( lua_State* L, int nInd, PNTVECTOR& vPar) ; -bool LuaGetParam( lua_State* L, int nInd, PNTUVECTOR& vParW) ; -bool LuaGetRefType( lua_State* L, int nInd, int& nRefType) ; -bool LuaGetRefId( lua_State* L, int nInd, int& nRefId) ; -bool LuaClearStack( lua_State* L) ; -// -bool LuaSetReturn( lua_State* L /*, nil */) ; -bool LuaSetReturn( lua_State* L, bool bPar) ; -bool LuaSetReturn( lua_State* L, int nPar) ; -bool LuaSetReturn( lua_State* L, double dPar) ; -bool LuaSetReturn( lua_State* L, const std::string& sPar) ; -bool LuaSetReturn( lua_State* L, const Vector3d& vtPar) ; -bool LuaSetReturn( lua_State* L, const Point3d& ptPar) ; -bool LuaSetReturn( lua_State* L, const Frame3d& frPar) ; -bool LuaSetReturn( lua_State* L, const Color& colPar) ; +bool LuaInstallGeneral( void) ; //-------------------------- GeoBase ----------------------------------------- -bool LuaInstallGeoBase( lua_State* L) ; +bool LuaInstallGeoBase( void) ; //-------------------------- GeomDB ------------------------------------------ -bool LuaInstallGeomDB( lua_State* L) ; +bool LuaInstallGeomDB( void) ; //-------------------------- GdbCreate --------------------------------------- -bool LuaInstallGdbCreate( lua_State* L) ; +bool LuaInstallGdbCreate( void) ; //-------------------------- GdbCreateCurve ---------------------------------- -bool LuaInstallGdbCreateCurve( lua_State* L) ; +bool LuaInstallGdbCreateCurve( void) ; //-------------------------- GdbCreateSurf ----------------------------------- -bool LuaInstallGdbCreateSurf( lua_State* L) ; +bool LuaInstallGdbCreateSurf( void) ; //-------------------------- GdbModify --------------------------------------- -bool LuaInstallGdbModify( lua_State* L) ; +bool LuaInstallGdbModify( void) ; //-------------------------- GdbModifyCurve ---------------------------------- -bool LuaInstallGdbModifyCurve( lua_State* L) ; +bool LuaInstallGdbModifyCurve( void) ; //-------------------------- GdbModifySurf ----------------------------------- -bool LuaInstallGdbModifySurf( lua_State* L) ; +bool LuaInstallGdbModifySurf( void) ; //-------------------------- GdbPartLayer ------------------------------------ -bool LuaInstallGdbPartLayer( lua_State* L) ; +bool LuaInstallGdbPartLayer( void) ; //-------------------------- GdbObjects -------------------------------------- -bool LuaInstallGdbObjects( lua_State* L) ; +bool LuaInstallGdbObjects( void) ; //-------------------------- GdbObjSelection --------------------------------- -bool LuaInstallGdbObjSelection( lua_State* L) ; +bool LuaInstallGdbObjSelection( void) ; //-------------------------- GdbObjAttribs ----------------------------------- -bool LuaInstallGdbObjAttribs( lua_State* L) ; +bool LuaInstallGdbObjAttribs( void) ; //-------------------------- GeoSnap ----------------------------------------- -bool LuaInstallGeoSnap( lua_State* L) ; +bool LuaInstallGeoSnap( void) ; //-------------------------- GeoTransform ------------------------------------ -bool LuaInstallGeoTransform( lua_State* L) ; +bool LuaInstallGeoTransform( void) ; //-------------------------- Scene ------------------------------------------- -bool LuaInstallScene( lua_State* L) ; +bool LuaInstallScene( void) ; //-------------------------- Exchange ---------------------------------------- -bool LuaInstallExchange( lua_State* L) ; +bool LuaInstallExchange( void) ; diff --git a/LUA_Aux.cpp b/LUA_Aux.cpp index 2bc4a6e..e9a104e 100644 --- a/LUA_Aux.cpp +++ b/LUA_Aux.cpp @@ -13,267 +13,11 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" +#include "LUA_Aux.h" #include "AuxTools.h" -#include "/EgtDev/Include/EGkFrame3d.h" -#include "/EgtDev/Include/EGkColor.h" -#include "/EgtDev/Include/EInConst.h" -#include "/EgtDev/Include/EGnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, bool& bPar) -{ - if ( ! lua_isboolean( L, nInd)) - return false ; - bPar = ( lua_toboolean( L, nInd) != 0) ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, int& nPar) -{ - if ( ! lua_isnumber( L, nInd)) - return false ; - double dVal = lua_tonumber( L, nInd) ; - nPar = int( dVal + (( dVal > 0) ? 0.5 : - 0.5)) ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, double& dPar) -{ - if ( ! lua_isnumber( L, nInd)) - return false ; - dPar = lua_tonumber( L, nInd) ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, string& sPar) -{ - if ( ! lua_isstring( L, nInd)) - return false ; - sPar = lua_tostring( L, nInd) ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, Vector3d& vtPar) -{ - if ( ! lua_istable( L, nInd)) - return false ; - for ( int i = 1 ; i <= 3 ; ++ i) { - lua_rawgeti( L, nInd, i) ; - if ( ! lua_isnumber( L, -1)) - return false ; - vtPar.v[i-1] = lua_tonumber( L, -1) ; - lua_pop( L, 1) ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, Point3d& ptPar) -{ - if ( ! lua_istable( L, nInd)) - return false ; - for ( int i = 1 ; i <= 3 ; ++ i) { - lua_rawgeti( L, nInd, i) ; - if ( ! lua_isnumber( L, -1)) - return false ; - ptPar.v[i-1] = lua_tonumber( L, -1) ; - lua_pop( L, 1) ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, POINTU& ptParW) -{ - if ( ! lua_istable( L, nInd)) - return false ; - for ( int i = 1 ; i <= 4 ; ++ i) { - lua_rawgeti( L, nInd, i) ; - if ( ! lua_isnumber( L, -1)) - return false ; - if ( i <= 3) - ptParW.first.v[i-1] = lua_tonumber( L, -1) ; - else - ptParW.second = lua_tonumber( L, -1) ; - lua_pop( L, 1) ; - } - - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, Frame3d& frPar) -{ - if ( ! lua_istable( L, nInd)) - return false ; - // recupero l'origine - lua_rawgeti( L, nInd, 1) ; - Point3d ptOrig ; - if ( ! LuaGetParam( L, -1, ptOrig)) - return false ; - lua_pop( L, 1) ; - // recupero il versore X - lua_rawgeti( L, nInd, 2) ; - Vector3d vtDirX ; - if ( ! LuaGetParam( L, -1, vtDirX)) - return false ; - lua_pop( L, 1) ; - // recupero il versore Y - lua_rawgeti( L, nInd, 3) ; - Vector3d vtDirY ; - if ( ! LuaGetParam( L, -1, vtDirY)) - return false ; - lua_pop( L, 1) ; - // recupero il versore Z - lua_rawgeti( L, nInd, 4) ; - Vector3d vtDirZ ; - if ( ! LuaGetParam( L, -1, vtDirZ)) - return false ; - lua_pop( L, 1) ; - // assegno il riferimento - return frPar.Set( ptOrig, vtDirX, vtDirY, vtDirZ) ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, Color& colPar) -{ - if ( ! lua_istable( L, nInd)) - return false ; - int nCol[4] ; - // red, gree, blue - for ( int i = 1 ; i <= 3 ; ++ i) { - lua_rawgeti( L, nInd, i) ; - if ( ! lua_isnumber( L, -1)) - return false ; - nCol[i-1] = int( lua_tonumber( L, -1) + 0.5) ; - lua_pop( L, 1) ; - } - // alpha opzionale - lua_rawgeti( L, nInd, 4) ; - if ( lua_isnumber( L, -1)) - nCol[3] = int( lua_tonumber( L, -1) + 0.5) ; - else - nCol[3] = 100 ; - lua_pop( L, 1) ; - // assegno il colore - colPar.Set( nCol[0], nCol[1], nCol[2], nCol[3]) ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, INTVECTOR& vPar) -{ - vPar.clear() ; - if ( lua_isnumber( L, nInd)) { - int nVal = int( lua_tointeger( L, nInd)) ; - vPar.push_back( nVal) ; - return true ; - } - else if ( lua_istable( L, nInd)) { - // lunghezza della tavola - lua_len( L, nInd) ; - if ( ! lua_isnumber( L, -1)) - return false ; - int nLen = int( lua_tointeger( L, -1)) ; - lua_pop( L, 1) ; - vPar.reserve( nLen) ; - for ( int i = 1 ; i <= nLen ; ++ i) { - lua_rawgeti( L, nInd, i) ; - if ( ! lua_isnumber( L, -1)) - return false ; - int nVal = int( lua_tointeger( L, -1)) ; - vPar.push_back( nVal) ; - lua_pop( L, 1) ; - } - return true ; - } - else - return false ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, PNTVECTOR& vPar) -{ - vPar.clear() ; - Point3d ptP ; - if ( LuaGetParam( L, nInd, ptP)) { - vPar.push_back( ptP) ; - return true ; - } - else if ( lua_istable( L, nInd)) { - // lunghezza della tavola - lua_len( L, nInd) ; - if ( ! lua_isnumber( L, -1)) - return false ; - int nLen = int( lua_tointeger( L, -1)) ; - lua_pop( L, 1) ; - vPar.reserve( nLen) ; - for ( int i = 1 ; i <= nLen ; ++ i) { - lua_rawgeti( L, nInd, i) ; - Point3d ptP ; - if ( ! LuaGetParam( L, -1, ptP)) - return false ; - vPar.push_back( ptP) ; - lua_pop( L, 1) ; - } - return true ; - } - else - return false ; -} - -//---------------------------------------------------------------------------- -bool -LuaGetParam( lua_State* L, int nInd, PNTUVECTOR& vParW) -{ - vParW.clear() ; - POINTU ptPW ; - if ( LuaGetParam( L, nInd, ptPW)) { - vParW.push_back( ptPW) ; - return true ; - } - else if ( lua_istable( L, nInd)) { - // lunghezza della tavola - lua_len( L, nInd) ; - if ( ! lua_isnumber( L, -1)) - return false ; - int nLen = int( lua_tointeger( L, -1)) ; - lua_pop( L, 1) ; - vParW.reserve( nLen) ; - for ( int i = 1 ; i <= nLen ; ++ i) { - lua_rawgeti( L, nInd, i) ; - POINTU ptPW ; - if ( ! LuaGetParam( L, -1, ptPW)) - return false ; - vParW.push_back( ptPW) ; - lua_pop( L, 1) ; - } - return true ; - } - else - return false ; -} - //---------------------------------------------------------------------------- bool LuaGetRefType( lua_State* L, int nInd, int& nRefType) @@ -303,187 +47,3 @@ LuaGetRefId( lua_State* L, int nInd, int& nRefId) // non trovato return false ; } - -//---------------------------------------------------------------------------- -bool -LuaClearStack( lua_State* L) -{ - int n = lua_gettop( L) ; - if ( n > 0) - lua_pop( L, n) ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L) -{ - try { - lua_pushnil( L) ; - } - catch ( ...) { - return false ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, bool bPar) -{ - try { - lua_pushboolean( L, ( bPar ? 1 : 0)) ; - } - catch ( ...) { - return false ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, int nPar) -{ - try { - lua_pushinteger( L, nPar) ; - } - catch ( ...) { - return false ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, double dPar) -{ - try { - lua_pushnumber( L, dPar) ; - } - catch ( ...) { - return false ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, const string& sPar) -{ - try { - lua_pushstring( L, sPar.c_str()) ; - } - catch ( ...) { - return false ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, const Vector3d& vtPar) -{ - try { - lua_createtable( L, 3, 0) ; - for ( int i = 1 ; i <= 3 ; ++ i) { - lua_pushnumber( L, vtPar.v[i-1]) ; - lua_rawseti( L, -2, i) ; - } - } - catch( ...) { - return false ; - } - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, const Point3d& ptPar) -{ - try { - lua_createtable( L, 3, 0) ; - for ( int i = 1 ; i <= 3 ; ++ i) { - lua_pushnumber( L, ptPar.v[i-1]) ; - lua_rawseti( L, -2, i) ; - } - } - catch( ...) { - return false ; - } - return true ; -} - -//------------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, const Frame3d& frPar) -{ - try { - // creo tavola per frame - lua_createtable( L, 4, 0) ; - // creo tavola per origine - lua_createtable( L, 3, 0) ; - lua_pushnumber( L, frPar.Orig().x) ; - lua_rawseti( L, -2, 1) ; - lua_pushnumber( L, frPar.Orig().y) ; - lua_rawseti( L, -2, 2) ; - lua_pushnumber( L, frPar.Orig().z) ; - lua_rawseti( L, -2, 3) ; - // la metto nel frame - lua_rawseti( L, -2, 1) ; - // creo tavola per versore X - lua_createtable( L, 3, 0) ; - lua_pushnumber( L, frPar.VersX().x) ; - lua_rawseti( L, -2, 1) ; - lua_pushnumber( L, frPar.VersX().y) ; - lua_rawseti( L, -2, 2) ; - lua_pushnumber( L, frPar.VersX().z) ; - lua_rawseti( L, -2, 3) ; - // la metto nel frame - lua_rawseti( L, -2, 2) ; - // creo tavola per versore Y - lua_createtable( L, 3, 0) ; - lua_pushnumber( L, frPar.VersY().x) ; - lua_rawseti( L, -2, 1) ; - lua_pushnumber( L, frPar.VersY().y) ; - lua_rawseti( L, -2, 2) ; - lua_pushnumber( L, frPar.VersY().z) ; - lua_rawseti( L, -2, 3) ; - // la metto nel frame - lua_rawseti( L, -2, 3) ; - // creo tavola per versore Z - lua_createtable( L, 3, 0) ; - lua_pushnumber( L, frPar.VersZ().x) ; - lua_rawseti( L, -2, 1) ; - lua_pushnumber( L, frPar.VersZ().y) ; - lua_rawseti( L, -2, 2) ; - lua_pushnumber( L, frPar.VersZ().z) ; - lua_rawseti( L, -2, 3) ; - // la metto nel frame - lua_rawseti( L, -2, 4) ; - } - catch( ...) { - return false ; - } - return true ; -} - -//------------------------------------------------------------------------------- -bool -LuaSetReturn( lua_State* L, const Color& colPar) -{ - try { - lua_createtable( L, 4, 0) ; - lua_pushinteger( L, colPar.GetIntRed()) ; - lua_rawseti( L, -2, 1) ; - lua_pushinteger( L, colPar.GetIntGreen()) ; - lua_rawseti( L, -2, 2) ; - lua_pushinteger( L, colPar.GetIntBlue()) ; - lua_rawseti( L, -2, 3) ; - lua_pushinteger( L, colPar.GetIntAlpha()) ; - lua_rawseti( L, -2, 4) ; - } - catch( ...) { - return false ; - } - return true ; -} diff --git a/LUA_Aux.h b/LUA_Aux.h new file mode 100644 index 0000000..b7ce74e --- /dev/null +++ b/LUA_Aux.h @@ -0,0 +1,20 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : LUA_Aux.h Data : 21.03.15 Versione : 1.6c6 +// Contenuto : Dichiarazione funzioni ausiliarielocali per LUA. +// +// +// +// Modifiche : 21.03.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "/EgtDev/Include/EgkLuaAux.h" + +//---------------------------------------------------------------------------- +bool LuaGetRefType( lua_State* L, int nInd, int& nRefType) ; +bool LuaGetRefId( lua_State* L, int nInd, int& nRefId) ; diff --git a/LUA_Base.cpp b/LUA_Base.cpp new file mode 100644 index 0000000..53e3063 --- /dev/null +++ b/LUA_Base.cpp @@ -0,0 +1,177 @@ +//---------------------------------------------------------------------------- +// EgalTech 2014-2014 +//---------------------------------------------------------------------------- +// File : LUA_General.cpp Data : 27.09.14 Versione : 1.5i5 +// Contenuto : Funzioni generali per LUA. +// +// +// +// Modifiche : 27.09.14 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "/EgtDev/Include/EGnLuaMgr.h" + +using namespace std ; + +//---------------------------------------------------------------------------- +static LuaMgr s_LuaMgr ; + +//---------------------------------------------------------------------------- +bool +LuaInit( void) +{ + // inizializzo l'interprete lua + if ( ! s_LuaMgr.Init()) + return false ; + + // carico le funzioni speciali + if ( ! LuaInstallGeneral()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGeneral (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGeoBase()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGeoBase (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGeomDB()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGeomDB (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbCreate()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbCreate (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbCreateCurve()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbCreateCurve (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbCreateSurf()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbCreateSurf (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbModify()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbModify (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbModifyCurve()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbModifyCurve (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbModifySurf()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbModifySurf (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbPartLayer()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbPartLayer (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbObjects()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjects (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbObjSelection()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjSelection (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGdbObjAttribs()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjAttribs (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGeoSnap()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGeoSnap (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallGeoTransform()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallGeoTransform (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallScene()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallScene (" __FUNCTION__ ")") + return false ; + } + if ( ! LuaInstallExchange()) { + LOG_ERROR( GetLogger(), "Error in LuaInstallExchange (" __FUNCTION__ ")") + return false ; + } + + // recupero la versione di Lua + string sLua ; + if ( s_LuaMgr.GetVersion( sLua)) + sLua += " interpreter started" ; + else + sLua = "Lua *.* interpreter started" ; + LOG_INFO( GetLogger(), sLua.c_str()) + return true ; +} + +//---------------------------------------------------------------------------- +bool +LuaExit( void) +{ + s_LuaMgr.Exit() ; + LOG_INFO( GetLogger(), "Lua interpreter closed") + return true ; +} + +//---------------------------------------------------------------------------- +bool +LuaSetLuaLibsDir( const string& sDir) +{ + return s_LuaMgr.SetLuaLibsDir( sDir) ; +} + +//---------------------------------------------------------------------------- +bool +LuaRequire( const string& sFile) +{ + return s_LuaMgr.Require( sFile) ; +} + +//---------------------------------------------------------------------------- +bool +LuaRegisterFunction( const std::string& sFunName, PFLUA pFun) +{ + return s_LuaMgr.RegisterFunction( sFunName, pFun) ; +} + +//---------------------------------------------------------------------------- +bool +LuaEvalNumExpr( const string& sExpr, double& dVal) +{ + return s_LuaMgr.EvalNumExpr( sExpr, dVal) ; +} + +//---------------------------------------------------------------------------- +bool +LuaEvalStringExpr( const string& sExpr, string& sVal) +{ + return s_LuaMgr.EvalStringExpr( sExpr, sVal) ; +} + +//---------------------------------------------------------------------------- +bool +LuaExecLine( const string& sLine) +{ + return s_LuaMgr.ExecLine( sLine) ; +} + +//---------------------------------------------------------------------------- +bool +LuaExecFile( const string& sFile) +{ + return s_LuaMgr.ExecFile( sFile) ; +} + +//---------------------------------------------------------------------------- +const string& +LuaGetLastError( void) +{ + return s_LuaMgr.GetLastError() ; +} diff --git a/LUA_Base.h b/LUA_Base.h new file mode 100644 index 0000000..a097336 --- /dev/null +++ b/LUA_Base.h @@ -0,0 +1,32 @@ +//---------------------------------------------------------------------------- +// EgalTech 2015-2015 +//---------------------------------------------------------------------------- +// File : LUA_Base.h Data : 21.03.15 Versione : 1.6c6 +// Contenuto : Dichiarazioni per funzioni di base gestione LUA. +// +// +// +// Modifiche : 21.03.15 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include + +//---------------------------------------------------------------------------- +struct lua_State ; +typedef int(*PFLUA) ( lua_State*) ; + +//---------------------------------------------------------------------------- +bool LuaInit( void) ; +bool LuaExit( void) ; +bool LuaSetLuaLibsDir( const std::string& sDir) ; +bool LuaRequire( const std::string& sFile) ; +bool LuaRegisterFunction( const std::string& sFunName, PFLUA pFun) ; +bool LuaEvalNumExpr( const std::string& sExpr, double& dVal) ; +bool LuaEvalStringExpr( const std::string& sExpr, std::string& sVal) ; +bool LuaExecLine( const std::string& sLine) ; +bool LuaExecFile( const std::string& sFile) ; +const std::string& LuaGetLastError( void) ; diff --git a/LUA_Exchange.cpp b/LUA_Exchange.cpp index ed54e6a..cde67ee 100644 --- a/LUA_Exchange.cpp +++ b/LUA_Exchange.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -103,17 +104,13 @@ LuaExportStl( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallExchange( lua_State* L) +LuaInstallExchange( void) { - try { - lua_register( L, "EgtImportDxf", LuaImportDxf) ; - lua_register( L, "EgtImportStl", LuaImportStl) ; - lua_register( L, "EgtImportCnc", LuaImportCnc) ; - lua_register( L, "EgtExportDxf", LuaExportDxf) ; - lua_register( L, "EgtExportStl", LuaExportStl) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtImportDxf", LuaImportDxf) ; + bOk = bOk && LuaRegisterFunction( "EgtImportStl", LuaImportStl) ; + bOk = bOk && LuaRegisterFunction( "EgtImportCnc", LuaImportCnc) ; + bOk = bOk && LuaRegisterFunction( "EgtExportDxf", LuaExportDxf) ; + bOk = bOk && LuaRegisterFunction( "EgtExportStl", LuaExportStl) ; + return bOk ; } diff --git a/LUA_GdbCreate.cpp b/LUA_GdbCreate.cpp index ebda20c..d56c565 100644 --- a/LUA_GdbCreate.cpp +++ b/LUA_GdbCreate.cpp @@ -13,14 +13,15 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "AuxTools.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInConst.h" #include "/EgtDev/Include/EGkExtText.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -233,19 +234,15 @@ LuaCreateTextAdv( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbCreate( lua_State* L) +LuaInstallGdbCreate( void) { - try { - lua_register( L, "EgtGroup", LuaCreateGroup) ; - lua_register( L, "EgtPoint", LuaCreateGeoPoint) ; - lua_register( L, "EgtVector", LuaCreateGeoVector) ; - lua_register( L, "EgtFrame", LuaCreateGeoFrame) ; - lua_register( L, "EgtText", LuaCreateText) ; - lua_register( L, "EgtTextEx", LuaCreateTextEx) ; - lua_register( L, "EgtTextAdv", LuaCreateTextAdv) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtGroup", LuaCreateGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtPoint", LuaCreateGeoPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtVector", LuaCreateGeoVector) ; + bOk = bOk && LuaRegisterFunction( "EgtFrame", LuaCreateGeoFrame) ; + bOk = bOk && LuaRegisterFunction( "EgtText", LuaCreateText) ; + bOk = bOk && LuaRegisterFunction( "EgtTextEx", LuaCreateTextEx) ; + bOk = bOk && LuaRegisterFunction( "EgtTextAdv", LuaCreateTextAdv) ; + return bOk ; } diff --git a/LUA_GdbCreateCurve.cpp b/LUA_GdbCreateCurve.cpp index 00211bd..54273ab 100644 --- a/LUA_GdbCreateCurve.cpp +++ b/LUA_GdbCreateCurve.cpp @@ -13,14 +13,15 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "AuxTools.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInConst.h" #include "/EgtDev/Include/EgkPolyLine.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -808,40 +809,36 @@ LuaCreatePolygonFromSide( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbCreateCurve( lua_State* L) +LuaInstallGdbCreateCurve( void) { - try { - lua_register( L, "EgtLine", LuaCreateCurveLine) ; - lua_register( L, "EgtLineEx", LuaCreateCurveLineEx) ; - lua_register( L, "EgtLinePVL", LuaCreateCurveLinePVL) ; - lua_register( L, "EgtLineMinPointCurve", LuaCreateCurveLineMinPointCurve) ; - lua_register( L, "EgtCircle", LuaCreateCurveCircle) ; - lua_register( L, "EgtCircleCPN", LuaCreateCurveCircleCPN) ; - lua_register( L, "EgtCircleCPNEx", LuaCreateCurveCircleCPNEx) ; - lua_register( L, "EgtCircle3P", LuaCreateCurveCircle3P) ; - lua_register( L, "EgtArc", LuaCreateCurveArc) ; - lua_register( L, "EgtArcC2PN", LuaCreateCurveArcC2PN) ; - lua_register( L, "EgtArcC2PNEx", LuaCreateCurveArcC2PNEx) ; - lua_register( L, "EgtArc3P", LuaCreateCurveArc3P) ; - lua_register( L, "EgtArc2PVN", LuaCreateCurveArc2PVN) ; - lua_register( L, "EgtArc2PVNEx", LuaCreateCurveArc2PVNEx) ; - lua_register( L, "EgtCurveFillet", LuaCreateCurveFillet) ; - lua_register( L, "EgtCurveChamfer", LuaCreateCurveChamfer) ; - lua_register( L, "EgtCurveBezier", LuaCreateCurveBezier) ; - lua_register( L, "EgtCurveBezierRat", LuaCreateCurveBezierRational) ; - lua_register( L, "EgtCurveBezierFromArc", LuaCreateCurveBezierFromArc) ; - lua_register( L, "EgtCurveCompo", LuaCreateCurveCompo) ; - lua_register( L, "EgtCurveCompoByChain", LuaCreateCurveCompoByChain) ; - lua_register( L, "EgtCurveCompoFromPoints", LuaCreateCurveCompoFromPoints) ; - lua_register( L, "EgtCurveCompoFromPointBulges", LuaCreateCurveCompoFromPointBulges) ; - lua_register( L, "EgtCurveCompoByApprox", LuaCreateCurveCompoByApprox) ; - lua_register( L, "EgtRectangle3P", LuaCreateRectangle3P) ; - lua_register( L, "EgtPolygonFromRadius", LuaCreatePolygonFromRadius) ; - lua_register( L, "EgtPolygonFromApothem", LuaCreatePolygonFromApothem) ; - lua_register( L, "EgtPolygonFromSide", LuaCreatePolygonFromSide) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtLine", LuaCreateCurveLine) ; + bOk = bOk && LuaRegisterFunction( "EgtLineEx", LuaCreateCurveLineEx) ; + bOk = bOk && LuaRegisterFunction( "EgtLinePVL", LuaCreateCurveLinePVL) ; + bOk = bOk && LuaRegisterFunction( "EgtLineMinPointCurve", LuaCreateCurveLineMinPointCurve) ; + bOk = bOk && LuaRegisterFunction( "EgtCircle", LuaCreateCurveCircle) ; + bOk = bOk && LuaRegisterFunction( "EgtCircleCPN", LuaCreateCurveCircleCPN) ; + bOk = bOk && LuaRegisterFunction( "EgtCircleCPNEx", LuaCreateCurveCircleCPNEx) ; + bOk = bOk && LuaRegisterFunction( "EgtCircle3P", LuaCreateCurveCircle3P) ; + bOk = bOk && LuaRegisterFunction( "EgtArc", LuaCreateCurveArc) ; + bOk = bOk && LuaRegisterFunction( "EgtArcC2PN", LuaCreateCurveArcC2PN) ; + bOk = bOk && LuaRegisterFunction( "EgtArcC2PNEx", LuaCreateCurveArcC2PNEx) ; + bOk = bOk && LuaRegisterFunction( "EgtArc3P", LuaCreateCurveArc3P) ; + bOk = bOk && LuaRegisterFunction( "EgtArc2PVN", LuaCreateCurveArc2PVN) ; + bOk = bOk && LuaRegisterFunction( "EgtArc2PVNEx", LuaCreateCurveArc2PVNEx) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveFillet", LuaCreateCurveFillet) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveChamfer", LuaCreateCurveChamfer) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveBezier", LuaCreateCurveBezier) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveBezierRat", LuaCreateCurveBezierRational) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveBezierFromArc", LuaCreateCurveBezierFromArc) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveCompo", LuaCreateCurveCompo) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveCompoByChain", LuaCreateCurveCompoByChain) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveCompoFromPoints", LuaCreateCurveCompoFromPoints) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveCompoFromPointBulges", LuaCreateCurveCompoFromPointBulges) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveCompoByApprox", LuaCreateCurveCompoByApprox) ; + bOk = bOk && LuaRegisterFunction( "EgtRectangle3P", LuaCreateRectangle3P) ; + bOk = bOk && LuaRegisterFunction( "EgtPolygonFromRadius", LuaCreatePolygonFromRadius) ; + bOk = bOk && LuaRegisterFunction( "EgtPolygonFromApothem", LuaCreatePolygonFromApothem) ; + bOk = bOk && LuaRegisterFunction( "EgtPolygonFromSide", LuaCreatePolygonFromSide) ; + return bOk ; } diff --git a/LUA_GdbCreateSurf.cpp b/LUA_GdbCreateSurf.cpp index 9872690..2269077 100644 --- a/LUA_GdbCreateSurf.cpp +++ b/LUA_GdbCreateSurf.cpp @@ -13,13 +13,14 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInConst.h" #include "/EgtDev/Include/EgkPolyLine.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -268,21 +269,17 @@ LuaCreateSurfTmBySewing( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbCreateSurf( lua_State* L) +LuaInstallGdbCreateSurf( void) { - try { - lua_register( L, "EgtSurfTmByFlatContour", LuaCreateSurfTmByFlatContour) ; - lua_register( L, "EgtSurfTmByRegion", LuaCreateSurfTmByRegion) ; - lua_register( L, "EgtSurfTmByExtrusion", LuaCreateSurfTmByExtrusion) ; - lua_register( L, "EgtSurfTmByRegionExtrusion", LuaCreateSurfTmByRegionExtrusion) ; - lua_register( L, "EgtSurfTmByRevolve", LuaCreateSurfTmByRevolve) ; - lua_register( L, "EgtSurfTmByScrewing", LuaCreateSurfTmByScrewing) ; - lua_register( L, "EgtSurfTmRuled", LuaCreateSurfTmRuled) ; - lua_register( L, "EgtSurfTmByTriangles", LuaCreateSurfTmByTriangles) ; - lua_register( L, "EgtSurfTmBySewing", LuaCreateSurfTmBySewing) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmByFlatContour", LuaCreateSurfTmByFlatContour) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmByRegion", LuaCreateSurfTmByRegion) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmByExtrusion", LuaCreateSurfTmByExtrusion) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmByRegionExtrusion", LuaCreateSurfTmByRegionExtrusion) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmByRevolve", LuaCreateSurfTmByRevolve) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmByScrewing", LuaCreateSurfTmByScrewing) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmRuled", LuaCreateSurfTmRuled) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmByTriangles", LuaCreateSurfTmByTriangles) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmBySewing", LuaCreateSurfTmBySewing) ; + return bOk ; } diff --git a/LUA_GdbModify.cpp b/LUA_GdbModify.cpp index 5fbaabe..d92ae9e 100644 --- a/LUA_GdbModify.cpp +++ b/LUA_GdbModify.cpp @@ -13,12 +13,13 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInConst.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -156,20 +157,16 @@ LuaSplitText( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbModify( lua_State* L) +LuaInstallGdbModify( void) { - try { - lua_register( L, "EgtChangeGroupFrame", LuaChangeGroupFrame) ; - lua_register( L, "EgtChangeVectorBase", LuaChangeVectorBase) ; - lua_register( L, "EgtModifyText", LuaModifyText) ; - lua_register( L, "EgtChangeTextFont", LuaChangeTextFont) ; - lua_register( L, "EgtFlipText", LuaFlipText) ; - lua_register( L, "EgtMirrorText", LuaMirrorText) ; - lua_register( L, "EgtExplodeText", LuaExplodeText) ; - lua_register( L, "EgtSplitText", LuaSplitText) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtChangeGroupFrame", LuaChangeGroupFrame) ; + bOk = bOk && LuaRegisterFunction( "EgtChangeVectorBase", LuaChangeVectorBase) ; + bOk = bOk && LuaRegisterFunction( "EgtModifyText", LuaModifyText) ; + bOk = bOk && LuaRegisterFunction( "EgtChangeTextFont", LuaChangeTextFont) ; + bOk = bOk && LuaRegisterFunction( "EgtFlipText", LuaFlipText) ; + bOk = bOk && LuaRegisterFunction( "EgtMirrorText", LuaMirrorText) ; + bOk = bOk && LuaRegisterFunction( "EgtExplodeText", LuaExplodeText) ; + bOk = bOk && LuaRegisterFunction( "EgtSplitText", LuaSplitText) ; + return bOk ; } diff --git a/LUA_GdbModifyCurve.cpp b/LUA_GdbModifyCurve.cpp index 3b088c3..8d2f117 100644 --- a/LUA_GdbModifyCurve.cpp +++ b/LUA_GdbModifyCurve.cpp @@ -13,13 +13,14 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInConst.h" #include "/EgtDev/Include/EGkCurve.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -344,30 +345,26 @@ LuaExplodeCurveBezier( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbModifyCurve( lua_State* L) +LuaInstallGdbModifyCurve( void) { - try { - lua_register( L, "EgtInvertCurve", LuaInvertCurve) ; - lua_register( L, "EgtOffsetCurve", LuaOffsetCurve) ; - lua_register( L, "EgtChangeClosedCurveStartPoint", LuaChangeClosedCurveStartPoint) ; - lua_register( L, "EgtModifyCurveStartPoint", LuaModifyCurveStartPoint) ; - lua_register( L, "EgtModifyCurveEndPoint", LuaModifyCurveEndPoint) ; - lua_register( L, "EgtModifyCurveExtrusion", LuaModifyCurveExtrusion) ; - lua_register( L, "EgtModifyCurveThickness", LuaModifyCurveThickness) ; - lua_register( L, "EgtTrimCurveStartAtLen", LuaTrimCurveStartAtLen) ; - lua_register( L, "EgtTrimCurveEndAtLen", LuaTrimCurveEndAtLen) ; - lua_register( L, "EgtTrimCurveStartAtParam", LuaTrimCurveStartAtParam) ; - lua_register( L, "EgtTrimCurveEndAtParam", LuaTrimCurveEndAtParam) ; - lua_register( L, "EgtTrimCurveStartEndAtParam", LuaTrimCurveStartEndAtParam) ; - lua_register( L, "EgtTrimExtendCurveByLen", LuaTrimExtendCurveByLen) ; - lua_register( L, "EgtSplitCurve", LuaSplitCurve) ; - lua_register( L, "EgtSplitCurveAtPoint", LuaSplitCurveAtPoint) ; - lua_register( L, "EgtModifyCurveArcRadius", LuaModifyCurveArcRadius) ; - lua_register( L, "EgtExplodeCurveCompo", LuaExplodeCurveCompo) ; - lua_register( L, "EgtExplodeCurveBezier", LuaExplodeCurveBezier) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtInvertCurve", LuaInvertCurve) ; + bOk = bOk && LuaRegisterFunction( "EgtOffsetCurve", LuaOffsetCurve) ; + bOk = bOk && LuaRegisterFunction( "EgtChangeClosedCurveStartPoint", LuaChangeClosedCurveStartPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtModifyCurveStartPoint", LuaModifyCurveStartPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtModifyCurveEndPoint", LuaModifyCurveEndPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtModifyCurveExtrusion", LuaModifyCurveExtrusion) ; + bOk = bOk && LuaRegisterFunction( "EgtModifyCurveThickness", LuaModifyCurveThickness) ; + bOk = bOk && LuaRegisterFunction( "EgtTrimCurveStartAtLen", LuaTrimCurveStartAtLen) ; + bOk = bOk && LuaRegisterFunction( "EgtTrimCurveEndAtLen", LuaTrimCurveEndAtLen) ; + bOk = bOk && LuaRegisterFunction( "EgtTrimCurveStartAtParam", LuaTrimCurveStartAtParam) ; + bOk = bOk && LuaRegisterFunction( "EgtTrimCurveEndAtParam", LuaTrimCurveEndAtParam) ; + bOk = bOk && LuaRegisterFunction( "EgtTrimCurveStartEndAtParam", LuaTrimCurveStartEndAtParam) ; + bOk = bOk && LuaRegisterFunction( "EgtTrimExtendCurveByLen", LuaTrimExtendCurveByLen) ; + bOk = bOk && LuaRegisterFunction( "EgtSplitCurve", LuaSplitCurve) ; + bOk = bOk && LuaRegisterFunction( "EgtSplitCurveAtPoint", LuaSplitCurveAtPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtModifyCurveArcRadius", LuaModifyCurveArcRadius) ; + bOk = bOk && LuaRegisterFunction( "EgtExplodeCurveCompo", LuaExplodeCurveCompo) ; + bOk = bOk && LuaRegisterFunction( "EgtExplodeCurveBezier", LuaExplodeCurveBezier) ; + return bOk ; } diff --git a/LUA_GdbModifySurf.cpp b/LUA_GdbModifySurf.cpp index e83afe0..0d05a20 100644 --- a/LUA_GdbModifySurf.cpp +++ b/LUA_GdbModifySurf.cpp @@ -13,12 +13,13 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInConst.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -62,14 +63,10 @@ LuaExtractSurfTmFacetLoops( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbModifySurf( lua_State* L) +LuaInstallGdbModifySurf( void) { - try { - lua_register( L, "EgtInvertSurf", LuaInvertSurf) ; - lua_register( L, "EgtExtractSurfTmFacetLoops", LuaExtractSurfTmFacetLoops) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtInvertSurf", LuaInvertSurf) ; + bOk = bOk && LuaRegisterFunction( "EgtExtractSurfTmFacetLoops", LuaExtractSurfTmFacetLoops) ; + return bOk ; } diff --git a/LUA_GdbObjAttribs.cpp b/LUA_GdbObjAttribs.cpp index e0b8232..8985118 100644 --- a/LUA_GdbObjAttribs.cpp +++ b/LUA_GdbObjAttribs.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -561,42 +562,38 @@ LuaRemoveInfo( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbObjAttribs( lua_State* L) +LuaInstallGdbObjAttribs( void) { - try { - lua_register( L, "EgtSetLevel", LuaSetLevel) ; - lua_register( L, "EgtRevertLevel", LuaRevertLevel) ; - lua_register( L, "EgtGetLevel", LuaGetLevel) ; - lua_register( L, "EgtGetCalcLevel", LuaGetCalcLevel) ; - lua_register( L, "EgtSetMode", LuaSetMode) ; - lua_register( L, "EgtRevertMode", LuaRevertMode) ; - lua_register( L, "EgtGetMode", LuaGetMode) ; - lua_register( L, "EgtGetCalcMode", LuaGetCalcMode) ; - lua_register( L, "EgtSetStatus", LuaSetStatus) ; - lua_register( L, "EgtRevertStatus", LuaRevertStatus) ; - lua_register( L, "EgtGetStatus", LuaGetStatus) ; - lua_register( L, "EgtGetCalcStatus", LuaGetCalcStatus) ; - lua_register( L, "EgtSetMark", LuaSetMark) ; - lua_register( L, "EgtResetMark", LuaResetMark) ; - lua_register( L, "EgtGetMark", LuaGetMark) ; - lua_register( L, "EgtGetCalcMark", LuaGetCalcMark) ; - lua_register( L, "EgtStdColor", LuaStdColor) ; - lua_register( L, "EgtSetColor", LuaSetColor) ; - lua_register( L, "EgtSetAlpha", LuaSetAlpha) ; - lua_register( L, "EgtResetColor", LuaResetColor) ; - lua_register( L, "EgtGetColor", LuaGetColor) ; - lua_register( L, "EgtGetCalcColor", LuaGetCalcColor) ; - lua_register( L, "EgtSetName", LuaSetName) ; - lua_register( L, "EgtGetName", LuaGetName) ; - lua_register( L, "EgtExistsName", LuaExistsName) ; - lua_register( L, "EgtRemoveName", LuaRemoveName) ; - lua_register( L, "EgtSetInfo", LuaSetInfo) ; - lua_register( L, "EgtGetInfo", LuaGetInfo) ; - lua_register( L, "EgtExistsInfo", LuaExistsInfo) ; - lua_register( L, "EgtRemoveInfo", LuaRemoveInfo) ; - } - catch ( ...) { - return false ; - } - return true ; + 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 ; } diff --git a/LUA_GdbObjSelection.cpp b/LUA_GdbObjSelection.cpp index 0263be3..0b5e696 100644 --- a/LUA_GdbObjSelection.cpp +++ b/LUA_GdbObjSelection.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -203,24 +204,20 @@ LuaGetPrevSelectedObj( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbObjSelection( lua_State* L) +LuaInstallGdbObjSelection( void) { - try { - lua_register( L, "EgtSelectObj", LuaSelectObj) ; - lua_register( L, "EgtDeselectObj", LuaDeselectObj) ; - lua_register( L, "EgtSelectAll", LuaSelectAll) ; - lua_register( L, "EgtDeselectAll", LuaDeselectAll) ; - lua_register( L, "EgtSelectGroupObjs", LuaSelectGroupObjs) ; - lua_register( L, "EgtDeselectGroupObjs", LuaDeselectGroupObjs) ; - lua_register( L, "EgtIsSelectedObj", LuaIsSelectedObj) ; - lua_register( L, "EgtGetSelectedObjNbr", LuaGetSelectedObjNbr) ; - lua_register( L, "EgtGetFirstSelectedObj", LuaGetFirstSelectedObj) ; - lua_register( L, "EgtGetNextSelectedObj", LuaGetNextSelectedObj) ; - lua_register( L, "EgtGetLastSelectedObj", LuaGetLastSelectedObj) ; - lua_register( L, "EgtGetPrevSelectedObj", LuaGetPrevSelectedObj) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtSelectObj", LuaSelectObj) ; + bOk = bOk && LuaRegisterFunction( "EgtDeselectObj", LuaDeselectObj) ; + bOk = bOk && LuaRegisterFunction( "EgtSelectAll", LuaSelectAll) ; + bOk = bOk && LuaRegisterFunction( "EgtDeselectAll", LuaDeselectAll) ; + bOk = bOk && LuaRegisterFunction( "EgtSelectGroupObjs", LuaSelectGroupObjs) ; + bOk = bOk && LuaRegisterFunction( "EgtDeselectGroupObjs", LuaDeselectGroupObjs) ; + bOk = bOk && LuaRegisterFunction( "EgtIsSelectedObj", LuaIsSelectedObj) ; + bOk = bOk && LuaRegisterFunction( "EgtGetSelectedObjNbr", LuaGetSelectedObjNbr) ; + bOk = bOk && LuaRegisterFunction( "EgtGetFirstSelectedObj", LuaGetFirstSelectedObj) ; + bOk = bOk && LuaRegisterFunction( "EgtGetNextSelectedObj", LuaGetNextSelectedObj) ; + bOk = bOk && LuaRegisterFunction( "EgtGetLastSelectedObj", LuaGetLastSelectedObj) ; + bOk = bOk && LuaRegisterFunction( "EgtGetPrevSelectedObj", LuaGetPrevSelectedObj) ; + return bOk ; } diff --git a/LUA_GdbObjects.cpp b/LUA_GdbObjects.cpp index d648e6c..073d086 100644 --- a/LUA_GdbObjects.cpp +++ b/LUA_GdbObjects.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -327,27 +328,23 @@ LuaEmptyGroup( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbObjects( lua_State* L) +LuaInstallGdbObjects( void) { - try { - lua_register( L, "EgtExistsObj", LuaExistsObj) ; - lua_register( L, "EgtGetGroupObjs", LuaGetGroupObjs) ; - lua_register( L, "EgtGetFirstInGroup", LuaGetFirstInGroup) ; - lua_register( L, "EgtGetNext", LuaGetNext) ; - lua_register( L, "EgtGetLastInGroup", LuaGetLastInGroup) ; - lua_register( L, "EgtGetPrev", LuaGetPrev) ; - lua_register( L, "EgtGetFirstNameInGroup", LuaGetFirstNameInGroup) ; - lua_register( L, "EgtGetNextName", LuaGetNextName) ; - lua_register( L, "EgtCopy", LuaCopy) ; - lua_register( L, "EgtCopyGlob", LuaCopyGlob) ; - lua_register( L, "EgtRelocate", LuaRelocate) ; - lua_register( L, "EgtRelocateGlob", LuaRelocateGlob) ; - lua_register( L, "EgtChangeId", LuaChangeId) ; - lua_register( L, "EgtErase", LuaErase) ; - lua_register( L, "EgtEmptyGroup", LuaEmptyGroup) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtExistsObj", LuaExistsObj) ; + bOk = bOk && LuaRegisterFunction( "EgtGetGroupObjs", LuaGetGroupObjs) ; + bOk = bOk && LuaRegisterFunction( "EgtGetFirstInGroup", LuaGetFirstInGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtGetNext", LuaGetNext) ; + bOk = bOk && LuaRegisterFunction( "EgtGetLastInGroup", LuaGetLastInGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtGetPrev", LuaGetPrev) ; + bOk = bOk && LuaRegisterFunction( "EgtGetFirstNameInGroup", LuaGetFirstNameInGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtGetNextName", LuaGetNextName) ; + bOk = bOk && LuaRegisterFunction( "EgtCopy", LuaCopy) ; + bOk = bOk && LuaRegisterFunction( "EgtCopyGlob", LuaCopyGlob) ; + bOk = bOk && LuaRegisterFunction( "EgtRelocate", LuaRelocate) ; + bOk = bOk && LuaRegisterFunction( "EgtRelocateGlob", LuaRelocateGlob) ; + bOk = bOk && LuaRegisterFunction( "EgtChangeId", LuaChangeId) ; + bOk = bOk && LuaRegisterFunction( "EgtErase", LuaErase) ; + bOk = bOk && LuaRegisterFunction( "EgtEmptyGroup", LuaEmptyGroup) ; + return bOk ; } diff --git a/LUA_GdbPartLayers.cpp b/LUA_GdbPartLayers.cpp index c333403..0a735ca 100644 --- a/LUA_GdbPartLayers.cpp +++ b/LUA_GdbPartLayers.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -214,25 +215,21 @@ LuaSelectPathObjs( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGdbPartLayer( lua_State* L) +LuaInstallGdbPartLayer( void) { - try { - lua_register( L, "EgtGetCurrPart", LuaGetCurrPart) ; - lua_register( L, "EgtGetCurrLayer", LuaGetCurrLayer) ; - lua_register( L, "EgtSetCurrPartLayer", LuaSetCurrPartLayer) ; - lua_register( L, "EgtResetCurrPartLayer", LuaResetCurrPartLayer) ; - lua_register( L, "EgtGetFirstVisiblePart", LuaGetFirstVisiblePart) ; - lua_register( L, "EgtGetNextVisiblePart", LuaGetNextVisiblePart) ; - lua_register( L, "EgtGetFirstVisibleLayer", LuaGetFirstVisibleLayer) ; - lua_register( L, "EgtGetNextVisibleLayer", LuaGetNextVisibleLayer) ; - lua_register( L, "EgtSelectPartObjs", LuaSelectPartObjs) ; - lua_register( L, "EgtDeselectPartObjs", LuaDeselectPartObjs) ; - lua_register( L, "EgtSelectLayerObjs", LuaSelectLayerObjs) ; - lua_register( L, "EgtDeselectLayerObjs", LuaDeselectLayerObjs) ; - lua_register( L, "EgtSelectPathObjs", LuaSelectPathObjs) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtGetCurrPart", LuaGetCurrPart) ; + bOk = bOk && LuaRegisterFunction( "EgtGetCurrLayer", LuaGetCurrLayer) ; + bOk = bOk && LuaRegisterFunction( "EgtSetCurrPartLayer", LuaSetCurrPartLayer) ; + bOk = bOk && LuaRegisterFunction( "EgtResetCurrPartLayer", LuaResetCurrPartLayer) ; + bOk = bOk && LuaRegisterFunction( "EgtGetFirstVisiblePart", LuaGetFirstVisiblePart) ; + bOk = bOk && LuaRegisterFunction( "EgtGetNextVisiblePart", LuaGetNextVisiblePart) ; + bOk = bOk && LuaRegisterFunction( "EgtGetFirstVisibleLayer", LuaGetFirstVisibleLayer) ; + bOk = bOk && LuaRegisterFunction( "EgtGetNextVisibleLayer", LuaGetNextVisibleLayer) ; + bOk = bOk && LuaRegisterFunction( "EgtSelectPartObjs", LuaSelectPartObjs) ; + bOk = bOk && LuaRegisterFunction( "EgtDeselectPartObjs", LuaDeselectPartObjs) ; + bOk = bOk && LuaRegisterFunction( "EgtSelectLayerObjs", LuaSelectLayerObjs) ; + bOk = bOk && LuaRegisterFunction( "EgtDeselectLayerObjs", LuaDeselectLayerObjs) ; + bOk = bOk && LuaRegisterFunction( "EgtSelectPathObjs", LuaSelectPathObjs) ; + return bOk ; } diff --git a/LUA_General.cpp b/LUA_General.cpp index 2062dab..82b8bdb 100644 --- a/LUA_General.cpp +++ b/LUA_General.cpp @@ -13,288 +13,20 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" -#include "API_Macro.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EGnStringUtils.h" #include "/EgtDev/Include/EGnFileUtils.h" #include "/EgtDev/Include/EGnFileCompare.h" #include "/EgtDev/Include/EgtPerfCounter.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; //---------------------------------------------------------------------------- -static lua_State* s_L = nullptr ; -static string s_LastError ; static PerformanceCounter s_Counter ; -//---------------------------------------------------------------------------- -bool -LuaInit( void) -{ - // se già aperto, lo fermo per riavviarlo - if ( s_L != nullptr) { - lua_close( s_L) ; - s_L = nullptr ; - } - // inizializzo Lua - s_L = luaL_newstate() ; - if ( s_L == nullptr) { - LOG_ERROR( GetLogger(), "Error in Lua interpreter starting (" __FUNCTION__ ")") - return false ; - } - // carico le librerie standard - luaL_openlibs( s_L) ; - // carico le funzioni speciali - if ( ! LuaInstallGeneral( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGeneral (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGeoBase( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGeoBase (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGeomDB( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGeomDB (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbCreate( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbCreate (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbCreateCurve( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbCreateCurve (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbCreateSurf( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbCreateSurf (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbModify( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbModify (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbModifyCurve( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbModifyCurve (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbModifySurf( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbModifySurf (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbPartLayer( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbPartLayer (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbObjects( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjects (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbObjSelection( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjSelection (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGdbObjAttribs( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGdbObjAttribs (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGeoSnap( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGeoSnap (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallGeoTransform( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallGeoTransform (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallScene( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallScene (" __FUNCTION__ ")") - return false ; - } - if ( ! LuaInstallExchange( s_L)) { - LOG_ERROR( GetLogger(), "Error in LuaInstallExchange (" __FUNCTION__ ")") - return false ; - } - - // recupero la versione di Lua - lua_getglobal( s_L, "_VERSION") ; - string sLua ; - if ( LuaGetParam( s_L, - 1, sLua)) - sLua += " interpreter started" ; - else - sLua = "Lua *.* interpreter started" ; - lua_pop( s_L, 1) ; - LOG_INFO( GetLogger(), sLua.c_str()) - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaExit( void) -{ - if ( s_L == nullptr) - return false ; - // termino Lua - lua_close( s_L) ; - s_L = nullptr ; - LOG_INFO( GetLogger(), "Lua interpreter closed") - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaSetLuaLibsDir( const string& sDir) -{ - // recupero la stringa globale package.path - lua_getglobal( s_L, "package") ; - lua_getfield( s_L, -1, "path") ; - string sCurPath = lua_tostring( s_L, -1) ; - // verifico se la dir ricevuta è già presente - if ( sCurPath.find( sDir) != string::npos) { - lua_pop( s_L, 2) ; - return true ; - } - // imposto la nuova dir - sCurPath = sDir ; - sCurPath += "\\?.lua" ; - lua_pop( s_L, 1) ; - lua_pushstring( s_L, sCurPath.c_str()) ; - lua_setfield( s_L, -2, "path") ; - lua_pop( s_L, 1) ; - return true ; -} - -//---------------------------------------------------------------------------- -bool -LuaEvalNumExpr( const string& sExpr, double& dVal) -{ - // completo la stringa da valutare - string sEval = "return " + sExpr ; - // valuto l'espressione - int nErr = luaL_loadstring( s_L, sEval.c_str()) || lua_pcall( s_L, 0, 1, 0) ; - // senza errori - if ( nErr == LUA_OK && lua_type( s_L, -1) == LUA_TNUMBER) { - dVal = lua_tonumber( s_L, -1) ; - lua_pop( s_L, 1) ; - s_LastError.clear() ; - return true ; - } - // altrimenti, errore - else { - // recupero il messaggio di errore - const char* szErr = lua_tostring( s_L, -1) ; - s_LastError = ( szErr != nullptr) ? szErr : "Error not a number" ; - lua_pop( s_L, 1) ; - // lo scrivo nel log - LOG_ERROR( GetLogger(), s_LastError.c_str()) - return false ; - } -} - -//---------------------------------------------------------------------------- -bool -LuaEvalStringExpr( const string& sExpr, string& sVal) -{ - // completo la stringa da valutare - string sEval = "return " + sExpr ; - // valuto l'espressione - int nErr = luaL_loadstring( s_L, sEval.c_str()) || lua_pcall( s_L, 0, 1, 0) ; - // senza errori - if ( nErr == LUA_OK && lua_type( s_L, -1) == LUA_TSTRING) { - sVal = lua_tostring( s_L, -1) ; - lua_pop( s_L, 1) ; - s_LastError.clear() ; - return true ; - } - // altrimenti, errore - else { - // recupero il messaggio di errore - const char* szErr = lua_tostring( s_L, -1) ; - s_LastError = ( szErr != nullptr) ? szErr : "Error not a string" ; - lua_pop( s_L, 1) ; - // lo scrivo nel log - LOG_ERROR( GetLogger(), s_LastError.c_str()) - return false ; - } -} - -//---------------------------------------------------------------------------- -bool -LuaExecLine( const string& sLine) -{ - // eseguo la linea - int nErr = luaL_loadstring( s_L, sLine.c_str()) || lua_pcall( s_L, 0, LUA_MULTRET, 0) ; - // senza errori - if ( nErr == LUA_OK) { - s_LastError.clear() ; - return true ; - } - // altrimenti, errore - else { - // recupero il messaggio di errore - const char* szErr = lua_tostring( s_L, -1) ; - s_LastError = ( szErr != nullptr) ? szErr : "Error unknown" ; - lua_pop( s_L, 1) ; - // lo scrivo nel log - LOG_ERROR( GetLogger(), s_LastError.c_str()) - return false ; - } -} - -//---------------------------------------------------------------------------- -bool -LuaExecFile( const string& sFile) -{ - // eseguo la linea - int nErr = luaL_loadfile( s_L, sFile.c_str()) || lua_pcall( s_L, 0, LUA_MULTRET, 0) ; - // senza errori - if ( nErr == LUA_OK) { - s_LastError.clear() ; - return true ; - } - // in caso di errore - else { - // recupero il messaggio di errore - const char* szErr = lua_tostring( s_L, -1) ; - s_LastError = ( szErr != nullptr) ? szErr : "Error unknown" ; - lua_pop( s_L, 1) ; - // lo scrivo nel log - LOG_ERROR( GetLogger(), s_LastError.c_str()) - return false ; - } -} - -//---------------------------------------------------------------------------- -bool -LuaRequire( const string& sFile) -{ - lua_getglobal( s_L, "require") ; - lua_pushstring( s_L, sFile.c_str()) ; - int nErr = lua_pcall( s_L, 1, 1, 0) ; /* call 'require(sFile)' */ - if ( nErr == LUA_OK) { - lua_setglobal( s_L, sFile.c_str()) ; /* global[sFile] = require return */ - s_LastError.clear() ; - return true ; - } - else { - // recupero il messaggio di errore - const char* szErr = lua_tostring( s_L, -1) ; - s_LastError = ( szErr != nullptr) ? szErr : "Error unknown" ; - lua_pop( s_L, 1) ; - // lo scrivo nel log - LOG_ERROR( GetLogger(), s_LastError.c_str()) - return false ; - } -} - -//---------------------------------------------------------------------------- -const string& -LuaGetLastError( void) -{ - return s_LastError ; -} - -//------------------------------------------------------------------------------- //------------------------------------------------------------------------------- static int MyPrint( lua_State* L) @@ -540,27 +272,23 @@ LuaIs64bit( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGeneral( lua_State* L) +LuaInstallGeneral( void) { - try { - lua_register( L, "print", MyPrint) ; - lua_register( L, "EgtSetContext", SetContext) ; - lua_register( L, "EgtGetContext", GetContext) ; - lua_register( L, "EgtPause", LuaPause) ; - lua_register( L, "EgtStartCounter", LuaStartCounter) ; - lua_register( L, "EgtStopCounter", LuaStopCounter) ; - lua_register( L, "EgtNumToString", LuaNumToString) ; - lua_register( L, "EgtExecTsc", LuaExecTsc) ; - lua_register( L, "EgtOutLog", LuaOutLog) ; - lua_register( L, "EgtEraseFile", LuaEraseFile) ; - lua_register( L, "EgtEmptyDirectory", LuaEmptyDirectory) ; - lua_register( L, "EgtTextFileCompare", LuaTextFileCompare) ; - lua_register( L, "EgtBinaryFileCompare", LuaBinaryFileCompare) ; - lua_register( L, "EgtGetVersion", LuaGetVersion) ; - lua_register( L, "EgtIs64bit", LuaIs64bit) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "print", MyPrint) ; + bOk = bOk && LuaRegisterFunction( "EgtSetContext", SetContext) ; + bOk = bOk && LuaRegisterFunction( "EgtGetContext", GetContext) ; + bOk = bOk && LuaRegisterFunction( "EgtPause", LuaPause) ; + bOk = bOk && LuaRegisterFunction( "EgtStartCounter", LuaStartCounter) ; + bOk = bOk && LuaRegisterFunction( "EgtStopCounter", LuaStopCounter) ; + bOk = bOk && LuaRegisterFunction( "EgtNumToString", LuaNumToString) ; + bOk = bOk && LuaRegisterFunction( "EgtExecTsc", LuaExecTsc) ; + bOk = bOk && LuaRegisterFunction( "EgtOutLog", LuaOutLog) ; + bOk = bOk && LuaRegisterFunction( "EgtEraseFile", LuaEraseFile) ; + bOk = bOk && LuaRegisterFunction( "EgtEmptyDirectory", LuaEmptyDirectory) ; + bOk = bOk && LuaRegisterFunction( "EgtTextFileCompare", LuaTextFileCompare) ; + bOk = bOk && LuaRegisterFunction( "EgtBinaryFileCompare", LuaBinaryFileCompare) ; + bOk = bOk && LuaRegisterFunction( "EgtGetVersion", LuaGetVersion) ; + bOk = bOk && LuaRegisterFunction( "EgtIs64bit", LuaIs64bit) ; + return bOk ; } diff --git a/LUA_GeoBase.cpp b/LUA_GeoBase.cpp index 5cba69c..1f36915 100644 --- a/LUA_GeoBase.cpp +++ b/LUA_GeoBase.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -352,26 +353,22 @@ LuaFrameLocToLoc( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGeoBase( lua_State* L) +LuaInstallGeoBase( void) { - try { - lua_register( L, "EgtVectorRotate", LuaVectorRotate) ; - lua_register( L, "EgtVectorToGlob", LuaVectorToGlob) ; - lua_register( L, "EgtVectorToLoc", LuaVectorToLoc) ; - lua_register( L, "EgtVectorLocToLoc", LuaVectorLocToLoc) ; - lua_register( L, "EgtPointRotate", LuaPointRotate) ; - lua_register( L, "EgtPointToGlob", LuaPointToGlob) ; - lua_register( L, "EgtPointToLoc", LuaPointToLoc) ; - lua_register( L, "EgtPointLocToLoc", LuaPointLocToLoc) ; - lua_register( L, "EgtFrameFrom3Points", LuaFrameFrom3Points) ; - lua_register( L, "EgtFrameOCS", LuaFrameOCS) ; - lua_register( L, "EgtFrameRotate", LuaFrameRotate) ; - lua_register( L, "EgtFrameToGlob", LuaFrameToGlob) ; - lua_register( L, "EgtFrameToLoc", LuaFrameToLoc) ; - lua_register( L, "EgtFrameLocToLoc", LuaFrameLocToLoc) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtVectorRotate", LuaVectorRotate) ; + bOk = bOk && LuaRegisterFunction( "EgtVectorToGlob", LuaVectorToGlob) ; + bOk = bOk && LuaRegisterFunction( "EgtVectorToLoc", LuaVectorToLoc) ; + bOk = bOk && LuaRegisterFunction( "EgtVectorLocToLoc", LuaVectorLocToLoc) ; + bOk = bOk && LuaRegisterFunction( "EgtPointRotate", LuaPointRotate) ; + bOk = bOk && LuaRegisterFunction( "EgtPointToGlob", LuaPointToGlob) ; + bOk = bOk && LuaRegisterFunction( "EgtPointToLoc", LuaPointToLoc) ; + bOk = bOk && LuaRegisterFunction( "EgtPointLocToLoc", LuaPointLocToLoc) ; + bOk = bOk && LuaRegisterFunction( "EgtFrameFrom3Points", LuaFrameFrom3Points) ; + bOk = bOk && LuaRegisterFunction( "EgtFrameOCS", LuaFrameOCS) ; + bOk = bOk && LuaRegisterFunction( "EgtFrameRotate", LuaFrameRotate) ; + bOk = bOk && LuaRegisterFunction( "EgtFrameToGlob", LuaFrameToGlob) ; + bOk = bOk && LuaRegisterFunction( "EgtFrameToLoc", LuaFrameToLoc) ; + bOk = bOk && LuaRegisterFunction( "EgtFrameLocToLoc", LuaFrameLocToLoc) ; + return bOk ; } diff --git a/LUA_GeoSnap.cpp b/LUA_GeoSnap.cpp index 1f5b986..e46ef0c 100644 --- a/LUA_GeoSnap.cpp +++ b/LUA_GeoSnap.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -554,38 +555,34 @@ LuaExtTextNormVersor( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGeoSnap( lua_State* L) +LuaInstallGeoSnap( void) { - try { - lua_register( L, "EgtSP", LuaStartPoint) ; - lua_register( L, "EgtEP", LuaEndPoint) ; - lua_register( L, "EgtMP", LuaMidPoint) ; - lua_register( L, "EgtCP", LuaCenterPoint) ; - lua_register( L, "EgtGP", LuaCentroid) ; - lua_register( L, "EgtUP", LuaAtParamPoint) ; - lua_register( L, "EgtNP", LuaNearPoint) ; - lua_register( L, "EgtIP", LuaIntersectionPoint) ; - lua_register( L, "EgtSV", LuaStartVector) ; - lua_register( L, "EgtEV", LuaEndVector) ; - lua_register( L, "EgtMV", LuaMidVector) ; - lua_register( L, "EgtUV", LuaAtParamVector) ; - lua_register( L, "EgtFR", LuaFrame) ; - lua_register( L, "EgtET", LuaExtrusionByThickness) ; - lua_register( L, "EgtCurveLength", LuaCurveLength) ; - lua_register( L, "EgtCurveExtrusion", LuaCurveExtrusion) ; - lua_register( L, "EgtCurveThickness", LuaCurveThickness) ; - lua_register( L, "EgtCurveArcRadius", LuaCurveArcRadius) ; - lua_register( L, "EgtCurveArcNormVersor", LuaCurveArcNormVersor) ; - lua_register( L, "EgtCurveCompoCenter", LuaCurveCompoCenter) ; - lua_register( L, "EgtSurfTmFacetNbr", LuaSurfTmFacetNbr) ; - lua_register( L, "EgtSurfTmFacetNearestEndPoint", LuaSurfTmFacetNearestEndPoint) ; - lua_register( L, "EgtSurfTmFacetNearestMidPoint", LuaSurfTmFacetNearestMidPoint) ; - lua_register( L, "EgtSurfTmFacetCenter", LuaSurfTmFacetCenter) ; - lua_register( L, "EgtSurfTmFacetNormVersor", LuaSurfTmFacetNormVersor) ; - lua_register( L, "EgtExtTextNormVersor", LuaExtTextNormVersor) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtSP", LuaStartPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtEP", LuaEndPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtMP", LuaMidPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtCP", LuaCenterPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtGP", LuaCentroid) ; + bOk = bOk && LuaRegisterFunction( "EgtUP", LuaAtParamPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtNP", LuaNearPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtIP", LuaIntersectionPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtSV", LuaStartVector) ; + bOk = bOk && LuaRegisterFunction( "EgtEV", LuaEndVector) ; + bOk = bOk && LuaRegisterFunction( "EgtMV", LuaMidVector) ; + bOk = bOk && LuaRegisterFunction( "EgtUV", LuaAtParamVector) ; + bOk = bOk && LuaRegisterFunction( "EgtFR", LuaFrame) ; + bOk = bOk && LuaRegisterFunction( "EgtET", LuaExtrusionByThickness) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveLength", LuaCurveLength) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveExtrusion", LuaCurveExtrusion) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveThickness", LuaCurveThickness) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveArcRadius", LuaCurveArcRadius) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveArcNormVersor", LuaCurveArcNormVersor) ; + bOk = bOk && LuaRegisterFunction( "EgtCurveCompoCenter", LuaCurveCompoCenter) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmFacetNbr", LuaSurfTmFacetNbr) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmFacetNearestEndPoint", LuaSurfTmFacetNearestEndPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmFacetNearestMidPoint", LuaSurfTmFacetNearestMidPoint) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmFacetCenter", LuaSurfTmFacetCenter) ; + bOk = bOk && LuaRegisterFunction( "EgtSurfTmFacetNormVersor", LuaSurfTmFacetNormVersor) ; + bOk = bOk && LuaRegisterFunction( "EgtExtTextNormVersor", LuaExtTextNormVersor) ; + return bOk ; } diff --git a/LUA_GeoTransform.cpp b/LUA_GeoTransform.cpp index b233c39..f9d14e1 100644 --- a/LUA_GeoTransform.cpp +++ b/LUA_GeoTransform.cpp @@ -13,12 +13,13 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EInConst.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -242,22 +243,18 @@ LuaShearGroup( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGeoTransform( lua_State* L) +LuaInstallGeoTransform( void) { - try { - lua_register( L, "EgtMove", LuaMove) ; - lua_register( L, "EgtRotate", LuaRotate) ; - lua_register( L, "EgtScale", LuaScale) ; - lua_register( L, "EgtMirror", LuaMirror) ; - lua_register( L, "EgtShear", LuaShear) ; - lua_register( L, "EgtMoveGroup", LuaMoveGroup) ; - lua_register( L, "EgtRotateGroup", LuaRotateGroup) ; - lua_register( L, "EgtScaleGroup", LuaScaleGroup) ; - lua_register( L, "EgtMirrorGroup", LuaMirrorGroup) ; - lua_register( L, "EgtShearGroup", LuaShearGroup) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtMove", LuaMove) ; + bOk = bOk && LuaRegisterFunction( "EgtRotate", LuaRotate) ; + bOk = bOk && LuaRegisterFunction( "EgtScale", LuaScale) ; + bOk = bOk && LuaRegisterFunction( "EgtMirror", LuaMirror) ; + bOk = bOk && LuaRegisterFunction( "EgtShear", LuaShear) ; + bOk = bOk && LuaRegisterFunction( "EgtMoveGroup", LuaMoveGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtRotateGroup", LuaRotateGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtScaleGroup", LuaScaleGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtMirrorGroup", LuaMirrorGroup) ; + bOk = bOk && LuaRegisterFunction( "EgtShearGroup", LuaShearGroup) ; + return bOk ; } diff --git a/LUA_GeomDB.cpp b/LUA_GeomDB.cpp index 840817d..2df8470 100644 --- a/LUA_GeomDB.cpp +++ b/LUA_GeomDB.cpp @@ -13,12 +13,13 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "AuxTools.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -157,20 +158,16 @@ LuaSaveFile( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallGeomDB( lua_State* L) +LuaInstallGeomDB( void) { - try { - lua_register( L, "EgtSetDefaultMaterial", LuaSetDefaultMaterial) ; - lua_register( L, "EgtSetGridFrame", LuaSetGridFrame) ; - lua_register( L, "EgtGetGridFrame", LuaGetGridFrame) ; - lua_register( L, "EgtGetGridVersZ", LuaGetGridVersZ) ; - lua_register( L, "EgtNewFile", LuaNewFile) ; - lua_register( L, "EgtOpenFile", LuaOpenFile) ; - lua_register( L, "EgtInsertFile", LuaInsertFile) ; - lua_register( L, "EgtSaveFile", LuaSaveFile) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtSetDefaultMaterial", LuaSetDefaultMaterial) ; + bOk = bOk && LuaRegisterFunction( "EgtSetGridFrame", LuaSetGridFrame) ; + bOk = bOk && LuaRegisterFunction( "EgtGetGridFrame", LuaGetGridFrame) ; + bOk = bOk && LuaRegisterFunction( "EgtGetGridVersZ", LuaGetGridVersZ) ; + bOk = bOk && LuaRegisterFunction( "EgtNewFile", LuaNewFile) ; + bOk = bOk && LuaRegisterFunction( "EgtOpenFile", LuaOpenFile) ; + bOk = bOk && LuaRegisterFunction( "EgtInsertFile", LuaInsertFile) ; + bOk = bOk && LuaRegisterFunction( "EgtSaveFile", LuaSaveFile) ; + return bOk ; } diff --git a/LUA_Scene.cpp b/LUA_Scene.cpp index e1f4bbb..f7ab436 100644 --- a/LUA_Scene.cpp +++ b/LUA_Scene.cpp @@ -13,11 +13,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "LUA.h" #include "API.h" +#include "LUA.h" +#include "LUA_Base.h" +#include "LUA_Aux.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EgnStringUtils.h" -#include "/EgtDev/Extern/Lua/Include/lua.hpp" using namespace std ; @@ -217,21 +218,17 @@ LuaSetViewCenter( lua_State* L) //------------------------------------------------------------------------------- bool -LuaInstallScene( lua_State* L) +LuaInstallScene( void) { - try { - lua_register( L, "EgtSetBackground", LuaSetBackground) ; - lua_register( L, "EgtDraw", LuaDraw) ; - lua_register( L, "EgtSetShowMode", LuaSetShowMode) ; - lua_register( L, "EgtSetShowCurveDirection", LuaSetShowCurveDirection) ; - lua_register( L, "EgtSetShowTriaAdv", LuaSetShowTriaAdv) ; - lua_register( L, "EgtZoom", LuaZoom) ; - lua_register( L, "EgtSetView", LuaSetView) ; - lua_register( L, "EgtSetGenericView", LuaSetGenericView) ; - lua_register( L, "EgtSetViewCenter", LuaSetViewCenter) ; - } - catch ( ...) { - return false ; - } - return true ; + bool bOk = true ; + bOk = bOk && LuaRegisterFunction( "EgtSetBackground", LuaSetBackground) ; + bOk = bOk && LuaRegisterFunction( "EgtDraw", LuaDraw) ; + bOk = bOk && LuaRegisterFunction( "EgtSetShowMode", LuaSetShowMode) ; + bOk = bOk && LuaRegisterFunction( "EgtSetShowCurveDirection", LuaSetShowCurveDirection) ; + bOk = bOk && LuaRegisterFunction( "EgtSetShowTriaAdv", LuaSetShowTriaAdv) ; + bOk = bOk && LuaRegisterFunction( "EgtZoom", LuaZoom) ; + bOk = bOk && LuaRegisterFunction( "EgtSetView", LuaSetView) ; + bOk = bOk && LuaRegisterFunction( "EgtSetGenericView", LuaSetGenericView) ; + bOk = bOk && LuaRegisterFunction( "EgtSetViewCenter", LuaSetViewCenter) ; + return bOk ; }