Dario Sassi
50b2d271ac
- aggiunto interprete Lua - portate in interfaccia API molte funzioni di base.
573 lines
16 KiB
C++
573 lines
16 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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 "LUA.h"
|
|
#include "API.h"
|
|
#include "/EgtDev/Include/EInAPI.h"
|
|
#include "/EgtDev/Include/EgnStringUtils.h"
|
|
#include "/EgtDev/Extern/Lua/Include/lua.hpp"
|
|
|
|
using namespace std ;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetLevel( lua_State* L)
|
|
{
|
|
// 2 parametri : Id, Livello
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
string sLevel ;
|
|
LuaCheckParam( L, 2, sLevel)
|
|
ToUpper( sLevel) ;
|
|
int nLevel = GDB_LV_USER ;
|
|
if ( sLevel == "SYSTEM")
|
|
nLevel = GDB_LV_SYSTEM ;
|
|
else if ( sLevel == "TEMP")
|
|
nLevel = GDB_LV_TEMP ;
|
|
LuaClearStack( L) ;
|
|
// imposto lo stato
|
|
bool bOk = ( EgtSetLevel( LuaGetGseContext(), nId, nLevel) ? true : false) ;
|
|
// restituisco il risultato
|
|
LuaSetReturn( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaRevertLevel( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// porto il livello al valore precedente
|
|
bool bOk = ( EgtRevertLevel( LuaGetGseContext(), nId) ? true : false) ;
|
|
// restituisco il risultato
|
|
LuaSetReturn( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetLevel( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il livello
|
|
int nLevel ;
|
|
if ( EgtGetLevel( LuaGetGseContext(), nId, &nLevel))
|
|
// restituisco il risultato
|
|
LuaSetReturn( L, nLevel) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaGetCalcLevel( lua_State* L)
|
|
{
|
|
// 1 parametro : Id
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
LuaClearStack( L) ;
|
|
// recupero il livello
|
|
int nLevel ;
|
|
if ( EgtGetCalcLevel( LuaGetGseContext(), nId, &nLevel))
|
|
// restituisco il risultato
|
|
LuaSetReturn( L, nLevel) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetMode( lua_State* L)
|
|
{
|
|
// 2 parametri : Id, Mode
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
string sMode ;
|
|
LuaCheckParam( L, 2, sMode)
|
|
ToUpper( sMode) ;
|
|
int nMode = GDB_MD_STD ;
|
|
if ( sMode == "LOCKED")
|
|
nMode = GDB_MD_LOCKED ;
|
|
else if ( sMode == "HIDDEN")
|
|
nMode = GDB_MD_HIDDEN ;
|
|
LuaClearStack( L) ;
|
|
// imposto il modo
|
|
bool bOk = ( EgtSetMode( LuaGetGseContext(), nId, nMode) ? true : 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( LuaGetGseContext(), nId) ? true : 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( LuaGetGseContext(), nId, &nMode))
|
|
// 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( LuaGetGseContext(), nId, &nMode))
|
|
// restituisco il risultato
|
|
LuaSetReturn( L, nMode) ;
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetStatus( lua_State* L)
|
|
{
|
|
// 2 parametri : Id, Stato
|
|
int nId ;
|
|
LuaCheckParam( L, 1, nId)
|
|
string sStatus ;
|
|
LuaCheckParam( L, 2, sStatus)
|
|
ToUpper( sStatus) ;
|
|
int nStatus = GDB_ST_ON ;
|
|
if ( sStatus == "OFF")
|
|
nStatus = GDB_ST_OFF ;
|
|
else if ( sStatus == "SEL")
|
|
nStatus = GDB_ST_SEL ;
|
|
LuaClearStack( L) ;
|
|
// imposto lo stato
|
|
bool bOk = ( EgtSetStatus( LuaGetGseContext(), nId, nStatus) ? true : false) ;
|
|
// 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( LuaGetGseContext(), nId) ? true : 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( LuaGetGseContext(), nId, &nStatus))
|
|
// 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( LuaGetGseContext(), nId, &nStatus))
|
|
// 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( LuaGetGseContext(), nId) ? true : 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( LuaGetGseContext(), nId) ? true : 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( LuaGetGseContext(), nId, &nMark))
|
|
// 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( LuaGetGseContext(), nId, &nMark))
|
|
// 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
|
|
int nRed, nGreen, nBlue, nAlpha ;
|
|
if ( EgtStdColor( sName, nRed, nGreen, nBlue, nAlpha)) {
|
|
Color cCol( nRed, nGreen, nBlue, nAlpha) ;
|
|
// restituisco il risultato
|
|
LuaSetReturn( L, cCol) ;
|
|
}
|
|
else
|
|
LuaSetReturn( L) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
LuaSetColor( lua_State* L)
|
|
{
|
|
// 2 parametri : Id/s, Colore
|
|
INTVECTOR vId ;
|
|
LuaCheckParam( L, 1, vId)
|
|
Color cCol ;
|
|
LuaCheckParam( L, 2, cCol)
|
|
LuaClearStack( L) ;
|
|
// assegno il colore
|
|
bool bOk = true ;
|
|
for ( size_t i = 0 ; i < vId.size() && bOk ; ++ i) {
|
|
if ( ! EgtSetColor( LuaGetGseContext(), vId[i], cCol.GetIntRed(),
|
|
cCol.GetIntGreen(), cCol.GetIntBlue(), cCol.GetIntAlpha()))
|
|
bOk = false ;
|
|
}
|
|
// 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 nRed, nGreen, nBlue, nAlpha ;
|
|
if ( EgtGetColor( LuaGetGseContext(), nId, nRed, nGreen, nBlue, nAlpha)) {
|
|
Color cCol( nRed, nGreen, nBlue, nAlpha) ;
|
|
// 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 nRed, nGreen, nBlue, nAlpha ;
|
|
if ( EgtGetCalcColor( LuaGetGseContext(), nId, nRed, nGreen, nBlue, nAlpha)) {
|
|
Color cCol( nRed, nGreen, nBlue, nAlpha) ;
|
|
// 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( LuaGetGseContext(), nId, sName) ? true : false) ;
|
|
// 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( LuaGetGseContext(), nId, sName) ? true : false) ;
|
|
// 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( LuaGetGseContext(), nId) ? true : 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( LuaGetGseContext(), nId) ? true : 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( LuaGetGseContext(), nId, sKey, sInfo) ? true : false) ;
|
|
// 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( LuaGetGseContext(), nId, sKey, sInfo) ? true : false) ;
|
|
// 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( LuaGetGseContext(), nId, sKey) ? true : false) ;
|
|
// 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( LuaGetGseContext(), nId, sKey) ? true : false) ;
|
|
// restituisco il risultato
|
|
LuaSetReturn( L, bOk) ;
|
|
return 1 ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
LuaInstallGdbObjAttribs( lua_State* L)
|
|
{
|
|
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, "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 ;
|
|
}
|