//---------------------------------------------------------------------------- // EgalTech 2013-2013 //---------------------------------------------------------------------------- // File : GdbObj.cpp Data : 05.03.14 Versione : 1.5c1 // Contenuto : Implementazione della classe GdbObj. // // // // Modifiche : 28.11.13 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "GeomDB.h" #include "GdbObj.h" #include "GdbGroup.h" #include "Attribs.h" #include "TextureData.h" #include "UserObjDefault.h" #include "NgeWriter.h" #include "NgeReader.h" #include "/EgtDev/Include/EGkGdbFunct.h" #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Include/EGkUserObjFactory.h" #include "/EgtDev/Include/EGnStringKeyVal.h" #include using namespace std ; //---------------------------------------------------------------------------- GdbObj::GdbObj( void) : m_nId( GDB_ID_NULL), m_pAttribs( nullptr), m_nStpFactor( 0), m_nStpPattern( 0), m_pTxrData( nullptr), m_pUserObj( nullptr), m_pGDB( nullptr), m_pNext( nullptr), m_pPrev( nullptr), m_pParent( nullptr), m_pSelNext( nullptr), m_pSelPrev( nullptr) { } //---------------------------------------------------------------------------- GdbObj::~GdbObj( void) { // cancello gli attributi if ( m_pAttribs != nullptr) delete m_pAttribs ; m_pAttribs = nullptr ; // cancello i dati della texture if ( m_pTxrData != nullptr) delete m_pTxrData ; m_pTxrData = nullptr ; // cancello UserObj if ( m_pUserObj != nullptr) delete m_pUserObj ; m_pUserObj = nullptr ; // aggiorno managers del Db geometrico di appartenenza if ( m_pGDB != nullptr) { // elimino da mappa dei nomi m_pGDB->m_IdManager.RemoveObj( m_nId) ; // eventuale rimozione da lista selezionati m_pGDB->m_SelManager.RemoveObj(this) ; // sistemazioni in eventuali GdbIterator con quell'oggetto corrente m_pGDB->m_IterManager.ResetObjIfSame( this) ; } m_pGDB = nullptr ; } //---------------------------------------------------------------------------- bool GdbObj::CopyFrom( const GdbObj* pSou) { // elimino eventuali attributi pre-esistenti if ( m_pAttribs != nullptr) delete m_pAttribs ; m_pAttribs = nullptr ; // reset stipple m_nStpFactor = 0 ; m_nStpPattern = 0 ; // elimino eventuali dati della texture pre-esistenti if ( m_pTxrData != nullptr) delete m_pTxrData ; m_pTxrData = nullptr ; // elimino eventuale UserObj pre-esistente if ( m_pUserObj != nullptr) delete m_pUserObj ; m_pUserObj = nullptr ; // se l'oggetto sorgente non esiste if ( pSou == nullptr) { m_nId = GDB_ID_NULL ; return false ; } // copio Id m_nId = pSou->m_nId ; // copio stipple m_nStpFactor = pSou->m_nStpFactor ; m_nStpPattern = pSou->m_nStpPattern ; // copio gli attributi, i dati della texture e UserObj return ( CopyAttribsFrom( pSou) && CopyTextureDataFrom( pSou) && CopyUserObjFrom( pSou)) ; } //---------------------------------------------------------------------------- bool GdbObj::CopyStippleDataFrom( const GdbObj* pSou) { // se l'oggetto sorgente non esiste if ( pSou == nullptr) return false ; // copio stipple m_nStpFactor = pSou->m_nStpFactor ; m_nStpPattern = pSou->m_nStpPattern ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::CopyAttribsFrom( const GdbObj* pSou) { // se l'oggetto sorgente non esiste if ( pSou == nullptr) return false ; // cancello gli attributi originali if ( m_pAttribs != nullptr) delete m_pAttribs ; m_pAttribs = nullptr ; // copio gli attributi if ( pSou->m_pAttribs != nullptr) { m_pAttribs = pSou->m_pAttribs->Clone() ; if ( m_pAttribs == nullptr) return false ; // se selezionato, deve diventare solo visibile if ( m_pAttribs->GetStatus() == GDB_ST_SEL) m_pAttribs->SetStatus( GDB_ST_ON) ; // marcatura sempre disabilitata m_pAttribs->ResetMark() ; } return true ; } //---------------------------------------------------------------------------- bool GdbObj::CopyTextureDataFrom( const GdbObj* pSou) { // se l'oggetto sorgente non esiste if ( pSou == nullptr) return false ; // cancello i dati di texture originali if ( m_pTxrData != nullptr) delete m_pTxrData ; m_pTxrData = nullptr ; // copio texture data if ( pSou->m_pTxrData != nullptr) { m_pTxrData = pSou->m_pTxrData->Clone() ; if ( m_pTxrData == nullptr) return false ; } return true ; } //---------------------------------------------------------------------------- bool GdbObj::CopyUserObjFrom( const GdbObj* pSou) { // se l'oggetto sorgente non esiste if ( pSou == nullptr) return false ; // copio UserObj originale if ( m_pUserObj != nullptr) delete m_pUserObj ; m_pUserObj = nullptr ; // copio UserObj if ( pSou->m_pUserObj != nullptr) { m_pUserObj = pSou->m_pUserObj->Clone() ; if ( m_pUserObj == nullptr) return false ; m_pUserObj->SetOwner( m_nId, m_pGDB) ; } return true ; } //---------------------------------------------------------------------------- // Node //---------------------------------------------------------------------------- int GdbObj::GetParentId( void) const { if ( m_pParent != nullptr) return m_pParent->m_nId ; else return GDB_ID_NULL ; } //---------------------------------------------------------------------------- bool GdbObj::AddTail( GdbGroup* pParent) { // se il padre non è definito, errore if ( pParent == nullptr) return false ; // se non ci sono figli if ( pParent->m_pLastObj == nullptr) { pParent->m_pLastObj = this ; pParent->m_pFirstObj = this ; m_pParent = pParent ; m_pNext = nullptr ; m_pPrev = nullptr ; m_pParent->ObjCountInc() ; return true ; } // caso standard return InsertAfter( pParent->m_pLastObj) ; } //---------------------------------------------------------------------------- bool GdbObj::AddHead( GdbGroup* pParent) { // se il padre non è definito, errore if ( pParent == nullptr) return false ; // se non ci sono figli if ( pParent->m_pFirstObj == nullptr) { pParent->m_pFirstObj = this ; pParent->m_pLastObj = this ; m_pParent = pParent ; m_pNext = nullptr ; m_pPrev = nullptr ; m_pParent->ObjCountInc() ; return true ; } // caso standard return InsertBefore( pParent->m_pFirstObj) ; } //---------------------------------------------------------------------------- bool GdbObj::InsertAfter( GdbObj* pRef) { // se riferimento non definito, errore if ( pRef == nullptr) return false ; // sistemazione puntatori di elemento inserito m_pNext = pRef->m_pNext ; m_pPrev = pRef ; m_pParent = pRef->m_pParent ; // sistemazione puntatori di elemento di riferimento pRef->m_pNext = this ; // sistemazione puntatori di eventuale elemento successivo if ( m_pNext != nullptr) m_pNext->m_pPrev = this ; // sistemazione dell'eventuale padre if ( m_pParent != nullptr) { // se nuovo ultimo nodo if ( m_pParent->m_pLastObj == pRef) m_pParent->m_pLastObj = this ; m_pParent->ObjCountInc() ; } return true ; } //---------------------------------------------------------------------------- bool GdbObj::InsertBefore( GdbObj* pRef) { // se riferimento non definito, errore if ( pRef == nullptr) return false ; // sistemazione puntatori di elemento inserito m_pNext = pRef ; m_pPrev = pRef->m_pPrev ; m_pParent = pRef->m_pParent ; // sistemazione puntatori di elemento corrente pRef->m_pPrev = this ; // sistemazione puntatori di eventuale elemento precedente if ( m_pPrev != nullptr) m_pPrev->m_pNext = this ; // sistemazione dell'eventuale padre if ( m_pParent != nullptr) { // se nuovo primo nodo if ( m_pParent->m_pFirstObj == pRef) m_pParent->m_pFirstObj = this ; m_pParent->ObjCountInc() ; } return true ; } /*-------------------------------------------------------------------------*/ bool GdbObj::Swap( GdbObj* pOther) { // verifico esistenza dell'altro if ( pOther == nullptr) return false ; // sistemazione degli eventuali padri if ( m_pParent != nullptr) { if ( m_pParent->m_pFirstObj == this) m_pParent->m_pFirstObj = pOther ; if ( m_pParent->m_pLastObj == this) m_pParent->m_pLastObj = pOther ; } if ( pOther->m_pParent != nullptr) { if ( pOther->m_pParent->m_pFirstObj == pOther) pOther->m_pParent->m_pFirstObj = this ; if ( pOther->m_pParent->m_pLastObj == pOther) pOther->m_pParent->m_pLastObj = this ; } swap( m_pParent, pOther->m_pParent) ; // sistemazione dei precedenti if ( m_pPrev != nullptr) m_pPrev->m_pNext = pOther ; if ( pOther->m_pPrev != nullptr) pOther->m_pPrev->m_pNext = this ; swap( m_pPrev, pOther->m_pPrev) ; // sistemazione dei successivi if ( m_pNext != nullptr) m_pNext->m_pPrev = pOther ; if ( pOther->m_pNext != nullptr) pOther->m_pNext->m_pPrev = this ; swap( m_pNext, pOther->m_pNext) ; return true ; } /*-------------------------------------------------------------------------*/ bool GdbObj::Remove( void) { // sistemazione dell'eventuale padre if ( m_pParent != nullptr) { if ( m_pParent->m_pFirstObj == this) m_pParent->m_pFirstObj = m_pNext ; if ( m_pParent->m_pLastObj == this) m_pParent->m_pLastObj = m_pPrev ; m_pParent->ObjCountDec() ; } // sistemazione di eventuale precedente if ( m_pPrev != nullptr) m_pPrev->m_pNext = m_pNext ; // sistemazione di eventuale successivo if ( m_pNext != nullptr) m_pNext->m_pPrev = m_pPrev ; return true ; } //---------------------------------------------------------------------------- // Attribs //---------------------------------------------------------------------------- bool GdbObj::SaveAttribs( NgeWriter& ngeOut) const { if ( m_pAttribs != nullptr) return m_pAttribs->Save( ngeOut) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::LoadAttribs( NgeReader& ngeIn) { if ( GetSafeAttribs() == nullptr) return false ; return m_pAttribs->Load( ngeIn) ; } //---------------------------------------------------------------------------- Attribs* GdbObj::GetSafeAttribs( void) { if ( m_pAttribs == nullptr) m_pAttribs = new( nothrow) Attribs ; return m_pAttribs ; } //---------------------------------------------------------------------------- bool GdbObj::SetLevel( int nLevel) { // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // assegno il livello m_pAttribs->SetLevel( nLevel) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::RevertLevel( void) { // se non ci sono attributi non fa alcunchè if ( m_pAttribs == nullptr) return true ; // ripristina il vecchio livello m_pAttribs->RevertLevel() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetLevel( int& nLevel) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // il livello è definito nLevel = m_pAttribs->GetLevel() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetCalcLevel( int& nLevel) const { // recupero il livello dell'oggetto int nObjLevel = GDB_LV_USER ; if ( m_pAttribs != nullptr) nObjLevel = m_pAttribs->GetLevel() ; // se il livello è TEMP, non ho bisogno di sapere altro if ( nObjLevel == GDB_LV_TEMP) { nLevel = GDB_LV_TEMP ; return true ; } // recupero il livello dell'eventuale padre int nParentLevel = GDB_LV_USER ; if ( GetParent() != nullptr) GetParent()->GetCalcLevel( nParentLevel) ; // calcolo il livello nLevel = ::CalcLevel( nObjLevel, nParentLevel) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::SetMode( int nMode) { // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // assegno il modo m_pAttribs->SetMode( nMode) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::RevertMode( void) { // se non ci sono attributi non fa alcunchè if ( m_pAttribs == nullptr) return true ; // ripristina il vecchio modo m_pAttribs->RevertMode() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetMode( int& nMode) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // il modo è definito nMode = m_pAttribs->GetMode() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetCalcMode( int& nMode) const { // recupero il modo dell'oggetto int nObjMode = GDB_MD_STD ; if ( m_pAttribs != nullptr) nObjMode = m_pAttribs->GetMode() ; // se il modo è HIDDEN, non ho bisogno di sapere altro if ( nObjMode == GDB_MD_HIDDEN) { nMode = GDB_MD_HIDDEN ; return true ; } // recupero il modo dell'eventuale padre int nParentMode = GDB_MD_STD ; if ( GetParent() != nullptr) GetParent()->GetCalcMode( nParentMode) ; // calcolo il modo nMode = ::CalcMode( nObjMode, nParentMode) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::SetStatus( int nStat) { // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // assegno lo stato m_pAttribs->SetStatus( nStat) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::RevertStatus( void) { // se non ci sono attributi non fa alcunchè if ( m_pAttribs == nullptr) return true ; // ripristina il vecchio stato m_pAttribs->RevertStatus() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::IsOff( void) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // lo stato è definito return ( m_pAttribs->GetStatus() == GDB_ST_OFF) ; } //---------------------------------------------------------------------------- bool GdbObj::IsOn( void) const { // se non ci sono attributi (On di default) if ( m_pAttribs == nullptr) return true ; // lo stato è definito return ( m_pAttribs->GetStatus() == GDB_ST_ON) ; } //---------------------------------------------------------------------------- bool GdbObj::IsSelected( void) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // lo stato è definito return ( m_pAttribs->GetStatus() == GDB_ST_SEL) ; } //---------------------------------------------------------------------------- bool GdbObj::GetStatus( int& nStat) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // lo stato è definito nStat = m_pAttribs->GetStatus() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetCalcStatus( int& nStat, int nLev) const { // recupero lo stato dell'oggetto int nObjStat = GDB_ST_ON ; if ( m_pAttribs != nullptr) nObjStat = m_pAttribs->GetStatus() ; // se lo stato è OFF, non ho bisogno di sapere altro if ( nObjStat == GDB_ST_OFF) { nStat = GDB_ST_OFF ; return true ; } // recupero lo stato dell'eventuale padre int nParentStat = GDB_ST_ON ; if ( GetParent() != nullptr) GetParent()->GetCalcStatus( nParentStat, ( nLev + 1)) ; // calcolo lo stato nStat = ::CalcStatus( nObjStat, nParentStat) ; // se sono alla chiamata iniziale, devo aggiustare lo stato con il modo if ( nLev == 0) { int nMode = GDB_MD_STD ; GetCalcMode( nMode) ; nStat = ::AdjustStatusWithMode( nStat, nMode) ; } return true ; } //---------------------------------------------------------------------------- bool GdbObj::SetMark( int nMark) { // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // assegno la marcatura m_pAttribs->SetMark( nMark) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::ResetMark( void) { // se non ci sono attributi non fa alcunchè if ( m_pAttribs == nullptr) return true ; // cancello la marcatura m_pAttribs->ResetMark() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetMark( int& nMark) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // la marcatura è definito nMark = m_pAttribs->GetMark() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetCalcMark( int& nMark) const { // recupero la marcatura dell'oggetto int nObjMark = GDB_MK_OFF ; if ( m_pAttribs != nullptr) nObjMark = m_pAttribs->GetMark() ; // se la marcatura è ON, non ho bisogno di sapere altro if ( nObjMark == GDB_MK_ON || nObjMark == GDB_MK_ON_2) { nMark = nObjMark ; return true ; } // recupero la marcatura dell'eventuale padre int nParentMark = GDB_MK_OFF ; if ( GetParent() != nullptr) GetParent()->GetCalcMark( nParentMark) ; // calcolo la marcatura nMark = ::CalcMark( nObjMark, nParentMark) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::SetMaterial( int nMat) { // ammessi da lista materiali o da padre (da colore si imposta con la SetColor) if ( nMat < GDB_MT_PARENT) return false ; // se materiale da padre e non ci sono attributi è già così if ( nMat == GDB_MT_PARENT && GetAttribs() == nullptr) return true ; // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // assegno il materiale m_pAttribs->SetMaterial( nMat) ; // notifico l'oggetto vero OnSetMaterial() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::SetMaterial( Color cCol) { // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // assegno il colore (e imposto il materiale da colore) m_pAttribs->SetColor( cCol) ; // notifico l'oggetto vero OnSetMaterial() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetMaterial( int& nMat) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // il materiale è definito nMat = m_pAttribs->GetMaterial() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetMaterial( Color& cCol) const { // se non ci sono attributi o ci si deve riferire al padre if ( m_pAttribs == nullptr || m_pAttribs->GetMaterial() == GDB_MT_PARENT) return false ; // il colore è definito cCol = m_pAttribs->GetColor() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetCalcMaterial( int& nMat) const { // se non ci sono attributi o ci si deve riferire al padre if ( m_pAttribs == nullptr || m_pAttribs->GetMaterial() == GDB_MT_PARENT) { if ( GetParent() != nullptr) GetParent()->GetCalcMaterial( nMat) ; else nMat = GDB_MT_COLOR ; return true ; } // il materiale è definito nMat = m_pAttribs->GetMaterial() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetCalcMaterial( Color& cCol) const { // se non ci sono attributi o ci si deve riferire al padre if ( m_pAttribs == nullptr || m_pAttribs->GetMaterial() == GDB_MT_PARENT) { if ( GetParent() != nullptr) GetParent()->GetCalcMaterial( cCol) ; else cCol.Set() ; return true ; } // il colore è definito cCol = m_pAttribs->GetColor() ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::SetName( const string& sName) { // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // assegno il nome return m_pAttribs->SetName( sName) ; } //---------------------------------------------------------------------------- bool GdbObj::GetName( string& sName) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // restituisco il nome return m_pAttribs->GetName( sName) ; } //---------------------------------------------------------------------------- bool GdbObj::ExistsName( void) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // restituisco il nome return m_pAttribs->ExistsName() ; } //---------------------------------------------------------------------------- bool GdbObj::RemoveName( void) { // se non ci sono attributi if ( m_pAttribs == nullptr) return true ; // cancello il nome return m_pAttribs->RemoveName() ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const string& sInfo) { // se Info non vuota if ( ! IsEmptyOrSpaces( sInfo)) { // verifico esistenza (con eventuale creazione) degli attributi if ( GetSafeAttribs() == nullptr) return false ; // eseguo assegnazione return m_pAttribs->SetInfo( sKey, sInfo) ; } // altrimenti else { // se esiste, la rimuovo return ( m_pAttribs == nullptr || m_pAttribs->RemoveInfo( sKey)) ; } } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, bool bInfo) { return SetInfo( sKey, ToString( bInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, int nInfo) { return SetInfo( sKey, ToString( nInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, double dInfo) { int nErr ; return ( SetInfo( sKey, ToString( dInfo, 6, &nErr)) && nErr == 0) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const Vector3d& vtInfo) { return SetInfo( sKey, ToString( vtInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const Point3d& ptInfo) { return SetInfo( sKey, ToString( ptInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const BBox3d& b3Info) { return SetInfo( sKey, ToString( b3Info)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const Frame3d& frInfo) { return SetInfo( sKey, ToString( frInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const INTVECTOR& vnInfo) { return SetInfo( sKey, ToString( vnInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const DBLVECTOR& vdInfo) { return SetInfo( sKey, ToString( vdInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::SetInfo( const string& sKey, const STRVECTOR& vsInfo) { return SetInfo( sKey, ToString( vsInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, string& sInfo) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // restituisco l'Info return m_pAttribs->GetInfo( sKey, sInfo) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, bool& bInfo) const { string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, bInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, int& nInfo) const { string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, nInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, double& dInfo) const { string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, dInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, Vector3d& vtInfo) const { string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, vtInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, Point3d& ptInfo) const { string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, ptInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, BBox3d& b3Info) const { string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, b3Info)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, Frame3d& frInfo) const { string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, frInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, INTVECTOR& vnInfo) const { vnInfo.clear() ; string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, vnInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, DBLVECTOR& vdInfo) const { vdInfo.clear() ; string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, vdInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::GetInfo( const string& sKey, STRVECTOR& vsInfo) const { vsInfo.clear() ; string sInfo ; return ( GetInfo( sKey, sInfo) && FromString( sInfo, vsInfo)) ; } //---------------------------------------------------------------------------- bool GdbObj::ExistsInfo( const string& sKey) const { // se non ci sono attributi if ( m_pAttribs == nullptr) return false ; // verifico l'esistenza dell'Info return m_pAttribs->ExistsInfo( sKey) ; } //---------------------------------------------------------------------------- bool GdbObj::RemoveInfo( const string& sKey) { // se non ci sono attributi if ( m_pAttribs == nullptr) return true ; // cancello l'Info return m_pAttribs->RemoveInfo( sKey) ; } //---------------------------------------------------------------------------- bool GdbObj::GetAllInfo( STRVECTOR& vsInfo) const { // se non ci sono attributi if ( m_pAttribs == nullptr) { vsInfo.clear() ; return true ; } // recupero tutte le Info return m_pAttribs->GetAllInfo( vsInfo) ; } //---------------------------------------------------------------------------- // Stipple (significativo solo per curve, per ora non viene salvato) //---------------------------------------------------------------------------- bool GdbObj::SetStipple( int nFactor, int nPattern) { m_nStpFactor = nFactor ; m_nStpPattern = nPattern ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetStipple( int& nFactor, int& nPattern) const { nFactor = m_nStpFactor ; nPattern = m_nStpPattern ; return true ; } //---------------------------------------------------------------------------- // TextureData //---------------------------------------------------------------------------- bool GdbObj::SaveTextureData( NgeWriter& ngeOut) const { if ( m_pTxrData != nullptr) return m_pTxrData->Save( ngeOut) ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::LoadTextureData( NgeReader& ngeIn) { if ( GetSafeTextureData() == nullptr) return false ; return m_pTxrData->Load( ngeIn) ; } //---------------------------------------------------------------------------- TextureData* GdbObj::GetSafeTextureData( void) { if ( m_pTxrData == nullptr) { TextureData* pTxrData = new( nothrow) TextureData ; if ( pTxrData == nullptr) return nullptr ; m_pTxrData = pTxrData ; } return m_pTxrData ; } //---------------------------------------------------------------------------- bool GdbObj::SetTextureName( const string& sTxrName) { // se nome vuoto non faccio alcunché if ( sTxrName.empty()) return false ; // verifico esistenza (con eventuale creazione) dei dati di texture if ( GetSafeTextureData() == nullptr) return false ; // assegno il nome return m_pTxrData->SetName( sTxrName) ; } //---------------------------------------------------------------------------- bool GdbObj::SetTextureFrame( const Frame3d& frTxrRef) { // verifico esistenza dei dati di texture if ( m_pTxrData == nullptr) return false ; // assegno il riferimento return m_pTxrData->SetFrame( frTxrRef) ; } //---------------------------------------------------------------------------- bool GdbObj::RemoveTextureData( void) { if ( m_pTxrData != nullptr) delete m_pTxrData ; m_pTxrData = nullptr ; return true ; } //---------------------------------------------------------------------------- bool GdbObj::GetTextureName( string& sTxrName) const { // se non ci sono dati di texture if ( m_pTxrData == nullptr) return false ; // restituisco il nome return m_pTxrData->GetName( sTxrName) ; } //---------------------------------------------------------------------------- bool GdbObj::GetTextureFrame( Frame3d& frTxrRef) const { // verifico esistenza dei dati di texture if ( m_pTxrData == nullptr) return false ; // restituisco il riferimento return m_pTxrData->GetFrame( frTxrRef) ; } //---------------------------------------------------------------------------- // IUserObj //---------------------------------------------------------------------------- bool GdbObj::SaveUserObj( int nBaseId, NgeWriter& ngeOut) const { // se definito UserObj e da salvare if ( m_pUserObj != nullptr && m_pUserObj->ToSave()) { // recupero il nome della sua classe string sName = m_pUserObj->GetClassName() ; if ( sName.empty()) return false ; // recupero le stringhe dei dati STRVECTOR vString ; if ( ! m_pUserObj->Save( nBaseId, vString)) return false ; // eseguo validazione di queste stringhe for ( auto iIter = vString.begin() ; iIter != vString.end() ; ++ iIter) ValidateVal( *iIter) ; // scrivo i dati : // flag presenza UserObj if ( ! ngeOut.WriteKey( NGE_U)) return false ; // nome della classe dell'oggetto if ( ! ngeOut.WriteString( sName, ";", true)) return false ; // numero di stringhe di dati (nelle linee successive) if ( ! ngeOut.WriteInt( int( vString.size()), ";", true)) return false ; // stringhe di dati for ( auto iIter = vString.cbegin() ; iIter != vString.cend() ; ++ iIter) { if ( ! ngeOut.WriteString( *iIter, nullptr, true)) return false ; } } return true ; } //---------------------------------------------------------------------------- bool GdbObj::LoadUserObj( NgeReader& ngeIn, int nBaseGdbId) { // leggo il nome della classe string sName ; if ( ! ngeIn.ReadString( sName, ";", true)) return false ; // numero di stringhe di dati (nelle linee successive) int nNext ; if ( ! ngeIn.ReadInt( nNext, ";", true)) return false ; // leggo le eventuali stringhe STRVECTOR vString ; vString.reserve( nNext) ; string sLine ; for ( int i = 0 ; i < nNext ; ++i) { // preparo la stringa vString.emplace_back( "") ; // leggo la linea if ( ! ngeIn.ReadString( vString.back(), nullptr, true)) return false ; } // creo l'oggetto corrispondente m_pUserObj = USEROBJ_CREATE( sName) ; // se non trovato uso quello di default if ( m_pUserObj == nullptr) m_pUserObj = new( nothrow) UserObjDefault( sName) ; ; if ( m_pUserObj == nullptr) return false ; // carico i dati nell'oggetto if ( ! m_pUserObj->Load( vString, nBaseGdbId)) return false ; // impostazione Id e GeomDB fatte successivamente return true ; }