//----------------------------------------------------------------------------
//  EgalTech 2014-2015
//----------------------------------------------------------------------------
// File : EXE_GdbObjAttribs.cpp      Data : 04.05.15       Versione : 1.6e1
// Contenuto : Funzioni sugli attributi degli oggetti di GeomDB per EXE.
//
//
//
// Modifiche : 03.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgtStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;

//-----------------------------------------------------------------------------
bool
ExeCopyAttributes( int nSouId, int nDestId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // copio gli attributi (compreso il nome)
   bool bOk = pGeomDB->CopyAttributes( nSouId, nDestId) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetLevel( int nId, int nLevel)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // imposto il livello
   bool bOk = pGeomDB->SetLevel( nId, nLevel) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeRevertLevel( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // porto il livello allo stato precedente
   bool bOk = pGeomDB->RevertLevel( nId) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetLevel( int nId, int* pnLevel)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnLevel == nullptr)
      return false ;
  // recupero il livello
   return pGeomDB->GetLevel( nId, *pnLevel) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetCalcLevel( int nId, int* pnLevel)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnLevel == nullptr)
      return false ;
  // recupero il modo
   return pGeomDB->GetCalcLevel( nId, *pnLevel) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetMode( int nId, int nMode)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // imposto il modo
   bool bOk = pGeomDB->SetMode( nId, nMode) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeRevertMode( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // porto il modo allo stato precedente
   bool bOk = pGeomDB->RevertMode( nId) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetMode( int nId, int* pnMode)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnMode == nullptr)
      return false ;
  // recupero il modo
   return pGeomDB->GetMode( nId, *pnMode) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetCalcMode( int nId, int* pnMode)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnMode == nullptr)
      return false ;
  // recupero il modo
   return pGeomDB->GetCalcMode( nId, *pnMode) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetStatus( const INTVECTOR& vIds, int nStat)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero pezzo e layer correnti
   bool bCurrPartOff = false ;
   bool bCurrLayerOff = false ;
   int nCurrPartId = ExeGetCurrPart() ;
   int nCurrLayerId = ExeGetCurrLayer() ;
  // ciclo sul vettore degli identificativi
   bool bOk = true ;
   for ( size_t i = 0 ; i < vIds.size() && bOk ; ++ i) {
     // impostazione stato
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL) {
        // imposto il modo
         if ( ! pGeomDB->SetStatus( nId, nStat))
            bOk = false ;
        // se nascosto pezzo corrente o layer corrente
         if ( nStat == GDB_ST_OFF) {
            if ( nId == nCurrPartId)
               bCurrPartOff = true ;
            else if ( nId == nCurrLayerId)
               bCurrLayerOff = true ;
         }
        // passo al successivo
         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
      }
   }
  // se pezzo o layer correnti da rideterminare
   bool bPrevCmdLog = SetCmdLog( false) ;
   if ( bCurrPartOff)
      ExeResetCurrPartLayer() ;
   else if ( bCurrLayerOff)
      ExeSetCurrPartLayer( nCurrPartId, ExeGetFirstLayer( nCurrPartId, true)) ;
   SetCmdLog( bPrevCmdLog) ;
  // dichiaro progetto modificato
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sStat = "GDB_ST.ON" ;
      if ( nStat == GDB_ST_SEL)
         sStat = "GDB_ST.SEL" ;
      else if ( nStat == GDB_ST_OFF)
         sStat = "GDB_ST.OFF" ;
      string sLua = "EgtSetStatus({" + IdListToString( vIds) + "}," +
                                       sStat + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeRevertStatus( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // porto lo stato al valore precedente
   bool bOk = pGeomDB->RevertStatus( nId) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetStatus( int nId, int* pnStat)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnStat == nullptr)
      return false ;
  // recupero lo stato
   return pGeomDB->GetStatus( nId, *pnStat) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetCalcStatus( int nId, int* pnStat)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnStat == nullptr)
      return false ;
  // recupero lo stato
   return pGeomDB->GetCalcStatus( nId, *pnStat) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetMark( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // imposto l'evidenziazione
   bool bOk = pGeomDB->SetMark( nId) ;
  // non produce modifica perchè mark ignorato in salvataggio  
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeResetMark( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // cancello l'evidenziazione
   bool bOk = pGeomDB->ResetMark( nId) ;
  // non produce modifica perchè mark ignorato in salvataggio  
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetMark( int nId, int* pnMark)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnMark == nullptr)
      return false ;
  // recupero l'evidenziazione
   return pGeomDB->GetMark( nId, *pnMark) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetCalcMark( int nId, int* pnMark)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnMark == nullptr)
      return false ;
  // recupero il modo
   return pGeomDB->GetCalcMark( nId, *pnMark) ;
}

//-----------------------------------------------------------------------------
bool
ExeStdColor( const string& sName, Color& ColStd)
{
   return GetStdColor( sName, ColStd) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetColor( const INTVECTOR& vIds, const Color& cCol, bool bSetAlpha)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno il colore
   bool bOk = true ;
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL) {
         Color cNew = cCol ;
        // se richiesto, recupero alpha originale
         if ( ! bSetAlpha) {
            Color cOri ;
            if ( pGeomDB->GetCalcMaterial( nId, cOri))
               cNew.SetAlpha( cOri.GetIntAlpha()) ;
         }
        // eseguo assegnazione
         if ( ! pGeomDB->SetMaterial( nId, cNew))
            bOk = false ;
        // passo al successivo
         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
      }
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSetColor({" + IdListToString( vIds) + "},{" +
                                      ToString( cCol) + "}," +
                                      ( bSetAlpha ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetAlpha( const INTVECTOR& vIds, int nAlpha)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
   bool bOk = true ;
  // assegno la trasparenza
   for ( size_t i = 0 ; i < vIds.size() ; ++ i) {
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL) {
        // recupero il colore originale
         Color cCol ;
         bOk = bOk && pGeomDB->GetCalcMaterial( nId, cCol) ;
         cCol.SetAlpha( nAlpha) ;
        // eseguo assegnazione
         bOk = bOk && pGeomDB->SetMaterial( nId, cCol) ;
        // passo al successivo
         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
      }
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSetAlpha({" + IdListToString( vIds) + "}," +
                                      ToString( nAlpha) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeResetColor( const INTVECTOR& vIds)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // tolgo il colore
   bool bOk = true ;
   for ( size_t i = 0 ; i < vIds.size() ; ++ i) {
      int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
      while ( nId != GDB_ID_NULL) {
         if ( ! pGeomDB->SetMaterial( nId, GDB_MT_PARENT))
            bOk = false ;
        // passo al successivo
         nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
      }
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtResetColor({" + IdListToString( vIds) + "})" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetColor( int nId, Color& cCol)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il colore
   return pGeomDB->GetMaterial( nId, cCol) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetCalcColor( int nId, Color& cCol)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il colore
   return pGeomDB->GetCalcMaterial( nId, cCol) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetName( int nId, const string& sName)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno il nome
   bool bOk = pGeomDB->SetName( nId, sName) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSetName(" + ToString( nId) + ",'" +
                                    StringToLuaString( sName) + "')" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetName( int nId, string& sName)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il nome
   return pGeomDB->GetName( nId, sName) ;
}

//-----------------------------------------------------------------------------
bool
ExeExistsName( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico esistenza del nome
   return pGeomDB->ExistsName( nId) ;
}

//-----------------------------------------------------------------------------
bool
ExeRemoveName( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // rimuovo il nome
   bool bOk = pGeomDB->RemoveName( nId) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtRemoveName(" + ToString( nId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, bool bInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, bInfo) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, int nInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, nInfo) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, double dInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, dInfo) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const string& sInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, sInfo) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSetInfo(" + ToString( nId) + ",'" +
                                    StringToLuaString( sKey) + "','" +
                                    StringToLuaString( sInfo) + "')" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const Vector3d& vtV)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, vtV) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const Point3d& ptP)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, ptP) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const BBox3d& b3Box)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, b3Box) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const Frame3d& frFrame)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, frFrame) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const INTVECTOR& vnInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, vnInfo) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const DBLVECTOR& vdInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, vdInfo) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetInfo( int nId, const string& sKey, const STRVECTOR& vsInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno la info
   bool bOk = pGeomDB->SetInfo( nId, sKey, vsInfo) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, bool& bInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, bInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, int& nInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, nInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, double& dInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, dInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, string& sInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero info
   return pGeomDB->GetInfo( nId, sKey, sInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, Vector3d& vtV)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, vtV) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, Point3d& ptP)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, ptP) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, BBox3d& b3Box)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, b3Box) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, Frame3d& frFrame)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, frFrame) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, INTVECTOR& vnInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, vnInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, DBLVECTOR& vdInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, vdInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetInfo( int nId, const string& sKey, STRVECTOR& vsInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la info
   return pGeomDB->GetInfo( nId, sKey, vsInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeExistsInfo( int nId, const string& sKey)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico esistenza info
   return pGeomDB->ExistsInfo( nId, sKey) ;
}

//-----------------------------------------------------------------------------
bool
ExeRemoveInfo( int nId, const string& sKey)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // rimuovo la info
   bool bOk = pGeomDB->RemoveInfo( nId, sKey) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtRemoveInfo(" + ToString( nId) + ",'" +
                                       StringToLuaString( sKey) + "')" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetAllInfo( int nId, STRVECTOR& vsInfo)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero tutte le info
   return pGeomDB->GetAllInfo( nId, vsInfo) ;
}

//-----------------------------------------------------------------------------
bool
ExeSetTextureName( int nId, const string& sTxrName)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // assegno il nome della texture
   bool bOk = pGeomDB->SetTextureName( nId, sTxrName) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeSetTextureFrame( int nId, const Frame3d& frTxrRef, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale l'origine e i versori
   Point3d ptOrigL = GetPointLocal( pGeomDB, frTxrRef.Orig(), nRefType, frLoc) ;
   Vector3d vtXL = GetVectorLocal( pGeomDB, frTxrRef.VersX(), nRefType, frLoc) ;
   Vector3d vtYL = GetVectorLocal( pGeomDB, frTxrRef.VersY(), nRefType, frLoc) ;
   Vector3d vtZL = GetVectorLocal( pGeomDB, frTxrRef.VersZ(), nRefType, frLoc) ;
  // ricreo il riferimento in locale
   Frame3d frTxrLoc ;
   bOk = bOk && frTxrLoc.Set( ptOrigL, vtXL, vtYL, vtZL) ;
  // assegno il riferimento della texture
   bOk = bOk && pGeomDB->SetTextureFrame( nId, frTxrLoc) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeRemoveTextureData( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // rimuovo i dati della texture
   bool bOk = pGeomDB->RemoveTextureData( nId) ;
   ExeSetModified() ;
   return bOk ;
}

//-----------------------------------------------------------------------------
bool
ExeGetTextureName( int nId, string& sTxrName)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il nome della texture
   return pGeomDB->GetTextureName( nId, sTxrName) ;
}

//-----------------------------------------------------------------------------
bool
ExeGetTextureFrame( int nId, int nRefId, Frame3d& frTxrRef)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il riferimento della texture
   if ( ! pGeomDB->GetTextureFrame( nId, frTxrRef))
      return false ;
  // gestione trasformazione ( eventuale)
   return TransformFrame( pGeomDB, nId, nRefId, frTxrRef) ;
}