diff --git a/Attribs.cpp b/Attribs.cpp new file mode 100644 index 0000000..974256c --- /dev/null +++ b/Attribs.cpp @@ -0,0 +1,150 @@ +//---------------------------------------------------------------------------- +// EgalTech 2014-2014 +//---------------------------------------------------------------------------- +// File : Attribs.cpp Data : 05.03.14 Versione : 1.5c1 +// Contenuto : Implementazione della classe Attribs. +// +// +// +// Modifiche : 05.03.14 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "Attribs.h" +#include "/EgtDev/Include/EgnStringUtils.h" + +using namespace std ; + +//---------------------------------------------------------------------------- +bool +Attribs::Dump( string& sOut, const char* szNewLine) const +{ + sOut += "Lev=" ; + switch ( m_Data[LEVEL]) { + default : /* LEV_USER */ sOut += "user" ; break ; + case LEV_SYSTEM : sOut += "system" ; break ; + case LEV_TEMP : sOut += "temp" ; break ; + } + sOut += " Mod=" ; + switch ( m_Data[MODE]) { + default : /* MOD_STD */ sOut += "std" ; break ; + case MOD_LOCKED : sOut += "locked" ; break ; + case MOD_HIDDEN : sOut += "hidden" ; break ; + } + sOut += " Sta=" ; + switch ( m_Data[STATUS]) { + default : /* STS_ON */ sOut += "on" ; break ; + case STS_SEL : sOut += "sel" ; break ; + case STS_OFF : sOut += "off" ; break ; + } + sOut += szNewLine ; + sOut += "Mat=" ; + switch ( m_Material) { + case MAT_PARENT : sOut += "by parent" ; break ; + case MAT_COLOR : sOut += "color" ; break ; + case MAT_NULL : sOut += "null" ; break ; + default : sOut += ToString( m_Material) ; break ; + } + if ( m_Material != MAT_PARENT && m_Material != MAT_NULL) { + sOut += " Col=" ; + sOut += ToString( m_Color.GetIntRed()) + "," ; + sOut += ToString( m_Color.GetIntGreen()) + "," ; + sOut += ToString( m_Color.GetIntBlue()) + "," ; + sOut += ToString( m_Color.GetIntAlpha()) ; + } + sOut += szNewLine ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Attribs::Save( ostream& osOut) const +{ + // flag presenza attributi + osOut << "A" << endl ; + + // livello + osOut << ToString( m_Data[LEVEL]) ; + // modo + osOut << "," << ToString( m_Data[MODE]) ; + // stato + osOut << "," << ToString( m_Data[STATUS]) ; + // altro + osOut << "," << ToString( m_Data[OTHER]) ; + // materiale + osOut << ";" << ToString( m_Material) ; + // colore + osOut << ";" << ToString( m_Color.GetIntRed()) ; + osOut << "," << ToString( m_Color.GetIntGreen()) ; + osOut << "," << ToString( m_Color.GetIntBlue()) ; + osOut << "," << ToString( m_Color.GetIntAlpha()) ; + // numero di stringhe (nelle linee successive) + osOut << ";" << ToString( 0) << ";" << endl ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +Attribs::Load( Scanner& TheScanner) +{ + // leggo la prossima linea + string sLine ; + if ( ! TheScanner.GetLine( sLine)) + return false ; + // la divido in parametri + STRVECTOR vsParams ; + Tokenize( sLine, ",;", vsParams) ; + // 10 parametri + if ( vsParams.size() != 10) + return false ; + // livello + int nLev ; + if ( ! FromString( vsParams[0], nLev)) + return false ; + m_Data[LEVEL] = CLIP( nLev, LEV_USER, LEV_TEMP) ; + // modo + int nMode ; + if ( ! FromString( vsParams[1], nMode)) + return false ; + m_Data[MODE] = CLIP( nMode, MOD_STD, MOD_HIDDEN) ; + // stato + int nStat ; + if ( ! FromString( vsParams[2], nStat)) + return false ; + m_Data[STATUS] = CLIP( nStat, STS_ON, STS_OFF) ; + // altro + int nOther ; + if ( ! FromString( vsParams[3], nOther)) + return false ; + m_Data[OTHER] = CLIP( nOther, 0, 255) ; + // materiale + int nMat ; + if ( ! FromString( vsParams[4], nMat)) + return false ; + m_Material = __max( nMat, MAT_PARENT) ; + // colore + int nRed ; + if ( ! FromString( vsParams[5], nRed)) + return false ; + int nGreen ; + if ( ! FromString( vsParams[6], nGreen)) + return false ; + int nBlue ; + if ( ! FromString( vsParams[7], nBlue)) + return false ; + int nAlpha ; + if ( ! FromString( vsParams[8], nAlpha)) + return false ; + m_Color.Set( nRed, nGreen, nBlue, nAlpha) ; + // numero di stringhe (nelle linee successive) + int nNext ; + if ( ! FromString( vsParams[9], nNext)) + return false ; + + return true ; +} \ No newline at end of file diff --git a/Attribs.h b/Attribs.h new file mode 100644 index 0000000..b37ef54 --- /dev/null +++ b/Attribs.h @@ -0,0 +1,79 @@ +//---------------------------------------------------------------------------- +// EgalTech 2014-2014 +//---------------------------------------------------------------------------- +// File : Attribs.h Data : 03.03.14 Versione : 1.5c1 +// Contenuto : Dichiarazione della classe GeoAttributes. +// +// +// +// Modifiche : 03.03.14 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "/EgtDev/Include/EGkColor.h" +#include "/EgtDev/Include/EGnScan.h" +#include + + +//---------------------------------------------------------------------------- +#define CLIP( nV, nMIN, nMAX) (( nV < nMIN) ? nMIN : (( nV > nMAX) ? nMAX : nV)) + +//---------------------------------------------------------------------------- +class Attribs +{ + public : + Attribs( void) + { m_Data[LEVEL] = LEV_USER ; m_Data[MODE] = MOD_STD ; + m_Data[STATUS] = STS_ON ; m_Data[OTHER] = 0 ; + m_Material = MAT_PARENT ; m_Color.Set( 0, 0, 0) ;} + Attribs* Clone( void) const + { Attribs* pAttribs ; + // alloco oggetto + pAttribs = new(std::nothrow) Attribs ; + if ( pAttribs != nullptr) + *pAttribs = *(const_cast(this)) ; + return pAttribs ; } + bool Dump( std::string& sOut, const char* szNewLine) const ; + bool Save( std::ostream& osOut) const ; + bool Load( Scanner& TheScanner) ; + void SetLevel( int nLev) + { m_Data[LEVEL] = CLIP( nLev, LEV_USER, LEV_TEMP) ; } + int GetLevel( void) const + { return m_Data[LEVEL] ; } + void SetMode( int nMode) + { m_Data[MODE] = CLIP( nMode, MOD_STD, MOD_HIDDEN) ; } + int GetMode( void) const + { return m_Data[MODE] ; } + void SetStatus( int nStat) + { m_Data[STATUS] = CLIP( nStat, STS_ON, STS_OFF) ; } + int GetStatus( void) const + { return m_Data[STATUS] ; } + void SetMaterial( int nMat) + { if ( nMat != MAT_COLOR) + m_Material = nMat ; } + int GetMaterial( void) const + { return m_Material ; } + void SetColor( Color cCol) + { m_Material = MAT_COLOR ; m_Color = cCol ; } + Color GetColor( void) const + { return m_Color ; } + + public : + enum Level { LEV_USER = 0, LEV_SYSTEM = 1, LEV_TEMP = 2} ; + enum Mode { MOD_STD = 0, MOD_LOCKED = 1, MOD_HIDDEN = 2} ; + enum Status { STS_ON = 0, STS_SEL = 1, STS_OFF = 2} ; + enum { MAT_PARENT = -2, MAT_COLOR = -1, MAT_NULL = 0} ; + + private : + enum { LEVEL = 0, MODE = 1, STATUS = 2, OTHER = 3, DIM = 4} ; + + private : + unsigned char m_Data[DIM] ; + int m_Material ; + Color m_Color ; + std::string m_sName ; + std::string m_sNotes ; +} ; \ No newline at end of file diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index 9291a06..0c62498 100644 Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ diff --git a/EgtGeomKernel.vcxproj b/EgtGeomKernel.vcxproj index a630743..dc0d2b9 100644 --- a/EgtGeomKernel.vcxproj +++ b/EgtGeomKernel.vcxproj @@ -225,6 +225,7 @@ copy $(TargetPath) \EgtProg\Dll64 + @@ -242,8 +243,8 @@ copy $(TargetPath) \EgtProg\Dll64 - + @@ -312,8 +313,9 @@ copy $(TargetPath) \EgtProg\Dll64 + - + diff --git a/EgtGeomKernel.vcxproj.filters b/EgtGeomKernel.vcxproj.filters index cd85d7e..1121af4 100644 --- a/EgtGeomKernel.vcxproj.filters +++ b/EgtGeomKernel.vcxproj.filters @@ -75,18 +75,12 @@ File di origine\Gdb - - File di origine\Gdb - File di origine\Script File di origine\Script - - File di origine\Gdb - File di origine\Gdb @@ -108,9 +102,6 @@ File di origine\Distanze - - File di origine\Distanze - File di origine\Base @@ -126,6 +117,18 @@ File di origine\Base + + File di origine\Gdb + + + File di origine\Gdb + + + File di origine\Gdb + + + File di origine\Gdb + @@ -203,9 +206,6 @@ File di intestazione - - File di intestazione - File di intestazione @@ -218,9 +218,6 @@ File di intestazione - - File di intestazione - File di intestazione @@ -317,6 +314,15 @@ File di intestazione + + File di intestazione + + + File di intestazione + + + File di intestazione + diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp index d5a57e9..b952566 100644 --- a/GdbExecutor.cpp +++ b/GdbExecutor.cpp @@ -128,6 +128,8 @@ GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR& return ExecuteCurveBez( sCmd2, vsParams) ; else if ( sCmd1 == "CC" || sCmd1 == "CURVECOMPO") return ExecuteCurveCompo( sCmd2, vsParams) ; + else if ( sCmd1 == "COL" || sCmd1 == "COLOR") + return ExecuteColor( sCmd2, vsParams) ; else if ( sCmd1 == "COPY") return ExecuteCopy( sCmd2, vsParams) ; else if ( sCmd1 == "ERASE") @@ -882,6 +884,48 @@ GdbExecutor::GetFrameParam( const std::string& sParam, Frame3d& frF) } } +//---------------------------------------------------------------------------- +bool +GdbExecutor::ExecuteColor( const string& sCmd2, const STRVECTOR& vsParams) +{ + // impostazione colore di default + if ( sCmd2 == "DEF" || sCmd2 == "DEFAULT") { + // 3 parametri ( Red, Green, Blue) + if ( vsParams.size() != 3) + return false ; + // recupero i colori + int nRed ; + int nGreen ; + int nBlue ; + if ( ! FromString( vsParams[0], nRed) || + ! FromString( vsParams[1], nGreen) || + ! FromString( vsParams[2], nBlue)) + return false ; + Color cCol( nRed, nGreen, nBlue) ; + return m_pGDB->SetDefaultColor( cCol) ; + } + // impostazione colore su oggetto + else { + // 4 o 5 parametri ( Id, Red, Green, Blue, Alpha) + if ( vsParams.size() != 4 && vsParams.size() != 5) + return false ; + // recupero i colori + int nRed ; + int nGreen ; + int nBlue ; + if ( ! FromString( vsParams[1], nRed) || + ! FromString( vsParams[2], nGreen) || + ! FromString( vsParams[3], nBlue)) + return false ; + int nAlpha = 100 ; + if ( vsParams.size() == 5 && + ! FromString( vsParams[4], nAlpha)) + return false ; + Color cCol( nRed, nGreen, nBlue, nAlpha) ; + return m_pGDB->SetColor( GetIdParam( vsParams[0]), cCol) ; + } +} + //---------------------------------------------------------------------------- bool GdbExecutor::ExecuteCopy( const std::string& sCmd2, const STRVECTOR& vsParams) diff --git a/GdbExecutor.h b/GdbExecutor.h index 2b54ce5..57fe2f8 100644 --- a/GdbExecutor.h +++ b/GdbExecutor.h @@ -46,6 +46,7 @@ class GdbExecutor : public IGdbExecutor bool ExecuteCurveArc( const std::string& sCmd2, const STRVECTOR& vsParams) ; bool ExecuteCurveBez( const std::string& sCmd2, const STRVECTOR& vsParams) ; bool ExecuteCurveCompo( const std::string& sCmd2, const STRVECTOR& vsParams) ; + bool ExecuteColor( const std::string& sCmd2, const STRVECTOR& vsParams) ; bool ExecuteCopy( const std::string& sCmd2, const STRVECTOR& vsParams) ; bool ExecuteErase( const STRVECTOR& vsParams) ; bool ExecuteTranslate( const std::string& sCmd2, const STRVECTOR& vsParams) ; diff --git a/GdbGeo.cpp b/GdbGeo.cpp new file mode 100644 index 0000000..e84cf95 --- /dev/null +++ b/GdbGeo.cpp @@ -0,0 +1,246 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : GdbGeo.cpp Data : 24.11.13 Versione : 1.3a1 +// Contenuto : Implementazione della classe GdbGeo oggetto del DB geometrico. +// +// +// +// Modifiche : 22.01.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "GdbGeo.h" +#include "GeoObjFactory.h" +#include "CurveAux.h" +#include "Attribs.h" +#include "/EgtDev/Include/EGnStringUtils.h" +#include + +using namespace std ; + +//---------------------------------------------------------------------------- +GdbGeo::GdbGeo( void) +{ + m_pGeoObj = nullptr ; +} + +//---------------------------------------------------------------------------- +GdbGeo::~GdbGeo( void) +{ + if ( m_pGeoObj != nullptr) + delete m_pGeoObj ; + m_pGeoObj = nullptr ; +} + +//---------------------------------------------------------------------------- +GdbGeo* +GdbGeo::Clone( int nId, IdManager& IdMgr) const +{ + GdbGeo* pGdbGeo ; + + + // alloco oggetto Gdb + pGdbGeo = new(nothrow) GdbGeo ; + if ( pGdbGeo == nullptr) + return nullptr ; + + // copio dati oggetto Gdb + pGdbGeo->GdbObj::Copy( this) ; + + // assegno nuovo Id + pGdbGeo->m_nId = nId ; + // l'aggiornamento del manager di Id viene fatto all'inserimento nel DB + + // copio oggetto Geo + if ( m_pGeoObj != nullptr) { + pGdbGeo->m_pGeoObj = m_pGeoObj->Clone() ; + if ( pGdbGeo->m_pGeoObj == nullptr) { + delete pGdbGeo ; + return nullptr ; + } + } + + return pGdbGeo ; +} + +//---------------------------------------------------------------------------- +GeoObjType +GdbGeo::GetType( void) const +{ + // non esiste l'oggetto geometrico + if ( m_pGeoObj == nullptr) + return GEO_NONE ; + + return m_pGeoObj->GetType() ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::Save( std::ostream& osOut) const +{ + bool bOk = true ; + + // tipo entità + osOut << m_pGeoObj->GetKey() << endl ; + // nome + osOut << m_nId << "@" << GetParentId() << endl ; + + // attributi + if ( ! GdbObj::SaveAttribs( osOut)) + bOk = false ; + + // parametri geometrici + osOut << "G" << endl ; + if ( ! m_pGeoObj->Save( osOut)) + bOk = false ; + + return bOk ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::Load( const std::string& sType, Scanner& TheScanner, int& nParentId) +{ + int nType ; + string sLine ; + STRVECTOR vsParams ; + + + // creo l'oggetto geometrico corrispondente + nType = GEOOBJ_KEYTOTYPE( sType) ; + m_pGeoObj = GEOOBJ_CREATE( nType) ; + if ( m_pGeoObj == nullptr) + return false ; + + // leggo la prossima linea + if ( ! TheScanner.GetLine( sLine)) + return false ; + // la divido in parametri + Tokenize( sLine, "@", vsParams) ; + // 2 parametri : Id e ParentId + if ( vsParams.size() != 2) + return false ; + // assegno l'identificativo + if ( ! FromString( vsParams[0], m_nId)) + return false ; + // assegno l'Id del padre + if ( ! FromString( vsParams[1], nParentId)) + return false ; + + // leggo la prossima linea + if ( ! TheScanner.GetLine( sLine)) + return false ; + + // eventuali attributi + if ( sLine == "A") { + if ( ! GdbObj::LoadAttribs( TheScanner)) + return false ; + // leggo la prossima linea + if ( ! TheScanner.GetLine( sLine)) + return false ; + } + + // verifico inizio dati geometrici + if ( sLine != "G") + return false ; + + // parametri geometrici + return m_pGeoObj->Load( TheScanner) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::GetLocalBBox( BBox3d& b3Loc) const +{ + if ( m_pGeoObj == nullptr) + return false ; + + return m_pGeoObj->GetLocalBBox( b3Loc) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const +{ + if ( m_pGeoObj == nullptr) + return false ; + + return m_pGeoObj->GetBBox( frRef, b3Ref) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::Translate( const Vector3d& vtMove) +{ + if ( m_pGeoObj == nullptr) + return false ; + + return m_pGeoObj->Translate( vtMove) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) +{ + if ( m_pGeoObj == nullptr) + return false ; + + return m_pGeoObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) +{ + if ( m_pGeoObj == nullptr) + return false ; + + // se arco e scalatura non omogenea + if ( m_pGeoObj->GetType() == CRV_ARC && + (fabs( dCoeffX - dCoeffY) > EPS_SMALL || fabs( dCoeffX - dCoeffZ) > EPS_SMALL)) { + // trasformo in curva di Bezier (semplice o composta) + ICurve* pCrvNew ; + if ( ! ArcToBezierCurve( GetCurve( m_pGeoObj), pCrvNew)) + return false ; + // elimino l'arco e lo sostituisco con la curva di Bezier + delete m_pGeoObj ; + m_pGeoObj = pCrvNew ; + } + + // eseguo scalatura + return m_pGeoObj->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) +{ + if ( m_pGeoObj == nullptr) + return false ; + + return m_pGeoObj->Mirror( ptOn, vtNorm) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::ToGlob( const Frame3d& frRef) +{ + if ( m_pGeoObj == nullptr) + return false ; + + return m_pGeoObj->ToGlob( frRef) ; +} + +//---------------------------------------------------------------------------- +bool +GdbGeo::ToLoc( const Frame3d& frRef) +{ + if ( m_pGeoObj == nullptr) + return false ; + + return m_pGeoObj->ToLoc( frRef) ; +} diff --git a/GdbGeo.h b/GdbGeo.h new file mode 100644 index 0000000..48b7b23 --- /dev/null +++ b/GdbGeo.h @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2013 +//---------------------------------------------------------------------------- +// File : GdbGeo.h Data : 05.03.14 Versione : 1.5c1 +// Contenuto : Dichiarazione della classe GdbGeo. +// +// +// +// Modifiche : 22.01.13 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "GdbObj.h" +#include "/EgtDev/Include/EGkGeoObjType.h" +#include + +class IGeoObj ; + +//---------------------------------------------------------------------------- +class GdbGeo : public GdbObj +{ + public : + virtual ~GdbGeo( void) ; + virtual GdbGeo* Clone( int nId, IdManager& IdMgr) const ; + virtual bool Save( std::ostream& osOut) const ; + virtual bool Load( const std::string& sType, Scanner& TheScanner, int& nParentId) ; + virtual bool GetLocalBBox( BBox3d& b3Loc) const ; + virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ; + virtual bool Translate( const Vector3d& vtMove) ; + virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) ; + virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) + { double dAngRad = dAngDeg * DEGTORAD ; + return Rotate( ptAx, vtAx, cos( dAngRad), sin( dAngRad)) ; } + virtual bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) ; + virtual bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm) ; + virtual bool ToGlob( const Frame3d& frRef) ; + virtual bool ToLoc( const Frame3d& frRef) ; + + public : + GdbGeo( void) ; + GeoObjType GetType( void) const ; + + public : + IGeoObj* m_pGeoObj ; +} ; diff --git a/GdbGroup.cpp b/GdbGroup.cpp index e2401bb..f9132f3 100644 --- a/GdbGroup.cpp +++ b/GdbGroup.cpp @@ -13,22 +13,22 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include "\EgtDev\Include\EGnStringUtils.h" #include "GdbGroup.h" #include "IdManager.h" - +#include "\EgtDev\Include\EGnStringUtils.h" using namespace std ; //---------------------------------------------------------------------------- GdbGroup::GdbGroup( void) - : m_nNodeCount( 0), m_pFirstNode( nullptr), m_pLastNode( nullptr) + : m_nObjCount( 0), m_pFirstObj( nullptr), m_pLastObj( nullptr) { } //---------------------------------------------------------------------------- GdbGroup::~GdbGroup( void) { + // elimino i figli Clear() ; } @@ -36,18 +36,16 @@ GdbGroup::~GdbGroup( void) bool GdbGroup::Clear( void) { - GdbNode* pNode ; - - // disalloco gli oggetti - pNode = GetFirstNode() ; - while ( pNode != nullptr) { + GdbObj* pObj ; + pObj = GetFirstObj() ; + while ( pObj != nullptr) { // lo rimuovo dalla lista - pNode->Remove() ; + pObj->Remove() ; // lo disalloco - delete pNode ; + delete pObj ; // passo al nuovo primo - pNode = GetFirstNode() ; + pObj = GetFirstObj() ; } return true ; @@ -57,41 +55,44 @@ GdbGroup::Clear( void) GdbGroup* GdbGroup::Clone( int nId, IdManager& IdMgr) const { - GdbGroup* pGdbGroup ; - const GdbNode* pNode ; - GdbNode* pNewNode ; - - // alloco gruppo Gdb + GdbGroup* pGdbGroup ; pGdbGroup = new(nothrow) GdbGroup ; if ( pGdbGroup == nullptr) return nullptr ; // copio dati oggetto Gdb + pGdbGroup->GdbObj::Copy( this) ; + + // assegno nuovo Id pGdbGroup->m_nId = nId ; IdMgr.UpdateMaxId( nId) ; + + // copio dati gruppo pGdbGroup->m_gfrFrame = m_gfrFrame ; - // clono i nodi figli - pNode = GetFirstNode() ; - while ( pNode != nullptr) { + // clono gli oggetti figli + const GdbObj* pObj = GetFirstObj() ; + while ( pObj != nullptr) { // eseguo copia - pNewNode = pNode->Clone( IdMgr.GetNewId(), IdMgr) ; - if ( pNewNode == nullptr) { + GdbObj* pNewObj = pObj->Clone( IdMgr.GetNewId(), IdMgr) ; + if ( pNewObj == nullptr) { delete pGdbGroup ; return nullptr ; } // lo inserisco nella lista dei figli - if ( ! pNewNode->AddTail( pGdbGroup)) { - delete pNewNode ; + if ( ! pNewObj->AddTail( pGdbGroup)) { + delete pNewObj ; delete pGdbGroup ; return nullptr ; } - // lo inserisco nella mappa dei nomi - if ( ! IdMgr.AddNode( pNewNode->m_nId, pNewNode)) + // lo inserisco nella mappa degli Id + if ( ! IdMgr.AddObj( pNewObj->m_nId, pNewObj)) { + delete pGdbGroup ; return nullptr ; - // passo al prossimo nodo - pNode = pNode->GetNext() ; + } + // passo al prossimo oggetto + pObj = pObj->GetNext() ; } return pGdbGroup ; @@ -107,15 +108,22 @@ GdbGroup::Save( std::ostream& osOut) const osOut << GetKey() << endl ; // identificativi osOut << m_nId << "@" << GetParentId() << endl ; - // dati del riferimento - m_gfrFrame.Save( osOut) ; - // lancio il salvataggio dei figli - const GdbNode* pGdbNode = GetFirstNode() ; - while ( pGdbNode != nullptr) { - if ( ! pGdbNode->Save( osOut)) + // attributi + if ( ! GdbObj::SaveAttribs( osOut)) + bOk = false ; + + // dati del riferimento + osOut << "G" << endl ; + if ( ! m_gfrFrame.Save( osOut)) + bOk = false ; + + // salvataggio dei figli + const GdbObj* pGdbObj = GetFirstObj() ; + while ( pGdbObj != nullptr) { + if ( ! pGdbObj->Save( osOut)) bOk = false ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = pGdbObj->GetNext() ; } return bOk ; @@ -143,6 +151,24 @@ GdbGroup::Load( const string& sType, Scanner& TheScanner, int& nParentId) // assegno l'Id del padre if ( ! FromString( vsParams[1], nParentId)) return false ; + + // leggo la prossima linea + if ( ! TheScanner.GetLine( sLine)) + return false ; + + // eventuali attributi + if ( sLine == "A") { + if ( ! GdbObj::LoadAttribs( TheScanner)) + return false ; + // leggo la prossima linea + if ( ! TheScanner.GetLine( sLine)) + return false ; + } + + // verifico inizio dati geometrici + if ( sLine != "G") + return false ; + // leggo i dati del riferimento m_gfrFrame.Load( TheScanner) ; @@ -154,13 +180,13 @@ bool GdbGroup::GetLocalBBox( BBox3d& b3Loc) const { b3Loc.Reset() ; - const GdbNode* pGdbNode = GetFirstNode() ; - while ( pGdbNode != nullptr) { + const GdbObj* pGdbObj = GetFirstObj() ; + while ( pGdbObj != nullptr) { BBox3d b3B ; // voglio il box come appare nel frame del gruppo, quindi passo frame identità - if ( pGdbNode->GetBBox( GLOB_FRM, b3B)) + if ( pGdbObj->GetBBox( GLOB_FRM, b3B)) b3Loc.Add( b3B) ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = pGdbObj->GetNext() ; } return true ; } @@ -171,12 +197,12 @@ GdbGroup::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const { Frame3d frCurr = m_gfrFrame.m_frF * frRef ; b3Ref.Reset() ; - const GdbNode* pGdbNode = GetFirstNode() ; - while ( pGdbNode != nullptr) { + const GdbObj* pGdbObj = GetFirstObj() ; + while ( pGdbObj != nullptr) { BBox3d b3B ; - if ( pGdbNode->GetBBox( frCurr, b3B)) + if ( pGdbObj->GetBBox( frCurr, b3B)) b3Ref.Add( b3B) ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = pGdbObj->GetNext() ; } return true ; } @@ -199,20 +225,20 @@ GdbGroup::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, dou bool GdbGroup::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) { - GdbNode* pGdbNode ; + GdbObj* pGdbObj ; // parziale scalatura del riferimento (non può essere completa) Frame3d frFrameS = m_gfrFrame.m_frF ; frFrameS.PseudoScale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; - // porto i nodi nel nuovo riferimento, senza modificarne la geometria in globale + // porto gli oggetti nel nuovo riferimento, senza modificarne la geometria in globale Frame3d frTrasf = m_gfrFrame.m_frF ; frTrasf.ToLoc( frFrameS) ; - pGdbNode = GetFirstNode() ; - while ( pGdbNode != nullptr) { - pGdbNode->ToGlob( frTrasf) ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = GetFirstObj() ; + while ( pGdbObj != nullptr) { + pGdbObj->ToGlob( frTrasf) ; + pGdbObj = pGdbObj->GetNext() ; } // assegno il nuovo riferimento @@ -224,11 +250,11 @@ GdbGroup::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dC // ciclo sui nodi bool bOk = true ; - pGdbNode = GetFirstNode() ; - while ( pGdbNode != nullptr) { - if ( ! pGdbNode->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ)) + pGdbObj = GetFirstObj() ; + while ( pGdbObj != nullptr) { + if ( ! pGdbObj->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ)) bOk = false ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = pGdbObj->GetNext() ; } return bOk ; @@ -238,7 +264,7 @@ GdbGroup::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dC bool GdbGroup::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) { - GdbNode* pGdbNode ; + GdbObj* pGdbObj ; // parziale mirror del riferimento (non può essere completa) @@ -248,10 +274,10 @@ GdbGroup::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) // porto i nodi nel nuovo riferimento, senza modificarne la geometria in globale Frame3d frTrasf = m_gfrFrame.m_frF ; frTrasf.ToLoc( frFrameS) ; - pGdbNode = GetFirstNode() ; - while ( pGdbNode != nullptr) { - pGdbNode->ToGlob( frTrasf) ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = GetFirstObj() ; + while ( pGdbObj != nullptr) { + pGdbObj->ToGlob( frTrasf) ; + pGdbObj = pGdbObj->GetNext() ; } // assegno il nuovo riferimento @@ -265,11 +291,11 @@ GdbGroup::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) // ciclo sui nodi bool bOk = true ; - pGdbNode = GetFirstNode() ; - while ( pGdbNode != nullptr) { - if ( ! pGdbNode->Mirror( ptOnLoc, vtNormLoc)) + pGdbObj = GetFirstObj() ; + while ( pGdbObj != nullptr) { + if ( ! pGdbObj->Mirror( ptOnLoc, vtNormLoc)) bOk = false ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = pGdbObj->GetNext() ; } return bOk ; @@ -279,13 +305,11 @@ GdbGroup::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) bool GdbGroup::GetGlobFrame( Frame3d& frGlob) const { - const GdbGroup* pParent ; - - // assegno il proprio frame frGlob = m_gfrFrame.m_frF ; // mentre ci sono padri + const GdbGroup* pParent ; pParent = GetParent() ; while ( pParent != nullptr) { // porto il riferimento corrente sopra il padre @@ -296,4 +320,3 @@ GdbGroup::GetGlobFrame( Frame3d& frGlob) const return true ; } - diff --git a/GdbGroup.h b/GdbGroup.h index d015130..260fb24 100644 --- a/GdbGroup.h +++ b/GdbGroup.h @@ -13,16 +13,15 @@ #pragma once -#include -#include "/EgtDev/Include/EGkGeoObj.h" #include "GeoFrame3d.h" -#include "GdbNode.h" - +#include "GdbObj.h" +#include "/EgtDev/Include/EGkGeoObj.h" +#include //---------------------------------------------------------------------------- -class GdbGroup : public GdbNode +class GdbGroup : public GdbObj { - friend class GdbNode ; + friend class GdbObj ; public : virtual ~GdbGroup( void) ; @@ -46,25 +45,33 @@ class GdbGroup : public GdbNode public : GdbGroup( void) ; bool Clear( void) ; - void NodeCountInc( void) { ++ m_nNodeCount ; } - void NodeCountDec( void) { -- m_nNodeCount ; } - int GetNodeCount( void) const { return m_nNodeCount ; } - GdbNode* GetFirstNode( void) { return m_pFirstNode ; } - const GdbNode* GetFirstNode( void) const { return m_pFirstNode ; } - GdbNode* GetLastNode( void) { return m_pLastNode ; } - const GdbNode* GetLastNode( void) const { return m_pLastNode ; } + void ObjCountInc( void) + { ++ m_nObjCount ; } + void ObjCountDec( void) + { -- m_nObjCount ; } + int GetObjCount( void) const + { return m_nObjCount ; } + GdbObj* GetFirstObj( void) + { return m_pFirstObj ; } + const GdbObj* GetFirstObj( void) const + { return m_pFirstObj ; } + GdbObj* GetLastObj( void) + { return m_pLastObj ; } + const GdbObj* GetLastObj( void) const + { return m_pLastObj ; } public : - static const std::string& GetKey( void) { static std::string s_sKey = "A_GRP" ; return s_sKey ; } + static const std::string& GetKey( void) + { static std::string s_sKey = "A_GRP" ; return s_sKey ; } public : bool GetGlobFrame( Frame3d& frGlob) const ; public : - GeoFrame3d m_gfrFrame ; + GeoFrame3d m_gfrFrame ; private : - int m_nNodeCount ; - GdbNode* m_pFirstNode ; - GdbNode* m_pLastNode ; + int m_nObjCount ; + GdbObj* m_pFirstObj ; + GdbObj* m_pLastObj ; } ; diff --git a/GdbIterator.cpp b/GdbIterator.cpp index e838e99..3ce7709 100644 --- a/GdbIterator.cpp +++ b/GdbIterator.cpp @@ -13,8 +13,9 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" -#include #include "GdbIterator.h" +#include "Attribs.h" +#include using namespace std ; @@ -31,7 +32,7 @@ CreateGdbIterator( void) GdbIterator::GdbIterator( void) { m_pGDB = nullptr ; - m_pCurrNode = nullptr ; + m_pCurrObj = nullptr ; } //---------------------------------------------------------------------------- @@ -56,9 +57,9 @@ GdbIterator::GoTo( int nId) if ( m_pGDB == nullptr) return false ; - m_pCurrNode = m_pGDB->GetGdbNode( nId) ; + m_pCurrObj = m_pGDB->GetGdbObj( nId) ; - return ( m_pCurrNode != nullptr) ; + return ( m_pCurrObj != nullptr) ; } //---------------------------------------------------------------------------- @@ -74,75 +75,73 @@ GdbIterator::GoToFirstInGroup( int nIdGroup) // recupero il gruppo pGdbGroup = m_pGDB->GetGdbGroup( nIdGroup) ; if ( pGdbGroup == nullptr) { - m_pCurrNode = nullptr ; + m_pCurrObj = nullptr ; return false ; } - // recupero il nodo - m_pCurrNode = pGdbGroup->GetFirstNode() ; + // recupero l'oggetto + m_pCurrObj = pGdbGroup->GetFirstObj() ; - return ( m_pCurrNode != nullptr) ; + return ( m_pCurrObj != nullptr) ; } //---------------------------------------------------------------------------- bool GdbIterator::GoToNext( void) { - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) return false ; - m_pCurrNode = m_pCurrNode->GetNext() ; + m_pCurrObj = m_pCurrObj->GetNext() ; - return ( m_pCurrNode != nullptr) ; + return ( m_pCurrObj != nullptr) ; } //---------------------------------------------------------------------------- bool GdbIterator::GoToLastInGroup( int nIdGroup) { - GdbGroup* pGdbGroup ; - - if ( m_pGDB == nullptr) return false ; // recupero il gruppo + GdbGroup* pGdbGroup ; pGdbGroup = m_pGDB->GetGdbGroup( nIdGroup) ; if ( pGdbGroup == nullptr) { - m_pCurrNode = nullptr ; + m_pCurrObj = nullptr ; return false ; } - // recupero il nodo - m_pCurrNode = pGdbGroup->GetLastNode() ; + // recupero l'oggetto + m_pCurrObj = pGdbGroup->GetLastObj() ; - return ( m_pCurrNode != nullptr) ; + return ( m_pCurrObj != nullptr) ; } //---------------------------------------------------------------------------- bool GdbIterator::GoToPrev( void) { - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) return false ; - m_pCurrNode = m_pCurrNode->GetPrev() ; + m_pCurrObj = m_pCurrObj->GetPrev() ; - return ( m_pCurrNode != nullptr) ; + return ( m_pCurrObj != nullptr) ; } //---------------------------------------------------------------------------- GdbType GdbIterator::GetGdbType( void) const { - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) return GDB_NONE ; // se oggetto geometrico - if ( GetGdbObj( m_pCurrNode) != nullptr) + if ( GetGdbGeo( m_pCurrObj) != nullptr) return GDB_GEO ; // se gruppo - else if ( GetGdbGroup( m_pCurrNode) != nullptr) + else if ( GetGdbGroup( m_pCurrObj) != nullptr) return GDB_GROUP ; // altro else @@ -153,31 +152,27 @@ GdbIterator::GetGdbType( void) const IGeoObj* GdbIterator::GetGeoObj( void) { - const GdbObj* pGdbObj ; - - - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) return false ; // recupero l'oggetto Gdb - if ( ( pGdbObj = GetGdbObj( m_pCurrNode)) == nullptr) + const GdbGeo* pGdbGeo ; + if ( ( pGdbGeo = GetGdbGeo( m_pCurrObj)) == nullptr) return nullptr ; // restituisco il suo contenuto geometrico - return pGdbObj->m_pGeoObj ; + return pGdbGeo->m_pGeoObj ; } //---------------------------------------------------------------------------- IGeoFrame3d* GdbIterator::GetGeoFrame( void) { - GdbGroup* pGdbGroup ; - - - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) return nullptr ; - if ( ( pGdbGroup = GetGdbGroup( m_pCurrNode)) == nullptr) + GdbGroup* pGdbGroup ; + if ( ( pGdbGroup = GetGdbGroup( m_pCurrObj)) == nullptr) return nullptr ; return &( pGdbGroup->m_gfrFrame) ; @@ -185,15 +180,13 @@ GdbIterator::GetGeoFrame( void) //---------------------------------------------------------------------------- bool -GdbIterator::GetGroupFrame( Frame3d& frGlob) +GdbIterator::GetGroupFrame( Frame3d& frGlob) const { - GdbGroup* pGdbGroup ; - - - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) return false ; - if ( ( pGdbGroup = GetGdbGroup( m_pCurrNode)) == nullptr) + GdbGroup* pGdbGroup ; + if ( ( pGdbGroup = GetGdbGroup( m_pCurrObj)) == nullptr) return false ; // copio il riferimento @@ -203,15 +196,13 @@ GdbIterator::GetGroupFrame( Frame3d& frGlob) //---------------------------------------------------------------------------- bool -GdbIterator::GetGroupGlobFrame( Frame3d& frGlob) +GdbIterator::GetGroupGlobFrame( Frame3d& frGlob) const { - GdbGroup* pGdbGroup ; - - - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) return false ; - if ( ( pGdbGroup = GetGdbGroup( m_pCurrNode)) == nullptr) + GdbGroup* pGdbGroup ; + if ( ( pGdbGroup = GetGdbGroup( m_pCurrObj)) == nullptr) return false ; return pGdbGroup->GetGlobFrame( frGlob) ; @@ -219,20 +210,44 @@ GdbIterator::GetGroupGlobFrame( Frame3d& frGlob) //---------------------------------------------------------------------------- int -GdbIterator::GetId( void) +GdbIterator::GetId( void) const { - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) - return - 1 ; + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) + return GDB_ID_NULL ; - return m_pCurrNode->m_nId ; + return m_pCurrObj->m_nId ; } //---------------------------------------------------------------------------- int -GdbIterator::GetParentId( void) +GdbIterator::GetParentId( void) const { - if ( m_pGDB == nullptr || m_pCurrNode == nullptr) - return - 1 ; + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) + return GDB_ID_NULL ; - return m_pCurrNode->GetParentId() ; + return m_pCurrObj->GetParentId() ; +} + +//---------------------------------------------------------------------------- +// Attributes +//---------------------------------------------------------------------------- +bool +GdbIterator::SetColor( Color cCol) +{ + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) + return false ; + + // assegno il colore + return m_pCurrObj->SetColor( cCol) ; +} + +//---------------------------------------------------------------------------- +bool +GdbIterator::GetColor( Color& cCol) const +{ + if ( m_pGDB == nullptr || m_pCurrObj == nullptr) + return false ; + + // recupero il colore + return m_pCurrObj->GetColor( cCol) ; } diff --git a/GdbIterator.h b/GdbIterator.h index 731c8a3..99fcd0d 100644 --- a/GdbIterator.h +++ b/GdbIterator.h @@ -32,14 +32,16 @@ class GdbIterator : public IGdbIterator virtual GdbType GetGdbType( void) const ; virtual IGeoObj* GetGeoObj( void) ; virtual IGeoFrame3d* GetGeoFrame( void) ; - virtual bool GetGroupFrame( Frame3d& frGlob) ; - virtual bool GetGroupGlobFrame( Frame3d& frGlob) ; - virtual int GetId( void) ; - virtual int GetParentId( void) ; - virtual bool GetGlobFrame( Frame3d& frGlob) + virtual bool GetGroupFrame( Frame3d& frGlob) const ; + virtual bool GetGroupGlobFrame( Frame3d& frGlob) const ; + virtual int GetId( void) const ; + virtual int GetParentId( void) const ; + virtual bool GetGlobFrame( Frame3d& frGlob) const { return m_pGDB->GetGroupGlobFrame( GetParentId(), frGlob) ; } + virtual bool SetColor( Color cCol) ; + virtual bool GetColor( Color& cCol) const ; private : - GeomDB* m_pGDB ; - GdbNode* m_pCurrNode ; + GeomDB* m_pGDB ; + GdbObj* m_pCurrObj ; } ; diff --git a/GdbNode.cpp b/GdbNode.cpp deleted file mode 100644 index 41a5924..0000000 --- a/GdbNode.cpp +++ /dev/null @@ -1,159 +0,0 @@ -//---------------------------------------------------------------------------- -// EgalTech 2013-2013 -//---------------------------------------------------------------------------- -// File : GdbNode.cpp Data : 28.11.13 Versione : 1.4a2 -// Contenuto : Implementazione della classe GdbNode. -// -// -// -// Modifiche : 28.11.13 DS Creazione modulo. -// -// -//---------------------------------------------------------------------------- - -//--------------------------- Include ---------------------------------------- -#include "stdafx.h" -#include "GdbNode.h" -#include "GdbGroup.h" - -//---------------------------------------------------------------------------- -GdbNode::GdbNode( void) - : m_nId( GDB_ID_NULL), m_pNext( nullptr), m_pPrev( nullptr), m_pParent( nullptr) -{ -} - -//---------------------------------------------------------------------------- -int -GdbNode::GetParentId( void) const -{ - if ( m_pParent != nullptr) - return m_pParent->m_nId ; - else - return 0 ; -} - -//---------------------------------------------------------------------------- -bool -GdbNode::AddTail( GdbGroup* pParent) -{ - // se il padre non è definito, errore - if ( pParent == nullptr) - return false ; - - // se non ci sono figli - if ( pParent->m_pLastNode == nullptr) { - pParent->m_pLastNode = this ; - pParent->m_pFirstNode = this ; - m_pParent = pParent ; - m_pNext = nullptr ; - m_pPrev = nullptr ; - m_pParent->NodeCountInc() ; - return true ; - } - - // caso standard - return InsertAfter( pParent->m_pLastNode) ; -} - -//---------------------------------------------------------------------------- -bool -GdbNode::AddHead( GdbGroup* pParent) -{ - // se il padre non è definito, errore - if ( pParent == nullptr) - return false ; - - // se non ci sono figli - if ( pParent->m_pFirstNode == nullptr) { - pParent->m_pFirstNode = this ; - pParent->m_pLastNode = this ; - m_pParent = pParent ; - m_pNext = nullptr ; - m_pPrev = nullptr ; - m_pParent->NodeCountInc() ; - return true ; - } - - // caso standard - return InsertBefore( pParent->m_pFirstNode) ; -} - -//---------------------------------------------------------------------------- -bool -GdbNode::InsertAfter( GdbNode* 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_pLastNode == pRef) - m_pParent->m_pLastNode = this ; - m_pParent->NodeCountInc() ; - } - - return true ; -} - -//---------------------------------------------------------------------------- -bool -GdbNode::InsertBefore( GdbNode* 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_pFirstNode == pRef) - m_pParent->m_pFirstNode = this ; - m_pParent->NodeCountInc() ; - } - - return true ; -} - -/*-------------------------------------------------------------------------*/ -bool -GdbNode::Remove( void) -{ - // sistemazione dell'eventuale padre - if ( m_pParent != nullptr) { - if ( m_pParent->m_pFirstNode == this) - m_pParent->m_pFirstNode = m_pNext ; - if ( m_pParent->m_pLastNode == this) - m_pParent->m_pLastNode = m_pPrev ; - m_pParent->NodeCountDec() ; - } - // 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 ; -} - - diff --git a/GdbNode.h b/GdbNode.h deleted file mode 100644 index 70c4c23..0000000 --- a/GdbNode.h +++ /dev/null @@ -1,65 +0,0 @@ -//---------------------------------------------------------------------------- -// EgalTech 2013-2013 -//---------------------------------------------------------------------------- -// File : GdbNode.h Data : 28.11.13 Versione : 1.4a2 -// Contenuto : Dichiarazione della classe GdbNode. -// -// -// -// Modifiche : 28.11.13 DS Creazione modulo. -// -// -//---------------------------------------------------------------------------- - -#pragma once - -#include -#include "/EgtDev/Include/EGkGdbConst.h" -#include "/EgtDev/Include/EGnScan.h" -#include "/EgtDev/Include/EGkBBox3d.h" - - -class GdbGroup ; -class IdManager ; - -//---------------------------------------------------------------------------- -class GdbNode -{ - public : - virtual ~GdbNode( void) {} - virtual GdbNode* Clone( int nId, IdManager& IdMgr) const = 0 ; - virtual bool Save( std::ostream& osOut) const = 0 ; - virtual bool Load( const std::string& sType, Scanner& TheScanner, int& nParentId) = 0 ; - virtual bool GetLocalBBox( BBox3d& b3Loc) const = 0 ; - virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const = 0 ; - virtual bool Translate( const Vector3d& vtMove) = 0 ; - virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) = 0 ; - virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngRad) = 0 ; - virtual bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) = 0 ; - virtual bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm) = 0 ; - virtual bool ToGlob( const Frame3d& frRef) = 0 ; - virtual bool ToLoc( const Frame3d& frRef) = 0 ; - - public : - GdbNode( void) ; - GdbNode* GetNext( void) { return m_pNext ; } - const GdbNode* GetNext( void) const { return m_pNext ; } - GdbNode* GetPrev( void) { return m_pPrev ; } - const GdbNode* GetPrev( void) const { return m_pPrev ; } - GdbGroup* GetParent( void) { return m_pParent ; } - const GdbGroup* GetParent( void) const { return m_pParent ; } - int GetParentId( void) const ; - bool AddTail( GdbGroup* pParent) ; - bool AddHead( GdbGroup* pParent) ; - bool InsertAfter( GdbNode* pRef) ; - bool InsertBefore( GdbNode* pRef) ; - bool Remove( void) ; - - public : - int m_nId ; - - private : - GdbNode* m_pNext ; - GdbNode* m_pPrev ; - GdbGroup* m_pParent ; -} ; diff --git a/GdbObj.cpp b/GdbObj.cpp index 62081a5..d0f5df1 100644 --- a/GdbObj.cpp +++ b/GdbObj.cpp @@ -1,12 +1,12 @@ //---------------------------------------------------------------------------- // EgalTech 2013-2013 //---------------------------------------------------------------------------- -// File : GdbObj.cpp Data : 24.11.13 Versione : 1.3a1 -// Contenuto : Implementazione della classe CGdbObj oggetto del DB geometrico. +// File : GdbObj.cpp Data : 05.03.14 Versione : 1.5c1 +// Contenuto : Implementazione della classe GdbObj. // // // -// Modifiche : 22.01.13 DS Creazione modulo. +// Modifiche : 28.11.13 DS Creazione modulo. // // //---------------------------------------------------------------------------- @@ -14,8 +14,8 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "GdbObj.h" -#include "GeoObjFactory.h" -#include "CurveAux.h" +#include "GdbGroup.h" +#include "Attribs.h" #include "/EgtDev/Include/EGnStringUtils.h" #include @@ -23,190 +23,251 @@ using namespace std ; //---------------------------------------------------------------------------- GdbObj::GdbObj( void) + : m_nId( GDB_ID_NULL), m_pAttribs( nullptr), + m_pNext( nullptr), m_pPrev( nullptr), m_pParent( nullptr) { - m_pGeoObj = nullptr ; } //---------------------------------------------------------------------------- GdbObj::~GdbObj( void) { - if ( m_pGeoObj != nullptr) - delete m_pGeoObj ; - m_pGeoObj = nullptr ; + if ( m_pAttribs != nullptr) + delete m_pAttribs ; + m_pAttribs = nullptr ; } //---------------------------------------------------------------------------- -GdbObj* -GdbObj::Clone( int nId, IdManager& IdMgr) const +bool +GdbObj::Copy( const GdbObj* pSou) { - GdbObj* pGdbObj ; + // elimino eventuali attributi pre-esistenti + if ( m_pAttribs != nullptr) + delete m_pAttribs ; + m_pAttribs = nullptr ; - - // alloco oggetto Gdb - pGdbObj = new(nothrow) GdbObj ; - if ( pGdbObj == nullptr) - return nullptr ; - - // copio dati oggetto Gdb - pGdbObj->m_nId = nId ; - // ... - - // copio oggetto Geo - pGdbObj->m_pGeoObj = m_pGeoObj->Clone() ; - if ( pGdbObj->m_pGeoObj == nullptr) { - delete pGdbObj ; - return nullptr ; + // se l'oggetto sorgente non esiste + if ( pSou == nullptr) { + m_nId = GDB_ID_NULL ; + return false ; } - return pGdbObj ; -} + // copio Id + m_nId = pSou->m_nId ; -//---------------------------------------------------------------------------- -GeoObjType -GdbObj::GetType( void) const -{ - // non esiste l'oggetto geometrico - if ( m_pGeoObj == nullptr) - return GEO_NONE ; - - return m_pGeoObj->GetType() ; -} - -//---------------------------------------------------------------------------- -bool -GdbObj::Save( std::ostream& osOut) const -{ - // tipo entità - osOut << m_pGeoObj->GetKey() << endl ; - // nome - osOut << m_nId << "@" << GetParentId() << endl ; - // parametri geometrici - return m_pGeoObj->Save( osOut) ; -} - -//---------------------------------------------------------------------------- -bool -GdbObj::Load( const std::string& sType, Scanner& TheScanner, int& nParentId) -{ - int nType ; - string sLine ; - STRVECTOR vsParams ; - - - // creo l'oggetto geometrico corrispondente - nType = GEOOBJ_KEYTOTYPE( sType) ; - m_pGeoObj = GEOOBJ_CREATE( nType) ; - if ( m_pGeoObj == nullptr) - return false ; - - // leggo la prossima linea - if ( ! TheScanner.GetLine( sLine)) - return false ; - // la divido in parametri - Tokenize( sLine, "@", vsParams) ; - // 2 parametri : Id e ParentId - if ( vsParams.size() != 2) - return false ; - // assegno l'identificativo - if ( ! FromString( vsParams[0], m_nId)) - return false ; - // assegno l'Id del padre - if ( ! FromString( vsParams[1], nParentId)) - return false ; - - // parametri geometrici - return m_pGeoObj->Load( TheScanner) ; -} - -//---------------------------------------------------------------------------- -bool -GdbObj::GetLocalBBox( BBox3d& b3Loc) const -{ - if ( m_pGeoObj == nullptr) - return false ; - - return m_pGeoObj->GetLocalBBox( b3Loc) ; -} - -//---------------------------------------------------------------------------- -bool -GdbObj::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const -{ - if ( m_pGeoObj == nullptr) - return false ; - - return m_pGeoObj->GetBBox( frRef, b3Ref) ; -} - -//---------------------------------------------------------------------------- -bool -GdbObj::Translate( const Vector3d& vtMove) -{ - if ( m_pGeoObj == nullptr) - return false ; - - return m_pGeoObj->Translate( vtMove) ; -} - -//---------------------------------------------------------------------------- -bool -GdbObj::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) -{ - if ( m_pGeoObj == nullptr) - return false ; - - return m_pGeoObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ; -} - -//---------------------------------------------------------------------------- -bool -GdbObj::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) -{ - if ( m_pGeoObj == nullptr) - return false ; - - // se arco e scalatura non omogenea - if ( m_pGeoObj->GetType() == CRV_ARC && - (fabs( dCoeffX - dCoeffY) > EPS_SMALL || fabs( dCoeffX - dCoeffZ) > EPS_SMALL)) { - // trasformo in curva di Bezier (semplice o composta) - ICurve* pCrvNew ; - if ( ! ArcToBezierCurve( GetCurve( m_pGeoObj), pCrvNew)) + // copio gli attributi + if ( pSou->m_pAttribs != nullptr) { + m_pAttribs = pSou->m_pAttribs->Clone() ; + if ( m_pAttribs == nullptr) return false ; - // elimino l'arco e lo sostituisco con la curva di Bezier - delete m_pGeoObj ; - m_pGeoObj = pCrvNew ; } - // eseguo scalatura - return m_pGeoObj->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; + return true ; +} + +//---------------------------------------------------------------------------- +// Node +//---------------------------------------------------------------------------- +int +GdbObj::GetParentId( void) const +{ + if ( m_pParent != nullptr) + return m_pParent->m_nId ; + else + return GDB_ID_NULL ; } //---------------------------------------------------------------------------- bool -GdbObj::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) +GdbObj::AddTail( GdbGroup* pParent) { - if ( m_pGeoObj == nullptr) + // se il padre non è definito, errore + if ( pParent == nullptr) return false ; - return m_pGeoObj->Mirror( ptOn, vtNorm) ; + // 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::ToGlob( const Frame3d& frRef) +GdbObj::AddHead( GdbGroup* pParent) { - if ( m_pGeoObj == nullptr) + // se il padre non è definito, errore + if ( pParent == nullptr) return false ; - return m_pGeoObj->ToGlob( frRef) ; + // 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::ToLoc( const Frame3d& frRef) +GdbObj::InsertAfter( GdbObj* pRef) { - if ( m_pGeoObj == nullptr) + // se riferimento non definito, errore + if ( pRef == nullptr) return false ; - return m_pGeoObj->ToLoc( frRef) ; + // 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::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( std::ostream& osOut) const +{ + if ( m_pAttribs != nullptr) + return m_pAttribs->Save( osOut) ; + + return true ; +} + +//---------------------------------------------------------------------------- +bool +GdbObj::LoadAttribs( Scanner& TheScanner) +{ + if ( GetSafeAttribs() == nullptr) + return false ; + + return m_pAttribs->Load( TheScanner) ; +} + +//---------------------------------------------------------------------------- +Attribs* +GdbObj::GetSafeAttribs( void) +{ + if ( m_pAttribs == nullptr) { + Attribs* pAttribs = new (nothrow) Attribs ; + if ( pAttribs == nullptr) + return nullptr ; + m_pAttribs = pAttribs ; + } + + return m_pAttribs ; +} + +//---------------------------------------------------------------------------- +bool +GdbObj::SetColor( Color cCol) +{ + // recupero gli attributi (se non ci sono, vengono creati) + Attribs* pAttribs = GetSafeAttribs() ; + if ( pAttribs == nullptr) + return false ; + + // assegno il colore + pAttribs->SetColor( cCol) ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +GdbObj::GetColor( Color& cCol) const +{ + // se non ci sono attributi o ci si deve riferire al padre + if ( m_pAttribs == nullptr || + m_pAttribs->GetMaterial() == Attribs::MAT_PARENT) { + if ( GetParent() != nullptr) + return GetParent()->GetColor( cCol) ; + else + return false ; + } + + // se il colore è definito + if ( m_pAttribs->GetMaterial() != Attribs::MAT_NULL) { + cCol = m_pAttribs->GetColor() ; + return true ; + } + + return false ; } diff --git a/GdbObj.h b/GdbObj.h index 2e0de2c..ac609f5 100644 --- a/GdbObj.h +++ b/GdbObj.h @@ -1,47 +1,86 @@ //---------------------------------------------------------------------------- -// EgalTech 2013-2013 +// EgalTech 2013-2014 //---------------------------------------------------------------------------- -// File : GdbObj.h Data : 08.04.13 Versione : 1.1c1 +// File : GdbObj.h Data : 05.03.14 Versione : 1.5c1 // Contenuto : Dichiarazione della classe GdbObj. // // // -// Modifiche : 22.01.13 DS Creazione modulo. +// Modifiche : 28.11.13 DS Creazione modulo. // // //---------------------------------------------------------------------------- #pragma once +#include "/EgtDev/Include/EGkGdbConst.h" +#include "/EgtDev/Include/EGkColor.h" +#include "/EgtDev/Include/EGnScan.h" +#include "/EgtDev/Include/EGkBBox3d.h" #include -#include "/EgtDev/Include/EGkGeoObj.h" -#include "GdbNode.h" +class GdbGroup ; +class IdManager ; +class Attribs ; + //---------------------------------------------------------------------------- -class GdbObj : public GdbNode +class GdbObj { public : virtual ~GdbObj( void) ; - virtual GdbObj* Clone( int nId, IdManager& IdMgr) const ; - virtual bool Save( std::ostream& osOut) const ; - virtual bool Load( const std::string& sType, Scanner& TheScanner, int& nParentId) ; - virtual bool GetLocalBBox( BBox3d& b3Loc) const ; - virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const ; - virtual bool Translate( const Vector3d& vtMove) ; - virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) ; - virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) - { double dAngRad = dAngDeg * DEGTORAD ; - return Rotate( ptAx, vtAx, cos( dAngRad), sin( dAngRad)) ; } - virtual bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) ; - virtual bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm) ; - virtual bool ToGlob( const Frame3d& frRef) ; - virtual bool ToLoc( const Frame3d& frRef) ; + virtual GdbObj* Clone( int nId, IdManager& IdMgr) const = 0 ; + virtual bool Save( std::ostream& osOut) const = 0 ; + virtual bool Load( const std::string& sType, Scanner& TheScanner, int& nParentId) = 0 ; + virtual bool GetLocalBBox( BBox3d& b3Loc) const = 0 ; + virtual bool GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const = 0 ; + virtual bool Translate( const Vector3d& vtMove) = 0 ; + virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) = 0 ; + virtual bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngRad) = 0 ; + virtual bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) = 0 ; + virtual bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm) = 0 ; + virtual bool ToGlob( const Frame3d& frRef) = 0 ; + virtual bool ToLoc( const Frame3d& frRef) = 0 ; public : GdbObj( void) ; - GeoObjType GetType( void) const ; + bool Copy( const GdbObj* pSou) ; public : - IGeoObj* m_pGeoObj ; + bool SaveAttribs( std::ostream& osOut) const ; + bool LoadAttribs( Scanner& TheScanner) ; + Attribs* GetAttribs( void) + { return m_pAttribs ; } + Attribs* GetSafeAttribs( void) ; + bool SetColor( Color cCol) ; + bool GetColor( Color& cCol) const ; + + public : + GdbObj* GetNext( void) + { return m_pNext ; } + const GdbObj* GetNext( void) const + { return m_pNext ; } + GdbObj* GetPrev( void) + { return m_pPrev ; } + const GdbObj* GetPrev( void) const + { return m_pPrev ; } + GdbGroup* GetParent( void) + { return m_pParent ; } + const GdbGroup* GetParent( void) const + { return m_pParent ; } + int GetParentId( void) const ; + bool AddTail( GdbGroup* pParent) ; + bool AddHead( GdbGroup* pParent) ; + bool InsertAfter( GdbObj* pRef) ; + bool InsertBefore( GdbObj* pRef) ; + bool Remove( void) ; + + public : + int m_nId ; + Attribs* m_pAttribs ; + + private : + GdbObj* m_pNext ; + GdbObj* m_pPrev ; + GdbGroup* m_pParent ; } ; diff --git a/GeomDB.cpp b/GeomDB.cpp index c94a386..fe203a3 100644 --- a/GeomDB.cpp +++ b/GeomDB.cpp @@ -14,8 +14,9 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "GeomDB.h" -#include "GdbObj.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" @@ -36,6 +37,7 @@ CreateGeomDB( void) GeomDB::GeomDB( void) { m_GrpRadix.m_nId = GDB_ID_ROOT ; + m_GrpRadix.SetColor( Color( 0, 0, 0)) ; } //---------------------------------------------------------------------------- @@ -48,9 +50,10 @@ GeomDB::~GeomDB( void) bool GeomDB::Init( void) { - // imposto numero minimo buckets del map degli Id m_IdManager.Init( 1024) ; + // imposto colore di default + m_GrpRadix.SetColor( Color( 0, 0, 0)) ; return true ; } @@ -93,7 +96,7 @@ GeomDB::Load( const std::string& sFileIn) // ciclo di lettura dei nodi bOk = true ; do { - if ( ! LoadOneNode( TheScanner, bEnd)) { + if ( ! LoadOneObj( TheScanner, bEnd)) { bOk = false ; string sOut = "GeomDbLoad : Error on line " + ToString( TheScanner.GetCurrLineNbr()) ; LOG_ERROR( GetEGkLogger(), sOut.c_str()) @@ -130,11 +133,11 @@ GeomDB::LoadStart( Scanner& TheScanner) //---------------------------------------------------------------------------- bool -GeomDB::LoadOneNode( Scanner& TheScanner, bool& bEnd) +GeomDB::LoadOneObj( Scanner& TheScanner, bool& bEnd) { - int nParentId ; - string sType ; - GdbNode* pGdbNode ; + int nParentId ; + string sType ; + GdbObj* pGdbObj ; // in generale non è fine file @@ -151,27 +154,27 @@ GeomDB::LoadOneNode( Scanner& TheScanner, bool& bEnd) } // se gruppo else if ( sType == GdbGroup::GetKey()) { - pGdbNode = new( nothrow) GdbGroup ; + pGdbObj = new( nothrow) GdbGroup ; } // se copia TODO ("X_CPY").. //else if ( sType == GdbCopy::GetKey) { - // pGdbNode = new( nothrow) GdbCopy ; + // pGdbObj = new( nothrow) GdbCopy ; //} // altrimenti oggetto geometrico else - pGdbNode = new( nothrow) GdbObj ; + pGdbObj = new( nothrow) GdbGeo ; - // verifico il nodo GDB - if ( pGdbNode == nullptr) + // verifico l'oggetto GDB + if ( pGdbObj == nullptr) return false ; // se lettura dati e inserimento nel DB vanno bene - if ( pGdbNode->Load( sType, TheScanner, nParentId) && - AddToGeomDB( pGdbNode, nParentId)) + if ( pGdbObj->Load( sType, TheScanner, nParentId) && + AddToGeomDB( pGdbObj, nParentId)) return true ; // altrimenti errore else { - delete pGdbNode ; + delete pGdbObj ; return false ; } } @@ -190,15 +193,15 @@ GeomDB::Save( const std::string& sFileOut) const // intestazione ofSave << "START" << endl ; - ofSave << "GeomDB,1.4a4" << endl ; + ofSave << "GeomDB,1.5c1" << endl ; // ciclo di scrittura degli oggetti bool bOk = true ; - const GdbNode* pGdbNode = m_GrpRadix.GetFirstNode() ; - while ( pGdbNode != nullptr) { + const GdbObj* pGdbObj = m_GrpRadix.GetFirstObj() ; + while ( pGdbObj != nullptr) { // oggetto geometrico - if ( ! pGdbNode->Save( ofSave)) + if ( ! pGdbObj->Save( ofSave)) bOk = false ; - pGdbNode = pGdbNode->GetNext() ; + pGdbObj = pGdbObj->GetNext() ; } ofSave << "END" << endl ; @@ -210,14 +213,14 @@ GeomDB::Save( const std::string& sFileOut) const //---------------------------------------------------------------------------- bool -GeomDB::ExistsNode( int nId) const +GeomDB::ExistsObj( int nId) const { - return ( (const_cast(this))->GetGdbNode(nId) != nullptr) ; + return ( (const_cast(this))->GetGdbObj( nId) != nullptr) ; } //---------------------------------------------------------------------------- -GdbNode* -GeomDB::GetGdbNode( int nId) +GdbObj* +GeomDB::GetGdbObj( int nId) { // impossibile if ( nId < GDB_ID_ROOT) @@ -227,19 +230,19 @@ GeomDB::GetGdbNode( int nId) return &m_GrpRadix ; // un nodo qualubque else - return m_IdManager.FindNode( nId) ; + return m_IdManager.FindObj( nId) ; } //---------------------------------------------------------------------------- bool -GeomDB::AddToGeomDB( GdbNode* pGNode, int nParentId) +GeomDB::AddToGeomDB( GdbObj* pGObj, int nParentId) { // verifico validità oggetto puntato - if ( pGNode == nullptr) + if ( pGObj == nullptr) return false ; // verifica validità e unicità del nome - if ( pGNode->m_nId <= GDB_ID_ROOT || ExistsNode( pGNode->m_nId)) + if ( pGObj->m_nId <= GDB_ID_ROOT || ExistsObj( pGObj->m_nId)) return false ; // cerco il padre @@ -247,14 +250,14 @@ GeomDB::AddToGeomDB( GdbNode* pGNode, int nParentId) if ( pGroup == nullptr) return false ; // inserisco in coda alla lista del padre - if ( ! pGNode->AddTail( pGroup)) + if ( ! pGObj->AddTail( pGroup)) return false ; // aggiorno gestore Id - m_IdManager.UpdateMaxId( pGNode->m_nId) ; + m_IdManager.UpdateMaxId( pGObj->m_nId) ; // inserisco in mappa nomi - return m_IdManager.AddNode( pGNode->m_nId, pGNode) ; + return m_IdManager.AddObj( pGObj->m_nId, pGObj) ; } //---------------------------------------------------------------------------- @@ -270,7 +273,7 @@ GeomDB::AddGroup( int nId, int nParentId, const Frame3d& frFrame) // verifico validità Id if ( nId <= GDB_ID_ROOT) nId = m_IdManager.GetNewId() ; - if ( ExistsNode( nId)) + if ( ExistsObj( nId)) return GDB_ID_NULL ; // alloco gruppo Gdb pGdbGroup = new(nothrow) GdbGroup ; @@ -293,7 +296,7 @@ GeomDB::AddGroup( int nId, int nParentId, const Frame3d& frFrame) int GeomDB::AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj) { - GdbObj* pGdbObj ; + GdbGeo* pGdbGeo ; // assegno GeoObj a gestore puntatore con rilascio automatico @@ -301,22 +304,22 @@ GeomDB::AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj) // verifico validità identificativo if ( nId <= GDB_ID_ROOT) nId = m_IdManager.GetNewId() ; - if ( ExistsNode( nId)) + if ( ExistsObj( nId)) return GDB_ID_NULL ; // verifico validità oggetto Geo if ( ! IsValid( pRPGeoObj) || ! pRPGeoObj->IsValid()) return GDB_ID_NULL ; // alloco oggetto Gdb - pGdbObj = new(nothrow) GdbObj ; - if ( pGdbObj == nullptr) + pGdbGeo = new(nothrow) GdbGeo ; + if ( pGdbGeo == nullptr) return GDB_ID_NULL ; // assegno identificativo - pGdbObj->m_nId = nId ; + pGdbGeo->m_nId = nId ; // assegno dati - pGdbObj->m_pGeoObj = Release( pRPGeoObj) ; + pGdbGeo->m_pGeoObj = Release( pRPGeoObj) ; // inserisco nel DB - if ( ! AddToGeomDB( pGdbObj, nParentId)) { - delete pGdbObj ; + if ( ! AddToGeomDB( pGdbGeo, nParentId)) { + delete pGdbGeo ; return GDB_ID_NULL ; } @@ -327,18 +330,18 @@ GeomDB::AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj) GdbType GeomDB::GetGdbType( int nId) const { - const GdbNode* pGdbNode ; + const GdbObj* pGdbObj ; - // recupero il nodo - if ( ( pGdbNode = (const_cast (this))->GetGdbNode( nId)) == nullptr) + // recupero l'oggetto + if ( ( pGdbObj = (const_cast (this))->GetGdbObj( nId)) == nullptr) return GDB_NONE ; // se oggetto geometrico - if ( ::GetGdbObj( pGdbNode) != nullptr) + if ( ::GetGdbGeo( pGdbObj) != nullptr) return GDB_GEO ; // se gruppo - else if ( ::GetGdbGroup( pGdbNode) != nullptr) + else if ( ::GetGdbGroup( pGdbObj) != nullptr) return GDB_GROUP ; // altro else @@ -349,25 +352,21 @@ GeomDB::GetGdbType( int nId) const IGeoObj* GeomDB::GetGeoObj( int nId) { - const GdbObj* pGdbObj ; - - // recupero l'oggetto Gdb - if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) + const GdbGeo* pGdbGeo ; + if ( ( pGdbGeo = GetGdbGeo( nId)) == nullptr) return nullptr ; // restituisco il suo contenuto geometrico - return pGdbObj->m_pGeoObj ; + return pGdbGeo->m_pGeoObj ; } //---------------------------------------------------------------------------- IGeoFrame3d* GeomDB::GetGeoFrame( int nId) { - GdbGroup* pGdbGroup ; - - // recupero il gruppo Gdb + GdbGroup* pGdbGroup ; if ( ( pGdbGroup = GetGdbGroup( nId)) == nullptr) return nullptr ; @@ -404,7 +403,7 @@ GeomDB::GetGroupGlobFrame( int nId, Frame3d& frGlob) const //---------------------------------------------------------------------------- int -GeomDB::GetGroupNodes( int nId) const +GeomDB::GetGroupObjs( int nId) const { // recupero il gruppo Gdb const GdbGroup* pGdbGroup ; @@ -412,35 +411,35 @@ GeomDB::GetGroupNodes( int nId) const return 0 ; // restituisco il numero di nodi (figli) - return pGdbGroup->GetNodeCount() ; + return pGdbGroup->GetObjCount() ; } //---------------------------------------------------------------------------- int GeomDB::GetParentId( int nId) const { - // recupero il nodo Gdb - const GdbNode* pGdbNode ; - if ( ( pGdbNode = (const_cast (this))->GetGdbNode( nId)) == nullptr) + // recupero l'oggetto Gdb + const GdbObj* pGdbObj ; + if ( ( pGdbObj = (const_cast (this))->GetGdbObj( nId)) == nullptr) return GDB_ID_NULL ; // restituisco l'Id del padre - return pGdbNode->GetParentId() ; + return pGdbObj->GetParentId() ; } //---------------------------------------------------------------------------- bool GeomDB::GetLocalBBox( int nId, BBox3d& b3Loc) const { - const GdbNode* pGdbNode ; + const GdbObj* pGdbObj ; // recupero l'oggetto - if ( ( pGdbNode = (const_cast (this))->GetGdbNode( nId)) == nullptr) + if ( ( pGdbObj = (const_cast (this))->GetGdbObj( nId)) == nullptr) return false ; // eseguo l'operazione - return pGdbNode->GetLocalBBox( b3Loc) ; + return pGdbObj->GetLocalBBox( b3Loc) ; } //---------------------------------------------------------------------------- @@ -448,17 +447,17 @@ bool GeomDB::GetGlobalBBox( int nId, BBox3d& b3Glob) const { // recupero l'oggetto - const GdbNode* pGdbNode ; - if ( ( pGdbNode = (const_cast (this))->GetGdbNode( nId)) == nullptr) + const GdbObj* pGdbObj ; + if ( ( pGdbObj = (const_cast (this))->GetGdbObj( nId)) == nullptr) return false ; // recupero il riferimento globale del gruppo cui appartiene Frame3d frGlob ; - if ( ! GetGroupGlobFrame( pGdbNode->GetParentId(), frGlob)) + if ( ! GetGroupGlobFrame( pGdbObj->GetParentId(), frGlob)) return false ; // eseguo l'operazione - return pGdbNode->GetBBox( frGlob, b3Glob) ; + return pGdbObj->GetBBox( frGlob, b3Glob) ; } //---------------------------------------------------------------------------- @@ -466,20 +465,20 @@ bool GeomDB::GetRefBBox( int nId, const Frame3d& frRef, BBox3d& b3Ref) const { // recupero l'oggetto - const GdbNode* pGdbNode ; - if ( ( pGdbNode = (const_cast (this))->GetGdbNode( nId)) == nullptr) + const GdbObj* pGdbObj ; + if ( ( pGdbObj = (const_cast (this))->GetGdbObj( nId)) == nullptr) return false ; // recupero il riferimento globale del gruppo cui appartiene Frame3d frGlob ; - if ( ! GetGroupGlobFrame( pGdbNode->GetParentId(), frGlob)) + if ( ! GetGroupGlobFrame( pGdbObj->GetParentId(), frGlob)) return false ; // lo porto nel riferimento passato frGlob.ToLoc( frRef) ; // eseguo l'operazione - return pGdbNode->GetBBox( frGlob, b3Ref) ; + return pGdbObj->GetBBox( frGlob, b3Ref) ; } //---------------------------------------------------------------------------- @@ -489,22 +488,22 @@ GeomDB::Copy( int nIdSou, int nIdDest, int nParentIdDest) // verifico Id destinazione if ( nIdDest <= GDB_ID_ROOT) nIdDest = m_IdManager.GetNewId() ; - if ( ExistsNode( nIdDest)) + if ( ExistsObj( nIdDest)) return GDB_ID_NULL ; // verifico esistenza del sorgente - GdbNode* pGdNSou ; - if ( ( pGdNSou = GetGdbNode( nIdSou)) == nullptr) + GdbObj* pGdOSou ; + if ( ( pGdOSou = GetGdbObj( nIdSou)) == nullptr) return GDB_ID_NULL ; // eseguo la copia - GdbNode* pGdNDest ; - if ( ( pGdNDest = pGdNSou->Clone( nIdDest, m_IdManager)) == nullptr) + GdbObj* pGdODest ; + if ( ( pGdODest = pGdOSou->Clone( nIdDest, m_IdManager)) == nullptr) return GDB_ID_NULL ; // inserisco nel DB - if ( ! AddToGeomDB( pGdNDest, nParentIdDest)) { - delete pGdNDest ; + if ( ! AddToGeomDB( pGdODest, nParentIdDest)) { + delete pGdODest ; return GDB_ID_NULL ; } @@ -518,12 +517,12 @@ GeomDB::CopyGlob( int nIdSou, int nIdDest, int nParentIdDest) // verifico Id destinazione if ( nIdDest <= GDB_ID_ROOT) nIdDest = m_IdManager.GetNewId() ; - if ( ExistsNode( nIdDest)) + if ( ExistsObj( nIdDest)) return GDB_ID_NULL ; // verifico esistenza del sorgente - GdbNode* pGdNSou ; - if ( ( pGdNSou = GetGdbNode( nIdSou)) == nullptr) + GdbObj* pGdOSou ; + if ( ( pGdOSou = GetGdbObj( nIdSou)) == nullptr) return GDB_ID_NULL ; // recupero il riferimento del sorgente @@ -537,19 +536,19 @@ GeomDB::CopyGlob( int nIdSou, int nIdDest, int nParentIdDest) return false ; // eseguo la copia - GdbNode* pGdNDest ; - if ( ( pGdNDest = pGdNSou->Clone( nIdDest, m_IdManager)) == nullptr) + 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)) { - pGdNDest->ToGlob( frSou) ; - pGdNDest->ToLoc( frDest) ; + pGdODest->ToGlob( frSou) ; + pGdODest->ToLoc( frDest) ; } // inserisco nel DB - if ( ! AddToGeomDB( pGdNDest, nParentIdDest)) { - delete pGdNDest ; + if ( ! AddToGeomDB( pGdODest, nParentIdDest)) { + delete pGdODest ; return GDB_ID_NULL ; } @@ -560,8 +559,8 @@ GeomDB::CopyGlob( int nIdSou, int nIdDest, int nParentIdDest) bool GeomDB::Erase( int nId) { - INTPGDBN_UMAP::const_iterator Iter ; - GdbNode* pGdbNode ; + INTPGDBO_UMAP::const_iterator Iter ; + GdbObj* pGdbObj ; // non si può cancellare il gruppo radice (escludo anche Id non validi) @@ -569,18 +568,18 @@ GeomDB::Erase( int nId) return false ; // recupero l'oggetto - pGdbNode = m_IdManager.FindNode( nId) ; - if ( pGdbNode == nullptr) + pGdbObj = m_IdManager.FindObj( nId) ; + if ( pGdbObj == nullptr) return false ; // elimino da mappa dei nomi - m_IdManager.RemoveNode( nId) ; + m_IdManager.RemoveObj( nId) ; // lo tolgo dalla lista - pGdbNode->Remove() ; + pGdbObj->Remove() ; // lo disalloco (distruttore virtuale) - delete pGdbNode ; + delete pGdbObj ; return true ; } @@ -590,11 +589,11 @@ bool GeomDB::Translate( int nId, const Vector3d& vtMove) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // eseguo la traslazione - return pGdbNode->Translate( vtMove) ; + return pGdbObj->Translate( vtMove) ; } //---------------------------------------------------------------------------- @@ -602,8 +601,8 @@ bool GeomDB::TranslateGlob( int nId, const Vector3d& vtMove) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // recupero il riferimento in cui è immerso Frame3d frObj ; @@ -614,7 +613,7 @@ GeomDB::TranslateGlob( int nId, const Vector3d& vtMove) if ( ! vtMoveLoc.ToLoc( frObj)) return false ; // eseguo la traslazione - return pGdbNode->Translate( vtMoveLoc) ; + return pGdbObj->Translate( vtMoveLoc) ; } //---------------------------------------------------------------------------- @@ -622,11 +621,11 @@ bool GeomDB::Rotate( int nId, const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // eseguo la rotazione - return pGdbNode->Rotate( ptAx, vtAx, dCosAng, dSinAng) ; + return pGdbObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ; } //---------------------------------------------------------------------------- @@ -634,8 +633,8 @@ bool GeomDB::RotateGlob( int nId, const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // recupero il riferimento in cui è immerso Frame3d frObj ; @@ -649,7 +648,7 @@ GeomDB::RotateGlob( int nId, const Point3d& ptAx, const Vector3d& vtAx, double d if ( ! vtAxLoc.ToLoc( frObj)) return false ; // eseguo la rotazione - return pGdbNode->Rotate( ptAxLoc, vtAxLoc, dCosAng, dSinAng) ; + return pGdbObj->Rotate( ptAxLoc, vtAxLoc, dCosAng, dSinAng) ; } //---------------------------------------------------------------------------- @@ -657,11 +656,11 @@ bool GeomDB::Scale( int nId, const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // eseguo la scalatura - return pGdbNode->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; + return pGdbObj->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; } //---------------------------------------------------------------------------- @@ -669,8 +668,8 @@ bool GeomDB::ScaleGlob( int nId, const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // recupero il riferimento in cui è immerso Frame3d frObj ; @@ -681,7 +680,7 @@ GeomDB::ScaleGlob( int nId, const Frame3d& frRef, double dCoeffX, double dCoeffY if ( ! frRefLoc.ToLoc( frObj)) return false ; // eseguo la scalatura - return pGdbNode->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ) ; + return pGdbObj->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ) ; } //---------------------------------------------------------------------------- @@ -689,11 +688,11 @@ bool GeomDB::Mirror( int nId, const Point3d& ptOn, const Vector3d& vtNorm) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // eseguo l'operazione - return pGdbNode->Mirror( ptOn, vtNorm) ; + return pGdbObj->Mirror( ptOn, vtNorm) ; } //---------------------------------------------------------------------------- @@ -701,8 +700,8 @@ bool GeomDB::MirrorGlob( int nId, const Point3d& ptOn, const Vector3d& vtNorm) { // recupero l'oggetto - GdbNode* pGdbNode ; - if ( ( pGdbNode = GetGdbNode( nId)) == nullptr) + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) return false ; // recupero il riferimento in cui è immerso Frame3d frObj ; @@ -716,5 +715,64 @@ GeomDB::MirrorGlob( int nId, const Point3d& ptOn, const Vector3d& vtNorm) if ( ! vtNormLoc.ToLoc( frObj)) return false ; // eseguo l'operazione - return pGdbNode->Mirror( ptOnLoc, vtNormLoc) ; + return pGdbObj->Mirror( ptOnLoc, vtNormLoc) ; +} + +//---------------------------------------------------------------------------- +// Attributes +//---------------------------------------------------------------------------- +bool +GeomDB::DumpAttributes( int nId, string& sOut, const char* szNewLine) const +{ + // recupero l'oggetto + const GdbObj* pGdbObj ; + if ( ( pGdbObj = (const_cast(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::SetDefaultColor( Color cCol) +{ + // recupero l'oggetto + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( GDB_ID_ROOT)) == nullptr) + return false ; + + // assegno il colore + return pGdbObj->SetColor( cCol) ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::SetColor( int nId, Color cCol) +{ + // recupero l'oggetto + GdbObj* pGdbObj ; + if ( ( pGdbObj = GetGdbObj( nId)) == nullptr) + return false ; + + // assegno il colore + return pGdbObj->SetColor( cCol) ; +} + +//---------------------------------------------------------------------------- +bool +GeomDB::GetColor( int nId, Color& cCol) const +{ + // recupero l'oggetto + const GdbObj* pGdbObj ; + if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr) + return false ; + + // recupero il colore + return pGdbObj->GetColor( cCol) ; } diff --git a/GeomDB.h b/GeomDB.h index 025a229..ef182ab 100644 --- a/GeomDB.h +++ b/GeomDB.h @@ -13,7 +13,7 @@ #pragma once -#include "GdbObj.h" +#include "GdbGeo.h" #include "GdbGroup.h" #include "IdManager.h" #include "/EgtDev/Include/EGkGeomDB.h" @@ -34,7 +34,7 @@ class GeomDB : public IGeomDB virtual bool Clear( void) ; virtual bool Load( const std::string& sFileIn) ; virtual bool Save( const std::string& sFileOut) const ; - virtual bool ExistsNode( int nId) const ; + virtual bool ExistsObj( int nId) const ; virtual int AddGroup( int nId, int nParentId, const Frame3d& frFrame) ; virtual int AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj) ; virtual GdbType GetGdbType( int nId) const ; @@ -42,7 +42,7 @@ class GeomDB : public IGeomDB virtual IGeoFrame3d* GetGeoFrame( int nId) ; virtual bool GetGroupFrame( int nId, Frame3d& frGrp) const ; virtual bool GetGroupGlobFrame( int nId, Frame3d& frGlob) const ; - virtual int GetGroupNodes( int nId) const ; + virtual int GetGroupObjs( int nId) const ; virtual int GetParentId( int nId) const ; virtual bool GetGlobFrame( int nId, Frame3d& frGlob) const { return GetGroupGlobFrame( GetParentId( nId), frGlob) ; } @@ -66,29 +66,35 @@ class GeomDB : public IGeomDB virtual bool ScaleGlob( int nId, const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) ; virtual bool Mirror( int nId, const Point3d& ptOn, const Vector3d& vtNorm) ; virtual bool MirrorGlob( int nId, const Point3d& ptOn, const Vector3d& vtNorm) ; + virtual bool DumpAttributes( int nId, std::string& sOut, const char* szNewLine) const ; + virtual bool SetDefaultColor( Color cCol) ; + virtual bool SetColor( int nId, Color cCol) ; + virtual bool GetColor( int nId, Color& cCol) const ; public : GeomDB( void) ; private : - GdbNode* GetGdbNode( int nId) ; - GdbObj* GetGdbObj( int nId) { return dynamic_cast( GetGdbNode( nId)) ; } - GdbGroup* GetGdbGroup( int nId) { return dynamic_cast( GetGdbNode( nId)) ; } - bool AddToGeomDB( GdbNode* pGNode, int nParentId) ; + GdbObj* GetGdbObj( int nId) ; + GdbGeo* GetGdbGeo( int nId) + { return dynamic_cast( GetGdbObj( nId)) ; } + GdbGroup* GetGdbGroup( int nId) + { return dynamic_cast( GetGdbObj( nId)) ; } + bool AddToGeomDB( GdbObj* pGObj, int nParentId) ; bool LoadStart( Scanner& TheScanner) ; - bool LoadOneNode( Scanner& TheScanner, bool& bEnd) ; + bool LoadOneObj( Scanner& TheScanner, bool& bEnd) ; private : - GdbGroup m_GrpRadix ; // gruppo radice di tutto il DB - IdManager m_IdManager ; // gestore del nuovo Id + GdbGroup m_GrpRadix ; // gruppo radice di tutto il DB + IdManager m_IdManager ; // gestore del nuovo Id } ; //---------------------------------------------------------------------------- -inline const GdbObj* GetGdbObj( const GdbNode* pGNode) - { return dynamic_cast(pGNode) ; } -inline GdbObj* GetGdbObj( GdbNode* pGNode) - { return dynamic_cast(pGNode) ; } -inline const GdbGroup* GetGdbGroup( const GdbNode* pGNode) - { return dynamic_cast(pGNode) ; } -inline GdbGroup* GetGdbGroup( GdbNode* pGNode) - { return dynamic_cast(pGNode) ; } +inline const GdbGeo* GetGdbGeo( const GdbObj* pGObj) + { return dynamic_cast(pGObj) ; } +inline GdbGeo* GetGdbGeo( GdbObj* pGObj) + { return dynamic_cast(pGObj) ; } +inline const GdbGroup* GetGdbGroup( const GdbObj* pGObj) + { return dynamic_cast(pGObj) ; } +inline GdbGroup* GetGdbGroup( GdbObj* pGObj) + { return dynamic_cast(pGObj) ; } diff --git a/IdManager.h b/IdManager.h index b13099d..bfd5995 100644 --- a/IdManager.h +++ b/IdManager.h @@ -17,30 +17,37 @@ //---------------------------------------------------------------------------- -typedef std::unordered_map< int, GdbNode*> INTPGDBN_UMAP ; +typedef std::unordered_map< int, GdbObj*> INTPGDBO_UMAP ; //---------------------------------------------------------------------------- class IdManager { public : - IdManager( void) { m_nMaxId = 0 ; } - bool Init( int nBuckets) { m_GdbIdMap.rehash( nBuckets) ; return true ; } - bool Clear( void) { m_GdbIdMap.clear() ; m_nMaxId = 0 ; return true ; } - GdbNode* FindNode( int nId) - { INTPGDBN_UMAP::const_iterator Iter = m_GdbIdMap.find( nId) ; - if ( Iter != m_GdbIdMap.end()) - return Iter->second ; - else - return nullptr ; } - bool AddNode( int nId, GdbNode* pGNode) - { return m_GdbIdMap.insert( std::pair< int, GdbNode*>( nId, pGNode)).second ; } - bool RemoveNode( int nId) - { m_GdbIdMap.erase( nId) ; return true ; } - int GetNewId( void) { return ++ m_nMaxId ; } - int GetMaxId( void) const { return m_nMaxId ; } - void UpdateMaxId( int nId) { if ( nId > m_nMaxId) m_nMaxId = nId ; } + IdManager( void) + { m_nMaxId = 0 ; } + bool Init( int nBuckets) + { m_GdbIdMap.rehash( nBuckets) ; return true ; } + bool Clear( void) + { m_GdbIdMap.clear() ; m_nMaxId = 0 ; return true ; } + GdbObj* FindObj( int nId) + { INTPGDBO_UMAP::const_iterator Iter = m_GdbIdMap.find( nId) ; + if ( Iter != m_GdbIdMap.end()) + return Iter->second ; + else + return nullptr ; } + bool AddObj( int nId, GdbObj* pGObj) + { if ( nId > m_nMaxId) m_nMaxId = nId ; + return m_GdbIdMap.insert( std::pair< int, GdbObj*>( nId, pGObj)).second ; } + bool RemoveObj( int nId) + { m_GdbIdMap.erase( nId) ; return true ; } + int GetNewId( void) + { return ( ++ m_nMaxId) ; } + int GetMaxId( void) const + { return m_nMaxId ; } + void UpdateMaxId( int nId) + { if ( nId > m_nMaxId) m_nMaxId = nId ; } private : int m_nMaxId ; - INTPGDBN_UMAP m_GdbIdMap ; // map basato sugli identificatori + INTPGDBO_UMAP m_GdbIdMap ; // map basato sugli identificatori } ; diff --git a/Resource.h b/Resource.h index 2b6c496..9a2df04 100644 Binary files a/Resource.h and b/Resource.h differ