//----------------------------------------------------------------------------
//  EgalTech 2013-2013
//----------------------------------------------------------------------------
// File : GeomDB.cpp           Data : 08.04.13          Versione : 1.3a5
// Contenuto : Implementazione della classe GeomDB.
//
//
//
// Modifiche : 22.01.13 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "GeomDB.h"
#include "GdbGeo.h"
#include "DllMain.h"
#include "Attribs.h"
#include "NgeReader.h"
#include "NgeWriter.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgnStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include <new>

using namespace std ;

//----------------------------------------------------------------------------
IGeomDB*
CreateGeomDB( void)
{
   return static_cast<IGeomDB*> ( new(nothrow) GeomDB) ;
}

//----------------------------------------------------------------------------
// GeomDB
//----------------------------------------------------------------------------
GeomDB::GeomDB( void)
{
   m_GrpRadix.m_nId = GDB_ID_ROOT ;
   m_GrpRadix.SetMaterial( Color()) ;
}

//----------------------------------------------------------------------------
GeomDB::~GeomDB( void)
{
   Clear() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Init( void)
{
  // pulizia
   Clear() ;
  // imposto numero minimo buckets del map degli Id
   m_IdManager.Init( 1024) ;
  // imposto materiale di default
   m_GrpRadix.SetMaterial( Color()) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Clear( void)
{
  // pulisco mappa degli identificatori
   m_IdManager.Clear() ;
  // pulisco lista dei selezionati
   m_SelManager.Clear() ;
  // cancello i materiali custom
   m_MatManager.Clear() ;
  // disalloco i gruppi e gli oggetti
   m_GrpRadix.Clear() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Load( const std::string& sFileIn)
{
  // apertura file
   NgeReader ngeIn ;
   if ( ! ngeIn.Init( sFileIn)) {
      LOG_ERROR( GetEGkLogger(), "GeomDbLoad : Error on Init ")
      return false ;
   }

  // leggo l'intestazione
   if ( ! LoadHeader( ngeIn)) {
      string sOut = "GeomDbLoad : Error on pos " + ToString( ngeIn.GetCurrPos()) ;
      LOG_ERROR( GetEGkLogger(), sOut.c_str())
      return false ;
   }

  // leggo i materiali custom
   if ( ! m_MatManager.Load( ngeIn)) {
      string sOut = "GeomDbLoad : Error on pos " + ToString( ngeIn.GetCurrPos()) ;
      LOG_ERROR( GetEGkLogger(), sOut.c_str())
      return false ;
   }

  // ciclo di lettura dei nodi
   bool bEnd ;
   bool bOk = true ;
   do {
      if ( ! LoadOneObj( ngeIn, bEnd)) {
         bOk = false ;
         string sOut = "GeomDbLoad : Error on pos " + ToString( ngeIn.GetCurrPos()) ;
         LOG_ERROR( GetEGkLogger(), sOut.c_str())
      }
   } while ( ! bEnd) ;

   return bOk ;
}

//----------------------------------------------------------------------------
bool
GeomDB::LoadHeader( NgeReader& ngeIn)
{
  // intestazione
   int nKey ;
   if ( ! ngeIn.ReadKey( nKey)  ||  nKey != NGE_START)
      return false ;
   string sVal ;
   if ( ! ngeIn.ReadString( sVal, ",")  ||  sVal != NGE_GEOMDB)
      return false ;
   int nVal ;
   if ( ! ngeIn.ReadInt( nVal, "."))
      return false ;
   if ( ! ngeIn.ReadInt( nVal, "."))
      return false ;
   if ( ! ngeIn.ReadInt( nVal, ";", true))
      return false ;

  // materiale di default come colore
   if ( ! ngeIn.ReadKey( nKey)  ||  nKey != NGE_MAT_DEF)
      return false ;
   Color colDef( 0, 0, 0, 0) ;
   if ( ! ngeIn.ReadCol( colDef, ";", true))
      return false ;
   return SetDefaultMaterial( colDef) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::LoadOneObj( NgeReader& ngeIn, bool& bEnd)
{
  // in generale non è fine file
   bEnd = false ;

  // leggo la prossima linea : tipo di nodo
   int nKey ;
   if ( ! ngeIn.ReadKey( nKey))
      return false ;

  // se fine dati
   GdbObj* pGdbObj ;
   if ( nKey == NGE_END) {
      bEnd = true ;
      return true ;
   }
  // se gruppo
   else if ( nKey == NGE_A_GRP) {
      pGdbObj = new( nothrow) GdbGroup ;
   }
  // se copia  TODO ("X_CPY")..
   //else if ( sType == GdbCopy::GetKey) {
   //   pGdbObj = new( nothrow) GdbCopy ;
   //}
  // altrimenti oggetto geometrico
   else 
      pGdbObj = new( nothrow) GdbGeo ;

  // verifico l'oggetto GDB
   if ( pGdbObj == nullptr)
      return false ;

  // se lettura dati e inserimento nel DB vanno bene
   int nParentId ;
   if ( pGdbObj->Load( nKey, ngeIn, nParentId)  &&
        AddToGeomDB( pGdbObj, nParentId))
      return true ;
  // altrimenti errore
   else {
      delete pGdbObj ;
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
GeomDB::Save( const std::string& sFileOut, bool bBinary) const
{
  // apertura file
   NgeWriter ngeOut ;
   if ( ! ngeOut.Init( sFileOut, bBinary)) {
      LOG_ERROR( GetEGkLogger(), "GeomDbSave : Error on Init ")
      return false ;
   }

  // intestazione
   bool bOk = SaveHeader( ngeOut) ;

  // materiali custom
   if ( ! m_MatManager.Save( ngeOut))
      bOk = false ;

  // ciclo di scrittura degli oggetti
   const GdbObj* pGdbObj = m_GrpRadix.GetFirstObj() ;
   while ( pGdbObj != nullptr) {
     // recupero il livello dell'oggetto
      int nLevel = GDB_LV_USER ;
      pGdbObj->GetLevel( nLevel) ;
     // se non temporaneo
      if ( nLevel != GDB_LV_TEMP) {
        // salvo l'oggetto
         if ( ! pGdbObj->Save( ngeOut))
            bOk = false ;
      }
     // passo al successivo
      pGdbObj = pGdbObj->GetNext() ;
   }

  // terminazione
   if ( ! SaveFooter( ngeOut))
      bOk = false ;

  // chiusura file
   if ( ! ngeOut.Close())
      bOk = false ;

   return bOk ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SaveHeader( NgeWriter& ngeOut) const
{
  // intestazione
   ngeOut.WriteKey( NGE_START) ;
   ngeOut.WriteString( NGE_GEOMDB, ",") ;
   ngeOut.WriteInt( NGE_MAJOR_VER, ".") ;
   ngeOut.WriteInt( NGE_MINOR_VER, ".") ;
   ngeOut.WriteInt( NGE_PATCH_VER, ";", true) ;

  // materiale di default come colore
   Color colDef( 0, 0, 0, 0) ;
   GetDefaultMaterial( colDef) ;
   ngeOut.WriteKey( NGE_MAT_DEF) ;
   ngeOut.WriteCol( colDef, ";", true) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SaveFooter( NgeWriter& ngeOut) const
{
  // terminazione
   ngeOut.WriteKey( NGE_END) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ExistsObj( int nId) const
{
   return ( GetGdbObj( nId) != nullptr) ;
}

//----------------------------------------------------------------------------
GdbObj*
GeomDB::GetGdbObj( int nId)
{
  // impossibile
   if ( nId < GDB_ID_ROOT)
      return nullptr ;
  // radice
   else if ( nId == GDB_ID_ROOT)
      return &m_GrpRadix ;
  // un nodo qualubque
   else
      return m_IdManager.FindObj( nId) ;
}

//----------------------------------------------------------------------------
const GdbObj*
GeomDB::GetGdbObj( int nId) const
{
  // impossibile
   if ( nId < GDB_ID_ROOT)
      return nullptr ;
  // radice
   else if ( nId == GDB_ID_ROOT)
      return &m_GrpRadix ;
  // un nodo qualubque
   else
      return ( const_cast<IdManager&>(m_IdManager)).FindObj( nId) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::AddToGeomDB( GdbObj* pGObj, int nParentId)
{
  // verifico validità oggetto puntato
   if ( pGObj == nullptr)
      return false ;

  // verifica validità e unicità del nome
   if ( pGObj->m_nId <= GDB_ID_ROOT  ||  ExistsObj( pGObj->m_nId))
      return false ;

  // cerco il padre
   GdbGroup* pGroup = GetGdbGroup( nParentId) ;
   if ( pGroup == nullptr)
      return false ;
  // inserisco in coda alla lista del padre
   if ( ! pGObj->AddTail( pGroup))
       return false ;

  // inserisco in mappa Id
   return m_IdManager.AddObj( pGObj->m_nId, pGObj) ;
}

//----------------------------------------------------------------------------
int
GeomDB::AddGroup( int nId, int nParentId, const Frame3d& frFrame)
{
   GdbGroup* pGdbGroup ;


  // verifico validità ParentId
   if ( nParentId < GDB_ID_ROOT)
      return GDB_ID_NULL ;
  // verifico validità Id
   if ( nId <= GDB_ID_ROOT)
      nId = m_IdManager.GetNewId() ;
   if ( ExistsObj( nId))
      return GDB_ID_NULL ;
  // alloco gruppo Gdb
   pGdbGroup = new(nothrow) GdbGroup ;
   if ( pGdbGroup == nullptr)
      return GDB_ID_NULL ;
  // assegno identificativo
   pGdbGroup->m_nId = nId ;
  // assegno riferimento
   pGdbGroup->m_gfrFrame.Set( frFrame) ;
  // inserisco nel DB
   if ( ! AddToGeomDB( pGdbGroup, nParentId)) {
      delete pGdbGroup ;
      return GDB_ID_NULL ;
   }

   return nId ;
}

//----------------------------------------------------------------------------
int
GeomDB::AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj)
{
   GdbGeo* pGdbGeo ;


  // assegno GeoObj a gestore puntatore con rilascio automatico
   PtrOwner<IGeoObj> pRPGeoObj( pGeoObj) ;
  // verifico validità identificativo
   if ( nId <= GDB_ID_ROOT)
      nId = m_IdManager.GetNewId() ;
   if ( ExistsObj( nId))
      return GDB_ID_NULL ;
  // verifico validità oggetto Geo
   if ( ! IsValid( pRPGeoObj)  ||  ! pRPGeoObj->IsValid())
      return GDB_ID_NULL ;
  // alloco oggetto Gdb
   pGdbGeo = new(nothrow) GdbGeo ;
   if ( pGdbGeo == nullptr)
      return GDB_ID_NULL ;
  // assegno identificativo
   pGdbGeo->m_nId = nId ;
  // assegno dati
   pGdbGeo->m_pGeoObj = Release( pRPGeoObj) ;
  // inserisco nel DB
   if ( ! AddToGeomDB( pGdbGeo, nParentId)) {
      delete pGdbGeo ;
      return GDB_ID_NULL ;
   }

   return nId ;
}

//----------------------------------------------------------------------------
int
GeomDB::GetGdbType( int nId) const
{
   const GdbObj* pGdbObj ;


  // recupero l'oggetto
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return GDB_TY_NONE ;

  // se oggetto geometrico
   if ( ::GetGdbGeo( pGdbObj) != nullptr)
      return GDB_TY_GEO ;
  // se gruppo
   else if ( ::GetGdbGroup( pGdbObj) != nullptr)
      return GDB_TY_GROUP ;
  // altro
   else
      return GDB_TY_NONE ;
}

//----------------------------------------------------------------------------
IGeoObj*
GeomDB::GetGeoObj( int nId)
{
  // recupero l'oggetto Gdb
   const GdbGeo* pGdbGeo ;
   if ( ( pGdbGeo = GetGdbGeo( nId)) == nullptr)
      return nullptr ;

  // restituisco il suo contenuto geometrico
   return pGdbGeo->m_pGeoObj ;
}

//----------------------------------------------------------------------------
IGeoFrame3d*
GeomDB::GetGeoFrame( int nId)
{
  // recupero il gruppo Gdb
   GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr)
      return nullptr ;

  // restituisco il suo riferimento
   return &(pGdbGroup->m_gfrFrame) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetGroupFrame( int nId, Frame3d& frGrp) const
{
  // recupero il gruppo Gdb
   const GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = (const_cast<GeomDB*> (this))->GetGdbGroup( nId)) == nullptr)
      return false ;

  // copio il riferimento
   frGrp = pGdbGroup->m_gfrFrame.GetFrame() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetGroupGlobFrame( int nId, Frame3d& frGlob) const
{
  // recupero il gruppo Gdb
   const GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = (const_cast<GeomDB*> (this))->GetGdbGroup( nId)) == nullptr)
      return false ;

  // ne faccio calcolare il riferimento globale
   return pGdbGroup->GetGlobFrame( frGlob) ;
}

//----------------------------------------------------------------------------
int
GeomDB::GetGroupObjs( int nId) const
{
  // recupero il gruppo Gdb
   const GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = (const_cast<GeomDB*> (this))->GetGdbGroup( nId)) == nullptr)
      return 0 ;

  // restituisco il numero di nodi (figli)
   return pGdbGroup->GetObjCount() ;
}

//----------------------------------------------------------------------------
int
GeomDB::GetParentId( int nId) const
{
  // recupero l'oggetto Gdb
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return GDB_ID_NULL ;

  // restituisco l'Id del padre
   return pGdbObj->GetParentId() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetLocalBBox( int nId, BBox3d& b3Loc, int nFlag) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // eseguo l'operazione
   return pGdbObj->GetLocalBBox( b3Loc, nFlag) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetGlobalBBox( int nId, BBox3d& b3Glob, int nFlag) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il riferimento globale del gruppo cui appartiene
   Frame3d frGlob ;
   if ( ! GetGroupGlobFrame( pGdbObj->GetParentId(), frGlob))
      return false ;

  // eseguo l'operazione
   return pGdbObj->GetBBox( frGlob, b3Glob, nFlag) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetRefBBox( int nId, const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il riferimento globale del gruppo cui appartiene
   Frame3d frGlob ;
   if ( ! GetGroupGlobFrame( pGdbObj->GetParentId(), frGlob))
      return false ;

  // lo porto nel riferimento passato
   frGlob.ToLoc( frRef) ;

  // eseguo l'operazione
   return pGdbObj->GetBBox( frGlob, b3Ref, nFlag) ;
}

//----------------------------------------------------------------------------
int
GeomDB::Copy( int nIdSou, int nIdDest, int nParentIdDest)
{
  // verifico Id destinazione
   if ( nIdDest <= GDB_ID_ROOT)
      nIdDest = m_IdManager.GetNewId() ;
   if ( ExistsObj( nIdDest))
      return GDB_ID_NULL ;

  // verifico esistenza del sorgente
   GdbObj* pGdOSou ;
   if ( ( pGdOSou = GetGdbObj( nIdSou)) == nullptr)
      return GDB_ID_NULL ;

  // eseguo la copia
   GdbObj* pGdODest ;
   if ( ( pGdODest = pGdOSou->Clone( nIdDest, m_IdManager)) == nullptr)
      return GDB_ID_NULL ;

  // inserisco nel DB
   if ( ! AddToGeomDB( pGdODest, nParentIdDest)) {
      delete pGdODest ;
      return GDB_ID_NULL ;
   }

   return nIdDest ;
}

//----------------------------------------------------------------------------
int
GeomDB::CopyGlob( int nIdSou, int nIdDest, int nParentIdDest)
{
  // verifico Id destinazione
   if ( nIdDest <= GDB_ID_ROOT)
      nIdDest = m_IdManager.GetNewId() ;
   if ( ExistsObj( nIdDest))
      return GDB_ID_NULL ;

  // verifico esistenza del sorgente
   GdbObj* pGdOSou = GetGdbObj( nIdSou) ;
   if ( pGdOSou == nullptr)
      return GDB_ID_NULL ;

  // recupero il riferimento del sorgente
   Frame3d  frSou ;
   if ( ! GetGlobFrame( nIdSou, frSou))
      return false ;

  // recupero il riferimento del gruppo destinazione
   Frame3d  frDest ;
   if ( ! GetGroupGlobFrame( nParentIdDest, frDest))
      return false ;

  // eseguo la copia
   GdbObj* pGdODest ;
   if ( ( pGdODest = pGdOSou->Clone( nIdDest, m_IdManager)) == nullptr)
      return GDB_ID_NULL ;

  // porto la copia da riferimento sorgente a quello destinazione
   if ( ! AreSameFrame( frSou, frDest)) {
      pGdODest->ToGlob( frSou) ;
      pGdODest->ToLoc( frDest) ;
   } 

  // inserisco nel DB
   if ( ! AddToGeomDB( pGdODest, nParentIdDest)) {
      delete pGdODest ;
      return GDB_ID_NULL ;
   }

   return nIdDest ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Relocate( int nId, int nNewParentId, bool bGlob)
{
  // verifico esistenza dell'oggetto
   GdbObj* pGdbObj = GetGdbObj( nId) ;
   if ( pGdbObj == nullptr)
      return false ;

  // verifico esistenza del padre
   GdbGroup* pGroup = pGdbObj->GetParent() ;
   if ( pGroup == nullptr)
      return false ;

  // cerco il nuovo padre
   GdbGroup* pNewGroup = GetGdbGroup( nNewParentId) ;
   if ( pNewGroup == nullptr)
      return false ;

  // se vecchio e nuovo padre coincidono, non devo fare alcunché
   if ( pGroup->m_nId == pNewGroup->m_nId)
      return true ;

  // se rilocazione in globale
   if ( bGlob) {
     // recupero il riferimento del sorgente
      Frame3d  frCurr ;
      if ( ! pGroup->GetGlobFrame( frCurr))
         return false ;
     // recupero il riferimento del nuovo padre
      Frame3d  frNew ;
      if ( ! pNewGroup->GetGlobFrame( frNew))
         return false ;
     // porto l'oggetto dal riferimento originale a quello nuovo
      if ( ! AreSameFrame( frCurr, frNew)) {
         pGdbObj->ToGlob( frCurr) ;
         pGdbObj->ToLoc( frNew) ;
      } 
   }

  // sistemazioni in eventuali GdbIterator con quell'oggetto corrente
   m_IterManager.ResetObjIfSame( pGdbObj) ;

  // lo estraggo dalla posizione corrente del DB geometrico
   pGdbObj->Remove() ;

  // lo inserisco in coda alla lista del padre
   if ( ! pGdbObj->AddTail( pNewGroup)) {
     // in caso di errore (condizione assai remota qui) cancello tutto
      m_IdManager.RemoveObj( pGdbObj->m_nId) ;
      m_SelManager.RemoveObj( pGdbObj) ;
      delete pGdbObj ;
      return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Erase( int nId)
{
  // non si può cancellare il gruppo radice (escludo anche Id non validi)
   if ( nId <= GDB_ID_ROOT)
      return false ;

  // recupero l'oggetto
   GdbObj* pGdbObj ;
   pGdbObj = m_IdManager.FindObj( nId) ;
   if ( pGdbObj == nullptr)
      return false ;

   return Erase( pGdbObj) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Erase( GdbObj* pGdbObj)
{
  // deve essere valido
   if ( pGdbObj == nullptr)
      return false ;

  // non si può cancellare il gruppo radice
   if ( pGdbObj == &m_GrpRadix)
      return false ;

  // elimino da mappa dei nomi
   m_IdManager.RemoveObj( pGdbObj->m_nId) ;

  // eliminazione eventuale da lista dei selezionati
   m_SelManager.RemoveObj( pGdbObj) ;

  // sistemazioni in eventuali GdbIterator con quell'oggetto corrente
   m_IterManager.ResetObjIfSame( pGdbObj) ;

  // lo tolgo dalla lista
   pGdbObj->Remove() ;

  // lo disalloco (distruttore virtuale)
   delete pGdbObj ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Translate( int nId, const Vector3d& vtMove)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // eseguo la traslazione
   return pGdbObj->Translate( vtMove) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::TranslateGlob( int nId, const Vector3d& vtMove)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // recupero il riferimento in cui è immerso
   Frame3d  frObj ;
   if ( ! GetGlobFrame( nId, frObj))
      return false ;
  // porto il movimento in locale
   Vector3d vtMoveLoc = vtMove ;
   if ( ! vtMoveLoc.ToLoc( frObj))
      return false ;
  // eseguo la traslazione
   return pGdbObj->Translate( vtMoveLoc) ;
}

//----------------------------------------------------------------------------
// La traslazione è espressa nel riferimento del gruppo (ovvero il proprio).
//----------------------------------------------------------------------------
bool
GeomDB::TranslateGroup( int nId, const Vector3d& vtMove)
{
  // recupero il gruppo Gdb
   GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr)
      return false ;
  // utilizzo il riferimento proprio
  // porto il movimento nel riferimento in cui è immerso
   Vector3d vtMoveLoc = vtMove ;
   if ( ! vtMoveLoc.ToGlob( pGdbGroup->GetFrame()))
      return false ;
  // eseguo la traslazione
   return pGdbGroup->Translate( vtMoveLoc) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Rotate( int nId, const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // eseguo la rotazione
   return pGdbObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::RotateGlob( int nId, const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // recupero il riferimento in cui è immerso
   Frame3d  frObj ;
   if ( ! GetGlobFrame( nId, frObj))
      return false ;
  // porto i parametri di rotazione in locale
   Point3d ptAxLoc = ptAx ;
   if ( ! ptAxLoc.ToLoc( frObj))
      return false ;
   Vector3d vtAxLoc = vtAx ;
   if ( ! vtAxLoc.ToLoc( frObj))
      return false ;
  // eseguo la rotazione
   return pGdbObj->Rotate( ptAxLoc, vtAxLoc, dCosAng, dSinAng) ;
}

//----------------------------------------------------------------------------
// La rotazione è espressa nel riferimento del gruppo (ovvero il proprio).
//----------------------------------------------------------------------------
bool
GeomDB::RotateGroup( int nId, const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
{
  // recupero il gruppo Gdb
   GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr)
      return false ;
  // utilizzo il riferimento proprio
  // porto i parametri di rotazione nel riferimento in cui è immerso
   Point3d ptAxLoc = ptAx ;
   if ( ! ptAxLoc.ToGlob( pGdbGroup->GetFrame()))
      return false ;
   Vector3d vtAxLoc = vtAx ;
   if ( ! vtAxLoc.ToGlob( pGdbGroup->GetFrame()))
      return false ;
  // eseguo la rotazione
   return pGdbGroup->Rotate( ptAxLoc, vtAxLoc, dCosAng, dSinAng) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Scale( int nId, const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // eseguo la scalatura
   return pGdbObj->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ScaleGlob( int nId, const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // recupero il riferimento in cui è immerso
   Frame3d  frObj ;
   if ( ! GetGlobFrame( nId, frObj))
      return false ;
  // porto il riferimento di scalatura in locale
   Frame3d frRefLoc = frRef ;
   if ( ! frRefLoc.ToLoc( frObj))
      return false ;
  // eseguo la scalatura
   return pGdbObj->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ) ;
}

//----------------------------------------------------------------------------
// La scalatura è espressa nel riferimento del gruppo (ovvero il proprio).
//----------------------------------------------------------------------------
bool
GeomDB::ScaleGroup( int nId, const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
{
  // recupero il gruppo Gdb
   GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr)
      return false ;
  // utilizzo il riferimento proprio
  // porto il riferimento di scalatura nel riferimento in cui è immerso
   Frame3d frRefLoc = frRef ;
   if ( ! frRefLoc.ToGlob( pGdbGroup->GetFrame()))
      return false ;
  // eseguo la scalatura
   return pGdbGroup->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Mirror( int nId, const Point3d& ptOn, const Vector3d& vtNorm)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // eseguo l'operazione
   return pGdbObj->Mirror( ptOn, vtNorm) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::MirrorGlob( int nId, const Point3d& ptOn, const Vector3d& vtNorm)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;
  // recupero il riferimento in cui è immerso
   Frame3d  frObj ;
   if ( ! GetGlobFrame( nId, frObj))
      return false ;
  // porto i parametri di mirror in locale
   Point3d ptOnLoc = ptOn ;
   if ( ! ptOnLoc.ToLoc( frObj))
      return false ;
   Vector3d vtNormLoc = vtNorm ;
   if ( ! vtNormLoc.ToLoc( frObj))
      return false ;
  // eseguo l'operazione
   return pGdbObj->Mirror( ptOnLoc, vtNormLoc) ;
}

//----------------------------------------------------------------------------
// La specchiatura è espressa nel riferimento del gruppo (ovvero il proprio).
//----------------------------------------------------------------------------
bool
GeomDB::MirrorGroup( int nId, const Point3d& ptOn, const Vector3d& vtNorm)
{
  // recupero il gruppo Gdb
   GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr)
      return false ;
  // utilizzo il riferimento proprio
  // porto i parametri di mirror nel riferimento in cui è immerso
   Point3d ptOnLoc = ptOn ;
   if ( ! ptOnLoc.ToGlob( pGdbGroup->GetFrame()))
      return false ;
   Vector3d vtNormLoc = vtNorm ;
   if ( ! vtNormLoc.ToGlob( pGdbGroup->GetFrame()))
      return false ;
  // eseguo l'operazione
   return pGdbGroup->Mirror( ptOnLoc, vtNormLoc) ;
}

//----------------------------------------------------------------------------
// Selection
//----------------------------------------------------------------------------
bool
GeomDB::SelectObj( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

   return SetStatus( pGdbObj, GDB_ST_SEL) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::DeselectObj( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // se selezionato, lo deseleziono
   if ( pGdbObj->IsSelected())
      return SetStatus( pGdbObj, GDB_ST_ON) ;
  // altrimenti, va già bene
   else
      return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SelectGroupObjs( int nId)
{
  // recupero il gruppo Gdb
   GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr)
      return false ;

  // ciclo sugli oggetti del gruppo e li seleziono
   GdbObj* pGdbObj = pGdbGroup->GetFirstObj() ;
   while ( pGdbObj != nullptr) {
      if ( ! SetStatus( pGdbObj, GDB_ST_SEL))
         return false ;
      pGdbObj = pGdbObj->GetNext() ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::DeselectGroupObjs( int nId)
{
  // recupero il gruppo Gdb
   GdbGroup* pGdbGroup ;
   if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr)
      return false ;

  // ciclo sugli oggetti del gruppo e li seleziono
   GdbObj* pGdbObj = pGdbGroup->GetFirstObj() ;
   while ( pGdbObj != nullptr) {
     // se selezionato, lo deseleziono
      if ( pGdbObj->IsSelected()) {
         if ( ! SetStatus( pGdbObj, GDB_ST_ON))
            return false ;
      }
      pGdbObj = pGdbObj->GetNext() ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::IsSelectedObj( int nId) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero lo stato
   return pGdbObj->IsSelected() ;
}

//----------------------------------------------------------------------------
int
GeomDB::GetSelectedObjNbr( void) const
{
   return m_SelManager.GetSize() ;
}

//----------------------------------------------------------------------------
int
GeomDB::GetFirstSelectedObj( void) const
{
   GdbObj* pGObj = m_SelManager.GetFirstObj() ;

   return (( pGObj == nullptr) ? GDB_ID_NULL : pGObj->m_nId) ;
}

//----------------------------------------------------------------------------
int
GeomDB::GetNextSelectedObj( void) const
{
   GdbObj* pGObj = m_SelManager.GetNextObj() ;

   return (( pGObj == nullptr) ? GDB_ID_NULL : pGObj->m_nId) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ClearSelection( void)
{
   GdbObj* pGObj = m_SelManager.GetFirstObj() ;
   while ( pGObj != nullptr) {
       m_SelManager.RemoveObj( pGObj) ;
       pGObj->SetStatus( GDB_ST_ON) ;
       pGObj = m_SelManager.GetFirstObj() ;
   }
   
   return true ;   
}

//----------------------------------------------------------------------------
// Attributes
//----------------------------------------------------------------------------
bool
GeomDB::DumpAttributes( int nId, string& sOut, const char* szNewLine) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // eseguo il dump
   if ( pGdbObj->m_pAttribs != nullptr)
      return pGdbObj->m_pAttribs->Dump( *this, sOut, szNewLine) ;
   else {
      Attribs attr ;
      return attr.Dump( *this, sOut, szNewLine) ;
   }
}

//----------------------------------------------------------------------------
bool
GeomDB::SetLevel( int nId, int nLevel)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // assegno il livello 
   return  pGdbObj->SetLevel( nLevel) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::RevertLevel( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // ripristino il livello precedente
   return  pGdbObj->RevertLevel() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetLevel( int nId, int& nLevel) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il livello
   return pGdbObj->GetLevel( nLevel) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcLevel( int nId, int& nLevel) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il livello calcolato
   return pGdbObj->GetCalcLevel( nLevel) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetMode( int nId, int nMode)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // assegno il modo 
   return  pGdbObj->SetMode( nMode) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::RevertMode( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // ripristino il modo precedente
   return  pGdbObj->RevertMode() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMode( int nId, int& nMode) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il modo
   return pGdbObj->GetMode( nMode) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcMode( int nId, int& nMode) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il modo calcolato
   return pGdbObj->GetCalcMode( nMode) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetStatus( int nId, int nStat)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

   return SetStatus( pGdbObj, nStat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetStatus( GdbObj* pGdbObj, int nStat)
{
  // verifico validità oggetto
   if ( pGdbObj == nullptr)
      return false ;

  // assegno lo stato
   if ( ! pGdbObj->SetStatus( nStat))
      return false ;

  // se il nuovo stato è selezionato, inserisco oggetto in lista selezionati
   if ( nStat == GDB_ST_SEL)
      m_SelManager.AddObj( pGdbObj) ;
  // altrimenti provo a toglierlo
   else
      m_SelManager.RemoveObj( pGdbObj) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::RevertStatus( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

   return RevertStatus( pGdbObj) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::RevertStatus( GdbObj* pGdbObj)
{
  // verifico validità oggetto
   if ( pGdbObj == nullptr)
      return false ;

  // ripristino lo stato precedente
   if ( ! pGdbObj->RevertStatus())
      return false ;

  // se il nuovo stato è selezionato, inserisco oggetto in lista selezionati
   int nStat = GDB_ST_ON ;
   if ( pGdbObj->GetStatus( nStat)  &&  nStat == GDB_ST_SEL)
      m_SelManager.AddObj( pGdbObj) ;
  // altrimenti provo a toglierlo
   else
      m_SelManager.RemoveObj( pGdbObj) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetStatus( int nId, int& nStat) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero lo stato
   return pGdbObj->GetStatus( nStat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcStatus( int nId, int& nStat) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero lo stato calcolato
   return pGdbObj->GetCalcStatus( nStat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetMark( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // imposto la marcatura
   return  pGdbObj->SetMark() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ResetMark( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // cancello la marcatura
   return  pGdbObj->ResetMark() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMark( int nId, int& nMark) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero la marcatura
   return  pGdbObj->GetMark( nMark) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcMark( int nId, int& nMark) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero la marcatura calcolata
   return  pGdbObj->GetCalcMark( nMark) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetDefaultMaterial( Color cCol)
{
  // recupero l'oggetto radice
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( GDB_ID_ROOT)) == nullptr)
      return false ;

  // assegno il colore
   return  pGdbObj->SetMaterial( cCol) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetDefaultMaterial( Color& cCol) const
{
  // recupero l'oggetto radice
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( GDB_ID_ROOT)) == nullptr)
      return false ;

  // recupero il colore
   return pGdbObj->GetMaterial( cCol) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetMaterial( int nId, int nMat)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // verifico che il materiale esista o sia da padre
   if ( ! ExistsMaterial( nMat)  &&  nMat != GDB_MT_PARENT)
      return false ;

  // assegno il materiale tramite indice
   return  pGdbObj->SetMaterial( nMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetMaterial( int nId, const string& sMatName)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // assegno il materiale
   return SetMaterial( pGdbObj, sMatName) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetMaterial( GdbObj* pGdbObj, const string& sMatName)
{
  // verifico validità oggetto
   if ( pGdbObj == nullptr)
      return false ;

  // cerco il materiale nella libreria (indice materiali 1 based)
   int nIdMat = FindMaterial( sMatName) ;
   if ( nIdMat <= GDB_MT_NULL)
      return false ;

  // recupero il materiale per assegnare anche il colore
   Material mMat ;
   GetMaterialData( nIdMat, mMat) ;

  // assegno il materiale tramite indice
   return ( pGdbObj->SetMaterial( mMat.GetDiffuse())  &&
            pGdbObj->SetMaterial( nIdMat)) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetMaterial( int nId, Color cCol)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // assegno il materiale tramite colore
   return  pGdbObj->SetMaterial( cCol) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMaterial( int nId, int& nMat) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero l'indice del materiale
   return pGdbObj->GetMaterial( nMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMaterial( int nId, Material& mMat) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il materiale
   return GetMaterial( pGdbObj, mMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMaterial( const GdbObj* pGdbObj, Material& mMat) const
{
  // verifico validità oggetto
   if ( pGdbObj == nullptr)
      return false ;

  // recupero l'indice del materiale
   int nIdMat ;
   if ( ! pGdbObj->GetMaterial( nIdMat)  ||
        nIdMat == GDB_MT_PARENT  ||  nIdMat == GDB_MT_COLOR)
      return false ;

  // recupero il materiale
   return GetMaterialData( nIdMat, mMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMaterial( int nId, Color& cCol) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il colore del materiale
   return pGdbObj->GetMaterial( cCol) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcMaterial( int nId, int& nMat) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero l'indice del materiale calcolato
   return pGdbObj->GetCalcMaterial( nMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcMaterial( int nId, Material& mMat) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il materiale
   return GetCalcMaterial( pGdbObj, mMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcMaterial( const GdbObj* pGdbObj, Material& mMat) const
{
  // verifico validità oggetto
   if ( pGdbObj == nullptr)
      return false ;

  // recupero il materiale tramite l'indice
   int nIdMat ;
   if ( pGdbObj->GetCalcMaterial( nIdMat)) {
      if ( nIdMat == GDB_MT_COLOR) {
         Color cCol ;
         if ( pGdbObj->GetCalcMaterial( cCol)) {
            mMat.Set( cCol) ;
            return true ;
         }
      }  
      else if ( GetMaterialData( nIdMat, mMat))
         return true ;
   }
  // qualcosa è andato male,  recupero il colore di default
   Color cDef ;
   GetDefaultMaterial( cDef) ;
   mMat.Set( cDef) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetCalcMaterial( int nId, Color& cCol) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il colore del materiale calcolato
   return pGdbObj->GetCalcMaterial( cCol) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::UsedMaterialInGroup( int nMat, const GdbGroup* pGdbGroup) const
{
  // verifico se il gruppo utilizza direttamente il materiale
   int nObjMat ; 
   if ( pGdbGroup->GetMaterial( nObjMat)  &&  nObjMat == nMat)
      return true ;
  // scandisco il gruppo
   for ( const GdbObj* pGdbObj = pGdbGroup->GetFirstObj() ;
         pGdbObj != nullptr ;
         pGdbObj = pGdbObj->GetNext()) {
     // verifico utilizzo del materiale da parte dell'oggetto
      if ( pGdbObj->GetMaterial( nObjMat)  &&  nObjMat == nMat)
         return true ;
     // se l'oggetto è un gruppo, devo cercare nei suoi figli
      const GdbGroup* pGdbSubGrp ;
      if ( ( pGdbSubGrp = ::GetGdbGroup( pGdbObj)) != nullptr) {
         if ( UsedMaterialInGroup( nMat, pGdbSubGrp))
            return true ;
      } 
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
GeomDB::NotifyObjectsWithMaterialInGroup( int nMat, Color cCol, bool bByParent, GdbGroup* pGdbGroup)
{
  // verifico se il gruppo utilizza direttamente il materiale
   int nObjMat ; 
   // recupero il materiale
   if ( ! pGdbGroup->GetMaterial( nObjMat))
      nObjMat = GDB_MT_PARENT ;
   // se il materiale è usato dal gruppo
   bByParent = ( nObjMat == nMat  ||  ( nObjMat == GDB_MT_PARENT  &&  bByParent)) ;
   // eventuale aggiornamento del colore
   if ( nObjMat == nMat) {
      pGdbGroup->SetMaterial( cCol) ;
      pGdbGroup->SetMaterial( nMat) ;
   }
  // scandisco il gruppo
   bool bOk = true ;
   for ( GdbObj* pGdbObj = pGdbGroup->GetFirstObj() ;
         pGdbObj != nullptr ;
         pGdbObj = pGdbObj->GetNext()) {
     // se sottogruppo, devo cercare nei suoi figli
      GdbGroup* pGdbSubGrp ;
      if ( ( pGdbSubGrp = ::GetGdbGroup( pGdbObj)) != nullptr) {
         if ( ! NotifyObjectsWithMaterialInGroup( nMat, cCol, bByParent, pGdbSubGrp))
            bOk = false ;
      } 
     // altrimenti oggetto
      else {
        // recupero il materiale
         if ( ! pGdbObj->GetMaterial( nObjMat))
            nObjMat = GDB_MT_PARENT ;
        // se il materiale è usato dall'oggetto
         if ( nObjMat == nMat  ||
              ( nObjMat == GDB_MT_PARENT  &&  bByParent)) {
            if ( ! pGdbObj->OnSetMaterial())
               bOk = false ;
         }
        // eventuale aggiornamento del colore
         if ( nObjMat == nMat) {
            pGdbObj->SetMaterial( cCol) ;
            pGdbObj->SetMaterial( nMat) ;
         }
      }
   }

   return bOk ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetName( int nId, const string& sName)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // assegno il nome
   return pGdbObj->SetName( sName) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetName( int nId, string& sName) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero il nome
   return pGdbObj->GetName( sName) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::RemoveName( int nId)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // rimuovo il nome
   return pGdbObj->RemoveName() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SetInfo( int nId, const string& sKey, const string& sInfo)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // assegno l'Info
   return pGdbObj->SetInfo( sKey, sInfo) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetInfo( int nId, const string& sKey, string& sInfo) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // recupero l'Info
   return pGdbObj->GetInfo( sKey, sInfo) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::RemoveInfo( int nId, const string& sKey)
{
  // recupero l'oggetto
   GdbObj* pGdbObj ;
   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
      return false ;

  // rimuovo l'Info
   return pGdbObj->RemoveInfo( sKey) ;
}

//----------------------------------------------------------------------------
// Material Library
//----------------------------------------------------------------------------
int
GeomDB::AddMaterial( const string& sName, const Material& matM)
{
   return m_MatManager.AddMaterial( sName, matM) ;
}

//----------------------------------------------------------------------------
int
GeomDB::FindMaterial( const std::string& sName) const
{
   return m_MatManager.FindMaterial( sName) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::EraseMaterial( int nMat, bool& bInUse)
{
  // verifico validità Id
   if ( nMat <= GDB_MT_NULL) {
      bInUse = false ;
      return false ;
   }
  // verifico esistenza materiale
   if ( ! m_MatManager.ExistsMaterial( nMat)) {
      bInUse = false ;
      return true ;
   }
  // verifico se usato da qualche oggetto
   if ( UsedMaterialInGroup( nMat, &m_GrpRadix)) {
      bInUse = true ;
      return false ;
   }
  // elimino il materiale
   bInUse = false ;
   return m_MatManager.EraseMaterial( nMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMaterialData( int nMat, Material& matM) const
{
   return m_MatManager.GetMaterialData( nMat, matM) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::GetMaterialName( int nMat, std::string& sName) const
{
   return m_MatManager.GetMaterialName( nMat, sName) ;
}

//----------------------------------------------------------------------------
int
GeomDB::GetMaxMaterialId( void) const
{
   return m_MatManager.GetMaxMaterialId() ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ExistsMaterial( int nMat) const
{
   return m_MatManager.ExistsMaterial( nMat) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::IsCustomMaterial( int nMat, bool& bCustom) const
{
   return m_MatManager.IsCustomMaterial( nMat, bCustom) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ModifyMaterialData( int nMat, const Material& matM)
{
   if ( ! m_MatManager.ModifyMaterialData( nMat, matM))
      return false ;
  // notifico gli oggetti che usano questo materiale (e gli aggiorno il colore)
   NotifyObjectsWithMaterialInGroup( nMat, matM.GetDiffuse(), false, &m_GrpRadix) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ModifyMaterialName( int nMat, const std::string& sName)
{
   return m_MatManager.ModifyMaterialName( nMat, sName) ;
}