diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index b486db4..1f6a294 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/Milling.cpp b/Milling.cpp
index 1415e0c..1f26db4 100644
--- a/Milling.cpp
+++ b/Milling.cpp
@@ -29,6 +29,7 @@
 #include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkExtText.h"
+#include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkUserObjFactory.h"
 #include "/EgtDev/Include/EGnStringKeyVal.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
@@ -2120,8 +2121,10 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
    double dAppr = m_Params.m_dStartPos ;
 
   // in caso di tabs ne aggiusto i parametri secondo il percorso
-   double dTabsRampLen, dTabsBottomLen, dTabsTopLen ;
-   AdjustTabsParams( pCompo, bPathTabsEnable, dTabsRampLen, dTabsBottomLen, dTabsTopLen) ;
+   TabData tdTabs ;
+   AdjustTabsParams( pCompo, bPathTabsEnable, tdTabs) ;
+   DBLVECTOR vdTabs ;
+   CalcTabsPositions( pCompo, bPathTabsEnable, tdTabs, vdTabs) ;
 
   // in caso di oscillazione ne aggiusto i parametri secondo il percorso
    double dOscRampLen, dOscFlatLen ;
@@ -2129,7 +2132,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
 
   // ciclo sulle curve elementari
    bool bClosed = pCompo->IsClosed() ;
-   m_dCurrTabsLen = dTabsRampLen + 0.5 * dTabsBottomLen ;
+   m_dCurrTabsLen = 0 ;
    m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
    int nMaxInd = pCompo->GetCurveCount() - 1 ;
    for ( int i = 0 ; i <= nMaxInd ; ++ i) {
@@ -2208,7 +2211,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
          ICurveLine* pLine = GetCurveLine( pCurve) ;
          SetFeed( GetFeed()) ;
          if ( bPathTabsEnable) {
-            if ( ! AddTabsLine( pLine, vtTool, dTabsRampLen, dTabsBottomLen, dTabsTopLen))
+            if ( ! AddTabsLine( pLine, vtTool, vdTabs, tdTabs))
                return false ;
          }
          else if ( bPathOscEnable) {
@@ -2225,7 +2228,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
          ICurveArc* pArc = GetCurveArc( pCurve) ;
          SetFeed( GetFeed()) ;
          if ( bPathTabsEnable) {
-            if ( ! AddTabsArc( pArc, vtTool, dTabsRampLen, dTabsBottomLen, dTabsTopLen))
+            if ( ! AddTabsArc( pArc, vtTool, vdTabs, tdTabs))
                return false ;
          }
          else if ( bPathOscEnable) {
@@ -4178,66 +4181,111 @@ Milling::AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRa
 
 //----------------------------------------------------------------------------
 bool
-Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, double& dTabsRampLen, double& dTabsBottomLen, double& dTabsTopLen)
+Milling::AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, TabData& tdTabs)
 {
   // se ci sono i tab cerco di aggiustare le lunghezze dei Bottom per finire con la stessa quota di partenza
    double dTabLen = m_Params.m_dTabLen + m_TParams.m_dDiam ;
    double dTabAngle = Clamp( abs( m_Params.m_dTabAngle), 15., 75.) ;
-   dTabsRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( dTabLen) / 2 - OSC_MIN_LEN) ;
-   dTabsTopLen = abs( dTabLen) - 2 * dTabsRampLen ;
-   dTabsBottomLen = abs( m_Params.m_dTabDist) - abs( dTabLen) ;
+   tdTabs.m_dRampLen = min( abs( m_Params.m_dTabHeight) / tan( dTabAngle * DEGTORAD), abs( dTabLen) / 2 - OSC_MIN_LEN) ;
+   tdTabs.m_dTopLen = abs( dTabLen) - 2 * tdTabs.m_dRampLen ;
+   tdTabs.m_dBottomLen = abs( m_Params.m_dTabDist) - abs( dTabLen) ;
    if ( bPathTabsEnable) {
      // lunghezza del percorso
       double dLen ; pCrv->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
      // se percorso non permette nemmeno un tab disabilito
-      if ( dLen < ( 2 * dTabsRampLen + 2 * dTabsTopLen)) {
+      if ( dLen < ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen)) {
          bPathTabsEnable = false ;
          m_pMchMgr->SetWarning( 2363, "Warning in Milling : tabs impossible") ;
       }
       else {
         // calcolo numero di tabs e distanza
-         int nTabs = max( static_cast<int>( dLen / ( 2 * dTabsRampLen + dTabsBottomLen + dTabsTopLen)), 1) ;
+         int nTabs = max( static_cast<int>( dLen / ( 2 * tdTabs.m_dRampLen + tdTabs.m_dBottomLen + tdTabs.m_dTopLen)), 1) ;
          nTabs = min( nTabs, m_Params.m_nTabMax) ;
          if ( nTabs < m_Params.m_nTabMin) {
-            if ( dLen > ( 2 * dTabsRampLen + 2 * dTabsTopLen) * m_Params.m_nTabMin)
+            if ( dLen > ( 2 * tdTabs.m_dRampLen + 2 * tdTabs.m_dTopLen) * m_Params.m_nTabMin)
                nTabs = m_Params.m_nTabMin ;
             else
                m_pMchMgr->SetWarning( 2364, "Warning in Milling : tabs number less than minimum") ;
          }
-         dTabsBottomLen = ( dLen - nTabs * ( 2 * dTabsRampLen + dTabsTopLen)) / nTabs ;
+         tdTabs.m_dBottomLen = ( dLen - nTabs * ( 2 * tdTabs.m_dRampLen + tdTabs.m_dTopLen)) / nTabs ;
       }
    }
+  // verifico che le lughezze non siano inferiori al minimo
+   tdTabs.m_dRampLen = max( tdTabs.m_dRampLen, OSC_MIN_LEN) ;
+   tdTabs.m_dBottomLen = max( tdTabs.m_dBottomLen, OSC_MIN_LEN) ;
+   tdTabs.m_dTopLen = max( tdTabs.m_dTopLen, OSC_MIN_LEN) ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen)
+Milling::CalcTabsPositions( const ICurveComposite* pCompo, bool bPathTabsEnable, const TabData& tdTabs, DBLVECTOR& vdTabs)
+{
+  // reset posizioni Tabs
+   vdTabs.clear() ;
+
+  // se Tabs non abilitati, esco
+   if ( ! bPathTabsEnable)
+      return true ;
+
+  // lunghezza del percorso
+   double dLen ; pCompo->GetLength( dLen) ; dLen -= m_dAddedOverlap ;
+
+  // determinazione intervalli validi
+   Intervals ivTabs ;
+  // inizializzo intervallo valido
+   ivTabs.Set( 0, dLen) ;
+  // elimino parti (test)
+   if ( dLen > 300) {
+      ivTabs.Subtract( 0, 100) ;
+      ivTabs.Subtract( dLen - 100, dLen) ;
+   }
+   else {
+      ivTabs.Subtract( 0.4 * dLen, 0.6 * dLen) ;
+   }
+
+  // determino posizioni di inizio dei Tabs
+   double dNextTab = 0.5 * tdTabs.m_dBottomLen ;
+   double dCurrLen = 0 ;
+   while ( dCurrLen + dNextTab < dLen) {
+      vdTabs.emplace_back( dCurrLen + dNextTab) ;
+      dCurrLen += dNextTab + tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen ;
+      dNextTab = tdTabs.m_dBottomLen ;
+   }
+   if ( ! vdTabs.empty())
+      vdTabs.emplace_back( dLen + m_dAddedOverlap + 100.) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
 {
   // lunghezze dei tratti di oscillazione
-   dTabsRampLen = max( dTabsRampLen, OSC_MIN_LEN) ;
-   dTabsBottomLen = max( dTabsBottomLen, OSC_MIN_LEN) ;
-   dTabsTopLen = max( dTabsTopLen, OSC_MIN_LEN) ;
-   double vLenRef[4] = { dTabsRampLen,
-                         dTabsRampLen + dTabsBottomLen,
-                         dTabsRampLen + dTabsBottomLen + dTabsRampLen,
-                         dTabsRampLen + dTabsBottomLen + dTabsRampLen + dTabsTopLen} ;
+   double vLen[4] = { 0,
+                      tdTabs.m_dRampLen,
+                      tdTabs.m_dRampLen + tdTabs.m_dTopLen,
+                      tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
   // lunghezza della linea
    double dLen ; pLine->GetLength( dLen) ;
   // lunghezza corrente sulla linea
    double dCurrLen = 0 ;
+  // indice corrente di posizione
+   int nI = 0 ;
   // emissione oscillazioni
-   while ( dCurrLen < dLen - EPS_ZERO) {
+   while ( dCurrLen < dLen - EPS_ZERO  &&  nI < int( vdTabs.size())) {
+     // lunghezze di riferimento dei tratti di oscillazione
+      double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
      // lunghezza rimanente
       double dNextLen = dLen - dCurrLen ;
-     // se inizio è sul primo tratto (rampa discendente)
+     // se inizio è sul primo tratto (parte piatta in basso)
       if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
         // se fine linea è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 = pLine->GetEnd() ;
-            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[0] - m_dCurrTabsLen) / ( vLenRef[0] - 0)) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
@@ -4259,13 +4307,14 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
                return false ;
          }
       }
-     // se inizio è sul secondo tratto (parte piatta in basso)
+     // se inizio è sul secondo tratto (rampa ascendente)
       else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
         // se fine linea è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 = pLine->GetEnd() ;
+            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
@@ -4274,6 +4323,7 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
             dCurrLen = dLen ;
             m_dCurrTabsLen = vLenRef[1] ;
             Point3d ptP3 = pLine->GetEnd() ;
+            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
@@ -4283,18 +4333,19 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
             m_dCurrTabsLen = vLenRef[1] ;
             double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
             Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
+            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
       }
-     // se inizio è sul terzo tratto (rampa ascendente)
+     // se inizio è sul terzo tratto (parte piatta in alto)
       else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
         // se fine linea è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 = pLine->GetEnd() ;
-            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[1]) / ( vLenRef[2] - vLenRef[1])) ;
+            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
@@ -4318,77 +4369,78 @@ Milling::AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dT
                return false ;
          }
       }
-     // altrimenti è sul quarto tratto (parte piatta in alto)
-      else {
+     // altrimenti è sul quarto tratto (rampa discendente)
+      else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
         // se fine linea è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 = pLine->GetEnd() ;
-            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
+            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
         // se fine linea è alla fine del tratto 
          else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
             dCurrLen = dLen ;
-            m_dCurrTabsLen = 0 ;
+            m_dCurrTabsLen = vLenRef[3] ;
             Point3d ptP3 = pLine->GetEnd() ;
-            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
         // altrimenti fine linea è oltre
          else {
             dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
-            m_dCurrTabsLen = 0 ;
+            m_dCurrTabsLen = vLenRef[3] ;
             double dU ; pLine->GetParamAtLength( dCurrLen, dU) ;
             Point3d ptP3 ; pLine->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
-            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             if ( AddLinearMove( ptP3) == GDB_ID_NULL)
                return false ;
          }
       }
+     // altrimenti passo all'intervallo successivo
+      else
+         ++ nI ;
    }
    return true ;
 }         
 
 //----------------------------------------------------------------------------
 bool
-Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen)
+Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs)
 {
   // lunghezze dei tratti di oscillazione
-   dTabsRampLen = max( dTabsRampLen, OSC_MIN_LEN) ;
-   dTabsBottomLen = max( dTabsBottomLen, OSC_MIN_LEN) ;
-   dTabsTopLen = max( dTabsTopLen, OSC_MIN_LEN) ;
-   double vLenRef[4] = { dTabsRampLen,
-                         dTabsRampLen + dTabsBottomLen,
-                         dTabsRampLen + dTabsBottomLen + dTabsRampLen,
-                         dTabsRampLen + dTabsBottomLen + dTabsRampLen + dTabsTopLen} ;
-  // parametria dell'arco
+   double vLen[4] = { 0,
+                      tdTabs.m_dRampLen,
+                      tdTabs.m_dRampLen + tdTabs.m_dTopLen,
+                      tdTabs.m_dRampLen + tdTabs.m_dTopLen + tdTabs.m_dRampLen} ;
+  // parametri dell'arco
    Point3d ptCen = pArc->GetCenter() ;
    double dAngCen = pArc->GetAngCenter() ;
    Vector3d vtN = pArc->GetNormVersor() ;
    double dLen ; pArc->GetLength( dLen) ;
   // lunghezza corrente sull'arco
    double dCurrLen = 0 ;
+  // indice corrente di posizione
+   int nI = 0 ;
   // emissione oscillazioni
-   while ( dCurrLen < dLen - EPS_ZERO) {
+   while ( dCurrLen < dLen - EPS_ZERO  &&  nI < int( vdTabs.size())) {
+     // lunghezze di riferimento dei tratti di oscillazione
+      double vLenRef[4] = { vdTabs[nI] + vLen[0], vdTabs[nI] + vLen[1], vdTabs[nI] + vLen[2], vdTabs[nI] + vLen[3]} ;
      // lunghezza rimanente
       double dNextLen = dLen - dCurrLen ;
-     // se inizio è sul primo tratto (rampa discendente)
+     // se inizio è sul primo tratto (parte piatta in basso)
       if ( m_dCurrTabsLen < vLenRef[0] - 10 * EPS_SMALL) {
-        // se fine linea è entro il tratto
+        // se fine arco è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[0] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
-            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[0] - m_dCurrTabsLen) / ( vLenRef[0] - 0)) ;
             double dCurrAngCen = dAngCen * dNextLen / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // se fine linea è alla fine del tratto 
+        // se fine arco è alla fine del tratto 
          else if ( m_dCurrTabsLen + dNextLen < vLenRef[0] + 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen = vLenRef[0] ;
@@ -4397,7 +4449,7 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // altrimenti fine linea è oltre
+        // altrimenti fine arco è oltre
          else {
             dCurrLen += vLenRef[0] - m_dCurrTabsLen ;
             m_dCurrTabsLen = vLenRef[0] ;
@@ -4408,50 +4460,53 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
                return false ;
          }
       }
-     // se inizio è sul secondo tratto (parte piatta in basso)
+     // se inizio è sul secondo tratto (rampa ascendente)
       else if ( m_dCurrTabsLen < vLenRef[1] - 10 * EPS_SMALL) {
-        // se fine linea è entro il tratto
+        // se fine arco è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[1] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
+            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[0]) / ( vLenRef[1] - vLenRef[0])) ;
             double dCurrAngCen = dAngCen * dNextLen / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // se fine linea è alla fine del tratto 
+        // se fine arco è alla fine del tratto 
          else if ( m_dCurrTabsLen + dNextLen < vLenRef[1] + 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen = vLenRef[1] ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
+            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             double dCurrAngCen = dAngCen * dNextLen / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // altrimenti fine linea è oltre
+        // altrimenti fine arco è oltre
          else {
             dCurrLen += vLenRef[1] - m_dCurrTabsLen ;
             m_dCurrTabsLen = vLenRef[1] ;
             double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
             Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
+            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
       }
-     // se inizio è sul terzo tratto (rampa ascendente)
+     // se inizio è sul terzo tratto  (parte piatta in alto)
       else if ( m_dCurrTabsLen < vLenRef[2] - 10 * EPS_SMALL) {
-        // se fine linea è entro il tratto
+        // se fine arco è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[2] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
-            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( m_dCurrTabsLen - vLenRef[1]) / ( vLenRef[2] - vLenRef[1])) ;
+            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             double dCurrAngCen = dAngCen * dNextLen / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // se fine linea è alla fine del tratto 
+        // se fine arco è alla fine del tratto 
          else if ( m_dCurrTabsLen + dNextLen < vLenRef[2] + 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen = vLenRef[2] ;
@@ -4461,7 +4516,7 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // altrimenti fine linea è oltre
+        // altrimenti fine arco è oltre
          else {
             dCurrLen += vLenRef[2] - m_dCurrTabsLen ;
             m_dCurrTabsLen = vLenRef[2] ;
@@ -4473,40 +4528,41 @@ Milling::AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabs
                return false ;
          }
       }
-     // altrimenti è sul quarto tratto (parte piatta in alto)
-      else {
-        // se fine linea è entro il tratto
+     // altrimenti è sul quarto tratto (rampa discendente)
+      else if ( m_dCurrTabsLen < vLenRef[3] - 10 * EPS_SMALL) {
+        // se fine arco è entro il tratto
          if ( m_dCurrTabsLen + dNextLen < vLenRef[3] - 10 * EPS_SMALL) {
             dCurrLen = dLen ;
             m_dCurrTabsLen += dNextLen ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
-            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
+            ptP3 += vtTool * ( abs( m_Params.m_dTabHeight) * ( vLenRef[3] - m_dCurrTabsLen) / ( vLenRef[3] - vLenRef[2])) ;
             double dCurrAngCen = dAngCen * dNextLen / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // se fine linea è alla fine del tratto 
+        // se fine arco è alla fine del tratto 
          else if ( m_dCurrTabsLen + dNextLen < vLenRef[3] + 10 * EPS_SMALL) {
             dCurrLen = dLen ;
-            m_dCurrTabsLen = 0 ;
+            m_dCurrTabsLen = vLenRef[3] ;
             Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
-            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             double dCurrAngCen = dAngCen * dNextLen / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // altrimenti fine linea è oltre
+        // altrimenti fine arco è oltre
          else {
             dCurrLen += vLenRef[3] - m_dCurrTabsLen ;
-            m_dCurrTabsLen = 0 ;
+            m_dCurrTabsLen = vLenRef[3] ;
             double dU ; pArc->GetParamAtLength( dCurrLen, dU) ;
             Point3d ptP3 ; pArc->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP3) ;
-            ptP3 += vtTool * abs( m_Params.m_dTabHeight) ;
             double dCurrAngCen = dAngCen * ( dNextLen + dCurrLen - dLen) / dLen ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
          }
       }
+     // altrimenti passo all'intervallo successivo
+      else
+         ++ nI ;
    }
    return true ;
 }
diff --git a/Milling.h b/Milling.h
index 608c3cd..f938b42 100644
--- a/Milling.h
+++ b/Milling.h
@@ -69,6 +69,13 @@ class Milling : public Machining
    public :
       Milling( void) ;
 
+   private :
+      struct TabData {
+         double m_dBottomLen ;
+         double m_dRampLen ;
+         double m_dTopLen ;
+      } ;
+
    private :
       bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
       bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
@@ -102,9 +109,10 @@ class Milling : public Machining
       bool AdjustOscillParams( const ICurve* pCrv, bool& bPathOscEnable, double& dRampLen, double& dFlatLen) ;
       bool AddOscillLine( const ICurveLine* pLine, const Vector3d& vtTool, double dRampLen, double dFlatLen) ;
       bool AddOscillArc( const ICurveArc* pArc, const Vector3d& vtTool, double dRampLen, double dFlatLen) ;
-      bool AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, double& dTabsRampLen, double& dTabsBottomLen, double& dTabsTopLen) ;
-      bool AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen) ;
-      bool AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, double dTabsRampLen, double dTabsBottomLen, double dTabsTopLen) ;
+      bool AdjustTabsParams( const ICurve* pCrv, bool& bPathTabsEnable, TabData& tdTabs) ;
+      bool CalcTabsPositions( const ICurveComposite* pCompo, bool bPathTabsEnable, const TabData& tdTabs, DBLVECTOR& vdTabs) ;
+      bool AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ;
+      bool AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ;
       double GetRadiusForStartEndElevation( void) const ;
       bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const ;
       bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ;