//---------------------------------------------------------------------------- // 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_NO = -2 ; static const int ID_ERROR = -3 ; //---------------------------------------------------------------------------- IGdbExecutor* CreateGdbExecutor( void) { return static_cast ( new GdbExecutor) ; } //---------------------------------------------------------------------------- GdbExecutor::GdbExecutor( void) { m_pGDB = nullptr ; m_pParser = nullptr ; m_pOtherExec = nullptr ; } //---------------------------------------------------------------------------- GdbExecutor::~GdbExecutor( void) { } //---------------------------------------------------------------------------- bool GdbExecutor::SetCmdParser( ICmdParser* pParser) { // salvo e verifico m_pParser = pParser ; if ( m_pParser == nullptr) return false ; // imposto eventuale parser dipendente if ( m_pOtherExec != nullptr) m_pOtherExec->SetCmdParser( m_pParser) ; return true ; } //---------------------------------------------------------------------------- bool GdbExecutor::AddExecutor( ICmdExecutor* pOtherExec) { m_pOtherExec = pOtherExec ; return true ; } //---------------------------------------------------------------------------- bool GdbExecutor::SetGeomDB( IGeomDB* pGdb) { m_pGDB = pGdb ; return ( m_pGDB != nullptr) ; } //---------------------------------------------------------------------------- bool GdbExecutor::AddStandardVariables( void) { // imposto variabili predefinite m_pParser->AddVariable( "$ROOT", GDB_ID_ROOT) ; m_pParser->AddVariable( "$NN", ID_NO) ; // se c'è esecutore dipendente if ( m_pOtherExec != nullptr) return m_pOtherExec->AddStandardVariables() ; else return true ; } //---------------------------------------------------------------------------- bool 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 false ; } // verifico validità CmdParser if ( m_pParser == nullptr) { LOG_ERROR( GetEGkLogger(), "Error : null CmdParser.") return false ; } // esecuzione comando if ( sCmd1 == "GR" || sCmd1 == "GROUP") return ExecuteGroup( sCmd2, vsParams) ; else if ( sCmd1 == "P" || sCmd1 == "POINT") return ExecutePoint( sCmd2, vsParams) ; else if ( sCmd1 == "V" || sCmd1 == "VECTOR") return ExecuteVector( sCmd2, vsParams) ; else if ( sCmd1 == "FR" || sCmd1 == "FRAME") return ExecuteFrame( sCmd2, vsParams) ; else if ( sCmd1 == "CL" || sCmd1 == "CURVELINE") return ExecuteCurveLine( sCmd2, vsParams) ; else if ( sCmd1 == "CA" || sCmd1 == "CURVEARC") return ExecuteCurveArc( sCmd2, vsParams) ; else if ( sCmd1 == "CB" || sCmd1 == "CURVEBEZIER") 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 == "MAT" || sCmd1 == "MATERIAL") return ExecuteMaterial( sCmd2, vsParams) ; else if ( sCmd1 == "NAM" || sCmd1 == "NAME") return ExecuteName( sCmd2, vsParams) ; else if ( sCmd1 == "INF" || sCmd1 == "INFO") return ExecuteInfo( sCmd2, vsParams) ; else if ( sCmd1 == "COPY") return ExecuteCopy( sCmd2, vsParams) ; else if ( sCmd1 == "ERASE") return ExecuteErase( vsParams) ; else if ( sCmd1 == "MOV" || sCmd1 == "MOVE") return ExecuteTranslate( sCmd2, vsParams) ; else if ( sCmd1 == "ROT" || sCmd1 == "ROTATE") return ExecuteRotate( sCmd2, vsParams) ; else if ( sCmd1 == "SCA" || sCmd1 == "SCALE") return ExecuteScale( sCmd2, vsParams) ; else if ( sCmd1 == "MIR" || sCmd1 == "MIRROR") return ExecuteMirror( sCmd2, vsParams) ; else if ( sCmd1 == "INVC" || sCmd1 == "INVERTCURVE") return ExecuteInvertCurve( vsParams) ; else if ( sCmd1 == "TRC" || sCmd1 == "TRIMCURVE") return ExecuteTrimCurve( sCmd2, vsParams) ; else if ( sCmd1 == "NEW") return ExecuteNew( vsParams) ; else if ( sCmd1 == "LOAD") return ExecuteLoad( vsParams) ; else if ( sCmd1 == "SAVE") return ExecuteSave( vsParams) ; else if ( sCmd1 == "OUTSCL") return ExecuteOutScl( sCmd2, vsParams) ; else if ( m_pOtherExec != nullptr) return m_pOtherExec->Execute( sCmd1, sCmd2, vsParams) ; return false ; } //---------------------------------------------------------------------------- bool GdbExecutor::ExecuteGroup( const string& sCmd2, const STRVECTOR& vsParams) { Frame3d frFrame ; // gruppo generico if ( sCmd2 == "MAKE" || sCmd2 == "") { 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 == "PLANEXY" || sCmd2 == "XY") { 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 == "MAKE" || sCmd2 == "") { 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 == "MAKE" || sCmd2 == "") { 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 == "MAKE" || sCmd2 == "") { 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 pCrvLine( CreateCurveLine()) ; if ( ! IsValid( pCrvLine)) return false ; // creazione linea dando gli estremi if ( sCmd2 == "MAKE" || sCmd2 == "") { // 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 == "MINPOINTCURVE" || sCmd2 == "MPC") { // 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 pCrvArc( CreateCurveArc()) ; if ( ! IsValid( pCrvArc)) return false ; // arco generico if ( sCmd2 == "MAKE" || sCmd2 == "") { // 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 == "PLANEXY" || sCmd2 == "XY") { // 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 == "CIRCLEXY" || sCmd2 == "CXY") { // 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 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 == "INTEG" || sCmd2 == "I") { 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 == "RATIO" || sCmd2 == "R") { 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 == "FROMARC" || sCmd2 == "A") { // 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 pCrvCompo( CreateCurveComposite()) ; if ( ! IsValid( pCrvCompo)) return false ; // per eventuale cancellazione curve di origine bool bErase ; STRVECTOR vsNames ; STRVECTOR::iterator Iter ; // curva composita generica if ( sCmd2 == "MAKE" || sCmd2 == "") { // 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], vsNames)) return false ; // recupero il riferimento del gruppo destinazione Frame3d frDest ; if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest)) return false ; // esecuzione for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { // recupero la curva int nIdCrv = GetIdParam( *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 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 == "FROMSPLIT" || sCmd2 == "S") { // 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 vsNames.push_back( vsParams[2]) ; // recupero la curva int nIdCrv = GetIdParam( vsParams[2]) ; 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 = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ! m_pGDB->Erase( GetIdParam(*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, STRVECTOR& vsNames) { STRVECTOR::iterator Iter ; // divido in parti Tokenize( sParam, ",", vsNames) ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) Trim( (*Iter), " \t\r\n()") ; 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, 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 ; cCol.Set( nRed, nGreen, nBlue, nAlpha) ; return true ; } // altrimenti colore predefinito else { return GetStdColor( sParam, 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::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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // recupero il colore Color cCol ; if ( ! GetColorParam( vsParams[1], cCol)) return false ; // esecuzione impostazione colore STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ! m_pGDB->SetMaterial( GetIdParam( *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 Color cCol ; if ( ! GetColorParam( vsParams[0], cCol)) 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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // eseguo assegnazione nome STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ! m_pGDB->SetName( GetIdParam( *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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // eseguo rimozione nome STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ! m_pGDB->RemoveName( GetIdParam( *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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // eseguo assegnazione Info di data Key STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ! m_pGDB->SetInfo( GetIdParam( *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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // eseguo rimozione nome Info di data Key STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ! m_pGDB->RemoveInfo( GetIdParam( *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 STRVECTOR& vsParams) { // 1 parametro ( Nome/i) if ( vsParams.size() != 1) return false ; // recupero lista nomi STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // esecuzione cancellazioni STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ! m_pGDB->Erase( GetIdParam( *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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) 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 STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( bGlob) { if ( ! m_pGDB->TranslateGlob( GetIdParam( *Iter), vtVN)) return false ; } else { if ( ! m_pGDB->Translate( GetIdParam( *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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) 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 STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( bGlob) { if ( ! m_pGDB->RotateGlob( GetIdParam( *Iter), ptPC, vtVN, dAngDeg)) return false ; } else { if ( ! m_pGDB->Rotate( GetIdParam( *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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) 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 STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( bGlob) { if ( ! m_pGDB->ScaleGlob( GetIdParam( *Iter), frRef, dCoeffX, dCoeffY, dCoeffZ)) return false ; } else { if ( ! m_pGDB->Scale( GetIdParam( *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 STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) 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 STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( bGlob) { if ( ! m_pGDB->MirrorGlob( GetIdParam( *Iter), ptPC, vtVN)) return false ; } else { if ( ! m_pGDB->Mirror( GetIdParam( *Iter), ptPC, vtVN)) return false ; } } return true ; } //---------------------------------------------------------------------------- bool GdbExecutor::ExecuteInvertCurve( const STRVECTOR& vsParams) { // 1 parametro ( Nome/i) if ( vsParams.size() != 1) return false ; // recupero lista nomi STRVECTOR vsNames ; if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // esecuzione inversione curve STRVECTOR::iterator Iter ; for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *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} ; SeLp StEnLenPar ; double dPar ; STRVECTOR vsNames ; STRVECTOR::iterator Iter ; ICurve* pCurve ; // 2 parametri ( Nome, parametro) if ( vsParams.size() != 2) return false ; // recupero lista nomi if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // recupero i dati di inizio if ( ! FromString( vsParams[1], dPar)) return false ; // determino il tipo di trim 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 for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { if ( ( pCurve = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *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 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 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 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") { int nFlag ; int nId ; STRVECTOR vsNames ; STRVECTOR::iterator Iter ; // almeno un parametro if ( vsParams.size() < 1) return false ; // se esiste il secondo if ( vsParams.size() == 2) FromString( vsParams[1], nFlag) ; else nFlag = 0 ; // recupero lista nomi if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // esecuzione for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { // recupero l'oggetto ed eseguo l'output nId = GetIdParam( *Iter) ; if ( ! OutGroupScl( nId, nFlag)) return false ; } return true ; } // emetto oggetto geometrico else if ( sCmd2 == "PUT") { int nFlag ; int nId ; STRVECTOR vsNames ; STRVECTOR::iterator Iter ; // almeno un parametro if ( vsParams.size() < 1) return false ; // se esiste il secondo if ( vsParams.size() == 2) FromString( vsParams[1], nFlag) ; else nFlag = 0 ; // recupero lista nomi if ( ! GetNamesParam( vsParams[0], vsNames)) return false ; // esecuzione for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { // recupero l'oggetto ed eseguo l'output nId = GetIdParam( *Iter) ; if ( ! m_OutScl.PutGeoObj( m_pGDB->GetGeoObj( nId), nFlag)) return false ; } return true ; } return false ; } //---------------------------------------------------------------------------- bool GdbExecutor::OutGroupScl( int nId, int nFlag) { bool bNext ; int nParentId ; int nGdbType ; Frame3d frFrame ; GdbIterator Iter ; 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 :") ; Iter.SetGDB( 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 ; }