EgtGeomKernel/GeomDB.cpp

//----------------------------------------------------------------------------
//  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 "/EgtDev/Include/EgnStringUtils.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() ;
  // disalloco i gruppi e gli oggetti
   m_GrpRadix.Clear() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::Load( const std::string& sFileIn)
{
   bool    bOk ;
   bool    bEnd ;
   Scanner TheScanner ;


  // inizializzo lo scanner
   if ( ! TheScanner.Init( sFileIn)) {
      LOG_ERROR( GetEGkLogger(), "GeomDbLoad : Error on Init ")
      return false ;
   }

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

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

   return bOk ;
}

//----------------------------------------------------------------------------
bool
GeomDB::LoadHeader( Scanner& TheScanner)
{
   string  sLine ;

   
  // recupero la prima linea
   if ( ! TheScanner.GetLine( sLine))
      return false ;
  // deve essere l'intestazione
   if ( sLine != "START")
      return false ;
  // recupero la riga successiva
   if ( ! TheScanner.GetLine( sLine))
      return false ;
  // leggo i parametri
   // TODO

  // recupero la linea
   if ( ! TheScanner.GetLine( sLine))
      return false ;
  // deve essere il materiale di default
   if ( sLine != "MAT_DEF")
      return false ;
  // recupero la riga successiva
   if ( ! TheScanner.GetLine( sLine))
      return false ;
  // la divido in parametri
   STRVECTOR vsParams ;
   Tokenize( sLine, ",;", vsParams) ;
  // 4 parametri
   if ( vsParams.size() != 4)
      return false ;
  // leggo il materiale come colore
   int nRed ;
   if ( ! FromString( vsParams[0], nRed))
      return false ;
   int nGreen ;
   if ( ! FromString( vsParams[1], nGreen))
      return false ;
   int nBlue ;
   if ( ! FromString( vsParams[2], nBlue))
      return false ;
   int nAlpha ;
   if ( ! FromString( vsParams[3], nAlpha))
      return false ;
   Color colDef( nRed, nGreen, nBlue, nAlpha) ;
   return SetDefaultMaterial( colDef) ;
}

//----------------------------------------------------------------------------
bool
GeomDB::LoadOneObj( Scanner& TheScanner, bool& bEnd)
{
   int     nParentId ;
   string  sType ;
   GdbObj* pGdbObj ;


  // in generale non è fine file
   bEnd = false ;

  // leggo la prossima linea : tipo di nodo
   if ( ! TheScanner.GetLine( sType))
      return false ;

  // se fine dati
   if ( sType == "END") {
      bEnd = true ;
      return true ;
   }
  // se gruppo
   else if ( sType == GdbGroup::GetKey()) {
      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
   if ( pGdbObj->Load( sType, TheScanner, nParentId)  &&
        AddToGeomDB( pGdbObj, nParentId))
      return true ;
  // altrimenti errore
   else {
      delete pGdbObj ;
      return false ;
   }
}

//----------------------------------------------------------------------------
bool
GeomDB::Save( const std::string& sFileOut) const
{
  // apertura file
   ofstream ofSave ;
   ofSave.open( stringtoW( sFileOut)) ;
   if ( ! ofSave.good())
      return false ;

  // intestazione
   bool bOk = SaveHeader( ofSave) ;

  // 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( ofSave))
            bOk = false ;
      }
     // passo al successivo
      pGdbObj = pGdbObj->GetNext() ;
   }
   ofSave << "END" << endl ;

  // chiusura file
   ofSave.close() ;

   return bOk ;
}

//----------------------------------------------------------------------------
bool
GeomDB::SaveHeader( ostream& osOut) const
{
  // intestazione
   osOut << "START" << endl ;
   osOut << "GeomDB,1.5.3.8;" << endl ;

  // materiale di default come colore
   osOut << "MAT_DEF" << endl ;
   Color colDef( 0, 0, 0, 0) ;
   GetDefaultMaterial( colDef) ; 
   osOut << ToString( colDef.GetIntRed()) ;
   osOut << "," << ToString( colDef.GetIntGreen()) ;
   osOut << "," << ToString( colDef.GetIntBlue()) ;
   osOut << "," << ToString( colDef.GetIntAlpha()) << ";" << endl ;

   return true ;
}

//----------------------------------------------------------------------------
bool
GeomDB::ExistsObj( int nId) const
{
   return ( (const_cast<GeomDB*>(this))->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) ;
}

//----------------------------------------------------------------------------
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 ;

  // aggiorno gestore Id
   m_IdManager.UpdateMaxId( pGObj->m_nId) ;

  // inserisco in mappa nomi
   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.m_frF = 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 = (const_cast<GeomDB*> (this))->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.m_frF ;
   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 = (const_cast<GeomDB*> (this))->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 = (const_cast<GeomDB*> (this))->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 = (const_cast<GeomDB*> (this))->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 = (const_cast<GeomDB*> (this))->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 ;
   if ( ( pGdOSou = GetGdbObj( nIdSou)) == 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::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) ;
}

//----------------------------------------------------------------------------
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) ;
}

//----------------------------------------------------------------------------
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) ;
}

//----------------------------------------------------------------------------
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) ;
}

//----------------------------------------------------------------------------
// 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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->GetGdbObj( nId)) == nullptr)
      return false ;

  // eseguo il dump
   if ( pGdbObj->m_pAttribs != nullptr)
      return pGdbObj->m_pAttribs->Dump( sOut, szNewLine) ;
   else {
      Attribs attr ;
      return attr.Dump( 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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->GetGdbObj( nId)) == nullptr)
      return false ;

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

//----------------------------------------------------------------------------
bool
GeomDB::SetDefaultMaterial( Color cCol)
{
  // recupero l'oggetto
   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
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = (const_cast<GeomDB*>(this))->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 ;

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

//----------------------------------------------------------------------------
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 = (const_cast<GeomDB*>(this))->GetGdbObj( nId)) == nullptr)
      return false ;

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

//----------------------------------------------------------------------------
bool
GeomDB::GetMaterial( int nId, Color& cCol) const
{
  // recupero l'oggetto
   const GdbObj* pGdbObj ;
   if ( ( pGdbObj = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->GetGdbObj( nId)) == nullptr)
      return false ;

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

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

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

//----------------------------------------------------------------------------
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 = (const_cast<GeomDB*>(this))->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 = (const_cast<GeomDB*>(this))->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) ;
}