EgtExecutor/LUA_GdbObjAttribs.cpp

//----------------------------------------------------------------------------
//  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 "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EGkGdbConst.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGnStringUtils.h"

using namespace std ;

//-------------------------------------------------------------------------------
static int
LuaSetLevel( lua_State* L)
{
  // 2 parametri : nId, nLevel
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nLevel ;
   LuaCheckParam( L, 2, nLevel)
  // imposto lo stato
   bool bOk = ExeSetLevel( nId, nLevel) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRevertLevel( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // porto il livello al valore precedente
   bool bOk = ExeRevertLevel( nId) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetLevel( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il livello
   int nLevel ;
   bool bOk = ExeGetLevel( nId, &nLevel) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetReturn( L, nLevel) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcLevel( lua_State* L)
{
  // 1 parametro : nId
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il livello
   int nLevel ;
   bool bOk = ExeGetCalcLevel( nId, &nLevel) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetReturn( L, nLevel) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetMode( lua_State* L)
{
  // 2 parametri : nId, nMode
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nMode ;
   LuaCheckParam( L, 2, nMode)
   LuaClearStack( L) ;
  // imposto il modo
   bool bOk = ExeSetMode( nId, nMode) ;
  // 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 = ExeRevertMode( nId) ;
  // 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 ( ExeGetMode( 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 ( ExeGetCalcMode( nId, &nMode))
     // restituisco il risultato
      LuaSetReturn( L, nMode) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetStatus( lua_State* L)
{
  // 2 parametri : Id, nStatus
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   int nStatus ;
   LuaCheckParam( L, 2, nStatus)
   LuaClearStack( L) ;
  // imposto lo stato
   bool bOk = ExeSetStatus( vId, nStatus) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRevertStatus( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // porto lo stato al valore precedente
   bool bOk = ExeRevertStatus( nId) ;
  // 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 ( ExeGetStatus( 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 ( ExeGetCalcStatus( 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 = ExeSetMark( nId) ;
  // 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 = ExeResetMark( nId) ;
  // 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 ( ExeGetMark( nId, &nMark))
     // restituisco il risultato
      LuaSetReturn( L, ( nMark != GDB_MK_OFF)) ;
   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 ( ExeGetCalcMark( nId, &nMark))
     // restituisco il risultato
      LuaSetReturn( L, ( nMark != GDB_MK_OFF)) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaStdColor( lua_State* L)
{
  // 1 parametro : Nome
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // recupero il colore con il nome indicato
   Color cCol ;
   if ( ExeStdColor( sName, cCol)) {
     // restituisco il risultato
      LuaSetReturn( L, cCol) ;
   }
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetColor( lua_State* L)
{
  // 2 o 3 parametri : Id/s, Colore [, bSetAlpha]
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Color cCol ;
   LuaCheckParam( L, 2, cCol)
   bool bSetAlpha = true ;
   LuaGetParam( L, 3, bSetAlpha) ;
   LuaClearStack( L) ;
  // assegno il colore
   bool bOk = ExeSetColor( vId, cCol, bSetAlpha) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetAlpha( lua_State* L)
{
  // 2 : Id/s, nAlpha
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   int nAlpha ;
   LuaCheckParam( L, 2, nAlpha)
   LuaClearStack( L) ;
  // assegno la trasparenza
   bool bOk = ExeSetAlpha( vId, nAlpha) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaResetColor( lua_State* L)
{
  // 1 parametro : Id/s
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   LuaClearStack( L) ;
  // tolgo il colore
   bool bOk = ExeResetColor( vId) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetColor( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il colore
   Color cCol ;
   if ( ExeGetColor( nId, cCol)) {
     // 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
   Color cCol ;
   if ( ExeGetCalcColor( nId, cCol)) {
     // 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 = ExeSetName( nId, sName) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetName( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il nome
   string sName ;
   bool bOk = ExeGetName( nId, sName) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetReturn( L, sName) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExistsName( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // verifico esistenza nome
   bool bOk = ExeExistsName( nId) ;
  // 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 = ExeRemoveName( nId) ;
  // 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 = ExeSetInfo( nId, sKey, sInfo) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetInfo( lua_State* L)
{
  // 2 parametri : Id, Key
   int nId ;
   LuaCheckParam( L, 1, nId)
   string sKey ;
   LuaCheckParam( L, 2, sKey)
   LuaClearStack( L) ;
  // recupero l'info
   string sInfo ;
   bool bOk = ExeGetInfo( nId, sKey, sInfo) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetReturn( L, sInfo) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExistsInfo( lua_State* L)
{
  // 2 parametri : Id, Key
   int nId ;
   LuaCheckParam( L, 1, nId)
   string sKey ;
   LuaCheckParam( L, 2, sKey)
   LuaClearStack( L) ;
  // verifico esistenza info
   bool bOk = ExeExistsInfo( nId, sKey) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveInfo( lua_State* L)
{
  // 2 parametri : Id, Key
   int nId ;
   LuaCheckParam( L, 1, nId)
   string sKey ;
   LuaCheckParam( L, 2, sKey)
   LuaClearStack( L) ;
  // rimuovo info
   bool bOk = ExeRemoveInfo( nId, sKey) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGdbObjAttribs( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetLevel", LuaSetLevel) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRevertLevel", LuaRevertLevel) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLevel", LuaGetLevel) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcLevel", LuaGetCalcLevel) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetMode", LuaSetMode) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRevertMode", LuaRevertMode) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMode", LuaGetMode) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcMode", LuaGetCalcMode) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetStatus", LuaSetStatus) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRevertStatus", LuaRevertStatus) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetStatus", LuaGetStatus) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcStatus", LuaGetCalcStatus) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetMark", LuaSetMark) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtResetMark", LuaResetMark) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetMark", LuaGetMark) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcMark", LuaGetCalcMark) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtStdColor", LuaStdColor) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetColor", LuaSetColor) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetAlpha", LuaSetAlpha) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtResetColor", LuaResetColor) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetColor", LuaGetColor) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCalcColor", LuaGetCalcColor) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetName", LuaSetName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetName", LuaGetName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExistsName", LuaExistsName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveName", LuaRemoveName) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetInfo", LuaSetInfo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetInfo", LuaGetInfo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExistsInfo", LuaExistsInfo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRemoveInfo", LuaRemoveInfo) ;
   return bOk ;
}