diff --git a/Attribs.cpp b/Attribs.cpp
index 4ca1f6e..c5bc538 100644
--- a/Attribs.cpp
+++ b/Attribs.cpp
@@ -31,35 +31,34 @@ Attribs::Dump( string& sOut, const char* szNewLine) const
// livello
sOut += "Lev=" ;
switch ( m_Data[LEVEL]) {
- default : /* LEV_USER */ sOut += "user" ; break ;
- case LEV_SYSTEM : sOut += "system" ; break ;
- case LEV_TEMP : sOut += "temp" ; break ;
+ default : /* GDB_LV_USER */ sOut += "user" ; break ;
+ case GDB_LV_SYSTEM : sOut += "system" ; break ;
+ case GDB_LV_TEMP : sOut += "temp" ; break ;
}
// modo
sOut += " Mod=" ;
switch ( m_Data[MODE]) {
- default : /* MOD_STD */ sOut += "std" ; break ;
- case MOD_LOCKED : sOut += "locked" ; break ;
- case MOD_HIDDEN : sOut += "hidden" ; break ;
+ default : /* GDB_MD_STD */ sOut += "std" ; break ;
+ case GDB_MD_LOCKED : sOut += "locked" ; break ;
+ case GDB_MD_HIDDEN : sOut += "hidden" ; break ;
}
// stato
sOut += " Sta=" ;
switch ( m_Data[STATUS]) {
- default : /* STS_ON */ sOut += "on" ; break ;
- case STS_SEL : sOut += "sel" ; break ;
- case STS_OFF : sOut += "off" ; break ;
+ default : /* GDB_ST_ON */ sOut += "on" ; break ;
+ case GDB_ST_SEL : sOut += "sel" ; break ;
+ case GDB_ST_OFF : sOut += "off" ; break ;
}
sOut += szNewLine ;
// materiale
sOut += "Mat=" ;
switch ( m_Material) {
- case MAT_PARENT : sOut += "by parent" ; break ;
- case MAT_COLOR : sOut += "color" ; break ;
- case MAT_NULL : sOut += "null" ; break ;
+ case GDB_MT_COLOR : sOut += "color" ; break ;
+ case GDB_MT_PARENT : sOut += "by parent" ; break ;
default : sOut += ToString( m_Material) ; break ;
}
// eventuale colore
- if ( m_Material != MAT_PARENT && m_Material != MAT_NULL) {
+ if ( m_Material == GDB_MT_COLOR) {
sOut += " Col=" ;
string sColName ;
if ( GetNameOfStdColor( m_Color, sColName))
@@ -91,8 +90,9 @@ Attribs::Save( ostream& osOut) const
osOut << ToString( m_Data[LEVEL]) << "," ;
// modo
osOut << ToString( m_Data[MODE]) << "," ;
- // stato
- osOut << ToString( m_Data[STATUS]) << "," ;
+ // stato (se SEL viene convertito in ON)
+ int nStat = (( m_Data[STATUS] == GDB_ST_SEL) ? GDB_ST_ON : m_Data[STATUS]) ;
+ osOut << ToString( nStat) << "," ;
// altro
osOut << ToString( m_Data[OTHER]) << ";" ;
// materiale
@@ -126,11 +126,14 @@ Attribs::Load( Scanner& TheScanner)
// Data (Level,Mode,Status,Other)
if ( ! DataFromString( vsParams[0]))
return false ;
+ // OldData è inizializzato con Data
+ for ( int i = 0 ; i < DIM ; ++ i)
+ m_OldData[i] = m_Data[i] ;
// materiale
int nMat ;
if ( ! FromString( vsParams[1], nMat))
return false ;
- m_Material = __max( nMat, MAT_PARENT) ;
+ m_Material = __max( nMat, GDB_MT_COLOR) ;
// colore
if ( ! FromString( vsParams[2], m_Color))
return false ;
@@ -164,22 +167,22 @@ Attribs::DataFromString( const string& sParam)
int nLev ;
if ( ! FromString( vsParams[0], nLev))
return false ;
- m_Data[LEVEL] = CLIP( nLev, LEV_USER, LEV_TEMP) ;
+ m_Data[LEVEL] = CLIP( nLev, GDB_LV_USER, GDB_LV_TEMP) ;
// modo
int nMode ;
if ( ! FromString( vsParams[1], nMode))
return false ;
- m_Data[MODE] = CLIP( nMode, MOD_STD, MOD_HIDDEN) ;
+ m_Data[MODE] = CLIP( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
// stato
int nStat ;
if ( ! FromString( vsParams[2], nStat))
return false ;
- m_Data[STATUS] = CLIP( nStat, STS_ON, STS_OFF) ;
+ m_Data[STATUS] = CLIP( nStat, GDB_ST_ON, GDB_ST_OFF) ;
// altro
- int nOther ;
- if ( ! FromString( vsParams[3], nOther))
+ int nOldStatus ;
+ if ( ! FromString( vsParams[3], nOldStatus))
return false ;
- m_Data[OTHER] = CLIP( nOther, 0, 255) ;
+ m_Data[OTHER] = CLIP( nOldStatus, 0, 255) ;
return true ;
}
diff --git a/Attribs.h b/Attribs.h
index e3f5911..383caac 100644
--- a/Attribs.h
+++ b/Attribs.h
@@ -13,6 +13,7 @@
#pragma once
+#include "/EgtDev/Include/EGkGdbConst.h"
#include "/EgtDev/Include/EGkColor.h"
#include "/EgtDev/Include/EGnScan.h"
#include "/EgtDev/Include/EGnStringBase.h"
@@ -26,9 +27,11 @@ 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) ;}
+ { m_Data[LEVEL] = GDB_LV_USER ; m_OldData[LEVEL] = m_Data[LEVEL] ;
+ m_Data[MODE] = GDB_MD_STD ; m_OldData[MODE] = m_Data[MODE] ;
+ m_Data[STATUS] = GDB_ST_ON ; m_OldData[STATUS] = m_Data[STATUS] ;
+ m_Data[OTHER] = 0 ; m_OldData[OTHER] = m_Data[OTHER] ;
+ m_Material = GDB_MT_PARENT ; m_Color.Set() ;}
Attribs* Clone( void) const
{ Attribs* pAttribs ;
// alloco oggetto
@@ -40,24 +43,37 @@ class Attribs
bool Save( std::ostream& osOut) const ;
bool Load( Scanner& TheScanner) ;
void SetLevel( int nLev)
- { m_Data[LEVEL] = CLIP( nLev, LEV_USER, LEV_TEMP) ; }
+ { m_OldData[LEVEL] = m_Data[LEVEL] ;
+ m_Data[LEVEL] = CLIP( nLev, GDB_LV_USER, GDB_LV_TEMP) ; }
+ void RevertLevel( void)
+ { std::swap( m_Data[LEVEL], m_OldData[LEVEL]) ; }
int GetLevel( void) const
{ return m_Data[LEVEL] ; }
void SetMode( int nMode)
- { m_Data[MODE] = CLIP( nMode, MOD_STD, MOD_HIDDEN) ; }
+ { m_OldData[MODE] = m_Data[MODE] ;
+ m_Data[MODE] = CLIP( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ; }
+ void RevertMode( void)
+ { std::swap( m_Data[MODE], m_OldData[MODE]) ; }
int GetMode( void) const
{ return m_Data[MODE] ; }
- void SetStatus( int nStat)
- { m_Data[STATUS] = CLIP( nStat, STS_ON, STS_OFF) ; }
+ void SetStatus( int nStat) // non si conserva il selezionato
+ { if ( m_Data[STATUS] != GDB_ST_SEL)
+ m_OldData[STATUS] = m_Data[STATUS] ;
+ m_Data[STATUS] = CLIP( nStat, GDB_ST_ON, GDB_ST_OFF) ; }
+ void RevertStatus( void)
+ { if ( m_Data[STATUS] != GDB_ST_SEL)
+ std::swap( m_Data[STATUS], m_OldData[STATUS]) ;
+ else
+ m_Data[STATUS] = m_OldData[STATUS] ; }
int GetStatus( void) const
{ return m_Data[STATUS] ; }
void SetMaterial( int nMat)
- { if ( nMat != MAT_COLOR)
+ { if ( nMat >= GDB_MT_PARENT)
m_Material = nMat ; }
int GetMaterial( void) const
{ return m_Material ; }
void SetColor( Color cCol)
- { m_Material = MAT_COLOR ; m_Color = cCol ; }
+ { m_Material = GDB_MT_COLOR ; m_Color = cCol ; }
Color GetColor( void) const
{ return m_Color ; }
bool SetName( const std::string& sName) ;
@@ -67,12 +83,6 @@ class Attribs
bool GetInfo( const std::string& sKey, std::string& sVal) const ;
bool RemoveInfo( const std::string& sKey) ;
- 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} ;
@@ -83,6 +93,7 @@ class Attribs
private :
unsigned char m_Data[DIM] ;
+ unsigned char m_OldData[DIM] ;
int m_Material ;
Color m_Color ;
STRLIST m_slInfo ;
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index a855045..0d40206 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/EgtGeomKernel.vcxproj b/EgtGeomKernel.vcxproj
index 12b0fec..f641a1a 100644
--- a/EgtGeomKernel.vcxproj
+++ b/EgtGeomKernel.vcxproj
@@ -277,6 +277,7 @@ copy $(TargetPath) \EgtProg\Dll64
+
diff --git a/EgtGeomKernel.vcxproj.filters b/EgtGeomKernel.vcxproj.filters
index 179acd8..557f574 100644
--- a/EgtGeomKernel.vcxproj.filters
+++ b/EgtGeomKernel.vcxproj.filters
@@ -329,6 +329,9 @@
File di intestazione
+
+ File di intestazione
+
diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index bce85cb..bb53ede 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -128,11 +128,17 @@ 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 == "LEV" || sCmd1 == "LEVEL")
+ return ExecuteLevel( sCmd2, vsParams) ;
+ else if ( sCmd1 == "MOD" || sCmd1 == "MODE")
+ return ExecuteMode( sCmd2, vsParams) ;
+ else if ( sCmd1 == "STA" || sCmd1 == "STATUS")
+ return ExecuteStatus( sCmd2, vsParams) ;
else if ( sCmd1 == "COL" || sCmd1 == "COLOR")
return ExecuteColor( sCmd2, vsParams) ;
- else if ( sCmd1 == "NA" || sCmd1 == "NAME")
+ else if ( sCmd1 == "NAM" || sCmd1 == "NAME")
return ExecuteName( sCmd2, vsParams) ;
- else if ( sCmd1 == "INFO")
+ else if ( sCmd1 == "INF" || sCmd1 == "INFO")
return ExecuteInfo( sCmd2, vsParams) ;
else if ( sCmd1 == "COPY")
return ExecuteCopy( sCmd2, vsParams) ;
@@ -919,6 +925,102 @@ GdbExecutor::GetColorParam( const std::string& sParam, Color& cCol)
}
}
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::ExecuteLevel( const string& sCmd2, const STRVECTOR& vsParams)
+{
+ // devono essere 2 parametri ( Id, Livello)
+ if ( vsParams.size() != 2)
+ return false ;
+ // recupero lista Id
+ STRVECTOR vsNames ;
+ if ( ! GetNamesParam( vsParams[0], vsNames))
+ return false ;
+ // recupero livello
+ string sLevel = vsParams[1] ;
+ ToUpper( sLevel) ;
+ int nLevel ;
+ if ( sLevel == "USER")
+ nLevel = GDB_LV_USER ;
+ else if ( sLevel == "SYSTEM")
+ nLevel = GDB_LV_SYSTEM ;
+ else if ( sLevel == "TEMP")
+ nLevel = GDB_LV_TEMP ;
+ else
+ return false ;
+ // esecuzione impostazione livello
+ STRVECTOR::iterator Iter ;
+ for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
+ if ( ! m_pGDB->SetLevel( GetIdParam( *Iter), nLevel))
+ return false ;
+ }
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::ExecuteMode( const string& sCmd2, const STRVECTOR& vsParams)
+{
+ // devono essere 2 parametri ( Id, Modo)
+ if ( vsParams.size() != 2)
+ return false ;
+ // recupero lista Id
+ STRVECTOR vsNames ;
+ if ( ! GetNamesParam( vsParams[0], vsNames))
+ return false ;
+ // recupero modo
+ string sMode = vsParams[1] ;
+ ToUpper( sMode) ;
+ int nMode ;
+ if ( sMode == "STD")
+ nMode = GDB_MD_STD ;
+ else if ( sMode == "LOCKED")
+ nMode = GDB_MD_LOCKED ;
+ else if ( sMode == "HIDDEN")
+ nMode = GDB_MD_HIDDEN ;
+ else
+ return false ;
+ // esecuzione impostazione modo
+ STRVECTOR::iterator Iter ;
+ for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
+ if ( ! m_pGDB->SetMode( GetIdParam( *Iter), nMode))
+ return false ;
+ }
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::ExecuteStatus( const string& sCmd2, const STRVECTOR& vsParams)
+{
+ // devono essere 2 parametri ( Id, Stato)
+ if ( vsParams.size() != 2)
+ return false ;
+ // recupero lista Id
+ STRVECTOR vsNames ;
+ if ( ! GetNamesParam( vsParams[0], vsNames))
+ return false ;
+ // recupero stato
+ string sStat = vsParams[1] ;
+ ToUpper( sStat) ;
+ int nStat ;
+ if ( sStat == "ON")
+ nStat = GDB_ST_ON ;
+ else if ( sStat == "SEL")
+ nStat = GDB_ST_SEL ;
+ else if ( sStat == "OFF")
+ nStat = GDB_ST_OFF ;
+ else
+ return false ;
+ // esecuzione impostazione stato
+ STRVECTOR::iterator Iter ;
+ for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
+ if ( ! m_pGDB->SetStatus( GetIdParam( *Iter), nStat))
+ return false ;
+ }
+ return true ;
+}
+
//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteColor( const string& sCmd2, const STRVECTOR& vsParams)
@@ -1499,11 +1601,11 @@ GdbExecutor::OutGroupScl( int nId, int nFlag)
bNext = Iter.GoToFirstInGroup( nId) ;
while ( bNext) {
nGdbType = Iter.GetGdbType() ;
- if ( nGdbType == GDB_GEO) {
+ if ( nGdbType == GDB_TY_GEO) {
if ( ! m_OutScl.PutGeoObj( Iter.GetGeoObj(), nFlag))
return false ;
}
- else if ( nGdbType == GDB_GROUP) {
+ else if ( nGdbType == GDB_TY_GROUP) {
if ( ! OutGroupScl( Iter.GetId(), nFlag))
return false ;
}
diff --git a/GdbExecutor.h b/GdbExecutor.h
index d5dbc68..04fdf09 100644
--- a/GdbExecutor.h
+++ b/GdbExecutor.h
@@ -50,6 +50,9 @@ 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 ExecuteLevel( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+ bool ExecuteMode( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+ bool ExecuteStatus( const std::string& sCmd2, const STRVECTOR& vsParams) ;
bool ExecuteColor( const std::string& sCmd2, const STRVECTOR& vsParams) ;
bool ExecuteName( const std::string& sCmd2, const STRVECTOR& vsParams) ;
bool ExecuteInfo( const std::string& sCmd2, const STRVECTOR& vsParams) ;
diff --git a/GdbIterator.cpp b/GdbIterator.cpp
index 1b1113d..ee9b08a 100644
--- a/GdbIterator.cpp
+++ b/GdbIterator.cpp
@@ -189,21 +189,21 @@ GdbIterator::GoToPrev( void)
}
//----------------------------------------------------------------------------
-GdbType
+int
GdbIterator::GetGdbType( void) const
{
if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
- return GDB_NONE ;
+ return GDB_TY_NONE ;
// se oggetto geometrico
if ( GetGdbGeo( m_pCurrObj) != nullptr)
- return GDB_GEO ;
+ return GDB_TY_GEO ;
// se gruppo
else if ( GetGdbGroup( m_pCurrObj) != nullptr)
- return GDB_GROUP ;
+ return GDB_TY_GROUP ;
// altro
else
- return GDB_NONE ;
+ return GDB_TY_NONE ;
}
//----------------------------------------------------------------------------
@@ -288,6 +288,138 @@ GdbIterator::GetParentId( void) const
//----------------------------------------------------------------------------
// Attributes
+//----------------------------------------------------------------------------
+bool
+GdbIterator::SetLevel( int nLevel)
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // assegno il livello
+ return m_pCurrObj->SetLevel( nLevel) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::RevertLevel( void)
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // ripristino il livello precedente
+ return m_pCurrObj->RevertLevel() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::GetLevel( int& nLevel) const
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // recupero il livello
+ return m_pCurrObj->GetLevel( nLevel) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::GetCalcLevel( int& nLevel) const
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // recupero il livello calcolato
+ return m_pCurrObj->GetCalcLevel( nLevel) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::SetMode( int nMode)
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // assegno il modo
+ return m_pCurrObj->SetMode( nMode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::RevertMode( void)
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // ripristino il modo precedente
+ return m_pCurrObj->RevertMode() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::GetMode( int& nMode) const
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // recupero il modo
+ return m_pCurrObj->GetMode( nMode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::GetCalcMode( int& nMode) const
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // recupero il modo calcolato
+ return m_pCurrObj->GetCalcMode( nMode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::SetStatus( int nStat)
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // assegno lo stato
+ return m_pCurrObj->SetStatus( nStat) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::RevertStatus( void)
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // ripristino lo stato precedente
+ return m_pCurrObj->RevertStatus() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::GetStatus( int& nStat) const
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // recupero lo stato
+ return m_pCurrObj->GetStatus( nStat) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbIterator::GetCalcStatus( int& nStat) const
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // recupero lo stato calcolato
+ return m_pCurrObj->GetCalcStatus( nStat) ;
+}
+
//----------------------------------------------------------------------------
bool
GdbIterator::SetColor( Color cCol)
@@ -310,6 +442,17 @@ GdbIterator::GetColor( Color& cCol) const
return m_pCurrObj->GetColor( cCol) ;
}
+//----------------------------------------------------------------------------
+bool
+GdbIterator::GetCalcColor( Color& cCol) const
+{
+ if ( m_pGDB == nullptr || m_pCurrObj == nullptr)
+ return false ;
+
+ // recupero il colore calcolato
+ return m_pCurrObj->GetCalcColor( cCol) ;
+}
+
//----------------------------------------------------------------------------
bool
GdbIterator::SetName( const string& sName)
diff --git a/GdbIterator.h b/GdbIterator.h
index ce02f39..b469c17 100644
--- a/GdbIterator.h
+++ b/GdbIterator.h
@@ -32,7 +32,7 @@ class GdbIterator : public IGdbIterator
virtual bool GoToLastInGroup( const IGdbIterator& iIter) ;
virtual bool GoToPrev( void) ;
- virtual GdbType GetGdbType( void) const ;
+ virtual int GetGdbType( void) const ;
virtual IGeoObj* GetGeoObj( void) ;
virtual IGeoFrame3d* GetGeoFrame( void) ;
virtual bool GetGroupFrame( Frame3d& frGlob) const ;
@@ -41,8 +41,21 @@ class GdbIterator : public IGdbIterator
virtual int GetParentId( void) const ;
virtual bool GetGlobFrame( Frame3d& frGlob) const
{ return m_pGDB->GetGroupGlobFrame( GetParentId(), frGlob) ; }
+ virtual bool SetLevel( int nLevel) ;
+ virtual bool RevertLevel( void) ;
+ virtual bool GetLevel( int& nLevel) const ;
+ virtual bool GetCalcLevel( int& nLevel) const ;
+ virtual bool SetMode( int nMode) ;
+ virtual bool RevertMode( void) ;
+ virtual bool GetMode( int& nMode) const ;
+ virtual bool GetCalcMode( int& nMode) const ;
+ virtual bool SetStatus( int nStat) ;
+ virtual bool RevertStatus( void) ;
+ virtual bool GetStatus( int& nStat) const ;
+ virtual bool GetCalcStatus( int& nStat) const ;
virtual bool SetColor( Color cCol) ;
virtual bool GetColor( Color& cCol) const ;
+ virtual bool GetCalcColor( Color& cCol) const ;
virtual bool SetName( const std::string& sName) ;
virtual bool GetName( std::string& sName) const ;
virtual bool RemoveName( void) ;
diff --git a/GdbObj.cpp b/GdbObj.cpp
index 19d3214..c49f1a1 100644
--- a/GdbObj.cpp
+++ b/GdbObj.cpp
@@ -16,6 +16,7 @@
#include "GdbObj.h"
#include "GdbGroup.h"
#include "Attribs.h"
+#include "/EgtDev/Include/EGkGdbFunct.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include
@@ -236,17 +237,216 @@ GdbObj::GetSafeAttribs( void)
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::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::SetColor( Color cCol)
{
- // recupero gli attributi (se non ci sono, vengono creati)
- Attribs* pAttribs = GetSafeAttribs() ;
- if ( pAttribs == nullptr)
+ // verifico esistenza (con eventuale creazione) degli attributi
+ if ( GetSafeAttribs() == nullptr)
return false ;
// assegno il colore
- pAttribs->SetColor( cCol) ;
+ m_pAttribs->SetColor( cCol) ;
return true ;
}
@@ -256,33 +456,43 @@ 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 ;
- }
+ m_pAttribs->GetMaterial() == GDB_MT_PARENT)
+ return false ;
- // se il colore è definito
- if ( m_pAttribs->GetMaterial() != Attribs::MAT_NULL) {
- cCol = m_pAttribs->GetColor() ;
+ // il colore è definito
+ cCol = m_pAttribs->GetColor() ;
+ return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbObj::GetCalcColor( 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()->GetCalcColor( cCol) ;
+ else
+ cCol.Set() ;
return true ;
}
- return false ;
+ // il colore è definito
+ cCol = m_pAttribs->GetColor() ;
+ return true ;
}
//----------------------------------------------------------------------------
bool
GdbObj::SetName( const string& sName)
{
- // recupero gli attributi (se non ci sono, vengono creati)
- Attribs* pAttribs = GetSafeAttribs() ;
- if ( pAttribs == nullptr)
+ // verifico esistenza (con eventuale creazione) degli attributi
+ if ( GetSafeAttribs() == nullptr)
return false ;
// assegno il nome
- return pAttribs->SetName( sName) ;
+ return m_pAttribs->SetName( sName) ;
}
//----------------------------------------------------------------------------
@@ -313,13 +523,12 @@ GdbObj::RemoveName( void)
bool
GdbObj::SetInfo( const string& sKey, const string& sInfo)
{
- // recupero gli attributi (se non ci sono, vengono creati)
- Attribs* pAttribs = GetSafeAttribs() ;
- if ( pAttribs == nullptr)
+ // verifico esistenza (con eventuale creazione) degli attributi
+ if ( GetSafeAttribs() == nullptr)
return false ;
// assegno il nome
- return pAttribs->SetInfo( sKey, sInfo) ;
+ return m_pAttribs->SetInfo( sKey, sInfo) ;
}
//----------------------------------------------------------------------------
diff --git a/GdbObj.h b/GdbObj.h
index 93827a3..16b1888 100644
--- a/GdbObj.h
+++ b/GdbObj.h
@@ -52,8 +52,21 @@ class GdbObj
Attribs* GetAttribs( void)
{ return m_pAttribs ; }
Attribs* GetSafeAttribs( void) ;
+ bool SetLevel( int nLevel) ;
+ bool RevertLevel( void) ;
+ bool GetLevel( int& nLevel) const ;
+ bool GetCalcLevel( int& nLevel) const ;
+ bool SetMode( int nMode) ;
+ bool RevertMode( void) ;
+ bool GetMode( int& nMode) const ;
+ bool GetCalcMode( int& nMode) const ;
+ bool SetStatus( int nStat) ;
+ bool RevertStatus( void) ;
+ bool GetStatus( int& nStat) const ;
+ bool GetCalcStatus( int& nStat, int nLev = 0) const ;
bool SetColor( Color cCol) ;
bool GetColor( Color& cCol) const ;
+ bool GetCalcColor( Color& cCol) const ;
bool SetName( const std::string& sName) ;
bool GetName( std::string& sName) const ;
bool RemoveName( void) ;
diff --git a/GeomDB.cpp b/GeomDB.cpp
index cb20555..52f5651 100644
--- a/GeomDB.cpp
+++ b/GeomDB.cpp
@@ -37,7 +37,7 @@ CreateGeomDB( void)
GeomDB::GeomDB( void)
{
m_GrpRadix.m_nId = GDB_ID_ROOT ;
- m_GrpRadix.SetColor( Color( 0, 0, 0)) ;
+ m_GrpRadix.SetColor( Color()) ;
}
//----------------------------------------------------------------------------
@@ -53,7 +53,7 @@ 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)) ;
+ m_GrpRadix.SetColor( Color()) ;
return true ;
}
@@ -221,9 +221,16 @@ GeomDB::Save( const std::string& sFileOut) const
// ciclo di scrittura degli oggetti
const GdbObj* pGdbObj = m_GrpRadix.GetFirstObj() ;
while ( pGdbObj != nullptr) {
- // oggetto geometrico
- if ( ! pGdbObj->Save( ofSave))
- bOk = false ;
+ // recupero il livello dell'oggetto
+ int nLevel = GDB_LV_USER ;
+ pGdbObj->GetLevel( nLevel) ;
+ // se non temporaneo
+ if ( nLevel != GDB_LV_TEMP) {
+ // salvo l'oggetto
+ if ( ! pGdbObj->Save( ofSave))
+ bOk = false ;
+ }
+ // passo al successivo
pGdbObj = pGdbObj->GetNext() ;
}
ofSave << "END" << endl ;
@@ -370,7 +377,7 @@ GeomDB::AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj)
}
//----------------------------------------------------------------------------
-GdbType
+int
GeomDB::GetGdbType( int nId) const
{
const GdbObj* pGdbObj ;
@@ -378,17 +385,17 @@ GeomDB::GetGdbType( int nId) const
// recupero l'oggetto
if ( ( pGdbObj = (const_cast (this))->GetGdbObj( nId)) == nullptr)
- return GDB_NONE ;
+ return GDB_TY_NONE ;
// se oggetto geometrico
if ( ::GetGdbGeo( pGdbObj) != nullptr)
- return GDB_GEO ;
+ return GDB_TY_GEO ;
// se gruppo
else if ( ::GetGdbGroup( pGdbObj) != nullptr)
- return GDB_GROUP ;
+ return GDB_TY_GROUP ;
// altro
else
- return GDB_NONE ;
+ return GDB_TY_NONE ;
}
//----------------------------------------------------------------------------
@@ -781,6 +788,162 @@ GeomDB::DumpAttributes( int nId, string& sOut, const char* szNewLine) const
}
}
+//----------------------------------------------------------------------------
+bool
+GeomDB::SetLevel( int nId, int nLevel)
+{
+ // recupero l'oggetto
+ GdbObj* pGdbObj ;
+ if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // assegno il livello
+ return pGdbObj->SetLevel( nLevel) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::RevertLevel( int nId)
+{
+ // recupero l'oggetto
+ GdbObj* pGdbObj ;
+ if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // ripristino il livello precedente
+ return pGdbObj->RevertLevel() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetLevel( int nId, int& nLevel) const
+{
+ // recupero l'oggetto
+ const GdbObj* pGdbObj ;
+ if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // recupero il livello
+ return pGdbObj->GetLevel( nLevel) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetCalcLevel( int nId, int& nLevel) const
+{
+ // recupero l'oggetto
+ const GdbObj* pGdbObj ;
+ if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // recupero il livello calcolato
+ return pGdbObj->GetCalcLevel( nLevel) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::SetMode( int nId, int nMode)
+{
+ // recupero l'oggetto
+ GdbObj* pGdbObj ;
+ if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // assegno il modo
+ return pGdbObj->SetMode( nMode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::RevertMode( int nId)
+{
+ // recupero l'oggetto
+ GdbObj* pGdbObj ;
+ if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // ripristino il modo precedente
+ return pGdbObj->RevertMode() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetMode( int nId, int& nMode) const
+{
+ // recupero l'oggetto
+ const GdbObj* pGdbObj ;
+ if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // recupero il modo
+ return pGdbObj->GetMode( nMode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetCalcMode( int nId, int& nMode) const
+{
+ // recupero l'oggetto
+ const GdbObj* pGdbObj ;
+ if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // recupero il modo calcolato
+ return pGdbObj->GetCalcMode( nMode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::SetStatus( int nId, int nStat)
+{
+ // recupero l'oggetto
+ GdbObj* pGdbObj ;
+ if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // assegno lo stato
+ return pGdbObj->SetStatus( nStat) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::RevertStatus( int nId)
+{
+ // recupero l'oggetto
+ GdbObj* pGdbObj ;
+ if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // ripristino lo stato precedente
+ return pGdbObj->RevertStatus() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetStatus( int nId, int& nStat) const
+{
+ // recupero l'oggetto
+ const GdbObj* pGdbObj ;
+ if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // recupero lo stato
+ return pGdbObj->GetStatus( nStat) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetCalcStatus( int nId, int& nStat) const
+{
+ // recupero l'oggetto
+ const GdbObj* pGdbObj ;
+ if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // recupero lo stato calcolato
+ return pGdbObj->GetCalcStatus( nStat) ;
+}
+
//----------------------------------------------------------------------------
bool
GeomDB::SetDefaultColor( Color cCol)
@@ -833,6 +996,19 @@ GeomDB::GetColor( int nId, Color& cCol) const
return pGdbObj->GetColor( cCol) ;
}
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetCalcColor( int nId, Color& cCol) const
+{
+ // recupero l'oggetto
+ const GdbObj* pGdbObj ;
+ if ( ( pGdbObj = (const_cast(this))->GetGdbObj( nId)) == nullptr)
+ return false ;
+
+ // recupero il colore calcolato
+ return pGdbObj->GetCalcColor( cCol) ;
+}
+
//----------------------------------------------------------------------------
bool
GeomDB::SetName( int nId, const string& sName)
diff --git a/GeomDB.h b/GeomDB.h
index ee726fd..1d6744a 100644
--- a/GeomDB.h
+++ b/GeomDB.h
@@ -37,7 +37,7 @@ class GeomDB : public IGeomDB
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 ;
+ virtual int GetGdbType( int nId) const ;
virtual IGeoObj* GetGeoObj( int nId) ;
virtual IGeoFrame3d* GetGeoFrame( int nId) ;
virtual bool GetGroupFrame( int nId, Frame3d& frGrp) const ;
@@ -67,10 +67,23 @@ class GeomDB : public IGeomDB
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 SetLevel( int nId, int nLevel) ;
+ virtual bool RevertLevel( int nId) ;
+ virtual bool GetLevel( int nId, int& nLevel) const ;
+ virtual bool GetCalcLevel( int nId, int& nLevel) const ;
+ virtual bool SetMode( int nId, int nMode) ;
+ virtual bool RevertMode( int nId) ;
+ virtual bool GetMode( int nId, int& nMode) const ;
+ virtual bool GetCalcMode( int nId, int& nMode) const ;
+ virtual bool SetStatus( int nId, int nStat) ;
+ virtual bool RevertStatus( int nId) ;
+ virtual bool GetStatus( int nId, int& nStat) const ;
+ virtual bool GetCalcStatus( int nId, int& nStat) const ;
virtual bool SetDefaultColor( Color cCol) ;
virtual bool GetDefaultColor( Color& cCol) const ;
virtual bool SetColor( int nId, Color cCol) ;
virtual bool GetColor( int nId, Color& cCol) const ;
+ virtual bool GetCalcColor( int nId, Color& cCol) const ;
virtual bool SetName( int nId, const std::string& sName) ;
virtual bool GetName( int nId, std::string& sName) const ;
virtual bool RemoveName( int nId) ;