//----------------------------------------------------------------------------
//  EgalTech 2013-2013
//----------------------------------------------------------------------------
// File : GdbExecutor.cpp        Data : 25.11.13          Versione : 1.3a5
// Contenuto : Implementazione della classe GdbExecutor.
//
//
//
// Modifiche : 27.03.13 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "GdbExecutor.h"
#include "GdbIterator.h"
#include "/EgtDev/Include/EgnStringUtils.h"
#include "/EgtDev/Include/EgnStringConverter.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/EgtPointerOwner.h"

using namespace std ;

//----------------------------------------------------------------------------
IGdbExecutor*
CreateGdbExecutor( void)
{
   return static_cast<IGdbExecutor*> ( new GdbExecutor) ;
}

//----------------------------------------------------------------------------
GdbExecutor::GdbExecutor( void)
{
   m_pGDB = nullptr ;
   m_pLogger = nullptr ;
}

//----------------------------------------------------------------------------
GdbExecutor::~GdbExecutor( void)
{
}

//----------------------------------------------------------------------------
bool
GdbExecutor::Init( IGeomDB* pGdb, ILogger* pLogger) 
{
   m_pGDB = pGdb ;
   m_pLogger = pLogger ;

   return ( m_pGDB != nullptr) ; 
}

//----------------------------------------------------------------------------
bool
GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR& vsParams) 
{
   string sOut ;
   STRVECTOR::const_iterator theConstIter ;


  // output di debug
   sOut = "Cmd = [" + sCmd1 + "/" + sCmd2 + "] Par = [" ;
   for ( theConstIter = vsParams.begin() ; theConstIter != vsParams.end() ; ++theConstIter) {
      if ( theConstIter != vsParams.begin())
         sOut += "/" ; 
      sOut += *theConstIter ;
   }
   sOut += "]" ;
   LOG_DEBUG( m_pLogger, sOut.c_str()) ;

  // esecuzione comando
   if ( sCmd1 == "ALIAS")
      return ExecuteAlias( sCmd2, vsParams) ;
   else 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 == "COPY")
      return ExecuteCopy( vsParams) ;
   else if ( sCmd1 == "ERASE")
      return ExecuteErase( vsParams) ;
   else if ( sCmd1 == "MOVE"  ||  sCmd1 == "TRANSLATE")
      return ExecuteTranslate( vsParams) ;
   else if ( sCmd1 == "ROTATE")
      return ExecuteRotate( vsParams) ;
   else if ( sCmd1 == "SCALE")
      return ExecuteScale( vsParams) ;
   else if ( sCmd1 == "MIRROR")
      return ExecuteMirror( vsParams) ;
   else if ( sCmd1 == "LOAD")
      return ExecuteLoad( vsParams) ;
   else if ( sCmd1 == "SAVE")
      return ExecuteSave( vsParams) ;
   else if ( sCmd1 == "OUTSCL")
      return ExecuteOutScl( sCmd2, vsParams) ;

   return false ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteAlias( const string& sCmd2, const STRVECTOR& vsParams) 
{
  // analisi ed esecuzione dei comandi
   if ( sCmd2 == "") {
      int nId ;
     // 2 parametri : stringa alias e Id
      if ( vsParams.size() != 2)
         return false ;
     // recupero Id
      if ( ! FromString( vsParams[1], nId))
         return false ;
     // inserisco le stringhe in coda alla lista
      return m_AliasMap.insert( pair< string, int>( vsParams[0], nId)).second ;
   }

   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]) ;
   int nIdNew = m_pGDB->AddGroup( nIdDest, GetIdParam( vsParams[1]), frFrame) ;
  // se IdDest da calcolare e indicato da Alias, ne cambio il valore
   if ( nIdDest == GDB_ID_NULL  &&  m_AliasMap.find( vsParams[0]) != m_AliasMap.end())
      m_AliasMap[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) 
{
  // analisi ed esecuzione dei comandi
   if ( sCmd2 == "MAKE"  ||  sCmd2 == "") {
      Point3d ptStart ;
      Point3d ptEnd ;
     // 4 parametri
      if ( vsParams.size() != 4)
         return false ;
     // recupero e setto punti iniziale e finale
      if ( ! GetPointParam( vsParams[2], ptStart)  ||
           ! GetPointParam( vsParams[3], ptEnd))
         return false ;
     // creo la linea
      PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
      if ( ! IsValid( pCrvLine)  ||  ! pCrvLine->Set( ptStart, ptEnd))
         return false ;
      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 == "MAKE"  ||  sCmd2 == "") {
      Point3d   ptCen ;
      Vector3d  vtN ;
      double    dRad ;
      Vector3d  vtS ;
      double    dAngCenDeg ;
      double    dDeltaZ ;
     // 8 parametri
      if ( vsParams.size() != 8)
         return false ;
     // centro
      if ( ! GetPointParam( vsParams[2], ptCen))
         return false ;
     // versore ortogonale al piano della circonferenza
      if ( ! GetVectorParam( vsParams[3], vtN))
         return false ;
     // raggio
      if ( ! FromString( vsParams[4], dRad))
         return false ;
     // versore iniziale
      if ( ! GetVectorParam( vsParams[5], vtS))
         return false ;
     // angolo al centro
      if ( ! FromString( vsParams[6], dAngCenDeg))
         return false ;
     // deltaZ
      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") {
      Point3d   ptCen ;
      double    dRad ;
      double    dAngIniDeg ;
      double    dAngCenDeg ;
      double    dDeltaZ ;
     // 7 parametri
      if ( vsParams.size() != 7)
         return false ;
     // centro
      if ( ! GetPointParam( vsParams[2], ptCen))
         return false ;
     // raggio
      if ( ! FromString( vsParams[3], dRad))
         return false ;
     // angolo iniziale
      if ( ! FromString( vsParams[4], dAngIniDeg))
         return false ;
     // angolo al centro
      if ( ! FromString( vsParams[5], dAngCenDeg))
         return false ;
     // deltaZ
      if ( ! FromString( vsParams[6], dDeltaZ))
         return false ;
     // setto l'arco
      if ( ! pCrvArc->Set( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
         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 ;

  // curva di Bezier intera (non razionale)
   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 ;
      }
   }
  // altrimenti errore
   else
      return false ;

  // inserisco la curva di Bezier nel DB
   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvBez)) ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams) 
{
  // curva composita generica
   if ( sCmd2 == "MAKE"  ||  sCmd2 == "") {
      bool bErase ;
      STRVECTOR vsNames ;
      STRVECTOR::iterator Iter ;
      const ICurve* pCrv ;
      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
      if ( ! IsValid( pCrvCompo))
         return false ;
     // 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 ;
     // esecuzione
      for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
        // recupero la curva
         pCrv = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *Iter))) ; 
         if ( pCrv == nullptr)
            return false ;
        // aggiungo questa curva
         if ( ! pCrvCompo->AddCurve( *pCrv))
            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 ;
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::AddGeoObj( const string& sId, const string& sIdParent, IGeoObj* pGeoObj)
{
  // creo il gruppo
   int nId = GetIdParam( sId) ;
   int nIdNew = m_pGDB->AddGeoObj( nId, GetIdParam( sIdParent), pGeoObj) ;
  // se IdDest da calcolare e indicato da Alias, ne cambio il valore
   if ( nId == GDB_ID_NULL  &&  m_AliasMap.find( sId) != m_AliasMap.end())
      m_AliasMap[sId] = nIdNew ;

   return ( nIdNew != GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
int
GdbExecutor::GetIdParam( const std::string& sParam)
{
   int     nVal ;
   AliasMap::iterator Iter ;   


  // sostituisco eventuali Alias
   Iter = m_AliasMap.find( sParam) ;
   if ( Iter != m_AliasMap.end())
      return Iter->second ;
  // converto in identificatore numerico
   else if ( FromString( sParam, nVal))
      return nVal ;
  // altrimenti errore
   else
      return - 1 ;
}

//----------------------------------------------------------------------------
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] == '(') {
      STRVECTOR vsParams ;
      STRVECTOR::iterator Iter ;
     // divido in parti
      Tokenize( sParam, ",", vsParams) ;
      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] == '(') {
      STRVECTOR vsParams ;
      STRVECTOR::iterator Iter ;
     // divido in parti
      Tokenize( sParam, ",", vsParams) ;
      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) 
{
   STRVECTOR vsParams ;
   STRVECTOR::iterator Iter ;


  // deve essere insieme di dati
   if ( sParam[0] != '(')
      return false ;

  // divido in parti
   Tokenize( sParam, ",", vsParams) ;
   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::ExecuteCopy( const STRVECTOR& vsParams) 
{
  // 3 parametri ( IdSou, IdDest, ParentIdDest)
   if ( vsParams.size() != 3)
      return false ;
  // esecuzione copia
   int nIdDest = GetIdParam( vsParams[1]) ;
   int nIdNew = m_pGDB->Copy( GetIdParam( vsParams[0]), nIdDest, GetIdParam( vsParams[2])) ;
  // se IdDest da calcolare e indicato da Alias, ne cambio il valore
   if ( nIdDest == GDB_ID_NULL  &&  m_AliasMap.find( vsParams[1]) != m_AliasMap.end())
      m_AliasMap[vsParams[1]] = nIdNew ;

   return ( nIdNew != GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteErase( const STRVECTOR& vsParams) 
{
   STRVECTOR vsNames ;
   STRVECTOR::iterator Iter ;


  // 1 parametro ( Nome/i)
   if ( vsParams.size() != 1)
      return false ;
  // recupero lista nomi
   if ( ! GetNamesParam( vsParams[0], vsNames))
      return false ;
  // esecuzione cancellazioni
   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
      if ( ! m_pGDB->Erase( GetIdParam( *Iter)))
         return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteTranslate( const STRVECTOR& vsParams) 
{
   STRVECTOR vsNames ;
   STRVECTOR::iterator Iter ;
   Vector3d vtVN ;


  // 2 parametri ( Nome/i, Vettore)
   if ( vsParams.size() != 2)
      return false ;
  // recupero lista nomi
   if ( ! GetNamesParam( vsParams[0], vsNames))
      return false ;
  // recupero il vettore
   if ( ! GetVectorParam( vsParams[1], vtVN))
      return false ;
  // esecuzione traslazioni
   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
      if ( ! m_pGDB->Translate( GetIdParam( *Iter), vtVN))
         return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteRotate( const STRVECTOR& vsParams) 
{
   STRVECTOR vsNames ;
   STRVECTOR::iterator Iter ;
   Point3d  ptPC ;
   Vector3d vtVN ;
   double dAngDeg ;


  // 4 parametri ( Nome, PtoAsse, VtAsse, AngDeg)
   if ( vsParams.size() != 4)
      return false ;
  // recupero lista nomi
   if ( ! GetNamesParam( vsParams[0], vsNames))
      return false ;
  // recupero il punto
   if ( ! GetPointParam( vsParams[1], ptPC))
      return false ;
  // recupero il vettore
   if ( ! GetVectorParam( vsParams[2], vtVN))
      return false ;
  // recupero i coefficienti
   if ( ! FromString( vsParams[3], dAngDeg))
      return false ;
  // esecuzione rotazioni
   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
      if ( ! m_pGDB->Rotate( GetIdParam( *Iter), ptPC, vtVN, dAngDeg))
         return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteScale( const STRVECTOR& vsParams) 
{
   STRVECTOR vsNames ;
   STRVECTOR::iterator Iter ;
   Point3d ptPC ;
   double dCoeffX ;
   double dCoeffY ;
   double dCoeffZ ;


  // 5 parametri ( Nome, Punto, CoeffX, CoeffY, CoeffZ)
   if ( vsParams.size() != 5)
      return false ;
  // recupero lista nomi
   if ( ! GetNamesParam( vsParams[0], vsNames))
      return false ;
  // recupero il punto
   if ( ! GetPointParam( vsParams[1], ptPC))
      return false ;
  // recupero i coefficienti
   if ( ! FromString( vsParams[2], dCoeffX)  ||
        ! FromString( vsParams[3], dCoeffY)  ||
        ! FromString( vsParams[4], dCoeffZ))
      return false ;
  // esecuzione scalature
   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
      if ( ! m_pGDB->Scale( GetIdParam( *Iter), ptPC, dCoeffX, dCoeffY, dCoeffZ))
         return false ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::ExecuteMirror( const STRVECTOR& vsParams) 
{
   STRVECTOR vsNames ;
   STRVECTOR::iterator Iter ;
   Point3d  ptPC ;
   Vector3d vtVN ;


  // 3 parametri ( Nome, Punto, Vettore)
   if ( vsParams.size() != 3)
      return false ;
  // recupero lista nomi
   if ( ! GetNamesParam( vsParams[0], vsNames))
      return false ;
  // recupero il punto
   if ( ! GetPointParam( vsParams[1], ptPC))
      return false ;
  // recupero il vettore
   if ( ! GetVectorParam( vsParams[2], vtVN))
      return false ;
  // esecuzione specchiature
   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
      if ( ! m_pGDB->Mirror( GetIdParam( *Iter), ptPC, vtVN))
         return false ;
   }

   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->ReInit() ;
  // 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 nId ;
     // un parametro
      if ( vsParams.size() != 1)
         return false ;
      nId = GetIdParam( vsParams[0]) ;
     // emetto gruppo e suoi sottoposti
      return OutGroupScl( nId) ;
   }
  // 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.PutCurve( m_pGDB->GetGeoObj( nId), nFlag))
            return false ;
      }
      return true ;
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
GdbExecutor::OutGroupScl( int nId) 
{
   bool bNext ;
   int  nParentId ;
   int  nGdbType ;
   Frame3d frFrame ;
   GdbIterator Iter ;


  // 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 ;
      }
   }
   else
      return false ;
  // emetto entità gruppo
   Iter.SetGDB( m_pGDB) ;
   bNext = Iter.GoToFirstInGroup( nId) ;
   while ( bNext) {
      nGdbType = Iter.GetGdbType() ;
      if ( nGdbType == GDB_GEO) {
         if ( ! m_OutScl.PutCurve( Iter.GetGeoObj(), 0))
            return false ;
      }
      else if ( nGdbType == GDB_GROUP) {
         if ( ! OutGroupScl( Iter.GetId()))
            return false ;
      }
      bNext = Iter.GoToNext() ;
   }

   return true ;
}