EgtExecutor/LUA_GdbPartLayers.cpp

//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : LUA_GdbPartLayers.cpp      Data : 29.01.15      Versione : 1.6a7
// Contenuto : Funzioni di gestione pezzi e layer relativi per LUA.
//
//
//
// Modifiche : 29.01.15 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"

using namespace std ;

//-------------------------------------------------------------------------------
static int
LuaIsPart( lua_State* L)
{
  // 1 parametro : nIdPart
   int nIdPart ;
   LuaCheckParam( L, 1, nIdPart)
   LuaClearStack( L) ;
  // verifico sia un pezzo
   bool bOk = ExeIsPart( nIdPart) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaIsLayer( lua_State* L)
{
  // 1 parametro : nIdLayer
   int nIdLayer ;
   LuaCheckParam( L, 1, nIdLayer)
   LuaClearStack( L) ;
  // verifico sia un layer
   bool bOk = ExeIsLayer( nIdLayer) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCurrPart( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il pezzo corrente
   int nId = ExeGetCurrPart() ;
  // restituisco il risultato
   LuaSetParam( L, nId) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetCurrLayer( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il layer corrente
   int nId = ExeGetCurrLayer() ;
  // restituisco il risultato
   LuaSetParam( L, nId) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetCurrPartLayer( lua_State* L)
{
  // 2 parametri : nPartId, nLayerId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   int nLayerId ;
   LuaCheckParam( L, 2, nLayerId)
   LuaClearStack( L) ;
  // imposto pezzo e layer correnti
   bool bOk = ExeSetCurrPartLayer( nPartId, nLayerId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaResetCurrPartLayer( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // cerco primo pezzo e layer validi per essere dichiarati correnti
   bool bOk = ExeResetCurrPartLayer() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetPartCount( lua_State* L)
{
  // nessuno o 1 parametro : [bOnlyVisible]
   bool bOnlyVisible = false ;
   LuaGetParam( L, 1, bOnlyVisible) ;
   LuaClearStack( L) ;
  // recupero numero pezzi
   int nNbr = ExeGetPartCount( bOnlyVisible) ;
  // restituisco il risultato
   LuaSetParam( L, nNbr) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetFirstPart( lua_State* L)
{
  // nessuno o 1 parametro : [bOnlyVisible]
   bool bOnlyVisible = false ;
   LuaGetParam( L, 1, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco primo pezzo
   int nId = ExeGetFirstPart( bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextPart( lua_State* L)
{
  // 1 o 2 parametri : nPartId [, bOnlyVisible]
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   bool bOnlyVisible = false ;
   LuaGetParam( L, 2, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco pezzo successivo
   int nId = ExeGetNextPart( nPartId, bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetLastPart( lua_State* L)
{
  // nessuno o 1 parametro : [bOnlyVisible]
   bool bOnlyVisible = false ;
   LuaGetParam( L, 1, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco ultimo pezzo
   int nId = ExeGetLastPart( bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetPrevPart( lua_State* L)
{
  // 1 o 2 parametri : nPartId [, bOnlyVisible]
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   bool bOnlyVisible = false ;
   LuaGetParam( L, 2, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco pezzo precedente
   int nId = ExeGetPrevPart( nPartId, bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetFirstLayer( lua_State* L)
{
  // 1 o 2 parametri : nPartId [, bOnlyVisible]
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   bool bOnlyVisible = false ;
   LuaGetParam( L, 2, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco il primo layer del pezzo
   int nId = ExeGetFirstLayer( nPartId, bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextLayer( lua_State* L)
{
  // 1 o 2 parametri : nLayerId [, bOnlyVisible]
   int nLayerId ;
   LuaCheckParam( L, 1, nLayerId)
   bool bOnlyVisible = false ;
   LuaGetParam( L, 2, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco il prossimo layer (ovviamente dello stesso pezzo)
   int nId = ExeGetNextLayer( nLayerId, bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetLastLayer( lua_State* L)
{
  // 1 o 2 parametri : nPartId [, bOnlyVisible]
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   bool bOnlyVisible = false ;
   LuaGetParam( L, 2, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco l'ultimo layer del pezzo
   int nId = ExeGetLastLayer( nPartId, bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetPrevLayer( lua_State* L)
{
  // 1 o 2 parametri : nLayerId [, bOnlyVisible]
   int nLayerId ;
   LuaCheckParam( L, 1, nLayerId)
   bool bOnlyVisible = false ;
   LuaGetParam( L, 2, bOnlyVisible) ;
   LuaClearStack( L) ;
  // cerco il precedente layer (ovviamente dello stesso pezzo)
   int nId = ExeGetPrevLayer( nLayerId, bOnlyVisible) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaIsGhostPart( lua_State* L)
{
  // 1 parametro : nGhostId
   int nGhostId ;
   LuaCheckParam( L, 1, nGhostId)
   LuaClearStack( L) ;
  // verifico sia un segnaposto di pezzo messo in grezzo
   bool bOk = ExeIsGhostPart( nGhostId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetFirstGhostPart( lua_State* L)
{
  // nessuno parametro
   LuaClearStack( L) ;
  // cerco primo pezzo messo in grezzo
   int nId = ExeGetFirstGhostPart() ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetNextGhostPart( lua_State* L)
{
  // 1 parametro : nGhostPartId
   int nGhostPartId ;
   LuaCheckParam( L, 1, nGhostPartId)
   LuaClearStack( L) ;
  // cerco pezzo successivo messo in grezzo
   int nId = ExeGetNextGhostPart( nGhostPartId) ;
  // restituisco il risultato
   if ( nId != GDB_ID_NULL)
      LuaSetParam( L, nId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaEraseEmptyParts( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // cancello i pezzi vuoti
   bool bOk = ExeEraseEmptyParts() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSelectPartObjs( lua_State* L)
{
  // 1 parametro : PartId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   LuaClearStack( L) ;
  // eseguo la selezione
   bool bOk = ExeSelectPartObjs( nPartId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDeselectPartObjs( lua_State* L)
{
  // 1 parametro : PartId
   int nPartId ;
   LuaCheckParam( L, 1, nPartId)
   LuaClearStack( L) ;
  // eseguo la selezione
   bool bOk = ExeDeselectPartObjs( nPartId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSelectLayerObjs( lua_State* L)
{
  // 1 parametro : LayerId
   int nLayerId ;
   LuaCheckParam( L, 1, nLayerId)
   LuaClearStack( L) ;
  // eseguo la selezione
   bool bOk = ExeSelectLayerObjs( nLayerId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDeselectLayerObjs( lua_State* L)
{
  // 1 parametro : LayerId
   int nLayerId ;
   LuaCheckParam( L, 1, nLayerId)
   LuaClearStack( L) ;
  // eseguo la selezione
   bool bOk = ExeDeselectLayerObjs( nLayerId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSelectPathObjs( lua_State* L)
{
  // 2 parametri : nId, bHaltOnFork
   int nId ;
   LuaCheckParam( L, 1, nId)
   bool bHaltOnFork ;
   LuaCheckParam( L, 2, bHaltOnFork)
   LuaClearStack( L) ;
  // eseguo la selezione
   bool bOk = ExeSelectPathObjs( nId, bHaltOnFork) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploNew( lua_State* L)
{
  // 1 parametro : nSouId
   int nSouId ;
   LuaCheckParam( L, 1, nSouId)
   LuaClearStack( L) ;
  // creo il duplicato
   int nNewId = ExeDuploNew( nSouId) ;
  // restituisco il risultato
   LuaSetParam( L, nNewId) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploCount( lua_State* L)
{
  // 1 parametro : nSouId
   int nSouId ;
   LuaCheckParam( L, 1, nSouId)
   LuaClearStack( L) ;
  // recupero il numero di duplicati
   int nCount ;
   bool bOk = ExeDuploCount( nSouId, nCount) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, nCount) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploList( lua_State* L)
{
  // 1 parametro : nSouId
   int nSouId ;
   LuaCheckParam( L, 1, nSouId)
   LuaClearStack( L) ;
  // recupero l'elenco dei duplicati
   INTVECTOR vnRef ;
   bool bOk = ExeDuploList( nSouId, vnRef) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, vnRef) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploInRawCount( lua_State* L)
{
  // 1 parametro : nSouId
   int nSouId ;
   LuaCheckParam( L, 1, nSouId)
   LuaClearStack( L) ;
  // recupero il numero di duplicati che sono riferiti da grezzi nei vari gruppi di lavoro del progetto
   int nCount ;
   bool bOk = ExeDuploInRawCount( nSouId, nCount) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, nCount) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploWithoutRawList( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero l'elenco dei duplicati
   INTVECTOR vnDup ;
   bool bOk = ExeDuploWithoutRawList( vnDup) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, vnDup) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploSetModified( lua_State* L)
{
  // 1 parametro : nSouId
   int nSouId ;
   LuaCheckParam( L, 1, nSouId)
   LuaClearStack( L) ;
  // dichiaro che il pezzo è modificato
   bool bOk = ExeDuploSetModified( nSouId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploGetModified( lua_State* L)
{
  // 1 parametro : nSouId
   int nSouId ;
   LuaCheckParam( L, 1, nSouId)
   LuaClearStack( L) ;
  // recupero lo stato di modifica del pezzo
   bool bModif ;
   bool bOk = ExeDuploGetModified( nSouId, bModif) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, bModif) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploSetLocked( lua_State* L)
{
  // 1 parametro : nDupId
   int nDupId ;
   LuaCheckParam( L, 1, nDupId)
   LuaClearStack( L) ;
  // blocco il duplicato (non modificabile)
   bool bOk = ExeDuploSetLocked( nDupId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploResetLocked( lua_State* L)
{
  // 1 parametro : nDupId
   int nDupId ;
   LuaCheckParam( L, 1, nDupId)
   LuaClearStack( L) ;
  // sblocco il duplicato (ritorna copia esatta dell'originale)
   bool bOk = ExeDuploResetLocked( nDupId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploGetLocked( lua_State* L)
{
  // 1 parametro : nDupId
   int nDupId ;
   LuaCheckParam( L, 1, nDupId)
   LuaClearStack( L) ;
  // recupero lo stato di blocco del duplicato
   bool bLocked ;
   bool bOk = ExeDuploGetLocked( nDupId, bLocked) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, bLocked) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploUpdate( lua_State* L)
{
  // 1 parametro : nSouId
   int nSouId ;
   LuaCheckParam( L, 1, nSouId)
   LuaClearStack( L) ;
  // aggiorno i duplicati del pezzo
   bool bOk = ExeDuploUpdate( nSouId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaIsDuplo( lua_State* L)
{
  // 1 parametro : nDouId
   int nDouId ;
   LuaCheckParam( L, 1, nDouId)
   LuaClearStack( L) ;
  // verifico se è un duplicato
   bool bOk = ExeIsDuplo( nDouId) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaDuploGetOriginal( lua_State* L)
{
  // 1 parametro : nDouId
   int nDouId ;
   LuaCheckParam( L, 1, nDouId)
   LuaClearStack( L) ;
  // verifico se è un duplicato
   int nOrigId = ExeDuploGetOriginal( nDouId) ;
  // restituisco il risultato
   if ( nOrigId != GDB_ID_NULL)
      LuaSetParam( L, nOrigId) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGdbPartLayer( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIsPart", LuaIsPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIsLayer", LuaIsLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrPart", LuaGetCurrPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetCurrLayer", LuaGetCurrLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetCurrPartLayer", LuaSetCurrPartLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtResetCurrPartLayer", LuaResetCurrPartLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPartCount", LuaGetPartCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstPart", LuaGetFirstPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextPart", LuaGetNextPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastPart", LuaGetLastPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevPart", LuaGetPrevPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstLayer", LuaGetFirstLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextLayer", LuaGetNextLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLastLayer", LuaGetLastLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetPrevLayer", LuaGetPrevLayer) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIsGhostPart", LuaIsGhostPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetFirstGhostPart", LuaGetFirstGhostPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetNextGhostPart", LuaGetNextGhostPart) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseEmptyParts", LuaEraseEmptyParts) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSelectPartObjs", LuaSelectPartObjs) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDeselectPartObjs", LuaDeselectPartObjs) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSelectLayerObjs", LuaSelectLayerObjs) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDeselectLayerObjs", LuaDeselectLayerObjs) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSelectPathObjs", LuaSelectPathObjs) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploNew", LuaDuploNew) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploCount", LuaDuploCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploList", LuaDuploList) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploInRawCount", LuaDuploInRawCount) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploWithoutRawList", LuaDuploWithoutRawList) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploSetModified", LuaDuploSetModified) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploGetModified", LuaDuploGetModified) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploSetLocked", LuaDuploSetLocked) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploResetLocked", LuaDuploResetLocked) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploGetLocked", LuaDuploGetLocked) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploUpdate", LuaDuploUpdate) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIsDuplo", LuaIsDuplo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDuploGetOriginal", LuaDuploGetOriginal) ;
   return bOk ;
}