diff --git a/CurveArc.cpp b/CurveArc.cpp
index 3862630..59d6439 100644
--- a/CurveArc.cpp
+++ b/CurveArc.cpp
@@ -127,15 +127,15 @@ CurveArc::Save( ostream& osOut) const
   // centro
    osOut << ToString( m_PtCen) ;
   // versore Normale
-   osOut << "," << ToString( m_VtN) ;
+   osOut << ";" << ToString( m_VtN) ;
   // raggio
-   osOut << "," << ToString( m_dRad) ;
+   osOut << ";" << ToString( m_dRad) ;
   // versore Iniziale
-   osOut << "," << ToString( m_VtS) ;
+   osOut << ";" << ToString( m_VtS) ;
   // angolo al centro
-   osOut << "," << ToString( m_dAngCenDeg) ;
+   osOut << ";" << ToString( m_dAngCenDeg) ;
   // deltaN
-   osOut << "," << ToString( m_dDeltaN) << endl ;
+   osOut << ";" << ToString( m_dDeltaN) << ";" << endl ;
 
    return true ;
 }
@@ -152,33 +152,27 @@ CurveArc::Load( CScan& TheScanner)
    if ( ! TheScanner.GetLine( sLine))
       return false ;
   // la divido in parametri
-   Tokenize( sLine, ",", vsParams) ;
-  // 12 parametri : centro, versore normale, raggio, versore iniziale, angolo al centro e delta Z 
-   if ( vsParams.size() != 12)
+   Tokenize( sLine, ";", vsParams) ;
+  // 6 parametri : centro, versore normale, raggio, versore iniziale, angolo al centro e delta Z 
+   if ( vsParams.size() != 6)
       return false ;
   // recupero il centro
-   if ( ! FromString( vsParams[0], m_PtCen.x)  ||
-        ! FromString( vsParams[1], m_PtCen.y)  ||
-        ! FromString( vsParams[2], m_PtCen.z))
+   if ( ! FromString( vsParams[0], m_PtCen))
       return false ;
   // recupero il versore normale
-   if ( ! FromString( vsParams[3], m_VtN.x)  ||
-        ! FromString( vsParams[4], m_VtN.y)  ||
-        ! FromString( vsParams[5], m_VtN.z))
+   if ( ! FromString( vsParams[1], m_VtN))
       return false ;
   // recupero il raggio
-   if ( ! FromString( vsParams[6], m_dRad))
+   if ( ! FromString( vsParams[2], m_dRad))
       return false ;
   // recupero il versore iniziale
-   if ( ! FromString( vsParams[7], m_VtS.x)  ||
-        ! FromString( vsParams[8], m_VtS.y)  ||
-        ! FromString( vsParams[9], m_VtS.z))
+   if ( ! FromString( vsParams[3], m_VtS))
       return false ;
   // recupero l'angolo al centro
-   if ( ! FromString( vsParams[10], m_dAngCenDeg))
+   if ( ! FromString( vsParams[4], m_dAngCenDeg))
       return false ;
   // recupero il delta N
-   if ( ! FromString( vsParams[11], m_dDeltaN))
+   if ( ! FromString( vsParams[5], m_dDeltaN))
       return false ;
   // eseguo validazione
    return Validate() ;
diff --git a/CurveBezier.cpp b/CurveBezier.cpp
index c6a2679..3062c4e 100644
--- a/CurveBezier.cpp
+++ b/CurveBezier.cpp
@@ -96,7 +96,7 @@ CurveBezier::Init( int nDeg, bool bIsRational)
   // pulisco, assegnando 0 ai punti e 1 ai pesi
    memset( m_aPtCtrl, 0, sizeof( Point3d) * ( m_nDeg + 1)) ;
    if ( m_bRat) {
-      for ( int i = 0 ; i <= m_nDeg ; i ++)
+      for ( int i = 0 ; i <= m_nDeg ; ++ i)
          m_aWeCtrl[i] = 1 ;
    }
    m_nStatus = TO_VERIFY ;
@@ -205,16 +205,16 @@ CurveBezier::Save( ostream& osOut) const
   // flag razionale
    osOut << m_bRat ;
   // dati della curva di bezier
-   osOut << "," << ToString( m_nDeg) ;
+   osOut << ";" << ToString( m_nDeg) ;
   // ciclo sui punti di controllo ( con pesi se razionale)
-   for ( i = 0 ; i <= m_nDeg ; i ++) {
-      osOut << "," << ToString( m_aPtCtrl[i]) ;
+   for ( i = 0 ; i <= m_nDeg ; ++ i) {
+      osOut << ";" << ToString( m_aPtCtrl[i]) ;
       if ( m_bRat) {
          osOut << "," << ToString( m_aWeCtrl[i]) ;
       }
    }
   // terminazione
-   osOut << endl ;
+   osOut << ";" << endl ;
 
    return true ;
 }
@@ -236,7 +236,7 @@ CurveBezier::Load( CScan& TheScanner)
    if ( ! TheScanner.GetLine( sLine))
       return false ;
   // la divido in parametri
-   Tokenize( sLine, ",", vsParams) ;
+   Tokenize( sLine, ";", vsParams) ;
   // almeno 2 parametri : flag razionale e grado
    if ( vsParams.size() < 2)
       return false ;
@@ -246,34 +246,26 @@ CurveBezier::Load( CScan& TheScanner)
   // recupero il grado
    if ( ! FromString( vsParams[1], nDeg))
       return false ;
+  // ri-controllo il numero dei parametri
+   if ( vsParams.size() != ( 2 + ( nDeg + 1)))
+      return false ;
   // inizializzo la curva di Bezier
    if ( ! Init( nDeg, bIsRat))
       return false ;
   // se integrale
    if ( ! bIsRat) {
-     // ri-controllo il numero dei parametri
-      if ( vsParams.size() != ( 2 + 3 * ( nDeg + 1)))
-         return false ;
      // recupero e setto punti di controllo
-      for ( i = 0 ; i <= nDeg ; i ++) {
-         if ( ! FromString( vsParams[3*i+2], ptP.x)  ||
-              ! FromString( vsParams[3*i+3], ptP.y)  ||
-              ! FromString( vsParams[3*i+4], ptP.z)  ||
+      for ( i = 0 ; i <= nDeg ; ++ i) {
+         if ( ! FromString( vsParams[i+2], ptP)  ||
               ! SetControlPoint( i, ptP))
             return false ;
       }
    }
   // altrimenti razionale
    else {
-     // ri-controllo il numero dei parametri
-      if ( vsParams.size() != ( 2 + 4 * ( nDeg + 1)))
-         return false ;
      // recupero e setto punti di controllo
-      for ( i = 0 ; i <= nDeg ; i ++) {
-         if ( ! FromString( vsParams[4*i+2], ptP.x)  ||
-              ! FromString( vsParams[4*i+3], ptP.y)  ||
-              ! FromString( vsParams[4*i+4], ptP.z)  ||
-              ! FromString( vsParams[4*i+5], dW)  ||
+      for ( i = 0 ; i <= nDeg ; ++ i) {
+         if ( ! FromString( vsParams[i+2], ptP, dW)  ||
               ! SetControlPoint( i, ptP, dW))
             return false ;
       }
@@ -360,12 +352,12 @@ CurveBezier::GetPointD1D2( double dU, Point3d& ptPos, Vector3d& vtDer1, Vector3d
 
      // calcolo dei polinomi di Bernstein di grado opportuno
       dBern[0] = 1 ;
-      for ( i = 1 ; i <= m_nDeg - 2 ; i ++)
+      for ( i = 1 ; i <= m_nDeg - 2 ; ++ i)
          IncreaseBernsteinOneDegree( dU, i, dBern) ;
 
      // calcolo della derivata seconda
       vtDer2.Set( 0, 0, 0) ;
-      for ( i = 0 ; i <= m_nDeg - 2 ; i ++) {
+      for ( i = 0 ; i <= m_nDeg - 2 ; ++ i) {
          vtDer2 = vtDer2 + dBern[i] * ( m_aPtCtrl[i+2] + m_aPtCtrl[i] - 2 * m_aPtCtrl[i+1]) ;
       }
       vtDer2 = m_nDeg * ( m_nDeg - 1) * vtDer2 ;
@@ -375,7 +367,7 @@ CurveBezier::GetPointD1D2( double dU, Point3d& ptPos, Vector3d& vtDer1, Vector3d
 
      // calcolo della derivata prima
       vtDer1.Set( 0, 0, 0) ;
-      for ( i = 0 ; i <= m_nDeg - 1 ; i ++) {
+      for ( i = 0 ; i <= m_nDeg - 1 ; ++ i) {
          vtDer1 = vtDer1 + dBern[i] * ( m_aPtCtrl[i+1] - m_aPtCtrl[i]) ;
       }
       vtDer1 = m_nDeg * vtDer1 ;
@@ -385,7 +377,7 @@ CurveBezier::GetPointD1D2( double dU, Point3d& ptPos, Vector3d& vtDer1, Vector3d
 
      // calcolo del punto
       ptPos.Set( 0, 0, 0) ;
-      for ( i = 0 ; i <= m_nDeg ; i ++)
+      for ( i = 0 ; i <= m_nDeg ; ++ i)
          ptPos = ptPos + dBern[i] * m_aPtCtrl[i] ;
    }
 
@@ -399,17 +391,17 @@ CurveBezier::GetPointD1D2( double dU, Point3d& ptPos, Vector3d& vtDer1, Vector3d
       Vector3d vtPos ;
 
      // porto i punti in forma omogenea moltiplicandoli per i pesi
-      for ( i = 0 ; i <= m_nDeg ; i ++)
+      for ( i = 0 ; i <= m_nDeg ; ++ i)
          aPtWCtrl[i] = m_aWeCtrl[i] * m_aPtCtrl[i] ;
 
      // calcolo dei polinomi di Bernstein di grado opportuno
       dBern[0] = 1 ;
-      for ( i = 1 ; i <= m_nDeg - 2 ; i ++)
+      for ( i = 1 ; i <= m_nDeg - 2 ; ++ i)
          IncreaseBernsteinOneDegree( dU, i, dBern) ;
 
      // calcolo della derivata seconda
       vtDer2.Set( 0, 0, 0) ; dW2 = 0 ;
-      for ( i = 0 ; i <= m_nDeg - 2 ; i ++) {
+      for ( i = 0 ; i <= m_nDeg - 2 ; ++ i) {
          vtDer2 = vtDer2 + dBern[i] * ( aPtWCtrl[i+2] + aPtWCtrl[i] - 2 * aPtWCtrl[i+1]) ;
          dW2 = dW2 + dBern[i] * ( m_aWeCtrl[i+2] + m_aWeCtrl[i] - 2 * m_aWeCtrl[i+1]) ;
       }
@@ -421,7 +413,7 @@ CurveBezier::GetPointD1D2( double dU, Point3d& ptPos, Vector3d& vtDer1, Vector3d
 
      // calcolo della derivata prima
       vtDer1.Set( 0, 0, 0) ; dW1 = 0 ;
-      for ( i = 0 ; i <= m_nDeg - 1 ; i ++) {
+      for ( i = 0 ; i <= m_nDeg - 1 ; ++ i) {
          vtDer1 = vtDer1 + dBern[i] * ( aPtWCtrl[i+1] - aPtWCtrl[i]) ;
          dW1 = dW1 + dBern[i] * ( m_aWeCtrl[i+1] - m_aWeCtrl[i]) ;
       }
@@ -433,7 +425,7 @@ CurveBezier::GetPointD1D2( double dU, Point3d& ptPos, Vector3d& vtDer1, Vector3d
 
      // calcolo del punto
       ptPos.Set( 0, 0, 0) ; dW = 0 ;
-      for ( i = 0 ; i <= m_nDeg ; i ++) {
+      for ( i = 0 ; i <= m_nDeg ; ++ i) {
          ptPos = ptPos + dBern[i] * aPtWCtrl[i] ;
          dW = dW + dBern[i] * m_aWeCtrl[i] ;
       }
@@ -461,7 +453,7 @@ CurveBezier::IncreaseBernsteinOneDegree( double dU, int nDeg, double dBern[]) co
 
    dU1 = 1 - dU ;
    dTot = 0 ;
-   for ( j = 0 ; j < nDeg ; j ++) {
+   for ( j = 0 ; j < nDeg ; ++ j) {
       dTmp = dBern[j] ;
       dBern[j] = dTot + dU1 * dTmp ;
       dTot = dU * dTmp ;
@@ -487,7 +479,7 @@ CurveBezier::GetLength( double& dLen) const
 
   // approssimo la curva con un numero fisso di segmenti    !!! DA MIGLIORARE !!!
    dLen = 0 ;
-   for ( i = 0 ; i <= NUM_SEG ; i ++ ) {
+   for ( i = 0 ; i <= NUM_SEG ; ++ i) {
      // ricavo il punto
       dU = i / (double) NUM_SEG ;
       GetPoint( dU, ptFin) ;
@@ -516,7 +508,7 @@ CurveBezier::Reverse( void)
 
   // inverto i punti di controllo
    nMid = ( m_nDeg + 1) / 2 ;
-   for ( i = 0 ; i < nMid ; i ++) {
+   for ( i = 0 ; i < nMid ; ++ i) {
       ptTemp = m_aPtCtrl[i] ;
       m_aPtCtrl[i] = m_aPtCtrl[m_nDeg-i] ;
       m_aPtCtrl[m_nDeg-i] = ptTemp ;
@@ -537,7 +529,7 @@ CurveBezier::Translate( const Vector3d& vtMove)
       return false ;
 
   // traslo i punti di controllo
-   for ( i = 0 ; i <= m_nDeg ; i ++)
+   for ( i = 0 ; i <= m_nDeg ; ++ i)
       m_aPtCtrl[i].Translate( vtMove) ;
 
    return true ;
@@ -559,7 +551,7 @@ CurveBezier::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
       return false ;
 
   // ruoto i punti di controllo
-   for ( i = 0 ; i <= m_nDeg ; i ++)
+   for ( i = 0 ; i <= m_nDeg ; ++ i)
       m_aPtCtrl[i].Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
 
    return true ;
@@ -581,7 +573,7 @@ CurveBezier::Scale( const Point3d& ptCen, double dCoeffX, double dCoeffY, double
       return false ;
 
   // scalo i punti di controllo
-   for ( i = 0 ; i <= m_nDeg ; i ++)
+   for ( i = 0 ; i <= m_nDeg ; ++ i)
       m_aPtCtrl[i].Scale( ptCen, dCoeffX, dCoeffY, dCoeffZ) ;
 
    return true ;
@@ -603,7 +595,7 @@ CurveBezier::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
       return false ;
 
   // specchio i punti di controllo
-   for ( i = 0 ; i <= m_nDeg ; i ++)
+   for ( i = 0 ; i <= m_nDeg ; ++ i)
       m_aPtCtrl[i].Mirror( ptOn, vtNorm) ;
 
    return true ;
@@ -625,7 +617,7 @@ CurveBezier::ToGlob( const Frame3d& frRef)
       return false ;
 
   // trasformo i punti di controllo
-   for ( i = 0 ; i <= m_nDeg ; i ++)
+   for ( i = 0 ; i <= m_nDeg ; ++ i)
       m_aPtCtrl[i].ToGlob( frRef) ;
 
    return true ;
@@ -647,7 +639,7 @@ CurveBezier::ToLoc( const Frame3d& frRef)
       return false ;
 
   // trasformo i punti di controllo
-   for ( i = 0 ; i <= m_nDeg ; i ++)
+   for ( i = 0 ; i <= m_nDeg ; ++ i)
       m_aPtCtrl[i].ToLoc( frRef) ;
 
    return true ;
diff --git a/CurveBezier.h b/CurveBezier.h
index 12c9f24..a3d23a3 100644
--- a/CurveBezier.h
+++ b/CurveBezier.h
@@ -68,7 +68,7 @@ class CurveBezier : public ICurveBezier
       CurveBezier( void) ;
       inline const CurveBezier& operator =( const CurveBezier& cbSrc)
                             { if ( &cbSrc != this  &&  Init( cbSrc.m_nDeg, cbSrc.m_bRat)) {
-                                 for ( int i = 0 ; i <= m_nDeg ; i ++ ) {
+                                 for ( int i = 0 ; i <= m_nDeg ; ++ i) {
                                     m_aPtCtrl[i] = cbSrc.m_aPtCtrl[i] ;
                                     if ( cbSrc.m_bRat)
                                        m_aWeCtrl[i] = cbSrc.m_aWeCtrl[i] ;
diff --git a/CurveComposite.cpp b/CurveComposite.cpp
index e331db0..59e1b28 100644
--- a/CurveComposite.cpp
+++ b/CurveComposite.cpp
@@ -45,7 +45,7 @@ CurveComposite::Clear( void)
 
 
   // ciclo di pulizia
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       delete (*Iter) ;
 
    m_CrvSmplS.clear() ;
@@ -221,7 +221,7 @@ CurveComposite::Load( CScan& TheScanner)
    if ( ! FromString( vsParams[0], nCounter))
       return false ;
   // leggo le curve componenti
-   for ( i = 0 ; i < nCounter ; i ++) {
+   for ( i = 0 ; i < nCounter ; ++ i) {
      // recupero la prossima linea (con il tipo di oggetto)
       if ( ! TheScanner.GetLine( sLine))
          return false ;
@@ -260,14 +260,14 @@ CurveComposite::Validate( void)
       PCRVSMPL_LIST::const_iterator Iter ;
      // ciclo su tutte le curve
       nCount = 0 ;
-      for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++) {
+      for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter) {
         // verifico validitā della curva e sua semplicitā
          if ( ! (*Iter)->IsValid()  ||  (*Iter)->GetType() == CRV_COMPO) {
             m_nStatus = ERR ;
             return false ;
          }
         // incremento contatore
-         nCount ++ ;
+         ++ nCount ;
         // verifico continuitā con la precedente (se non č la prima)
          if ( nCount > 1) {
             (*Iter)->GetStartPoint( ptStart) ;
@@ -347,7 +347,7 @@ CurveComposite::GetPointD1D2( double dU, Point3d& ptPos, Vector3d& vtDer1, Vecto
       dU = m_nCounter ;
 
   // determino la curva di appartenenza e faccio eseguire il calcolo
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++) {
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter) {
       if ( dU <= 1)
          return (*Iter)->GetPointD1D2( dU, ptPos, vtDer1, vtDer2) ;
       else
@@ -367,7 +367,7 @@ CurveComposite::GetLength( double& dLen) const
 
   // ciclo di calcolo
    dLen = 0 ;
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++) {
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter) {
       if ( (*Iter)->GetLength( dLenCrvSmpl))
          dLen += dLenCrvSmpl ;
       else
@@ -385,7 +385,7 @@ CurveComposite::Reverse( void)
 
 
   // inverto le singole curve
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       (*Iter)->Reverse() ;
 
   // inverto l'ordine della lista
@@ -405,7 +405,7 @@ CurveComposite::Translate( const Vector3d& vtMove)
 
 
   // traslo le singole curve
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       (*Iter)->Translate( vtMove) ;
 
   // traslo i punti estremi
@@ -427,7 +427,7 @@ CurveComposite::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAn
       return false ;
 
   // ruoto le singole curve
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       (*Iter)->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
 
   // ruoto i punti estremi
@@ -453,7 +453,7 @@ CurveComposite::Scale( const Point3d& ptCen, double dCoeffX, double dCoeffY, dou
       return false ;
 
   // scalo le singole curve
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       (*Iter)->Scale( ptCen, dCoeffX, dCoeffX, dCoeffX) ;
 
   // scalo i punti estremi
@@ -475,7 +475,7 @@ CurveComposite::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
       return false ;
 
   // specchio le singole curve
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       (*Iter)->Mirror( ptOn, vtNorm) ;
 
   // specchio i punti estremi
@@ -497,7 +497,7 @@ CurveComposite::ToGlob( const Frame3d& frRef)
       return false ;
 
   // trasformo le singole curve
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       (*Iter)->ToGlob( frRef) ;
 
   // trasformo i punti estremi
@@ -519,7 +519,7 @@ CurveComposite::ToLoc( const Frame3d& frRef)
       return false ;
 
   // trasformo le singole curve
-   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; Iter++)
+   for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter)
       (*Iter)->ToLoc( frRef) ;
 
   // trasformo i punti estremi
diff --git a/CurveComposite.h b/CurveComposite.h
index ed6595b..65f33e6 100644
--- a/CurveComposite.h
+++ b/CurveComposite.h
@@ -70,7 +70,7 @@ class CurveComposite : public ICurveComposite
                             { if ( &ccSrc != this) {
                                  Clear() ;
                                  PCRVSMPL_LIST::const_iterator Iter ;
-                                 for ( Iter = ccSrc.m_CrvSmplS.begin() ; Iter != ccSrc.m_CrvSmplS.end() ; Iter++)
+                                 for ( Iter = ccSrc.m_CrvSmplS.begin() ; Iter != ccSrc.m_CrvSmplS.end() ; ++Iter)
                                     AddCurve( **Iter) ;
                               }
                               return *this ; }
diff --git a/CurveLine.cpp b/CurveLine.cpp
index f10ab11..5eadd1a 100644
--- a/CurveLine.cpp
+++ b/CurveLine.cpp
@@ -74,7 +74,7 @@ CurveLine::Save( ostream& osOut) const
 {
   // parametri : punti iniziale e finale
    osOut << ToString( m_PtStart) ;
-   osOut << "," << ToString( m_PtEnd) << endl ;
+   osOut << ";" << ToString( m_PtEnd) << ";" << endl ;
 
    return true ;
 }
@@ -91,19 +91,15 @@ CurveLine::Load( CScan& TheScanner)
    if ( ! TheScanner.GetLine( sLine))
       return false ;
   // la divido in parametri
-   Tokenize( sLine, ",", vsParams) ;
-  // 6 parametri : punto iniziale e punto finale
-   if ( vsParams.size() != 6)
+   Tokenize( sLine, ";", vsParams) ;
+  // 2 parametri : punto iniziale e punto finale
+   if ( vsParams.size() != 2)
       return false ;
   // recupero il punto iniziale
-   if ( ! FromString( vsParams[0], m_PtStart.x)  ||
-        ! FromString( vsParams[1], m_PtStart.y)  ||
-        ! FromString( vsParams[2], m_PtStart.z))
+   if ( ! FromString( vsParams[0], m_PtStart))
       return false ;
   // recupero il punto finale
-   if ( ! FromString( vsParams[3], m_PtEnd.x)  ||
-        ! FromString( vsParams[4], m_PtEnd.y)  ||
-        ! FromString( vsParams[5], m_PtEnd.z))
+   if ( ! FromString( vsParams[1], m_PtEnd))
       return false ;
   // eseguo validazione
    return Validate() ;
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index bba1c2b..a62766f 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/EgtGeomKernel.vcxproj b/EgtGeomKernel.vcxproj
index 1ac6012..3c7c20b 100644
--- a/EgtGeomKernel.vcxproj
+++ b/EgtGeomKernel.vcxproj
@@ -126,6 +126,8 @@ copy $(TargetPath) \EgtProg\Dll</Command>
     <ClCompile Include="CurveLine.cpp" />
     <ClCompile Include="EGkDllMain.cpp" />
     <ClCompile Include="Frame3d.cpp" />
+    <ClCompile Include="GdbGroup.cpp" />
+    <ClCompile Include="GdbNode.cpp" />
     <ClCompile Include="GdbObj.cpp" />
     <ClCompile Include="GeomDB.cpp" />
     <ClCompile Include="GeoObj.cpp" />
@@ -164,7 +166,9 @@ copy $(TargetPath) \EgtProg\Dll</Command>
     <ClInclude Include="CurveBezier.h" />
     <ClInclude Include="CurveComposite.h" />
     <ClInclude Include="CurveLine.h" />
+    <ClInclude Include="GdbGroup.h" />
     <ClInclude Include="GdbObj.h" />
+    <ClInclude Include="GdbNode.h" />
     <ClInclude Include="GeomDB.h" />
     <ClInclude Include="GeoObjFactory.h" />
     <ClInclude Include="GeoPoint3d.h" />
diff --git a/EgtGeomKernel.vcxproj.filters b/EgtGeomKernel.vcxproj.filters
index 02c24c9..aeefdf3 100644
--- a/EgtGeomKernel.vcxproj.filters
+++ b/EgtGeomKernel.vcxproj.filters
@@ -81,6 +81,12 @@
     <ClCompile Include="GdbExecutor.cpp">
       <Filter>File di origine\Script</Filter>
     </ClCompile>
+    <ClCompile Include="GdbNode.cpp">
+      <Filter>File di origine\Gdb</Filter>
+    </ClCompile>
+    <ClCompile Include="GdbGroup.cpp">
+      <Filter>File di origine\Gdb</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="stdafx.h">
@@ -179,6 +185,12 @@
     <ClInclude Include="..\Include\EgtReleasePointer.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
+    <ClInclude Include="GdbNode.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
+    <ClInclude Include="GdbGroup.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGeomKernel.rc">
diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index e4cde2e..3861143 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -102,7 +102,7 @@ GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR&
   // output di debug
    cout << "Cmd = [" << sCmd1 << "/" << sCmd2 << "]" ;
    cout << " Par = [" ;
-   for ( theConstIter = vsParams.begin() ; theConstIter != vsParams.end() ; theConstIter ++) {
+   for ( theConstIter = vsParams.begin() ; theConstIter != vsParams.end() ; ++theConstIter) {
       if ( theConstIter != vsParams.begin())
          cout << "/" ; 
       cout << *theConstIter ;
@@ -112,6 +112,8 @@ GdbExecutor::Execute( const string& sCmd1, const string& sCmd2, const STRVECTOR&
   // 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")
@@ -166,6 +168,22 @@ GdbExecutor::ExecuteAlias( const string& sCmd2, const STRVECTOR& vsParams)
    return false ;
 }
 
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::ExecuteGroup( const string& sCmd2, const STRVECTOR& vsParams) 
+{
+  // analisi ed esecuzione dei comandi
+   if ( sCmd2 == "MAKE"  ||  sCmd2 == "") {
+     // 2 parametri : Id e Id del padre
+      if ( vsParams.size() != 2)
+         return false ;
+     // creo il gruppo
+      return m_pGDB->AddGroup( GetIdParam( vsParams[0]), GetIdParam( vsParams[1])) ;
+   }
+
+   return false ;
+}
+
 //----------------------------------------------------------------------------
 bool
 GdbExecutor::ExecutePoint( const string& sCmd2, const STRVECTOR& vsParams) 
@@ -173,20 +191,20 @@ GdbExecutor::ExecutePoint( const string& sCmd2, const STRVECTOR& vsParams)
   // analisi ed esecuzione dei comandi
    if ( sCmd2 == "MAKE"  ||  sCmd2 == "") {
       Point3d Pnt ;
-     // 4 parametri : un nome e 3 coordinate
-      if ( vsParams.size() != 4)
+     // 5 parametri : Id, IdParent e 3 coordinate
+      if ( vsParams.size() != 5)
          return false ;
      // recupero le tre coordinate
-      if ( ! FromString( vsParams[1], Pnt.x)  ||
-           ! FromString( vsParams[2], Pnt.y)  ||
-           ! FromString( vsParams[3], Pnt.z))
+      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 m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), pGPnt) ;
+      return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), GetIdParam( vsParams[1]),pGPnt) ;
    }
 
    return false ;
@@ -199,20 +217,20 @@ GdbExecutor::ExecuteVector( const string& sCmd2, const STRVECTOR& vsParams)
   // analisi ed esecuzione dei comandi
    if ( sCmd2 == "MAKE"  ||  sCmd2 == "") {
       Vector3d Vect ;
-     // 4 parametri
-      if ( vsParams.size() != 4)
+     // 5 parametri
+      if ( vsParams.size() != 5)
          return false ;
      // recupero i tre componenti
-      if ( ! FromString( vsParams[1], Vect.x)  ||
-           ! FromString( vsParams[2], Vect.y)  ||
-           ! FromString( vsParams[3], Vect.z))
+      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 m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), pGVect) ;
+      return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), GetIdParam( vsParams[1]), pGVect) ;
    }
 
    return false ;
@@ -226,18 +244,18 @@ GdbExecutor::ExecuteCurveLine( const string& sCmd2, const STRVECTOR& vsParams)
    if ( sCmd2 == "MAKE"  ||  sCmd2 == "") {
       Point3d ptStart ;
       Point3d ptEnd ;
-     // 3 parametri
-      if ( vsParams.size() != 3)
+     // 4 parametri
+      if ( vsParams.size() != 4)
          return false ;
      // recupero e setto punti iniziale e finale
-      if ( ! GetPointParam( vsParams[1], ptStart)  ||
-           ! GetPointParam( vsParams[2], ptEnd))
+      if ( ! GetPointParam( vsParams[2], ptStart)  ||
+           ! GetPointParam( vsParams[3], ptEnd))
          return false ;
      // creo la linea
       ReleasePtr<ICurveLine> pCrvLine( CreateCurveLine()) ;
       if ( ! IsValid( pCrvLine)  ||  ! pCrvLine->Set( ptStart, ptEnd))
          return false ;
-      return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), Release( pCrvLine)) ;
+      return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), GetIdParam( vsParams[1]), Release( pCrvLine)) ;
    }
 
    return false ;
@@ -260,26 +278,26 @@ GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
       Vector3d  vtS ;
       double    dAngCenDeg ;
       double    dDeltaZ ;
-     // 7 parametri
-      if ( vsParams.size() != 7)
+     // 8 parametri
+      if ( vsParams.size() != 8)
          return false ;
      // centro
-      if ( ! GetPointParam( vsParams[1], ptCen))
+      if ( ! GetPointParam( vsParams[2], ptCen))
          return false ;
      // versore ortogonale al piano della circonferenza
-      if ( ! GetVectorParam( vsParams[2], vtN))
+      if ( ! GetVectorParam( vsParams[3], vtN))
          return false ;
      // raggio
-      if ( ! FromString( vsParams[3], dRad))
+      if ( ! FromString( vsParams[4], dRad))
          return false ;
      // versore iniziale
-      if ( ! GetVectorParam( vsParams[4], vtS))
+      if ( ! GetVectorParam( vsParams[5], vtS))
          return false ;
      // angolo al centro
-      if ( ! FromString( vsParams[5], dAngCenDeg))
+      if ( ! FromString( vsParams[6], dAngCenDeg))
          return false ;
      // deltaZ
-      if ( ! FromString( vsParams[6], dDeltaZ))
+      if ( ! FromString( vsParams[7], dDeltaZ))
          return false ;
      // setto l'arco
       if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
@@ -292,23 +310,23 @@ GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
       double    dAngIniDeg ;
       double    dAngCenDeg ;
       double    dDeltaZ ;
-     // 6 parametri
-      if ( vsParams.size() != 6)
+     // 7 parametri
+      if ( vsParams.size() != 7)
          return false ;
      // centro
-      if ( ! GetPointParam( vsParams[1], ptCen))
+      if ( ! GetPointParam( vsParams[2], ptCen))
          return false ;
      // raggio
-      if ( ! FromString( vsParams[2], dRad))
+      if ( ! FromString( vsParams[3], dRad))
          return false ;
      // angolo iniziale
-      if ( ! FromString( vsParams[3], dAngIniDeg))
+      if ( ! FromString( vsParams[4], dAngIniDeg))
          return false ;
      // angolo al centro
-      if ( ! FromString( vsParams[4], dAngCenDeg))
+      if ( ! FromString( vsParams[5], dAngCenDeg))
          return false ;
      // deltaZ
-      if ( ! FromString( vsParams[5], dDeltaZ))
+      if ( ! FromString( vsParams[6], dDeltaZ))
          return false ;
      // setto l'arco
       if ( ! pCrvArc->Set( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
@@ -319,7 +337,7 @@ GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
       return false ;
 
   // inserisco l'arco nel DB
-   return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), Release( pCrvArc)) ;
+   return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), GetIdParam( vsParams[1]), Release( pCrvArc)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -336,18 +354,18 @@ GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
       int     i ;
       int     nDeg ;
       Point3d ptP ;
-     // almeno 2 parametri
-      if ( vsParams.size() < 2)
+     // almeno 3 parametri
+      if ( vsParams.size() < 3)
          return false ;
      // recupero il grado
-      if ( ! FromString( vsParams[1], nDeg))
+      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+2], ptP)  ||
+      for ( i = 0 ; i <= nDeg ; ++ i) {
+         if ( ! GetPointParam( vsParams[i+3], ptP)  ||
               ! pCrvBez->SetControlPoint( i, ptP))
             return false ;
       }
@@ -358,18 +376,18 @@ GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
       int     nDeg ;
       double  dW ;
       Point3d ptP ;
-     // almeno 2 parametri
-      if ( vsParams.size() < 2)
+     // almeno 3 parametri
+      if ( vsParams.size() < 3)
          return false ;
      // recupero il grado
-      if ( ! FromString( vsParams[1], nDeg))
+      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 ( ! GetPointWeParam( vsParams[i+2], ptP, dW)  ||
+      for ( i = 0 ; i <= nDeg ; ++ i) {
+         if ( ! GetPointWeParam( vsParams[i+3], ptP, dW)  ||
               ! pCrvBez->SetControlPoint( i, ptP, dW))
             return false ;
       }
@@ -379,7 +397,7 @@ GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
       return false ;
 
   // inserisco la curva di Bezier nel DB
-   return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), Release( pCrvBez)) ;
+   return m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), GetIdParam( vsParams[1]), Release( pCrvBez)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -395,17 +413,17 @@ GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams)
       ReleasePtr<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
       if ( ! IsValid( pCrvCompo))
          return false ;
-     // 2 o 3 parametri
+     // 3 o 4 parametri
       switch ( vsParams.size()) {
-      case 2 : bErase = false ; break ;
-      case 3 : bErase = ( vsParams[2] != "0") ; break ;
+      case 3 : bErase = false ; break ;
+      case 4 : bErase = ( vsParams[3] != "0") ; break ;
       default : return false ; break ;
       }
      // recupero lista nomi
-      if ( ! GetNamesParam( vsParams[1], vsNames))
+      if ( ! GetNamesParam( vsParams[2], vsNames))
          return false ;
      // esecuzione
-      for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+      for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
         // recupero la curva
          pCrv = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *Iter))) ; 
          if ( pCrv == nullptr)
@@ -415,10 +433,10 @@ GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams)
             return false ;
       }
      // inserisco la curva composita nel DB
-      if ( m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), Release( pCrvCompo))) {
+      if ( m_pGDB->AddGeoObj( GetIdParam( vsParams[0]), GetIdParam( vsParams[1]), Release( pCrvCompo))) {
         // se richiesto, cancello le curve originali
          if ( bErase) {
-            for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+            for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
                if ( ! m_pGDB->Erase( GetIdParam(*Iter)))
                   return false ;
             }
@@ -461,7 +479,7 @@ GdbExecutor::GetNamesParam( const std::string& sParam, STRVECTOR& vsNames)
 
   // divido in parti
    Tokenize( sParam, ",", vsNames) ;
-   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++)
+   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter)
       Trim( (*Iter), " \t\r\n()") ;
 
    return true ;
@@ -477,7 +495,7 @@ GdbExecutor::GetVectorParam( const std::string& sParam, Vector3d& vtV)
       STRVECTOR::iterator Iter ;
      // divido in parti
       Tokenize( sParam, ",", vsParams) ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; 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)
@@ -506,7 +524,7 @@ GdbExecutor::GetPointParam( const std::string& sParam, Point3d& ptP)
       STRVECTOR::iterator Iter ;
      // divido in parti
       Tokenize( sParam, ",", vsParams) ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; 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)
@@ -539,7 +557,7 @@ GdbExecutor::GetPointWeParam( const std::string& sParam, Point3d& ptP, double& d
 
   // divido in parti
    Tokenize( sParam, ",", vsParams) ;
-   for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; Iter++)
+   for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
       Trim( (*Iter), " \t\r\n()") ;
 
   // se 4 parti, sono 3 coordinate e un peso
@@ -568,11 +586,11 @@ GdbExecutor::GetPointWeParam( const std::string& sParam, Point3d& ptP, double& d
 bool
 GdbExecutor::ExecuteCopy( const STRVECTOR& vsParams) 
 {
-  // 2 parametri ( NomeSou, NomeDest)
-   if ( vsParams.size() != 2)
+  // 3 parametri ( IdSou, IdDest, ParentIdDest)
+   if ( vsParams.size() != 3)
       return false ;
   // esecuzione copia
-   return m_pGDB->Copy( GetIdParam( vsParams[0]), GetIdParam( vsParams[1])) ;
+   return m_pGDB->Copy( GetIdParam( vsParams[0]), GetIdParam( vsParams[1]), GetIdParam( vsParams[2])) ;
 }
 
 //----------------------------------------------------------------------------
@@ -590,7 +608,7 @@ GdbExecutor::ExecuteErase( const STRVECTOR& vsParams)
    if ( ! GetNamesParam( vsParams[0], vsNames))
       return false ;
   // esecuzione cancellazioni
-   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
       if ( ! m_pGDB->Erase( GetIdParam( *Iter)))
          return false ;
    }
@@ -617,7 +635,7 @@ GdbExecutor::ExecuteTranslate( const STRVECTOR& vsParams)
    if ( ! GetVectorParam( vsParams[1], vtVN))
       return false ;
   // esecuzione traslazioni
-   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
       if ( ! m_pGDB->Translate( GetIdParam( *Iter), vtVN))
          return false ;
    }
@@ -652,7 +670,7 @@ GdbExecutor::ExecuteRotate( const STRVECTOR& vsParams)
    if ( ! FromString( vsParams[3], dAngDeg))
       return false ;
   // esecuzione rotazioni
-   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
       if ( ! m_pGDB->Rotate( GetIdParam( *Iter), ptPC, vtVN, dAngDeg))
          return false ;
    }
@@ -687,7 +705,7 @@ GdbExecutor::ExecuteScale( const STRVECTOR& vsParams)
         ! FromString( vsParams[4], dCoeffZ))
       return false ;
   // esecuzione scalature
-   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
       if ( ! m_pGDB->Scale( GetIdParam( *Iter), ptPC, dCoeffX, dCoeffY, dCoeffZ))
          return false ;
    }
@@ -718,7 +736,7 @@ GdbExecutor::ExecuteMirror( const STRVECTOR& vsParams)
    if ( ! GetVectorParam( vsParams[2], vtVN))
       return false ;
   // esecuzione specchiature
-   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
       if ( ! m_pGDB->Mirror( GetIdParam( *Iter), ptPC, vtVN))
          return false ;
    }
@@ -811,7 +829,7 @@ GdbExecutor::ExecuteOutScl( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetNamesParam( vsParams[0], vsNames))
          return false ;
      // esecuzione
-      for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; Iter++) {
+      for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
         // recupero l'oggetto ed eseguo l'output
          nId = GetIdParam( *Iter) ;
          switch ( m_pGDB->GetObjType( nId)) {
diff --git a/GdbExecutor.h b/GdbExecutor.h
index 28b8cfb..a9c8490 100644
--- a/GdbExecutor.h
+++ b/GdbExecutor.h
@@ -37,6 +37,7 @@ class GdbExecutor : public IGdbExecutor
       bool GetPointParam( const std::string& sParam, Point3d& ptP) ;
       bool GetPointWeParam( const std::string& sParam, Point3d& ptP, double& dW) ;
       bool ExecuteAlias( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool ExecuteGroup( const std::string& sCmd2, const STRVECTOR& vsParams) ;
       bool ExecutePoint( const std::string& sCmd2, const STRVECTOR& vsParams) ;
       bool ExecuteVector( const std::string& sCmd2, const STRVECTOR& vsParams) ;
       bool ExecuteCurveLine( const std::string& sCmd2, const STRVECTOR& vsParams) ;
diff --git a/GdbGroup.cpp b/GdbGroup.cpp
new file mode 100644
index 0000000..cafeb17
--- /dev/null
+++ b/GdbGroup.cpp
@@ -0,0 +1,148 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2013
+//----------------------------------------------------------------------------
+// File : GdbGroup.cpp         Data : 28.11.13          Versione : 1.4a2
+// Contenuto : Implementazione della classe GdbGroup.
+//
+//
+//
+// Modifiche : 28.11.13 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "\EgtDev\Include\EGnStringUtils.h"
+#include "GdbGroup.h"
+
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+GdbGroup::GdbGroup( void)
+{
+   m_nNodeCount = 0 ;
+   m_pFirstNode = nullptr ;
+   m_pLastNode = nullptr ;
+}
+
+//----------------------------------------------------------------------------
+GdbGroup::~GdbGroup( void)
+{
+   Clear() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbGroup::Clear( void)
+{
+   GdbNode* pNode ;
+
+
+  // disalloco gli oggetti
+   pNode = GetFirstNode() ;
+   while ( pNode != nullptr) {
+     // lo rimuovo dalla lista
+      pNode->Remove() ;
+     // lo disalloco
+      delete pNode ;
+     // passo al nuovo primo
+      pNode = GetFirstNode() ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+GdbGroup*
+GdbGroup::Clone( int nId) const
+{
+   GdbGroup* pGdbGroup ;
+   const GdbNode* pNode ;
+   GdbNode* pNewNode ;
+
+
+  // alloco gruppo Gdb
+   pGdbGroup = new(nothrow) GdbGroup ;
+   if ( pGdbGroup == nullptr)
+      return nullptr ; 
+
+  // copio dati oggetto Gdb
+   pGdbGroup->m_nId = nId ;
+   // ...
+
+  // clono  i nodi figli
+   pNode = GetFirstNode() ;
+   while ( pNode != nullptr) {
+     // eseguo copia
+      pNewNode = pNode->Clone( ++ nId) ;
+      if ( pNewNode == nullptr) {
+         delete pGdbGroup ;
+         return nullptr ;
+      }
+     // lo inserisco nella lista dei figli
+      if ( ! pNewNode->AddTail( pGdbGroup)) {
+         delete pNewNode ;
+         delete pGdbGroup ;
+         return nullptr ;
+      }
+     // passo al prossimo nodo
+      pNode = pNode->GetNext() ;
+   }
+
+   return pGdbGroup ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbGroup::Save( std::ostream& osOut) const
+{
+   bool bOk = true ;
+
+  // tipo entitā
+   osOut << GetKey() << endl ;
+  // identificativi
+   osOut << m_nId << "@" << GetParentId() << endl ;
+  // altri parametri
+   // TODO ...
+
+  // lancio il salvataggio dei figli
+   const GdbNode* pGdbNode = GetFirstNode() ;
+   while ( pGdbNode != nullptr) {
+     // oggetto geometrico
+      if ( ! pGdbNode->Save( osOut))
+         bOk = false ;
+      pGdbNode = pGdbNode->GetNext() ;
+   }
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbGroup::Load( const string& sType, CScan& TheScanner, int& nParentId)
+{
+   string    sLine ;
+   STRVECTOR vsParams ;
+
+
+  // leggo la prossima linea
+   if ( ! TheScanner.GetLine( sLine))
+      return false ;
+  // la divido in parametri
+   Tokenize( sLine, "@", vsParams) ;
+  // 2 parametri : Id e ParentId
+   if ( vsParams.size() != 2)
+      return false ;
+  // assegno l'identificativo
+   if ( ! FromString( vsParams[0], m_nId))
+      return false ;
+  // assegno l'Id del padre
+   if ( ! FromString( vsParams[1], nParentId))
+      return false ;
+
+   return true ;
+}
+
+
diff --git a/GdbGroup.h b/GdbGroup.h
new file mode 100644
index 0000000..41068f7
--- /dev/null
+++ b/GdbGroup.h
@@ -0,0 +1,50 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2013
+//----------------------------------------------------------------------------
+// File : GdbGroup.h         Data : 28.11.13          Versione : 1.4a2
+// Contenuto : Dichiarazione della classe GdbGroup.
+//
+//
+//
+// Modifiche : 28.11.13 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include <string>
+#include "/EgtDev/Include/EGkGeoObj.h"
+#include "GdbNode.h"
+
+
+//----------------------------------------------------------------------------
+class GdbGroup : public GdbNode
+{
+   friend class GdbNode ;
+
+   public :
+      virtual ~GdbGroup( void) ;
+      virtual GdbGroup* Clone( int nId) const ;
+      virtual bool Save( std::ostream& osOut) const ;
+      virtual bool Load( const std::string& sType, CScan& TheScanner, int& nParentId) ;
+
+   public :
+      GdbGroup( void) ;
+      bool Clear( void) ;
+      void NodeCountInc( void) { ++ m_nNodeCount ; } 
+      void NodeCountDec( void) { -- m_nNodeCount ; }
+      int GetNodeCount( void) const { return m_nNodeCount ; } 
+      GdbNode* GetFirstNode( void) { return m_pFirstNode ; }
+      const GdbNode* GetFirstNode( void) const { return m_pFirstNode ; }
+      GdbNode* GetLastNode( void) { return m_pLastNode ; }
+      const GdbNode* GetLastNode( void) const { return m_pLastNode ; }
+
+   public :
+      static const std::string& GetKey( void) { static std::string s_sKey = "A_GRP" ; return s_sKey ; }
+
+   private :
+      int      m_nNodeCount ;
+      GdbNode* m_pFirstNode ;
+      GdbNode* m_pLastNode ;
+} ;
diff --git a/GdbNode.cpp b/GdbNode.cpp
new file mode 100644
index 0000000..5ab4a5b
--- /dev/null
+++ b/GdbNode.cpp
@@ -0,0 +1,162 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2013
+//----------------------------------------------------------------------------
+// File : GdbNode.cpp          Data : 28.11.13          Versione : 1.4a2
+// Contenuto : Implementazione della classe GdbNode.
+//
+//
+//
+// Modifiche : 28.11.13 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "GdbNode.h"
+#include "GdbGroup.h"
+
+//----------------------------------------------------------------------------
+GdbNode::GdbNode( void)
+{
+   m_nId = - 1 ;
+   m_pNext = nullptr ;
+   m_pPrev = nullptr ;
+   m_pParent = nullptr ;
+}
+
+//----------------------------------------------------------------------------
+int
+GdbNode::GetParentId( void) const
+{
+   if ( m_pParent != nullptr)
+      return m_pParent->m_nId ;
+   else
+      return 0 ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbNode::AddTail( GdbGroup* pParent)
+{
+  // se il padre non č definito, errore
+   if ( pParent == nullptr)
+      return false ;
+
+  // se non ci sono figli
+   if ( pParent->m_pLastNode == nullptr) {
+      pParent->m_pLastNode = this ;
+      pParent->m_pFirstNode = this ;
+      m_pParent = pParent ;
+      m_pNext = nullptr ;
+      m_pPrev = nullptr ;
+      m_pParent->NodeCountInc() ;
+      return true ;
+   }
+
+  // caso standard 
+   return InsertAfter( pParent->m_pLastNode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbNode::AddHead( GdbGroup* pParent)
+{
+  // se il padre non č definito, errore
+   if ( pParent == nullptr)
+      return false ;
+
+   // se non ci sono figli
+   if ( pParent->m_pFirstNode == nullptr) {
+      pParent->m_pFirstNode = this ;
+      pParent->m_pLastNode = this ;
+      m_pParent = pParent ;
+      m_pNext = nullptr ;
+      m_pPrev = nullptr ;
+      m_pParent->NodeCountInc() ;
+      return true ;
+   }
+
+  // caso standard 
+   return InsertBefore( pParent->m_pFirstNode) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbNode::InsertAfter( GdbNode* pRef)
+{
+  // se riferimento non definito, errore
+   if ( pRef == nullptr)
+      return false ;
+
+  // sistemazione puntatori di elemento inserito
+   m_pNext = pRef->m_pNext ;
+   m_pPrev = pRef ;
+   m_pParent = pRef->m_pParent ;
+  // sistemazione puntatori di elemento di riferimento
+   pRef->m_pNext = this ;
+  // sistemazione puntatori di eventuale elemento successivo
+   if ( m_pNext != nullptr)
+      m_pNext->m_pPrev = this ;
+  // sistemazione dell'eventuale padre
+   if ( m_pParent != nullptr) {
+     // se nuovo ultimo nodo
+      if ( m_pParent->m_pLastNode == pRef)
+         m_pParent->m_pLastNode = this ;
+      m_pParent->NodeCountInc() ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbNode::InsertBefore( GdbNode* pRef)
+{
+  // se riferimento non definito, errore
+   if ( pRef == nullptr)
+      return false ;
+
+  // sistemazione puntatori di elemento inserito
+   m_pNext = pRef ;
+   m_pPrev = pRef->m_pPrev ;
+   m_pParent = pRef->m_pParent ;
+  // sistemazione puntatori di elemento corrente
+   pRef->m_pPrev = this ;
+  // sistemazione puntatori di eventuale elemento precedente
+   if ( m_pPrev != nullptr)
+      m_pPrev->m_pNext = this ;
+  // sistemazione dell'eventuale padre
+   if ( m_pParent != nullptr) {
+     //  se nuovo primo nodo
+      if ( m_pParent->m_pFirstNode == pRef)
+         m_pParent->m_pFirstNode = this ;
+      m_pParent->NodeCountInc() ;
+   }
+
+   return true ;
+}
+
+/*-------------------------------------------------------------------------*/
+bool
+GdbNode::Remove( void)
+{
+  // sistemazione dell'eventuale padre
+   if ( m_pParent != nullptr) {
+      if ( m_pParent->m_pFirstNode == this)
+         m_pParent->m_pFirstNode = m_pNext ;
+      if ( m_pParent->m_pLastNode == this)
+         m_pParent->m_pLastNode = m_pPrev ;
+      m_pParent->NodeCountDec() ;
+   }
+  // sistemazione di eventuale precedente
+   if ( m_pPrev != nullptr) 
+      m_pPrev->m_pNext = m_pNext ;
+  // sistemazione di eventuale successivo
+   if ( m_pNext != nullptr) 
+      m_pNext->m_pPrev = m_pPrev ;
+
+   return true ;
+}
+
+
diff --git a/GdbNode.h b/GdbNode.h
new file mode 100644
index 0000000..b8d4750
--- /dev/null
+++ b/GdbNode.h
@@ -0,0 +1,53 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2013
+//----------------------------------------------------------------------------
+// File : GdbNode.h          Data : 28.11.13          Versione : 1.4a2
+// Contenuto : Dichiarazione della classe GdbNode.
+//
+//
+//
+// Modifiche : 28.11.13 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include <string>
+#include "/EgtDev/Include/EGnScan.h"
+
+
+class GdbGroup ;
+
+//----------------------------------------------------------------------------
+class GdbNode
+{
+   public :
+      virtual ~GdbNode( void) {}
+      virtual GdbNode* Clone( int nId) const = 0 ;
+      virtual bool Save( std::ostream& osOut) const = 0 ;
+      virtual bool Load( const std::string& sType, CScan& TheScanner, int& nParentId) = 0 ;
+
+   public :
+      GdbNode( void) ;
+      GdbNode* GetNext( void) { return m_pNext ; }
+      const GdbNode* GetNext( void) const { return m_pNext ; }
+      GdbNode* GetPrev( void) { return m_pPrev ; }
+      const GdbNode* GetPrev( void) const { return m_pPrev ; }
+      GdbGroup* GetParent( void) { return m_pParent ; }
+      const GdbGroup* GetParent( void) const { return m_pParent ; }
+      int GetParentId( void) const ;
+      bool AddTail( GdbGroup* pParent) ;
+      bool AddHead( GdbGroup* pParent) ;
+      bool InsertAfter( GdbNode* pRef) ;
+      bool InsertBefore( GdbNode* pRef) ;
+      bool Remove( void) ;
+
+   public :
+      int       m_nId ;
+
+   private :
+      GdbNode*  m_pNext ;
+      GdbNode*  m_pPrev ;
+      GdbGroup* m_pParent ;
+} ;
diff --git a/GdbObj.cpp b/GdbObj.cpp
index c405a68..38943ad 100644
--- a/GdbObj.cpp
+++ b/GdbObj.cpp
@@ -36,18 +36,25 @@ GdbObj::~GdbObj( void)
 
 //----------------------------------------------------------------------------
 GdbObj*
-GdbObj::Clone( void) const
+GdbObj::Clone( int nId) const
 {
    GdbObj* pGdbObj ;
 
 
   // alloco oggetto Gdb
    pGdbObj = new(nothrow) GdbObj ;
-   if ( pGdbObj != nullptr) {
-     // copio dati oggetto Gdb
-      // ...
-     // copio oggetto Geo
-      pGdbObj->m_pGeoObj = m_pGeoObj->Clone() ;
+   if ( pGdbObj == nullptr)
+      return nullptr ;
+
+  // copio dati oggetto Gdb
+   pGdbObj->m_nId = nId ;
+   // ...
+
+  // copio oggetto Geo
+   pGdbObj->m_pGeoObj = m_pGeoObj->Clone() ;
+   if ( pGdbObj->m_pGeoObj == nullptr) {
+      delete pGdbObj ;
+      return nullptr ;
    }
 
    return pGdbObj ;
@@ -71,7 +78,7 @@ GdbObj::Save( std::ostream& osOut) const
   // tipo entitā
    osOut << m_pGeoObj->GetKey() << endl ;
   // nome
-   osOut << m_nId << endl ;
+   osOut << m_nId << "@" << GetParentId() << endl ;
   // parametri geometrici
    return m_pGeoObj->Save( osOut) ;
 
@@ -80,39 +87,33 @@ GdbObj::Save( std::ostream& osOut) const
 
 //----------------------------------------------------------------------------
 bool
-GdbObj::Load( CScan& TheScanner, string& sErrLine)
+GdbObj::Load( const std::string& sType, CScan& TheScanner, int& nParentId)
 {
    int       nType ;
    string    sLine ;
    STRVECTOR vsParams ;
 
 
-  // reset linea errata
-   sErrLine.clear() ;
-
-  // leggo la prossima linea : tipo di entitā
-   if ( ! TheScanner.GetLine( sLine))
-      return false ;
-
   // creo l'oggetto geometrico corrispondente
-   nType = GEOOBJ_KEYTOTYPE( sLine) ;
+   nType = GEOOBJ_KEYTOTYPE( sType) ;
    m_pGeoObj = GEOOBJ_CREATE( nType) ;
-   if ( m_pGeoObj == nullptr) {
-      sErrLine = sLine ;
+   if ( m_pGeoObj == nullptr)
       return false ;
-   }
 
   // leggo la prossima linea
    if ( ! TheScanner.GetLine( sLine))
       return false ;
   // la divido in parametri
-   Tokenize( sLine, ",", vsParams) ;
-  // 1 parametro : Id
-   if ( vsParams.size() != 1)
+   Tokenize( sLine, "@", vsParams) ;
+  // 2 parametri : Id e ParentId
+   if ( vsParams.size() != 2)
       return false ;
   // assegno l'identificativo
    if ( ! FromString( vsParams[0], m_nId))
       return false ;
+  // assegno l'Id del padre
+   if ( ! FromString( vsParams[1], nParentId))
+      return false ;
 
   // parametri geometrici
    return m_pGeoObj->Load( TheScanner) ;
diff --git a/GdbObj.h b/GdbObj.h
index eff8fd1..95866c5 100644
--- a/GdbObj.h
+++ b/GdbObj.h
@@ -15,40 +15,22 @@
 
 #include <string>
 #include "/EgtDev/Include/EGkGeoObj.h"
+#include "GdbNode.h"
 
 
 //----------------------------------------------------------------------------
-class GdbObj
+class GdbObj : public GdbNode
 {
    public :
-      GdbObj( void);
-      ~GdbObj( void) ;
-      GdbObj* Clone( void) const ;
-      GeoObjType GetType( void) const ;
-      bool Save( std::ostream& osOut) const ;
-      bool Load( CScan& TheScanner, std::string& sErrLine) ;
-      bool Translate( const Vector3d& vtMove)
-              { if ( m_pGeoObj == nullptr)
-                   return false ;
-                return m_pGeoObj->Translate( vtMove) ; }
-      bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
-              { if ( m_pGeoObj == nullptr)
-                   return false ;
-                return m_pGeoObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ; }
-      bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngRad)
-              { if ( m_pGeoObj == nullptr)
-                   return false ;
-                return m_pGeoObj->Rotate( ptAx, vtAx, dAngRad) ; }
-      bool Scale( const Point3d& ptCen, double dCoeffX, double dCoeffY, double dCoeffZ)
-              { if ( m_pGeoObj == nullptr)
-                   return false ;
-                return m_pGeoObj->Scale( ptCen, dCoeffX, dCoeffY, dCoeffZ) ; }
-      bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
-              { if ( m_pGeoObj == nullptr)
-                   return false ;
-                return m_pGeoObj->Mirror( ptOn, vtNorm) ; }
+      virtual ~GdbObj( void) ;
+      virtual GdbObj* Clone( int nId) const ;
+      virtual bool Save( std::ostream& osOut) const ;
+      virtual bool Load( const std::string& sType, CScan& TheScanner, int& nParentId) ;
+
+   public :
+      GdbObj( void);
+      GeoObjType GetType( void) const ;
 
    public :
-      int      m_nId ;
       IGeoObj* m_pGeoObj ;
 } ;
diff --git a/GeoPoint3d.cpp b/GeoPoint3d.cpp
index f1fa1ca..a4fd837 100644
--- a/GeoPoint3d.cpp
+++ b/GeoPoint3d.cpp
@@ -70,7 +70,7 @@ bool
 GeoPoint3d::Save( ostream& osOut) const
 {
   // parametri : punto
-   osOut << ToString( m_ptP) << endl ;
+   osOut << ToString( m_ptP) << ";" << endl ;
 
    return true ;
 }
@@ -79,22 +79,16 @@ GeoPoint3d::Save( ostream& osOut) const
 bool
 GeoPoint3d::Load( CScan& TheScanner)
 {
-   string    sLine ;
-   STRVECTOR vsParams ;
+   string sLine ;
 
 
   // leggo la prossima linea
    if ( ! TheScanner.GetLine( sLine))
       return false ;
-  // la divido in parametri
-   Tokenize( sLine, ",", vsParams) ;
-  // 3 parametri : le coordinate
-   if ( vsParams.size() != 3)
-      return false ;
-  // recupero le tre coordinate
-   if ( ! FromString( vsParams[0], m_ptP.x)  ||
-        ! FromString( vsParams[1], m_ptP.y)  ||
-        ! FromString( vsParams[2], m_ptP.z))
+  // 1 solo parametro : il punto
+   TrimRight( sLine, ";") ;
+  // recupero il punto
+   if ( ! FromString( sLine, m_ptP))
       return false ;
 
    return true ;
diff --git a/GeoVector3d.cpp b/GeoVector3d.cpp
index 279c972..70747f9 100644
--- a/GeoVector3d.cpp
+++ b/GeoVector3d.cpp
@@ -69,7 +69,7 @@ bool
 GeoVector3d::Save( ostream& osOut) const
 {
   // parametri : punto
-   osOut << ToString( m_vtV) << endl ;
+   osOut << ToString( m_vtV) << ";" << endl ;
 
    return true ;
 }
@@ -78,22 +78,16 @@ GeoVector3d::Save( ostream& osOut) const
 bool
 GeoVector3d::Load( CScan& TheScanner)
 {
-   string    sLine ;
-   STRVECTOR vsParams ;
+   string sLine ;
 
 
   // leggo la prossima linea
    if ( ! TheScanner.GetLine( sLine))
       return false ;
-  // la divido in parametri
-   Tokenize( sLine, ",", vsParams) ;
-  // 3 parametri : le coordinate
-   if ( vsParams.size() != 3)
-      return false ;
-  // recupero le tre coordinate
-   if ( ! FromString( vsParams[0], m_vtV.x)  ||
-        ! FromString( vsParams[1], m_vtV.y)  ||
-        ! FromString( vsParams[2], m_vtV.z))
+  // 1 solo parametro : il vettore
+   TrimRight( sLine, ";") ;
+  // recupero il vettore
+   if ( ! FromString( sLine, m_vtV))
       return false ;
 
    return true ;
diff --git a/GeomDB.cpp b/GeomDB.cpp
index 51d60f0..424f1fa 100644
--- a/GeomDB.cpp
+++ b/GeomDB.cpp
@@ -34,6 +34,7 @@ CreateGeomDB( void)
 //----------------------------------------------------------------------------
 GeomDB::GeomDB( void)
 {
+   m_GrpRadix.m_nId = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -56,16 +57,12 @@ GeomDB::Init( void)
 bool
 GeomDB::Clear( void)
 {
-   PGDBO_LIST::iterator Iter ;
-
-
-  // ciclo di pulizia
-   for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; Iter++)
-      delete (*Iter) ;
-
-   m_GeomDB.clear() ;
+  // elimino mappa degli identificatori
    m_GdbIdMap.clear() ;
 
+  // disalloco i gruppi e gli oggetti
+   m_GrpRadix.Clear() ;
+
    return true ;
 }
 
@@ -90,10 +87,10 @@ GeomDB::Load( std::ifstream& osIn)
       return false ;
    }
 
-  // ciclo di lettura degli oggetti
+  // ciclo di lettura dei nodi
    bOk = true ;
    do {
-      if ( ! LoadOneObject( TheScanner, bEnd)) {
+      if ( ! LoadOneNode( TheScanner, bEnd)) {
          bOk = false ;
          cout << "GeomDbLoad : Error on line " << TheScanner.GetCurrLineNbr() << endl ;
       }
@@ -129,65 +126,68 @@ GeomDB::LoadStart( CScan& TheScanner)
 
 //----------------------------------------------------------------------------
 bool
-GeomDB::LoadOneObject( CScan& TheScanner, bool& bEnd)
+GeomDB::LoadOneNode( CScan& TheScanner, bool& bEnd)
 {
-   string  sErrLine ;
-   GdbObj* pGdbObj ;
+   int      nParentId ;
+   string   sType ;
+   GdbNode* pGdbNode ;
 
 
   // in generale non č fine file
    bEnd = false ;
 
-  // creo l'oggetto GDB
-   pGdbObj = new GdbObj ;
-   if ( pGdbObj == nullptr)
+  // leggo la prossima linea : tipo di nodo
+   if ( ! TheScanner.GetLine( sType))
       return false ;
 
-  // se lettura dati va bene
-   if ( pGdbObj->Load( TheScanner, sErrLine)) {
-     // se inserimento nel DB va bene
-      if ( AddToGeomDB( pGdbObj))
-         return true ;
-     // altrimenti errore
-      else {
-         delete pGdbObj ;
-         return false ;
-      }
+  // se fine dati
+   if ( sType == "END") {
+      bEnd = true ;
+      return true ;
    }
+  // se gruppo
+   else if ( sType == GdbGroup::GetKey()) {
+      pGdbNode = new( nothrow) GdbGroup ;
+   }
+  // se copia  TODO ("X_CPY")..
+   //else if ( sType == GdbCopy::GetKey) {
+   //   pGdbNode = new( nothrow) GdbCopy ;
+   //}
+  // altrimenti oggetto geometrico
+   else 
+      pGdbNode = new( nothrow) GdbObj ;
 
+  // verifico il nodo GDB
+   if ( pGdbNode == nullptr)
+      return false ;
+
+  // se lettura dati e inserimento nel DB vanno bene
+   if ( pGdbNode->Load( sType, TheScanner, nParentId)  &&
+        AddToGeomDB( pGdbNode, nParentId))
+      return true ;
+  // altrimenti errore
    else {
-     // in ogni caso non serve oggetto GDB
-      delete pGdbObj ;
-     // se fine dati
-      if ( sErrLine == "END") {
-         bEnd = true ;
-         return true ;
-      }
-     // altrimenti errore
-      else
-         return false ;
+      delete pGdbNode ;
+      return false ;
    }
 }
 
 //----------------------------------------------------------------------------
 bool
-GeomDB::Save( std::ofstream& osOut)
+GeomDB::Save( std::ofstream& osOut) const
 {
-   bool bOk ;
-   PGDBO_LIST::iterator Iter ;
-
-
-   bOk = true ;
+   bool bOk = true ;
   // intestazione
    osOut << "START" << endl ;
-   osOut << "GeomDB,1.2a3" << endl ;
+   osOut << "GeomDB,1.4a1" << endl ;
   // ciclo di scrittura degli oggetti
-   for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; ++Iter) {
+   const GdbNode* pGdbNode = m_GrpRadix.GetFirstNode() ;
+   while ( pGdbNode != nullptr) {
      // oggetto geometrico
-      if ( ! (*Iter)->Save( osOut))
+      if ( ! pGdbNode->Save( osOut))
          bOk = false ;
+      pGdbNode = pGdbNode->GetNext() ;
    }
-  // terminazione
    osOut << "END" << endl ;
 
    return bOk ;
@@ -195,9 +195,9 @@ GeomDB::Save( std::ofstream& osOut)
 
 //----------------------------------------------------------------------------
 bool
-GeomDB::ExistsObj( int nId)
+GeomDB::ExistsNode( int nId) const
 {
-   INTPGDBO_UMAP::const_iterator Iter ;
+   INTPGDBN_UMAP::const_iterator Iter ;
 
 
    Iter = m_GdbIdMap.find( nId) ;
@@ -205,50 +205,86 @@ GeomDB::ExistsObj( int nId)
 }
 
 //----------------------------------------------------------------------------
-GdbObj*
-GeomDB::GetGdbObj( int nId)
+GdbNode*
+GeomDB::GetGdbNode( int nId)
 {
-   INTPGDBO_UMAP::const_iterator Iter ;
-
-
-   Iter = m_GdbIdMap.find( nId) ;
-   if ( Iter != m_GdbIdMap.end())
-      return Iter->second ;
-   else
+  // impossibile
+   if ( nId < 0)
       return nullptr ;
+  // radice
+   else if ( nId == 0)
+      return &m_GrpRadix ;
+  // un nodo qualubque
+   else {
+      INTPGDBN_UMAP::const_iterator Iter = m_GdbIdMap.find( nId) ;
+      if ( Iter != m_GdbIdMap.end())
+         return Iter->second ;
+      else
+         return nullptr ;
+   }
 }
 
 //----------------------------------------------------------------------------
 bool
-GeomDB::AddToGeomDB( GdbObj* pGdbObj)
+GeomDB::AddToGeomDB( GdbNode* pGNode, int nParentId)
 {
   // verifico validitā oggetto puntato
-   if ( pGdbObj == nullptr)
+   if ( pGNode == nullptr)
       return false ;
 
   // verifica validitā e unicitā del nome
-   if ( pGdbObj->m_nId <= 0  ||  ExistsObj( pGdbObj->m_nId))
+   if ( pGNode->m_nId <= 0  ||  ExistsNode( pGNode->m_nId))
       return false ;
 
-  // inserisco in lista principale
-   m_GeomDB.push_back( pGdbObj) ;
+  // cerco il padre
+   GdbGroup* pGroup = GetGdbGroup( nParentId) ;
+   if ( pGroup == nullptr)
+      return false ;
+  // inserisco in coda alla lista del padre
+   if ( ! pGNode->AddTail( pGroup))
+       return false ;
 
   // inserisco in mappa nomi
-   m_GdbIdMap[ pGdbObj->m_nId] = pGdbObj ;
+   return m_GdbIdMap.insert( pair< int, GdbNode*>( pGNode->m_nId, pGNode)).second ; 
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::AddGroup( int nId, int nParentId)
+{
+   GdbGroup* pGdbGroup ;
+
+
+  // verifico validitā Id e ParentId
+   if ( nId <= 0  ||  nParentId < 0)
+      return false ;
+  // alloco gruppo Gdb
+   pGdbGroup = new(nothrow) GdbGroup ;
+   if ( pGdbGroup == nullptr)
+      return false ;
+  // assegno identificativo
+   pGdbGroup->m_nId = nId ;
+  // assegno dati
+   // TODO ...
+  // inserisco nel DB
+   if ( ! AddToGeomDB( pGdbGroup, nParentId)) {
+      delete pGdbGroup ;
+      return false ;
+   }
 
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-GeomDB::AddGeoObj( int nId, IGeoObj* pGeoObj)
+GeomDB::AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj)
 {
    GdbObj* pGdbObj ;
 
 
   // assegno GeoObj a gestore puntatore con rilascio automatico
    ReleasePtr<IGeoObj> pRPGeoObj( pGeoObj) ;
-  // verifico validitā nome
+  // verifico validitā identificativo
    if ( nId <= 0)
       return false ;
   // verifico validitā oggetto Geo
@@ -258,12 +294,12 @@ GeomDB::AddGeoObj( int nId, IGeoObj* pGeoObj)
    pGdbObj = new(nothrow) GdbObj ;
    if ( pGdbObj == nullptr)
       return false ;
-  // assegno nome
+  // assegno identificativo
    pGdbObj->m_nId = nId ;
   // assegno dati ( ma non ne trasferisco il possesso)
    pGdbObj->m_pGeoObj = Get( pRPGeoObj) ;
   // inserisco nel DB
-   if ( ! AddToGeomDB( pGdbObj)) {
+   if ( ! AddToGeomDB( pGdbObj, nParentId)) {
       delete pGdbObj ;
       return false ;
    }
@@ -274,13 +310,13 @@ GeomDB::AddGeoObj( int nId, IGeoObj* pGeoObj)
 
 //----------------------------------------------------------------------------
 GeoObjType
-GeomDB::GetObjType( int nId)
+GeomDB::GetObjType( int nId) const
 {
    const GdbObj* pGdbObj ;
 
 
   // recupero l'oggetto
-   if ( ( pGdbObj = GetGdbObj( nId)) == nullptr)
+   if ( ( pGdbObj = (const_cast<GeomDB*>(this))->GetGdbObj( nId)) == nullptr)
       return GEO_NONE ;
   // ne identifico il tipo
    return pGdbObj->GetType() ;
@@ -303,30 +339,27 @@ GeomDB::GetGeoObj( int nId)
 
 //----------------------------------------------------------------------------
 bool
-GeomDB::Copy( int nIdSou, int nIdDest)
+GeomDB::Copy( int nIdSou, int nIdDest, int nParentIdDest)
 {
-   GdbObj* pGdoSou ;
-   GdbObj* pGdoDest ;
+   GdbNode* pGdNSou ;
+   GdbNode* pGdNDest ;
 
 
   // verifico validitā Id destinazione
-   if ( nIdDest <= 0)
+   if ( nIdDest <= 0  ||  ExistsNode( nIdDest))
       return false ;
 
   // verifico esistenza del sorgente
-   if ( ( pGdoSou = GetGdbObj( nIdSou)) == nullptr)
+   if ( ( pGdNSou = GetGdbNode( nIdSou)) == nullptr)
       return false ;
 
   // eseguo la copia
-   if ( ( pGdoDest = pGdoSou->Clone()) == nullptr)
+   if ( ( pGdNDest = pGdNSou->Clone( nIdDest)) == nullptr)
       return false ;
 
-  // assegno il nuovo nome
-   pGdoDest->m_nId = nIdDest ;
-
   // inserisco nel DB
-   if ( ! AddToGeomDB( pGdoDest)) {
-      delete pGdoDest ;
+   if ( ! AddToGeomDB( pGdNDest, nParentIdDest)) {
+      delete pGdNDest ;
       return false ;
    }
 
@@ -337,26 +370,26 @@ GeomDB::Copy( int nIdSou, int nIdDest)
 bool
 GeomDB::Erase( int nId)
 {
-   PGDBO_LIST::iterator Iter ;
+   INTPGDBN_UMAP::const_iterator Iter ;
+   GdbNode* pGdbNode ;
 
 
+  // recupero l'oggetto
+   Iter = m_GdbIdMap.find( nId) ;
+   if ( Iter == m_GdbIdMap.end())
+      return false ;
+   pGdbNode = Iter->second ;
+
   // elimino da mappa dei nomi
    m_GdbIdMap.erase( nId) ;
 
-  // elimino da lista principale
-   for ( Iter = m_GeomDB.begin() ; Iter != m_GeomDB.end() ; Iter++) {
-     // se oggetto cercato
-      if ( (*Iter)->m_nId == nId) {
-        // lo disalloco (distruttore virtuale)
-         delete( (*Iter)) ;
-        // lo tolgo dalla lista
-         m_GeomDB.erase( Iter) ;
-        // esco
-         return true ;
-      }
-   }
+  // lo tolgo dalla lista
+   pGdbNode->Remove() ;
 
-   return false ;
+  // lo disalloco (distruttore virtuale)
+   delete pGdbNode ;
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------
@@ -371,7 +404,10 @@ GeomDB::Translate( int nId, const Vector3d& vtMove)
       return false ;
 
   // eseguo l'operazione
-   return pGdbObj->Translate( vtMove) ;
+   if ( pGdbObj->m_pGeoObj != nullptr)
+      return pGdbObj->m_pGeoObj->Translate( vtMove) ;
+   else
+      return false ;
 }
 
 //----------------------------------------------------------------------------
@@ -386,7 +422,10 @@ GeomDB::Rotate( int nId, const Point3d& ptAx, const Vector3d& vtAx, double dCosA
       return false ;
 
   // eseguo l'operazione
-   return pGdbObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
+   if ( pGdbObj->m_pGeoObj != nullptr)
+      return pGdbObj->m_pGeoObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
+   else
+      return false ;
 }
 
 //----------------------------------------------------------------------------
@@ -401,7 +440,10 @@ GeomDB::Scale( int nId, const Point3d& ptCen, double dCoeffX, double dCoeffY, do
       return false ;
 
   // eseguo l'operazione
-   return pGdbObj->Scale( ptCen, dCoeffX, dCoeffY, dCoeffZ) ;
+   if ( pGdbObj->m_pGeoObj != nullptr)
+      return pGdbObj->m_pGeoObj->Scale( ptCen, dCoeffX, dCoeffY, dCoeffZ) ;
+   else
+      return false ;
 }
 
 //----------------------------------------------------------------------------
@@ -416,5 +458,8 @@ GeomDB::Mirror( int nId, const Point3d& ptOn, const Vector3d& vtNorm)
       return false ;
 
   // eseguo l'operazione
-   return pGdbObj->Mirror( ptOn, vtNorm) ;
+   if ( pGdbObj->m_pGeoObj != nullptr)
+      return pGdbObj->m_pGeoObj->Mirror( ptOn, vtNorm) ;
+   else
+      return false ;
 }
diff --git a/GeomDB.h b/GeomDB.h
index 98b652f..7592a1f 100644
--- a/GeomDB.h
+++ b/GeomDB.h
@@ -17,10 +17,10 @@
 #include <unordered_map>
 #include "/EgtDev/Include/EGkGeomDB.h"
 #include "GdbObj.h"
+#include "GdbGroup.h"
 
 //----------------------------------------------------------------------------
-typedef std::list< GdbObj*> PGDBO_LIST ;
-typedef std::unordered_map< int, GdbObj*> INTPGDBO_UMAP ;
+typedef std::unordered_map< int, GdbNode*> INTPGDBN_UMAP ;
 
 //----------------------------------------------------------------------------
 class CScan ;
@@ -33,12 +33,13 @@ class GeomDB : public IGeomDB
       virtual bool Init( void) ;
       virtual bool Clear( void) ;
       virtual bool Load( std::ifstream& osIn) ;
-      virtual bool Save( std::ofstream& osOut) ;
-      virtual bool ExistsObj( int nId) ;
-      virtual bool AddGeoObj( int nId, IGeoObj* pGeoObj) ;
-      virtual GeoObjType GetObjType( int nId) ;
+      virtual bool Save( std::ofstream& osOut) const ;
+      virtual bool ExistsNode( int nId) const ;
+      virtual bool AddGroup( int nId, int nParentId) ;
+      virtual bool AddGeoObj( int nId, int nParentId, IGeoObj* pGeoObj) ;
+      virtual GeoObjType GetObjType( int nId) const ;
       virtual IGeoObj* GetGeoObj( int nId) ;
-      virtual bool Copy( int nIdSou, int nIdDest) ;
+      virtual bool Copy( int nIdSou, int nIdDest, int nParentIdDest) ;
       virtual bool Erase( int nId) ;
       virtual bool Translate( int nId, const Vector3d& vtMove) ;
       virtual bool Rotate( int nId, const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) ;
@@ -52,12 +53,14 @@ class GeomDB : public IGeomDB
       GeomDB( void) ;
 
    private :
-      GdbObj* GetGdbObj( int nId) ;
-      bool AddToGeomDB( GdbObj* pGObj) ;
+      GdbNode* GetGdbNode( int nId) ;
+      GdbObj* GetGdbObj( int nId) { return dynamic_cast<GdbObj*>( GetGdbNode( nId)) ; }
+      GdbGroup* GetGdbGroup( int nId) { return dynamic_cast<GdbGroup*>( GetGdbNode( nId)) ; }
+      bool AddToGeomDB( GdbNode* pGNode, int nParentId) ;
       bool LoadStart( CScan& TheScanner) ;
-      bool LoadOneObject( CScan& TheScanner, bool& bEnd) ;
+      bool LoadOneNode( CScan& TheScanner, bool& bEnd) ;
 
    private :
-      PGDBO_LIST     m_GeomDB ;           // lista principale, proprietaria degli oggetti
-      INTPGDBO_UMAP  m_GdbIdMap ;         // map basato sugli identificatori
+      GdbGroup       m_GrpRadix ;         // gruppo radice di tutto il DB
+      INTPGDBN_UMAP  m_GdbIdMap ;         // map basato sugli identificatori
 } ;
diff --git a/OutScl.cpp b/OutScl.cpp
index f8d1d02..e65da0d 100644
--- a/OutScl.cpp
+++ b/OutScl.cpp
@@ -261,7 +261,7 @@ OutScl::PutCurveArc( const ICurveArc& CrvArc)
    nNumSeg = (int) ( fabs( CrvArc.GetAngCenter()) / DELTA_ANG) + 1 ;
   // ciclo sui segmenti
    Remark( "CurveArc") ;
-   for ( i = 0 ; i <= nNumSeg ; i ++) {
+   for ( i = 0 ; i <= nNumSeg ; ++ i) {
      // ricavo il punto
       dU = i / (double) nNumSeg ;
       CrvArc.GetPoint( dU, ptFin) ;
@@ -273,7 +273,7 @@ OutScl::PutCurveArc( const ICurveArc& CrvArc)
    }
   // ciclo per disegnare le derivate
    Remark( "ArcTangents+Der2") ;
-   for ( i = 0 ; i <= nNumSeg ; i ++ ) {
+   for ( i = 0 ; i <= nNumSeg ; ++ i) {
      // ricavo il punto
       dU = i / (double) nNumSeg ;
       CrvArc.GetPointTangNormCurv( dU, ptFin, vtT, vtN, dCurv) ;
@@ -306,7 +306,7 @@ OutScl::PutCurveBez( const ICurveBezier& CrvBez)
 
   // ciclo per disegnare i segmenti
    Remark( "BezierCurve") ;
-   for ( i = 0 ; i <= NUM_SEG ; i ++ ) {
+   for ( i = 0 ; i <= NUM_SEG ; ++ i) {
      // ricavo il punto
       dU = i / (double) NUM_SEG ;
       CrvBez.GetPoint( dU, ptFin) ;
@@ -318,7 +318,7 @@ OutScl::PutCurveBez( const ICurveBezier& CrvBez)
    }
   // ciclo per disegnare le derivate
    Remark( "BezierTangents+Der2") ;
-   for ( i = 0 ; i <= NUM_SEG ; i ++ ) {
+   for ( i = 0 ; i <= NUM_SEG ; ++ i) {
      // ricavo il punto
       dU = i / (double) NUM_SEG ;
       CrvBez.GetPointTangNormCurv( dU, ptFin, vtT, vtN, dCurv) ;
@@ -351,7 +351,7 @@ OutScl::PutPolygBez( const ICurveBezier& CrvBez)
 
   // ciclo per disegnare il poligono di controllo
    Remark( "BezierPolygon") ;
-   for ( i = 0 ; i <= CrvBez.GetDegree() ; i ++) {
+   for ( i = 0 ; i <= CrvBez.GetDegree() ; ++ i) {
       ptFin = CrvBez.GetControlPoint( i) ;
      // dopo il primo, disegno
       if ( i > 0)