EgtInterface/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 "API.h"
#include "LUA.h"
#include "LUA_Base.h"
#include "LUA_Aux.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgnStringUtils.h"

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( nId, nLevel) != 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( nId) != 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( nId, &nLevel) != FALSE)
     // 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( nId, &nLevel) != FALSE)
     // 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( nId, nMode) != FALSE) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRevertMode( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // porto il modo al valore precedente
   bool bOk = ( EgtRevertMode( nId) != FALSE) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMode( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il modo
   int nMode ;
   if ( EgtGetMode( nId, &nMode) != FALSE)
     // restituisco il risultato
      LuaSetReturn( L, nMode) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcMode( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il modo calcolato (ovvero proprio ed ereditato)
   int nMode ;
   if ( EgtGetCalcMode( nId, &nMode) != FALSE)
     // restituisco il risultato
      LuaSetReturn( L, nMode) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetStatus( lua_State* L)
{
  // 2 parametri : Id, Stato
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   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( vId, nStatus) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRevertStatus( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // porto lo stato al valore precedente
   bool bOk = ( EgtRevertStatus( nId) != FALSE) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetStatus( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero lo stato
   int nStatus ;
   if ( EgtGetStatus( nId, &nStatus) != FALSE)
     // restituisco il risultato
      LuaSetReturn( L, nStatus) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcStatus( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero lo stato
   int nStatus ;
   if ( EgtGetCalcStatus( nId, &nStatus) != FALSE)
     // restituisco il risultato
      LuaSetReturn( L, nStatus) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetMark( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // imposto l'evidenziazione
   bool bOk = ( EgtSetMark( nId) != FALSE) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaResetMark( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // cancello l'evidenziazione
   bool bOk = ( EgtResetMark( nId) != FALSE) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMark( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero lo stato di evidenziazione
   BOOL nMark ;
   if ( EgtGetMark( nId, &nMark) != FALSE)
     // restituisco il risultato
      LuaSetReturn( L, ( nMark != FALSE)) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcMark( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero lo stato calcolato di evidenziazione
   BOOL nMark ;
   if ( EgtGetCalcMark( nId, &nMark) != FALSE)
     // restituisco il risultato
      LuaSetReturn( L, ( nMark != FALSE)) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

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

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

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

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

//-------------------------------------------------------------------------------
static int
LuaGetColor( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il colore
   int vCol[4] ;
   if ( EgtGetColor( nId, vCol) != FALSE) {
      Color cCol( vCol) ;
     // restituisco il risultato
      LuaSetReturn( L, cCol) ;
   }
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCalcColor( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // recupero il colore
   int vCol[4] ;
   if ( EgtGetCalcColor( nId, vCol) != FALSE) {
      Color cCol( vCol) ;
     // restituisco il risultato
      LuaSetReturn( L, cCol) ;
   }
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetName( lua_State* L)
{
  // 2 parametri : Id, Name
   int nId ;
   LuaCheckParam( L, 1, nId)
   string sName ;
   LuaCheckParam( L, 2, sName)
   LuaClearStack( L) ;
  // assegno il nome
   bool bOk = EgtSetName( nId, sName) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

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

//-------------------------------------------------------------------------------
static int
LuaExistsName( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // verifico esistenza nome
   bool bOk = ( EgtExistsName( nId) != FALSE) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRemoveName( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // verifico esistenza nome
   bool bOk = ( EgtRemoveName( nId) != FALSE) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetInfo( lua_State* L)
{
  // 3 parametri : Id, Key, Info
   int nId ;
   LuaCheckParam( L, 1, nId)
   string sKey ;
   LuaCheckParam( L, 2, sKey)
   string sInfo ;
   LuaCheckParam( L, 3, sInfo)
   LuaClearStack( L) ;
  // assegno la info
   bool bOk = EgtSetInfo( nId, sKey, sInfo) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

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

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

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

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