//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : EXE_GdbPartLayers.cpp       Data : 04.05.15        Versione : 1.6e1
// Contenuto : Funzioni di gestione pezzi e layer relativi per EXE.
//
//
//
// Modifiche : 29.01.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EgkCurve.h"
#include "/EgtDev/Include/EgkChainCurves.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"

using namespace std ;

//-------------------------------------------------------------------------------
static bool
ExeIsUserObj( IGeomDB* pGeomDB, int nId)
{
   int nLev ;
   return ( pGeomDB->GetCalcLevel( nId, nLev)  &&  nLev == GDB_LV_USER) ;
}

//-------------------------------------------------------------------------------
static bool
ExeIsSystemObj( IGeomDB* pGeomDB, int nId)
{
   int nLev ;
   return ( pGeomDB->GetCalcLevel( nId, nLev)  &&  nLev == GDB_LV_SYSTEM) ;
}

//-------------------------------------------------------------------------------
static bool
ExeIsVisibleObj( IGeomDB* pGeomDB, int nId)
{
   int nStat ;
   return ( pGeomDB->GetCalcStatus( nId, nStat)  &&  nStat != GDB_ST_OFF) ;
}

//-------------------------------------------------------------------------------
static int
ExeVerifyOrNext( IGeomDB* pGeomDB, int nId, bool bOnlyVisible)
{
   while ( nId != GDB_ID_NULL) {
      if ( ExeIsUserObj( pGeomDB, nId)  &&
           ! pGeomDB->ExistsInfo( nId, GDB_SI_SOURCE)  &&
           ( ! bOnlyVisible  ||  ExeIsVisibleObj( pGeomDB, nId)))
         return nId ;
      nId = pGeomDB->GetNextGroup( nId) ;
   }
   return GDB_ID_NULL ;
}

//-------------------------------------------------------------------------------
static int
ExeVerifyOrPrev( IGeomDB* pGeomDB, int nId, bool bOnlyVisible)
{
   while ( nId != GDB_ID_NULL) {
      if ( ExeIsUserObj( pGeomDB, nId)  &&
           ( ! bOnlyVisible  ||  ExeIsVisibleObj( pGeomDB, nId)))
         return nId ;
      nId = pGeomDB->GetPrevGroup( nId) ;
   }
   return GDB_ID_NULL ;
}

//-------------------------------------------------------------------------------
static int
ExeGhostVerifyOrNext( IGeomDB* pGeomDB, int nId)
{
   while ( nId != GDB_ID_NULL) {
      if ( ExeIsSystemObj( pGeomDB, nId)  &&
           pGeomDB->ExistsInfo( nId, GDB_SI_SOURCE)) {
         int nPartId = GDB_ID_NULL ;
         pGeomDB->GetInfo( nId, GDB_SI_SOURCE, nPartId) ;
         int nRawId = pGeomDB->GetParentId( nPartId) ;
         if ( ExeIsRawPart( nRawId))
            return nId ;
      }
      nId = pGeomDB->GetNextGroup( nId) ;
   }
   return GDB_ID_NULL ;
}

//-------------------------------------------------------------------------------
bool
ExeIsPart( int nPartId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico sia un pezzo (gruppo sotto la radice con livello utente)
   if ( pGeomDB->GetGdbType( nPartId) == GDB_TY_GROUP  &&
        pGeomDB->GetParentId( nPartId) == GDB_ID_ROOT  &&
        ExeIsUserObj( pGeomDB, nPartId))
      return true ;
   else
      return false ;  
}

//-------------------------------------------------------------------------------
bool
ExeIsLayer( int nLayerId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico sia un layer (gruppo sotto un pezzo con livello utente)
   if ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP  &&
        ExeIsPart( pGeomDB->GetParentId( nLayerId))  &&
        ExeIsUserObj( pGeomDB, nLayerId))
      return true ;
   else
      return false ;  
}

//-------------------------------------------------------------------------------
int
ExeGetCurrPart( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, GDB_ID_NULL)
  // recupero il pezzo corrente
   return pGseCtx->m_nCurrPart ;
}

//-------------------------------------------------------------------------------
int
ExeGetCurrLayer( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, GDB_ID_NULL)
  // recupero il pezzo corrente
   return pGseCtx->m_nCurrLayer ;
}

//-------------------------------------------------------------------------------
bool
ExeSetCurrPartLayer( int nPartId, int nLayerId)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
   IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
   bool bOk = true ;
  // verifico validità e visibilità pezzo
   if ( pGeomDB->GetParentId( nPartId) == GDB_ID_ROOT  &&
        ExeIsUserObj( pGeomDB, nPartId)  &&
        ExeIsVisibleObj( pGeomDB, nPartId)) {
      if ( nPartId != pGseCtx->m_nCurrPart)
         pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
      pGseCtx->m_nCurrPart = nPartId ;
   }
   else {
      if ( nPartId == pGseCtx->m_nCurrPart || nPartId == GDB_ID_NULL) {
         pGseCtx->m_nCurrPart = GDB_ID_NULL ;
         pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
      }
     bOk = false ;
   }
  // verifico validità e visibilità layer
   if ( pGeomDB->GetParentId( nLayerId) == pGseCtx->m_nCurrPart  &&
        ExeIsUserObj( pGeomDB, nLayerId)  &&
        ExeIsVisibleObj( pGeomDB, nLayerId)) {
      pGseCtx->m_nCurrLayer = nLayerId ;
   }
   else {
      if ( nLayerId == pGseCtx->m_nCurrLayer  ||  nLayerId == GDB_ID_NULL)
         pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
     bOk = false ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSetCurrPartLayer(" + ToString( nPartId) + "," +
                                             ToString( nLayerId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
bool
ExeResetCurrPartLayer( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
   IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
  // reset
   pGseCtx->m_nCurrPart = GDB_ID_NULL ;
   pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
  // cerco il primo pezzo con un layer visibile
   int nPartId = ExeGetFirstPart( true) ;
   while ( nPartId != GDB_ID_NULL) {
     // cerco il primo layer visibile del pezzo
      int nLayerId = ExeGetFirstLayer( nPartId, true) ;
      if ( nLayerId != GDB_ID_NULL) {
        // assegno il pezzo corrente
         pGseCtx->m_nCurrPart = nPartId  ;
        // assegno il layer corrente
         pGseCtx->m_nCurrLayer = nLayerId ;
        // esco dal ciclo di ricerca
         break ;
      }
      nPartId = ExeGetNextPart( nPartId, true) ;
   }
  // se non ho trovato layer visibile mi accontento del primo pezzo visibile
   if ( pGseCtx->m_nCurrPart == GDB_ID_NULL)
      pGseCtx->m_nCurrPart = ExeGetFirstPart( true) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtResetCurrPartLayer()"
                    " -- Ids=" + ToString( pGseCtx->m_nCurrPart) + "," + ToString( pGseCtx->m_nCurrLayer) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return true ;
}

//-------------------------------------------------------------------------------
int
ExeGetPartCount( bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, 0)
  // conto i pezzi, considerando richiesta di visibilità
   int nCount = 0 ;
   int nPartId = ExeGetFirstPart( bOnlyVisible) ;
   while ( nPartId != GDB_ID_NULL) {
      ++ nCount ;
      nPartId = ExeGetNextPart( nPartId, bOnlyVisible) ;
   }
   return nCount ;
}

//-------------------------------------------------------------------------------
int
ExeGetFirstPart( bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il primo gruppo sotto la radice
   int nPartId = pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
  // verifico oppure passo al primo successivo valido
   return ExeVerifyOrNext( pGeomDB, nPartId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetNextPart( int nId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il successivo gruppo
   int nPartId = pGeomDB->GetNextGroup( nId) ;
  // verifico oppure passo al primo successivo valido
   return ExeVerifyOrNext( pGeomDB, nPartId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetLastPart( bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero l'ultimo gruppo sotto la radice
   int nPartId = pGeomDB->GetLastGroupInGroup( GDB_ID_ROOT) ;
  // verifico oppure passo al primo precedente valido
   return ExeVerifyOrPrev( pGeomDB, nPartId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetPrevPart( int nId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il precedente gruppo
   int nPartId = pGeomDB->GetPrevGroup( nId) ;
  // verifico oppure passo al primo precedente valido
   return ExeVerifyOrPrev( pGeomDB, nPartId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetFirstLayer( int nPartId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // verifico il pezzo (livello utente e se richiesto visibile)
   if ( ! ExeIsUserObj( pGeomDB, nPartId)  ||
        ( bOnlyVisible  &&  ! ExeIsVisibleObj( pGeomDB, nPartId)))
      return GDB_ID_NULL ;
  // recupero il primo layer nel pezzo
   int nLayerId = pGeomDB->GetFirstGroupInGroup( nPartId) ;
  // verifico oppure passo al primo successivo valido
   return ExeVerifyOrNext( pGeomDB, nLayerId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetNextLayer( int nId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il successivo gruppo
   int nLayerId = pGeomDB->GetNextGroup( nId) ;
  // verifico sia visibile oppure passo al primo successivo visibile
   return ExeVerifyOrNext( pGeomDB, nLayerId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetLastLayer( int nPartId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // verifico il pezzo (livello utente e se richiesto visibile)
   if ( ! ExeIsUserObj( pGeomDB, nPartId)  ||
        ( bOnlyVisible  &&  ! ExeIsVisibleObj( pGeomDB, nPartId)))
      return GDB_ID_NULL ;
  // recupero l'ultimo layer nel pezzo
   int nLayerId = pGeomDB->GetLastGroupInGroup( nPartId) ;
  // verifico oppure passo al primo precedente valido
   return ExeVerifyOrPrev( pGeomDB, nLayerId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetPrevLayer( int nId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il precedente gruppo
   int nLayerId = pGeomDB->GetPrevGroup( nId) ;
  // verifico sia visibile oppure passo al primo precedente visibile
   return ExeVerifyOrPrev( pGeomDB, nLayerId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
ExeGetFirstGhostPart( void)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il primo gruppo sotto la radice
   int nPartId = pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
  // verifico oppure passo al primo successivo valido
   return ExeGhostVerifyOrNext( pGeomDB, nPartId) ;
}

//-------------------------------------------------------------------------------
int
ExeGetNextGhostPart( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il successivo gruppo
   int nPartId = pGeomDB->GetNextGroup( nId) ;
  // verifico oppure passo al primo successivo valido
   return ExeGhostVerifyOrNext( pGeomDB, nPartId) ;
}

//-------------------------------------------------------------------------------
bool
ExeEraseEmptyParts( void)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il primo pezzo
   int nPartId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT), false)  ;
  // ciclo sui pezzi
   while ( nPartId != GDB_ID_NULL) {
     // verifico se il pezzo non contiene alcuna entità geometrica
      bool bFound = false ;
     // ciclo sui layer dei pezzi
      int nLayerId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetFirstGroupInGroup( nPartId), false) ;
      while ( nLayerId != GDB_ID_NULL) {
        // verifico se il layer contiene qualcosa
         if ( pGeomDB->GetGroupObjs( nLayerId) > 0) {
            bFound = true ;
            break ;
         }
        // passo al layer successivo
         nLayerId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetNextGroup( nLayerId), false) ;
      }
     // verifico se gruppo sorgente di pezzo in gruppo di lavorazione
      if ( pGeomDB->ExistsInfo( nPartId, GDB_SI_SOURCE))
         bFound = true ;
     // salvo Id pezzo corrente
      int nOldId = nPartId ;
     // passo al pezzo successivo
      nPartId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetNextGroup( nPartId), false) ;
     // se corrente da cancellare, procedo
      if ( ! bFound)
         pGeomDB->Erase( nOldId) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtEraseEmptyParts()" 
                    " -- Ok=" + ToString( true) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return true ;
}

//-----------------------------------------------------------------------------
static bool
MySelectGroupObjs( IGeomDB* pGeomDB, int nGrpId, int nFilter)
{
   bool bOk = true ;
  // Ciclo sugli oggetti del gruppo
   int nId = pGeomDB->GetFirstInGroup( nGrpId) ;
   while ( nId != GDB_ID_NULL) {
     // Se è gruppo seleziono i suoi componenti (ma non il gruppo)
      if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP) {
         bOk = MySelectGroupObjs( pGeomDB, nId, nFilter) ;
      }
     // altrimenti, se selezionabile lo seleziono direttamente
      else {
         if ( ( pGeomDB->GetGeoType( nId) & nFilter) != 0) {
            if ( ! pGeomDB->SelectObj( nId))
               bOk = false ;
         }
      }
     // Passo al successivo
      nId = pGeomDB->GetNext( nId) ;
   }
   return bOk ;
}

//-----------------------------------------------------------------------------
static bool
MyDeselectGroupObjs( IGeomDB* pGeomDB, int nGrpId)
{
   bool bOk = true ;
  // Ciclo sugli oggetti del gruppo
   int nId = pGeomDB->GetFirstInGroup( nGrpId) ;
   while ( nId != GDB_ID_NULL) {
     // Se è gruppo deseleziono i suoi componenti
      if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP) {
         bOk = MyDeselectGroupObjs( pGeomDB, nId) ;
      }
     // Eseguo deselezione (anche del gruppo per maggior sicurezza)
      if ( ! pGeomDB->DeselectObj( nId))
         bOk = false ;
     // Passo al successivo
      nId = pGeomDB->GetNext( nId) ;
   }
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSelectPartObjs( int nPartId)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
   IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
  // verifico sia veramente un pezzo
   bool bOk = ExeIsPart( nPartId) ;
  // eseguo selezione
   bOk = bOk && MySelectGroupObjs( pGeomDB, nPartId, pGseCtx->m_nObjFilterForSelect) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSelectPartObjs(" + ToString( nPartId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeDeselectPartObjs( int nPartId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico sia veramente un pezzo
   bool bOk = ExeIsPart( nPartId) ;
  // eseguo deselezione (anche del pezzo per maggior sicurezza)
   bOk = bOk && MyDeselectGroupObjs( pGeomDB, nPartId) && pGeomDB->DeselectObj( nPartId) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtDeselectPartObjs(" + ToString( nPartId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSelectLayerObjs( int nLayerId)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
   IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
  // verifico sia veramente un layer o almeno un gruppo di un pezzo
   bool bOk = ExeIsLayer( nLayerId)  ||
              ( ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP)  &&  ExeIsPart( pGeomDB->GetParentId( nLayerId))) ;
  // eseguo selezione
   bOk = bOk && MySelectGroupObjs( pGeomDB, nLayerId, pGseCtx->m_nObjFilterForSelect) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSelectLayerObjs(" + ToString( nLayerId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeDeselectLayerObjs( int nLayerId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico sia veramente un layer o almeno un gruppo di un pezzo
   bool bOk = ExeIsLayer( nLayerId)  ||
              ( ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP)  &&  ExeIsPart( pGeomDB->GetParentId( nLayerId))) ;
  // eseguo deselezione (anche del layer per maggior sicurezza)
   bOk = bOk && MyDeselectGroupObjs( pGeomDB, nLayerId) && pGeomDB->DeselectObj( nLayerId) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtDeselectLayerObjs(" + ToString( nLayerId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSelectPathObjs( int nId, bool bHaltOnFork)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, false)
   IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
  // verifico appartenga ad un layer (di un pezzo libero o in un grezzo)
   int nIdLayer = pGeomDB->GetParentId( nId) ;
   int nIdPart = pGeomDB->GetParentId( nIdLayer) ;
   bool bOk = ( nIdLayer != GDB_ID_NULL && nIdPart != GDB_ID_NULL &&
                ( ExeIsLayer( nIdLayer)  ||  ExeGetRawPartFromPart( nIdPart) != GDB_ID_NULL)) ;
  // verifico sia abilitata la selezione di curve
   bOk = bOk && ( pGseCtx->m_nObjFilterForSelect & GEO_CURVE) != 0 ;
  // seleziono percorso a partire da entità indicata usando tutte le curve del pezzo
   const int CHAIN_SIZE = 1000 ;
   const double CHAIN_TOLER = 10 * EPS_SMALL ;
   Point3d ptNear ;
   ChainCurves chainC ;
   bOk = bOk && chainC.Init( true, CHAIN_TOLER, CHAIN_SIZE) ;
   // ciclo sui layer del pezzo
   for ( int nLayId = pGeomDB->GetFirstGroupInGroup( nIdPart) ;
         nLayId != GDB_ID_NULL ;
         nLayId = pGeomDB->GetNextGroup( nLayId)) {
      // ciclo sulle entità del layer
      for ( int nEntId = pGeomDB->GetFirstInGroup( nLayId) ;
            nEntId != GDB_ID_NULL ;
            nEntId = pGeomDB->GetNext( nEntId)) {
        // non deve essere nascosta
         int nEntStat ;
         pGeomDB->GetCalcStatus( nEntId, nEntStat) ;
         if ( nEntStat == GDB_ST_OFF)
            continue ;
        // recupero la curva e il suo riferimento
         ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nEntId)) ;
         if ( pCrv == nullptr)
            continue ;
         Frame3d frCrv ;
         if ( ! pGeomDB->GetGlobFrame( nEntId, frCrv))
            continue ;
        // recupero i dati della curva necessari al concatenamento e li assegno
         Point3d ptStart, ptEnd ;
         Vector3d vtStart, vtEnd ;
         if ( ! pCrv->GetStartPoint( ptStart)  ||  ! pCrv->GetStartDir( vtStart)  ||
              ! pCrv->GetEndPoint( ptEnd)  ||  ! pCrv->GetEndDir( vtEnd))
            continue ;
         ptStart.ToGlob( frCrv) ;
         vtStart.ToGlob( frCrv) ;
         ptEnd.ToGlob( frCrv) ;
         vtEnd.ToGlob( frCrv) ;
         if ( nEntId == nId)
            ptNear = ptStart + CHAIN_TOLER * vtStart ;
         bOk = bOk && chainC.AddCurve( nEntId, ptStart, vtStart, ptEnd, vtEnd) ;
      }
   }
  // recupero il primo percorso concatenato
   int nFirstId = GDB_ID_NULL ;
   INTVECTOR vId2s ;
   bOk = bOk && chainC.GetChainFromNear( ptNear, bHaltOnFork, vId2s) ;
   for ( size_t i = 0 ; i < vId2s.size() ; ++i) {
      pGeomDB->SetStatus( abs( vId2s[i]), GDB_ST_SEL) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSelectPathObjs(" + ToString( nId) + "," +
                                           ( bHaltOnFork ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}