Dario Sassi
033236491d
- gestione cancellazione oggetti puntati da GdbIterator - aggiunte a GdbIterator EraseAndGoToNext e EraseAndGoToPrev - possibilità di passare IGeomDB* al costruttore di GdbIterator.
1728 lines
55 KiB
C++
1728 lines
55 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2013-2014
|
|
//----------------------------------------------------------------------------
|
|
// File : GdbExecutor.cpp Data : 19.01.14 Versione : 1.5a6
|
|
// Contenuto : Implementazione della classe GdbExecutor.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 27.03.13 DS Creazione modulo.
|
|
// 19.01.14 DS Agg. COUNTER.
|
|
// 18.02.14 DS Agg. NEW.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "GdbExecutor.h"
|
|
#include "GdbIterator.h"
|
|
#include "GeomDB.h"
|
|
#include "DllMain.h"
|
|
#include "/EgtDev/Include/EgnStringUtils.h"
|
|
#include "/EgtDev/Include/EgnStringConverter.h"
|
|
#include "/EgtDev/Include/EgnCmdParser.h"
|
|
#include "/EgtDev/Include/EgkGeoPoint3d.h"
|
|
#include "/EgtDev/Include/EgkGeoVector3d.h"
|
|
#include "/EgtDev/Include/EgkGeoFrame3d.h"
|
|
#include "/EgtDev/Include/EgkCurveLine.h"
|
|
#include "/EgtDev/Include/EgkCurveArc.h"
|
|
#include "/EgtDev/Include/EgkCurveBezier.h"
|
|
#include "/EgtDev/Include/EgkCurveComposite.h"
|
|
#include "/EgtDev/Include/EgkDistPointCurve.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
static const int ID_SEL = -2 ;
|
|
static const int ID_NO = -3 ;
|
|
static const int ID_ERROR = -4 ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
IGdbExecutor*
|
|
CreateGdbExecutor( void)
|
|
{
|
|
return static_cast<IGdbExecutor*> ( new GdbExecutor) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GdbExecutor::GdbExecutor( void)
|
|
{
|
|
m_pGDB = nullptr ;
|
|
m_pParser = nullptr ;
|
|
// assegno chiavi a funzioni di esecuzione
|
|
m_ExecMgr.Init( 128) ;
|
|
m_ExecMgr.Insert( "GR", &GdbExecutor::ExecuteGroup) ;
|
|
m_ExecMgr.Insert( "GROUP", &GdbExecutor::ExecuteGroup) ;
|
|
m_ExecMgr.Insert( "P", &GdbExecutor::ExecutePoint) ;
|
|
m_ExecMgr.Insert( "POINT", &GdbExecutor::ExecutePoint) ;
|
|
m_ExecMgr.Insert( "V", &GdbExecutor::ExecuteVector) ;
|
|
m_ExecMgr.Insert( "VECTOR", &GdbExecutor::ExecuteVector) ;
|
|
m_ExecMgr.Insert( "FR", &GdbExecutor::ExecuteFrame) ;
|
|
m_ExecMgr.Insert( "FRAME", &GdbExecutor::ExecuteFrame) ;
|
|
m_ExecMgr.Insert( "CL", &GdbExecutor::ExecuteCurveLine) ;
|
|
m_ExecMgr.Insert( "CURVELINE", &GdbExecutor::ExecuteCurveLine) ;
|
|
m_ExecMgr.Insert( "CA", &GdbExecutor::ExecuteCurveArc) ;
|
|
m_ExecMgr.Insert( "CURVEARC", &GdbExecutor::ExecuteCurveArc) ;
|
|
m_ExecMgr.Insert( "CB", &GdbExecutor::ExecuteCurveBez) ;
|
|
m_ExecMgr.Insert( "CURVEBEZIER", &GdbExecutor::ExecuteCurveBez) ;
|
|
m_ExecMgr.Insert( "CC", &GdbExecutor::ExecuteCurveCompo) ;
|
|
m_ExecMgr.Insert( "CURVECOMPO", &GdbExecutor::ExecuteCurveCompo) ;
|
|
m_ExecMgr.Insert( "LEV", &GdbExecutor::ExecuteLevel) ;
|
|
m_ExecMgr.Insert( "LEVEL", &GdbExecutor::ExecuteLevel) ;
|
|
m_ExecMgr.Insert( "MOD", &GdbExecutor::ExecuteMode) ;
|
|
m_ExecMgr.Insert( "MODE", &GdbExecutor::ExecuteMode) ;
|
|
m_ExecMgr.Insert( "STA", &GdbExecutor::ExecuteStatus) ;
|
|
m_ExecMgr.Insert( "STATUS", &GdbExecutor::ExecuteStatus) ;
|
|
m_ExecMgr.Insert( "SEL", &GdbExecutor::ExecuteSelect) ;
|
|
m_ExecMgr.Insert( "SELECT", &GdbExecutor::ExecuteSelect) ;
|
|
m_ExecMgr.Insert( "DESEL", &GdbExecutor::ExecuteDeselect) ;
|
|
m_ExecMgr.Insert( "DESELECT", &GdbExecutor::ExecuteDeselect) ;
|
|
m_ExecMgr.Insert( "MAT", &GdbExecutor::ExecuteMaterial) ;
|
|
m_ExecMgr.Insert( "MATERIAL", &GdbExecutor::ExecuteMaterial) ;
|
|
m_ExecMgr.Insert( "NAM", &GdbExecutor::ExecuteName) ;
|
|
m_ExecMgr.Insert( "NAME", &GdbExecutor::ExecuteName) ;
|
|
m_ExecMgr.Insert( "INF", &GdbExecutor::ExecuteInfo) ;
|
|
m_ExecMgr.Insert( "INFO", &GdbExecutor::ExecuteInfo) ;
|
|
m_ExecMgr.Insert( "COPY", &GdbExecutor::ExecuteCopy) ;
|
|
m_ExecMgr.Insert( "ERASE", &GdbExecutor::ExecuteErase) ;
|
|
m_ExecMgr.Insert( "MOV", &GdbExecutor::ExecuteTranslate) ;
|
|
m_ExecMgr.Insert( "MOVE", &GdbExecutor::ExecuteTranslate) ;
|
|
m_ExecMgr.Insert( "ROT", &GdbExecutor::ExecuteRotate) ;
|
|
m_ExecMgr.Insert( "ROTATE", &GdbExecutor::ExecuteRotate) ;
|
|
m_ExecMgr.Insert( "SCA", &GdbExecutor::ExecuteScale) ;
|
|
m_ExecMgr.Insert( "SCALE", &GdbExecutor::ExecuteScale) ;
|
|
m_ExecMgr.Insert( "MIR", &GdbExecutor::ExecuteMirror) ;
|
|
m_ExecMgr.Insert( "MIRROR", &GdbExecutor::ExecuteMirror) ;
|
|
m_ExecMgr.Insert( "INVC", &GdbExecutor::ExecuteInvertCurve) ;
|
|
m_ExecMgr.Insert( "INVERTCURVE", &GdbExecutor::ExecuteInvertCurve) ;
|
|
m_ExecMgr.Insert( "TRC", &GdbExecutor::ExecuteTrimCurve) ;
|
|
m_ExecMgr.Insert( "TRIMCURVE", &GdbExecutor::ExecuteTrimCurve) ;
|
|
m_ExecMgr.Insert( "NEW", &GdbExecutor::ExecuteNew) ;
|
|
m_ExecMgr.Insert( "LOAD", &GdbExecutor::ExecuteLoad) ;
|
|
m_ExecMgr.Insert( "SAVE", &GdbExecutor::ExecuteSave) ;
|
|
m_ExecMgr.Insert( "OUTSCL", &GdbExecutor::ExecuteOutScl) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GdbExecutor::~GdbExecutor( void)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::SetCmdParser( ICmdParser* pParser)
|
|
{
|
|
m_pParser = pParser ;
|
|
return ( m_pParser != nullptr) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::AddStandardVariables( void)
|
|
{
|
|
// imposto variabili predefinite
|
|
m_pParser->AddVariable( "$ROOT", GDB_ID_ROOT) ;
|
|
m_pParser->AddVariable( "$SEL", ID_SEL) ;
|
|
m_pParser->AddVariable( "$NN", ID_NO) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// verifico validita GeomDB
|
|
if ( m_pGDB == nullptr) {
|
|
LOG_ERROR( GetEGkLogger(), "Error : null GeomDb.")
|
|
return ER_ERR ;
|
|
}
|
|
|
|
// verifico validità CmdParser
|
|
if ( m_pParser == nullptr) {
|
|
LOG_ERROR( GetEGkLogger(), "Error : null CmdParser.")
|
|
return ER_ERR ;
|
|
}
|
|
|
|
// esecuzione comando
|
|
return m_ExecMgr.Execute( *this, sCmd1, sCmd2, vsParams) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::SetGeomDB( IGeomDB* pGdb)
|
|
{
|
|
m_pGDB = pGdb ;
|
|
return ( m_pGDB != nullptr) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteGroup( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
Frame3d frFrame ;
|
|
|
|
|
|
// gruppo generico
|
|
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
|
Point3d ptOrig ;
|
|
Vector3d vtDirX ;
|
|
Vector3d vtDirY ;
|
|
Vector3d vtDirZ ;
|
|
// 6 parametri : Id, Id del padre, Orig, VersX, VersY, VersZ
|
|
if ( vsParams.size() != 6)
|
|
return false ;
|
|
// recupero i componenti
|
|
if ( ! GetPointParam( vsParams[2], ptOrig) ||
|
|
! GetVectorParam( vsParams[3], vtDirX) ||
|
|
! GetVectorParam( vsParams[4], vtDirY) ||
|
|
! GetVectorParam( vsParams[5], vtDirZ))
|
|
return false ;
|
|
// costruisco il riferimento
|
|
if ( ! frFrame.Set( ptOrig, vtDirX, vtDirY, vtDirZ))
|
|
return false ;
|
|
}
|
|
// gruppo orientato come il padre
|
|
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY") {
|
|
Point3d ptOrig ;
|
|
// 3 parametri : Id, Id del padre, Orig
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
// recupero i componenti
|
|
if ( ! GetPointParam( vsParams[2], ptOrig))
|
|
return false ;
|
|
// costruisco il riferimento
|
|
if ( ! frFrame.Set( ptOrig, Frame3d::TOP))
|
|
return false ;
|
|
}
|
|
else
|
|
return false ;
|
|
|
|
// creo il gruppo
|
|
int nIdDest = GetIdParam( vsParams[0], true) ;
|
|
int nIdNew = m_pGDB->AddGroup( nIdDest, GetIdParam( vsParams[1]), frFrame) ;
|
|
// se IdDest da calcolare, può essere una variabili a cui cambiare il valore
|
|
if ( nIdDest == GDB_ID_NULL)
|
|
m_pParser->SetVariable( vsParams[0], nIdNew) ;
|
|
|
|
return ( nIdNew != GDB_ID_NULL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecutePoint( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// analisi ed esecuzione dei comandi
|
|
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
|
Point3d Pnt ;
|
|
// 5 parametri : Id, IdParent e 3 coordinate
|
|
if ( vsParams.size() != 5)
|
|
return false ;
|
|
// recupero le tre coordinate
|
|
if ( ! FromString( vsParams[2], Pnt.x) ||
|
|
! FromString( vsParams[3], Pnt.y) ||
|
|
! FromString( vsParams[4], Pnt.z))
|
|
return false ;
|
|
// creo il punto
|
|
IGeoPoint3d* pGPnt = CreateGeoPoint3d() ;
|
|
if ( pGPnt == nullptr)
|
|
return false ;
|
|
pGPnt->Set( Pnt) ;
|
|
return AddGeoObj( vsParams[0], vsParams[1], pGPnt) ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteVector( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// analisi ed esecuzione dei comandi
|
|
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
|
Vector3d Vect ;
|
|
// 5 parametri
|
|
if ( vsParams.size() != 5)
|
|
return false ;
|
|
// recupero i tre componenti
|
|
if ( ! FromString( vsParams[2], Vect.x) ||
|
|
! FromString( vsParams[3], Vect.y) ||
|
|
! FromString( vsParams[4], Vect.z))
|
|
return false ;
|
|
// creo il vettore
|
|
IGeoVector3d* pGVect = CreateGeoVector3d() ;
|
|
if ( pGVect == nullptr)
|
|
return false ;
|
|
pGVect->Set( Vect) ;
|
|
return AddGeoObj( vsParams[0], vsParams[1], pGVect) ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteFrame( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// analisi ed esecuzione dei comandi
|
|
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
|
Point3d ptOrig ;
|
|
Vector3d vtDirX ;
|
|
Vector3d vtDirY ;
|
|
Vector3d vtDirZ ;
|
|
// 6 parametri
|
|
if ( vsParams.size() != 6)
|
|
return false ;
|
|
// recupero i componenti
|
|
if ( ! GetPointParam( vsParams[2], ptOrig) ||
|
|
! GetVectorParam( vsParams[3], vtDirX) ||
|
|
! GetVectorParam( vsParams[4], vtDirY) ||
|
|
! GetVectorParam( vsParams[5], vtDirZ))
|
|
return false ;
|
|
// creo il riferimento
|
|
IGeoFrame3d* pGFrame = CreateGeoFrame3d() ;
|
|
if ( pGFrame == nullptr)
|
|
return false ;
|
|
pGFrame->Set( ptOrig, vtDirX, vtDirY, vtDirZ) ;
|
|
return AddGeoObj( vsParams[0], vsParams[1], pGFrame) ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteCurveLine( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// creo la linea
|
|
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
|
|
if ( ! IsValid( pCrvLine))
|
|
return false ;
|
|
|
|
// creazione linea dando gli estremi
|
|
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
|
// 4 parametri
|
|
if ( vsParams.size() != 4)
|
|
return false ;
|
|
// recupero punto iniziale
|
|
Point3d ptStart ;
|
|
if ( ! GetPointParam( vsParams[2], ptStart))
|
|
return false ;
|
|
// recupero punto finale
|
|
Point3d ptEnd ;
|
|
if ( ! GetPointParam( vsParams[3], ptEnd))
|
|
return false ;
|
|
// setto la linea
|
|
if ( ! pCrvLine->Set( ptStart, ptEnd))
|
|
return false ;
|
|
}
|
|
// creazione linea di minima distanza tra punto e curva
|
|
else if ( sCmd2 == "MPC" || sCmd2 == "MINPOINTCURVE") {
|
|
// almeno 4 parametri
|
|
if ( vsParams.size() < 4)
|
|
return false ;
|
|
// recupero l'identificativo del gruppo destinazione
|
|
int nIdParent ;
|
|
if ( ( nIdParent = GetIdParam( vsParams[1])) == ID_ERROR)
|
|
return false ;
|
|
// recupero il riferimento del gruppo destinazione
|
|
Frame3d frPoint ;
|
|
if ( ! m_pGDB->GetGroupGlobFrame( nIdParent, frPoint))
|
|
return false ;
|
|
// recupero il punto
|
|
Point3d ptStart ;
|
|
if ( ! GetPointParam( vsParams[2], ptStart))
|
|
return false ;
|
|
// recupero l'identificativo della curva
|
|
int nId ;
|
|
if ( ( nId = GetIdParam( vsParams[3])) == ID_ERROR)
|
|
return false ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCurve ;
|
|
if ( ! m_pGDB->GetGlobFrame( nId, frCurve))
|
|
return false ;
|
|
// recupero la curva
|
|
const ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( nId)) ;
|
|
if ( pCurve == nullptr)
|
|
return false ;
|
|
// porto il punto nel riferimento della curva
|
|
Point3d ptSloc = ptStart ;
|
|
ptSloc.LocToLoc( frPoint, frCurve) ;
|
|
// recupero eventuale parametro per discriminare tra più soluzioni
|
|
double dNearParam ;
|
|
if ( vsParams.size() < 5 || ! FromString( vsParams[4], dNearParam))
|
|
dNearParam = 0 ;
|
|
// calcolo il punto a minima distanza
|
|
int nFlag ;
|
|
Point3d ptEnd ;
|
|
DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
|
|
if ( ! dstPtCurve.GetMinDistPoint( dNearParam, ptEnd, nFlag))
|
|
return false ;
|
|
// porto il punto finale nel riferimento di creazione
|
|
ptEnd.LocToLoc( frCurve, frPoint) ;
|
|
// setto la linea
|
|
if ( ! pCrvLine->Set( ptStart, ptEnd))
|
|
return false ;
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
|
|
// inserisco la linea nel DB
|
|
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// creo l'arco
|
|
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
|
if ( ! IsValid( pCrvArc))
|
|
return false ;
|
|
|
|
// arco generico
|
|
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
|
// 8 parametri
|
|
if ( vsParams.size() != 8)
|
|
return false ;
|
|
// centro
|
|
Point3d ptCen ;
|
|
if ( ! GetPointParam( vsParams[2], ptCen))
|
|
return false ;
|
|
// versore ortogonale al piano della circonferenza
|
|
Vector3d vtN ;
|
|
if ( ! GetVectorParam( vsParams[3], vtN))
|
|
return false ;
|
|
// raggio
|
|
double dRad ;
|
|
if ( ! FromString( vsParams[4], dRad))
|
|
return false ;
|
|
// versore iniziale
|
|
Vector3d vtS ;
|
|
if ( ! GetVectorParam( vsParams[5], vtS))
|
|
return false ;
|
|
// angolo al centro
|
|
double dAngCenDeg ;
|
|
if ( ! FromString( vsParams[6], dAngCenDeg))
|
|
return false ;
|
|
// deltaZ
|
|
double dDeltaZ ;
|
|
if ( ! FromString( vsParams[7], dDeltaZ))
|
|
return false ;
|
|
// setto l'arco
|
|
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
|
|
return false ;
|
|
}
|
|
// arco nel piano XY
|
|
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY") {
|
|
// 7 parametri
|
|
if ( vsParams.size() != 7)
|
|
return false ;
|
|
// centro
|
|
Point3d ptCen ;
|
|
if ( ! GetPointParam( vsParams[2], ptCen))
|
|
return false ;
|
|
// raggio
|
|
double dRad ;
|
|
if ( ! FromString( vsParams[3], dRad))
|
|
return false ;
|
|
// angolo iniziale
|
|
double dAngIniDeg ;
|
|
if ( ! FromString( vsParams[4], dAngIniDeg))
|
|
return false ;
|
|
// angolo al centro
|
|
double dAngCenDeg ;
|
|
if ( ! FromString( vsParams[5], dAngCenDeg))
|
|
return false ;
|
|
// deltaZ
|
|
double dDeltaZ ;
|
|
if ( ! FromString( vsParams[6], dDeltaZ))
|
|
return false ;
|
|
// setto l'arco
|
|
if ( ! pCrvArc->Set( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
|
|
return false ;
|
|
}
|
|
// circonferenza nel piano XY
|
|
else if ( sCmd2 == "CXY" || sCmd2 == "CIRCLEXY") {
|
|
// 4 parametri
|
|
if ( vsParams.size() != 4)
|
|
return false ;
|
|
// centro
|
|
Point3d ptCen ;
|
|
if ( ! GetPointParam( vsParams[2], ptCen))
|
|
return false ;
|
|
// raggio
|
|
double dRad ;
|
|
if ( ! FromString( vsParams[3], dRad))
|
|
return false ;
|
|
// setto l'arco
|
|
if ( ! pCrvArc->Set( ptCen, dRad))
|
|
return false ;
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
|
|
// inserisco l'arco nel DB
|
|
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// creo la curva di Bezier
|
|
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
|
|
if ( ! IsValid( pCrvBez))
|
|
return false ;
|
|
// per cancellazione eventuale arco di origine
|
|
bool bErase = false ;
|
|
int nIdArc = ID_ERROR ;
|
|
|
|
// curva di Bezier intera (polinomiale)
|
|
if ( sCmd2 == "I" || sCmd2 == "INTEG") {
|
|
int i ;
|
|
int nDeg ;
|
|
Point3d ptP ;
|
|
// almeno 3 parametri
|
|
if ( vsParams.size() < 3)
|
|
return false ;
|
|
// recupero il grado
|
|
if ( ! FromString( vsParams[2], nDeg))
|
|
return false ;
|
|
// inizializzo la curva di Bezier
|
|
if ( ! pCrvBez->Init( nDeg, false))
|
|
return false ;
|
|
// recupero e setto punti di controllo
|
|
for ( i = 0 ; i <= nDeg ; ++ i) {
|
|
if ( ! GetPointParam( vsParams[i+3], ptP) ||
|
|
! pCrvBez->SetControlPoint( i, ptP))
|
|
return false ;
|
|
}
|
|
}
|
|
// curva di Bezier razionale
|
|
else if ( sCmd2 == "R" || sCmd2 == "RATIO") {
|
|
int i ;
|
|
int nDeg ;
|
|
double dW ;
|
|
Point3d ptP ;
|
|
// almeno 3 parametri
|
|
if ( vsParams.size() < 3)
|
|
return false ;
|
|
// recupero il grado
|
|
if ( ! FromString( vsParams[2], nDeg))
|
|
return false ;
|
|
// inizializzo la curva di Bezier
|
|
if ( ! pCrvBez->Init( nDeg, true))
|
|
return false ;
|
|
// recupero e setto punti di controllo
|
|
for ( i = 0 ; i <= nDeg ; ++ i) {
|
|
if ( ! GetPointWParam( vsParams[i+3], ptP, dW) ||
|
|
! pCrvBez->SetControlPoint( i, ptP, dW))
|
|
return false ;
|
|
}
|
|
}
|
|
// curva di Bezier ricavata da un arco
|
|
else if ( sCmd2 == "A" || sCmd2 == "FROMARC") {
|
|
// 3 o 4 parametri
|
|
switch ( vsParams.size()) {
|
|
case 3 : bErase = false ; break ;
|
|
case 4 : bErase = ( vsParams[3] != "0") ; break ;
|
|
default : return false ; break ;
|
|
}
|
|
// recupero l'arco
|
|
nIdArc = GetIdParam( vsParams[2]) ;
|
|
const ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( nIdArc)) ;
|
|
if ( pCrvArc == nullptr)
|
|
return false ;
|
|
// ne deduco la curva di Bezier
|
|
if ( ! pCrvBez->FromArc( *pCrvArc))
|
|
return false ;
|
|
// recupero il riferimento dell'arco
|
|
Frame3d frSou ;
|
|
if ( ! m_pGDB->GetGlobFrame( nIdArc, frSou))
|
|
return false ;
|
|
// recupero il riferimento del gruppo destinazione
|
|
Frame3d frDest ;
|
|
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
|
|
return false ;
|
|
// porto la curva di Bezier dal riferimento dell'arco a quello di inserimento
|
|
if ( ! AreSameFrame( frSou, frDest)) {
|
|
pCrvBez->ToGlob( frSou) ;
|
|
pCrvBez->ToLoc( frDest) ;
|
|
}
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
|
|
// inserisco la curva di Bezier nel DB
|
|
if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvBez))) {
|
|
// se richiesto, cancello eventuale arco di origine
|
|
if ( bErase && ! m_pGDB->Erase( nIdArc))
|
|
return false ;
|
|
else
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// creo la curva composita
|
|
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
|
|
if ( ! IsValid( pCrvCompo))
|
|
return false ;
|
|
// per eventuale cancellazione curve di origine
|
|
bool bErase ;
|
|
INTVECTOR vnNames ;
|
|
INTVECTOR::iterator Iter ;
|
|
|
|
// curva composita generica
|
|
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
|
// 3 o 4 parametri
|
|
switch ( vsParams.size()) {
|
|
case 3 : bErase = false ; break ;
|
|
case 4 : bErase = ( vsParams[3] != "0") ; break ;
|
|
default : return false ; break ;
|
|
}
|
|
// recupero lista nomi
|
|
if ( ! GetNamesParam( vsParams[2], vnNames))
|
|
return false ;
|
|
// recupero il riferimento del gruppo destinazione
|
|
Frame3d frDest ;
|
|
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
|
|
return false ;
|
|
// esecuzione
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
// recupero la curva
|
|
int nIdCrv = *Iter ;
|
|
const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
|
|
if ( pCrv == nullptr)
|
|
return false ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frSou ;
|
|
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frSou))
|
|
return false ;
|
|
// se i riferimenti sono uguali
|
|
if ( AreSameFrame( frSou, frDest)) {
|
|
// aggiungo direttamente questa curva
|
|
if ( ! pCrvCompo->AddCurve( *pCrv))
|
|
return false ;
|
|
}
|
|
// altrimenti devo prima trasformare la curva
|
|
else {
|
|
// creo una copia della curva (da buttare alla fine)
|
|
PtrOwner<ICurve> pModCrv( GetCurve( pCrv->Clone())) ;
|
|
if ( ! IsValid( pModCrv))
|
|
return false ;
|
|
// eseguo la trasformazione
|
|
pModCrv->ToGlob( frSou) ;
|
|
pModCrv->ToLoc( frDest) ;
|
|
// aggiungo la curva modificata
|
|
if ( ! pCrvCompo->AddCurve( *pModCrv))
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
// da split di curva semplice
|
|
else if ( sCmd2 == "S" || sCmd2 == "FROMSPLIT") {
|
|
// 4 o 5 parametri
|
|
switch ( vsParams.size()) {
|
|
case 4 : bErase = false ; break ;
|
|
case 5 : bErase = ( vsParams[4] != "0") ; break ;
|
|
default : return false ; break ;
|
|
}
|
|
// salvo nome curva originale per eventuale cancellazione
|
|
int nIdCrv = GetIdParam( vsParams[2]) ;
|
|
vnNames.push_back( nIdCrv) ;
|
|
// recupero la curva
|
|
const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ;
|
|
if ( pCrv == nullptr)
|
|
return false ;
|
|
// recupero il numero delle parti in cui spezzare
|
|
int nParts ;
|
|
if ( ! FromString( vsParams[3], nParts))
|
|
return false ;
|
|
// ne deduco la curva composita
|
|
if ( ! pCrvCompo->FromSplit( *pCrv, nParts))
|
|
return false ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frSou ;
|
|
if ( ! m_pGDB->GetGlobFrame( nIdCrv, frSou))
|
|
return false ;
|
|
// recupero il riferimento del gruppo destinazione
|
|
Frame3d frDest ;
|
|
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
|
|
return false ;
|
|
// porto la curva composita dal riferimento della sorgente a quello di inserimento
|
|
if ( ! AreSameFrame( frSou, frDest)) {
|
|
pCrvCompo->ToGlob( frSou) ;
|
|
pCrvCompo->ToLoc( frDest) ;
|
|
}
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
|
|
// inserisco la curva composita nel DB
|
|
if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo))) {
|
|
// se richiesto, cancello le curve originali
|
|
if ( bErase) {
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->Erase( *Iter))
|
|
return false ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::AddGeoObj( const string& sId, const string& sIdParent, IGeoObj* pGeoObj)
|
|
{
|
|
// creo il gruppo
|
|
int nId = GetIdParam( sId, true) ;
|
|
int nIdNew = m_pGDB->AddGeoObj( nId, GetIdParam( sIdParent), pGeoObj) ;
|
|
// se IdDest da calcolare, può essere una variabili a cui cambiare il valore
|
|
if ( nId == GDB_ID_NULL)
|
|
m_pParser->SetVariable( sId, nIdNew) ;
|
|
|
|
return ( nIdNew != GDB_ID_NULL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
GdbExecutor::GetIdParam( const std::string& sParam, bool bNewAllowed)
|
|
{
|
|
int nVal ;
|
|
|
|
|
|
// se nome di identificatore numerico
|
|
if ( sParam[0] == '$') {
|
|
// se variabile già definita, ne restituisco il valore
|
|
if ( m_pParser->GetVariable( sParam, nVal))
|
|
return nVal ;
|
|
// se ammessa nuova definizione, provo ad inserirlo
|
|
else if ( bNewAllowed &&
|
|
m_pParser->AddVariable( sParam, GDB_ID_NULL))
|
|
return GDB_ID_NULL ;
|
|
// altrimenti errore
|
|
else
|
|
return ID_ERROR ;
|
|
}
|
|
// se identificatore numerico
|
|
else if ( FromString( sParam, nVal))
|
|
return nVal ;
|
|
// altrimenti errore
|
|
else
|
|
return ID_ERROR ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::GetNamesParam( const std::string& sParam, INTVECTOR& vnNames)
|
|
{
|
|
// divido in parti
|
|
STRVECTOR vsNames ;
|
|
Tokenize( sParam, ",", vsNames) ;
|
|
// converto in interi
|
|
vnNames.clear() ;
|
|
vnNames.reserve( vsNames.size()) ;
|
|
STRVECTOR::iterator Iter ;
|
|
for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
|
|
Trim( (*Iter), " \t\r\n()") ;
|
|
int nId = GetIdParam( *Iter) ;
|
|
if ( nId != ID_SEL) {
|
|
vnNames.push_back( nId) ;
|
|
}
|
|
else {
|
|
nId = m_pGDB->GetFirstSelectedObj() ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
vnNames.push_back( nId) ;
|
|
nId = m_pGDB->GetNextSelectedObj() ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::GetVectorParam( const std::string& sParam, Vector3d& vtV)
|
|
{
|
|
// se insieme di tre componenti
|
|
if ( sParam[0] == '(') {
|
|
// divido in parti
|
|
STRVECTOR vsParams ;
|
|
Tokenize( sParam, ",", vsParams) ;
|
|
STRVECTOR::iterator Iter ;
|
|
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
|
|
Trim( (*Iter), " \t\r\n()") ;
|
|
// verifico siano 3 parti e le converto
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
return ( FromString( vsParams[0], vtV.x) &&
|
|
FromString( vsParams[1], vtV.y) &&
|
|
FromString( vsParams[2], vtV.z)) ;
|
|
}
|
|
// altrimenti nome di vettore già nel DB
|
|
else {
|
|
const IGeoVector3d* pV ;
|
|
if ( ( pV = GetGeoVector3d( m_pGDB->GetGeoObj( GetIdParam( sParam)))) == nullptr)
|
|
return false ;
|
|
vtV = pV->GetVector() ;
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::GetPointParam( const std::string& sParam, Point3d& ptP)
|
|
{
|
|
// se insieme di tre coordinate
|
|
if ( sParam[0] == '(') {
|
|
// divido in parti
|
|
STRVECTOR vsParams ;
|
|
Tokenize( sParam, ",", vsParams) ;
|
|
STRVECTOR::iterator Iter ;
|
|
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
|
|
Trim( (*Iter), " \t\r\n()") ;
|
|
// verifico siano 3 parti e le converto
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
return ( FromString( vsParams[0], ptP.x) &&
|
|
FromString( vsParams[1], ptP.y) &&
|
|
FromString( vsParams[2], ptP.z)) ;
|
|
}
|
|
// altrimenti nome di punto già nel DB
|
|
else {
|
|
const IGeoPoint3d* pPt ;
|
|
if ( ( pPt = GetGeoPoint3d( m_pGDB->GetGeoObj( GetIdParam( sParam)))) == nullptr)
|
|
return false ;
|
|
ptP = pPt->GetPoint() ;
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::GetPointWParam( const std::string& sParam, Point3d& ptP, double& dW)
|
|
{
|
|
// deve essere insieme di dati
|
|
if ( sParam[0] != '(')
|
|
return false ;
|
|
|
|
// divido in parti
|
|
STRVECTOR vsParams ;
|
|
Tokenize( sParam, ",", vsParams) ;
|
|
STRVECTOR::iterator Iter ;
|
|
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
|
|
Trim( (*Iter), " \t\r\n()") ;
|
|
|
|
// se 4 parti, sono 3 coordinate e un peso
|
|
if ( vsParams.size() == 4) {
|
|
return ( FromString( vsParams[0], ptP.x) &&
|
|
FromString( vsParams[1], ptP.y) &&
|
|
FromString( vsParams[2], ptP.z) &&
|
|
FromString( vsParams[3], dW)) ;
|
|
}
|
|
// se 2 parti, nome di punto già nel DB e un peso
|
|
else if ( vsParams.size() == 2) {
|
|
const IGeoPoint3d* pPt ;
|
|
// recupero il punto
|
|
if ( ( pPt = GetGeoPoint3d( m_pGDB->GetGeoObj( GetIdParam( vsParams[0])))) == nullptr)
|
|
return false ;
|
|
ptP = pPt->GetPoint() ;
|
|
// recupero il peso
|
|
return FromString( vsParams[1], dW) ;
|
|
}
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::GetFrameParam( const std::string& sParam, Frame3d& frF)
|
|
{
|
|
// se insieme di punto origine e tre versori
|
|
if ( sParam[0] == '(') {
|
|
Point3d ptOrig ;
|
|
Vector3d vtX ;
|
|
Vector3d vtY ;
|
|
Vector3d vtZ ;
|
|
string sTmp ;
|
|
STRVECTOR vsParams ;
|
|
STRVECTOR::iterator Iter ;
|
|
// elimino primo e ultimo carattere
|
|
sTmp = sParam.substr( 1, sParam.size()-2) ;
|
|
// divido in parti
|
|
Tokenize( sTmp, ",", "(", ")", vsParams) ;
|
|
// verifico siano 4 parti e le converto
|
|
if ( vsParams.size() != 4)
|
|
return false ;
|
|
if ( GetPointParam( vsParams[0], ptOrig) &&
|
|
GetVectorParam( vsParams[1], vtX) &&
|
|
GetVectorParam( vsParams[2], vtY) &&
|
|
GetVectorParam( vsParams[3], vtZ))
|
|
return frF.Set( ptOrig, vtX, vtY, vtZ) ;
|
|
else
|
|
return false ;
|
|
}
|
|
// altrimenti nome di frame già nel DB
|
|
else {
|
|
const IGeoFrame3d* pFr ;
|
|
if ( ( pFr = GetGeoFrame3d( m_pGDB->GetGeoObj( GetIdParam( sParam)))) == nullptr)
|
|
return false ;
|
|
frF = pFr->GetFrame() ;
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::GetColorParam( const std::string& sParam, bool& bByParent, Color& cCol)
|
|
{
|
|
// se insieme di tre o quattro valori
|
|
if ( sParam[0] == '(') {
|
|
// divido in parti
|
|
STRVECTOR vsParams ;
|
|
Tokenize( sParam, ",", vsParams) ;
|
|
STRVECTOR::iterator Iter ;
|
|
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
|
|
Trim( (*Iter), " \t\r\n()") ;
|
|
// devono essere 3 o 4 parametri ( Red, Green, Blue [, Alpha])
|
|
if ( vsParams.size() != 3 && vsParams.size() != 4)
|
|
return false ;
|
|
int nRed, nGreen, nBlue ;
|
|
if ( ! FromString( vsParams[0], nRed) ||
|
|
! FromString( vsParams[1], nGreen) ||
|
|
! FromString( vsParams[2], nBlue))
|
|
return false ;
|
|
int nAlpha = 100 ;
|
|
if ( vsParams.size() == 4 &&
|
|
! FromString( vsParams[3], nAlpha))
|
|
return false ;
|
|
bByParent = false ;
|
|
cCol.Set( nRed, nGreen, nBlue, nAlpha) ;
|
|
return true ;
|
|
}
|
|
// se colore predefinito
|
|
else if ( GetStdColor( sParam, cCol)) {
|
|
bByParent = false ;
|
|
return true ;
|
|
}
|
|
// altrimeti
|
|
else {
|
|
// verifico se colore dal padre
|
|
string sTemp = sParam ;
|
|
ToUpper( sTemp) ;
|
|
ReplaceString( sTemp, " ", "") ;
|
|
if ( sTemp == "BYPARENT") {
|
|
bByParent = true ;
|
|
return true ;
|
|
}
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteLevel( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// devono essere 2 parametri ( Id, Livello)
|
|
if ( vsParams.size() != 2)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
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
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->SetLevel( *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
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
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
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->SetMode( *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
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
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
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->SetStatus( *Iter, nStat))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteSelect( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// selezione di un oggetto
|
|
if ( sCmd2.empty()) {
|
|
// deve essere 1 parametro ( Id)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione selezione
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->SelectObj( *Iter))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
// selezione di tutti gli oggetti di un gruppo
|
|
else if ( sCmd2 == "GOBJS") {
|
|
// deve essere 1 parametro ( Id)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione selezione di tutti gli oggetti di ogni gruppo
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->SelectGroupObjs( *Iter))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteDeselect( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// deselezione di un oggetto
|
|
if ( sCmd2.empty()) {
|
|
// deve essere 1 parametro ( Id)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione deselezione
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->DeselectObj( *Iter))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
// deselezione di tutti gli oggetti di un gruppo
|
|
else if ( sCmd2 == "GOBJS") {
|
|
// deve essere 1 parametro ( Id)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione deselezione di tutti gli oggetti di ogni gruppo
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->DeselectGroupObjs( *Iter))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
// deselezione di tutto
|
|
else if ( sCmd2 == "ALL") {
|
|
// nessun parametro
|
|
if ( vsParams.size() != 0)
|
|
return false ;
|
|
// cancello selezione oggetti
|
|
if ( ! m_pGDB->ClearSelection())
|
|
return false ;
|
|
return true ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteMaterial( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// assegnazione colore di oggetto
|
|
if ( sCmd2.empty()) {
|
|
// devono essere 2 parametri ( Id, Colore)
|
|
if ( vsParams.size() != 2)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// recupero il colore
|
|
bool bByParent ;
|
|
Color cCol ;
|
|
if ( ! GetColorParam( vsParams[1], bByParent, cCol))
|
|
return false ;
|
|
// esecuzione impostazione colore
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( bByParent) {
|
|
if ( ! m_pGDB->SetMaterial( *Iter, GDB_MT_PARENT))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! m_pGDB->SetMaterial( *Iter, cCol))
|
|
return false ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
// impostazione colore di default
|
|
else if ( sCmd2 == "DEF" || sCmd2 == "DEFAULT") {
|
|
// 1 parametro ( Colore)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero il colore (deve essere concreto)
|
|
bool bByParent ;
|
|
Color cCol ;
|
|
if ( ! GetColorParam( vsParams[0], bByParent, cCol) || bByParent)
|
|
return false ;
|
|
// imposto il colore di default
|
|
return m_pGDB->SetDefaultMaterial( cCol) ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteName( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// assegnazione nome
|
|
if ( sCmd2.empty()) {
|
|
// 2 parametri ( Id, Nome)
|
|
if ( vsParams.size() != 2)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// eseguo assegnazione nome
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->SetName( *Iter, vsParams[1]))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
// rimozione nome
|
|
else if ( sCmd2 == "REM" || sCmd2 == "REMOVE") {
|
|
// 1 parametro ( Id)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// eseguo rimozione nome
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->RemoveName( *Iter))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteInfo( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// assegnazione informazione
|
|
if ( sCmd2.empty()) {
|
|
// 3 parametri ( Id, Key, Info)
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// eseguo assegnazione Info di data Key
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->SetInfo( *Iter, vsParams[1], vsParams[2]))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
// rimozione informazione
|
|
else if ( sCmd2 == "REM" || sCmd2 == "REMOVE") {
|
|
// 2 parametri ( Id, Key)
|
|
if ( vsParams.size() != 2)
|
|
return false ;
|
|
// recupero lista Id
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// eseguo rimozione nome Info di data Key
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->RemoveInfo( *Iter, vsParams[1]))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteCopy( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 3 parametri ( IdSou, IdDest, ParentIdDest)
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
// recupero flag per globale
|
|
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
|
|
// esecuzione copia
|
|
int nIdDest = GetIdParam( vsParams[1], true) ;
|
|
int nIdNew ;
|
|
if ( bGlob)
|
|
nIdNew = m_pGDB->CopyGlob( GetIdParam( vsParams[0]), nIdDest, GetIdParam( vsParams[2])) ;
|
|
else
|
|
nIdNew = m_pGDB->Copy( GetIdParam( vsParams[0]), nIdDest, GetIdParam( vsParams[2])) ;
|
|
// se IdDest da calcolare, può essere una variabili a cui cambiare il valore
|
|
if ( nIdDest == GDB_ID_NULL)
|
|
m_pParser->SetVariable( vsParams[1], nIdNew) ;
|
|
|
|
return ( nIdNew != GDB_ID_NULL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteErase( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 1 parametro ( Nome/i)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione cancellazioni
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( ! m_pGDB->Erase( *Iter))
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteTranslate( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 2 parametri ( Nome/i, Vettore)
|
|
if ( vsParams.size() != 2)
|
|
return false ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// recupero il vettore
|
|
Vector3d vtVN ;
|
|
if ( ! GetVectorParam( vsParams[1], vtVN))
|
|
return false ;
|
|
// recupero flag per globale
|
|
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
|
|
// esecuzione traslazioni
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( bGlob) {
|
|
if ( ! m_pGDB->TranslateGlob( *Iter, vtVN))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! m_pGDB->Translate( *Iter, vtVN))
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteRotate( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 4 parametri ( Nome, PtoAsse, VtAsse, AngDeg)
|
|
if ( vsParams.size() != 4)
|
|
return false ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// recupero il punto
|
|
Point3d ptPC ;
|
|
if ( ! GetPointParam( vsParams[1], ptPC))
|
|
return false ;
|
|
// recupero il vettore
|
|
Vector3d vtVN ;
|
|
if ( ! GetVectorParam( vsParams[2], vtVN))
|
|
return false ;
|
|
// recupero i coefficienti
|
|
double dAngDeg ;
|
|
if ( ! FromString( vsParams[3], dAngDeg))
|
|
return false ;
|
|
// recupero flag per globale
|
|
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
|
|
// esecuzione rotazioni
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( bGlob) {
|
|
if ( ! m_pGDB->RotateGlob( *Iter, ptPC, vtVN, dAngDeg))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! m_pGDB->Rotate( *Iter, ptPC, vtVN, dAngDeg))
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteScale( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 5 parametri ( Nome, Punto o Frame, CoeffX, CoeffY, CoeffZ)
|
|
if ( vsParams.size() != 5)
|
|
return false ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// provo a recuperare un punto
|
|
Point3d ptPC ;
|
|
Frame3d frRef ;
|
|
if ( GetPointParam( vsParams[1], ptPC))
|
|
frRef.Set( ptPC, Frame3d::TOP) ;
|
|
// provo a recuperare un frame
|
|
else if ( GetFrameParam( vsParams[1], frRef))
|
|
;
|
|
// altrimenti errore
|
|
else
|
|
return false ;
|
|
// recupero i coefficienti
|
|
double dCoeffX, dCoeffY, dCoeffZ ;
|
|
if ( ! FromString( vsParams[2], dCoeffX) ||
|
|
! FromString( vsParams[3], dCoeffY) ||
|
|
! FromString( vsParams[4], dCoeffZ))
|
|
return false ;
|
|
// recupero flag per globale
|
|
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
|
|
// esecuzione scalature
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( bGlob) {
|
|
if ( ! m_pGDB->ScaleGlob( *Iter, frRef, dCoeffX, dCoeffY, dCoeffZ))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! m_pGDB->Scale( *Iter, frRef, dCoeffX, dCoeffY, dCoeffZ))
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteMirror( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 3 parametri ( Nome, Punto, Vettore)
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// recupero il punto
|
|
Point3d ptPC ;
|
|
if ( ! GetPointParam( vsParams[1], ptPC))
|
|
return false ;
|
|
// recupero il vettore
|
|
Vector3d vtVN ;
|
|
if ( ! GetVectorParam( vsParams[2], vtVN))
|
|
return false ;
|
|
// recupero flag per globale
|
|
bool bGlob = ( sCmd2 == "GLOB" || sCmd2 == "G") ;
|
|
// esecuzione specchiature
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
if ( bGlob) {
|
|
if ( ! m_pGDB->MirrorGlob( *Iter, ptPC, vtVN))
|
|
return false ;
|
|
}
|
|
else {
|
|
if ( ! m_pGDB->Mirror( *Iter, ptPC, vtVN))
|
|
return false ;
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteInvertCurve( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 1 parametro ( Nome/i)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione inversione curve
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( *Iter)) ;
|
|
if ( pCurve == nullptr || ! pCurve->Invert())
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteTrimCurve( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
enum SeLp { SL, EL, SP, EP} ;
|
|
|
|
|
|
// 2 parametri ( Nome, parametro)
|
|
if ( vsParams.size() != 2)
|
|
return false ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// recupero i dati di inizio
|
|
double dPar ;
|
|
if ( ! FromString( vsParams[1], dPar))
|
|
return false ;
|
|
// determino il tipo di trim
|
|
SeLp StEnLenPar ;
|
|
if ( sCmd2 == "STARTLEN" || sCmd2 == "SL")
|
|
StEnLenPar = SL ;
|
|
else if ( sCmd2 == "ENDLEN" || sCmd2 == "EL")
|
|
StEnLenPar = EL ;
|
|
else if ( sCmd2 == "STARTPAR" || sCmd2 == "SP")
|
|
StEnLenPar = SP ;
|
|
else if ( sCmd2 == "ENDPAR" || sCmd2 == "EP")
|
|
StEnLenPar = EP ;
|
|
else
|
|
return false ;
|
|
// esecuzione trim
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
ICurve* pCurve ;
|
|
if ( ( pCurve = GetCurve( m_pGDB->GetGeoObj( *Iter))) != nullptr) {
|
|
switch ( StEnLenPar) {
|
|
case SL :
|
|
if ( ! pCurve->TrimStartAtLen( dPar))
|
|
return false ;
|
|
break ;
|
|
case EL :
|
|
if ( ! pCurve->TrimEndAtLen( dPar))
|
|
return false ;
|
|
break ;
|
|
case SP :
|
|
if ( ! pCurve->TrimStartAtParam( dPar))
|
|
return false ;
|
|
break ;
|
|
case EP :
|
|
if ( ! pCurve->TrimEndAtParam( dPar))
|
|
return false ;
|
|
break ;
|
|
}
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteNew( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// nessun parametro
|
|
if ( vsParams.size() != 0)
|
|
return false ;
|
|
// pulizia e reinizializzazione del DB geometrico
|
|
m_pGDB->Clear() ;
|
|
m_pGDB->Init() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteLoad( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 1 parametro ( NomeFile)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// pulizia e reinizializzazione del DB geometrico
|
|
m_pGDB->Clear() ;
|
|
m_pGDB->Init() ;
|
|
// esecuzione caricamento
|
|
return m_pGDB->Load( vsParams[0]) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteSave( const std::string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// 1 parametro ( NomeFile)
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// esecuzione salvataggio
|
|
return m_pGDB->Save( vsParams[0]) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::ExecuteOutScl( const string& sCmd2, const STRVECTOR& vsParams)
|
|
{
|
|
// apro il file di uscita Scl
|
|
if ( sCmd2 == "OPEN") {
|
|
// 1 parametro
|
|
if ( vsParams.size() != 1)
|
|
return false ;
|
|
// apro il file e scrivo intestazione
|
|
return m_OutScl.Open( vsParams[0]) ;
|
|
}
|
|
// chiudo il file di uscita Scl
|
|
else if ( sCmd2 == "CLOSE") {
|
|
// nessun parametro
|
|
if ( vsParams.size() != 0)
|
|
return false ;
|
|
// scrivo terminazioni e chiudo il file
|
|
return m_OutScl.Close() ;
|
|
}
|
|
// imposto materiale corrente
|
|
else if ( sCmd2 == "SETRGB") {
|
|
double dRed, dGreen, dBlue ;
|
|
// 3 parametri
|
|
if ( vsParams.size() != 3)
|
|
return false ;
|
|
// recupero i 3 colori
|
|
if ( ! FromString( vsParams[0], dRed) ||
|
|
! FromString( vsParams[1], dGreen) ||
|
|
! FromString( vsParams[2], dBlue))
|
|
return false ;
|
|
// definisco il materiale opportuno
|
|
return m_OutScl.SetMaterial( dRed, dGreen, dBlue) ;
|
|
}
|
|
// imposto pezzo e layer correnti
|
|
else if ( sCmd2 == "SETPL") {
|
|
// 2 parametri
|
|
if ( vsParams.size() != 2)
|
|
return false ;
|
|
// eseguo
|
|
return m_OutScl.SetPartLay( vsParams[0], vsParams[1]) ;
|
|
}
|
|
// emetto gruppo
|
|
else if ( sCmd2 == "PUTGR") {
|
|
// almeno un parametro
|
|
if ( vsParams.size() < 1)
|
|
return false ;
|
|
// se esiste il secondo
|
|
int nFlag ;
|
|
if ( vsParams.size() == 2)
|
|
FromString( vsParams[1], nFlag) ;
|
|
else
|
|
nFlag = 0 ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
// recupero l'oggetto ed eseguo l'output
|
|
if ( ! OutGroupScl( *Iter, nFlag))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
// emetto oggetto geometrico
|
|
else if ( sCmd2 == "PUT") {
|
|
// almeno un parametro
|
|
if ( vsParams.size() < 1)
|
|
return false ;
|
|
// se esiste il secondo
|
|
int nFlag ;
|
|
if ( vsParams.size() == 2)
|
|
FromString( vsParams[1], nFlag) ;
|
|
else
|
|
nFlag = 0 ;
|
|
// recupero lista nomi
|
|
INTVECTOR vnNames ;
|
|
if ( ! GetNamesParam( vsParams[0], vnNames))
|
|
return false ;
|
|
// esecuzione
|
|
INTVECTOR::iterator Iter ;
|
|
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
|
// recupero l'oggetto ed eseguo l'output
|
|
if ( ! m_OutScl.PutGeoObj( m_pGDB->GetGeoObj( *Iter), nFlag))
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
GdbExecutor::OutGroupScl( int nId, int nFlag)
|
|
{
|
|
bool bNext ;
|
|
int nParentId ;
|
|
int nGdbType ;
|
|
Frame3d frFrame ;
|
|
|
|
|
|
m_OutScl.Remark( "Start Group ---") ;
|
|
// emetto dati gruppo
|
|
if ( m_pGDB->GetGroupGlobFrame( nId, frFrame)) {
|
|
nParentId = m_pGDB->GetParentId( nId) ;
|
|
if ( nParentId > GDB_ID_ROOT) {
|
|
if ( ! m_OutScl.SetPartLayRef( ToString( nParentId), ToString( nId), frFrame))
|
|
return false ;
|
|
m_OutScl.PutCurrRef() ;
|
|
}
|
|
}
|
|
else
|
|
return false ;
|
|
// emetto eventuale box
|
|
if ( ( nFlag & 8) != 0) {
|
|
BBox3d b3Loc ;
|
|
if ( m_pGDB->GetLocalBBox( nId, b3Loc))
|
|
m_OutScl.PutBBox( b3Loc) ;
|
|
}
|
|
// emetto entità gruppo
|
|
m_OutScl.Remark( "Entities :") ;
|
|
GdbIterator Iter( m_pGDB) ;
|
|
bNext = Iter.GoToFirstInGroup( nId) ;
|
|
while ( bNext) {
|
|
nGdbType = Iter.GetGdbType() ;
|
|
if ( nGdbType == GDB_TY_GEO) {
|
|
if ( ! m_OutScl.PutGeoObj( Iter.GetGeoObj(), nFlag))
|
|
return false ;
|
|
}
|
|
else if ( nGdbType == GDB_TY_GROUP) {
|
|
if ( ! OutGroupScl( Iter.GetId(), nFlag))
|
|
return false ;
|
|
}
|
|
bNext = Iter.GoToNext() ;
|
|
}
|
|
m_OutScl.Remark( "End Group ---") ;
|
|
|
|
return true ;
|
|
}
|