diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index ca00e74..d088e4e 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/EgtMachKernel.vcxproj b/EgtMachKernel.vcxproj
index 3d24985..1c36f6a 100644
--- a/EgtMachKernel.vcxproj
+++ b/EgtMachKernel.vcxproj
@@ -221,6 +221,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="Drilling.cpp" />
     <ClCompile Include="DrillingData.cpp" />
     <ClCompile Include="EMkDllMain.cpp" />
+    <ClCompile Include="Estimator.cpp" />
     <ClCompile Include="Exit.cpp" />
     <ClCompile Include="Generator.cpp" />
     <ClCompile Include="GenMachining.cpp" />
@@ -257,6 +258,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="OperationCL.cpp" />
     <ClCompile Include="Pocketing.cpp" />
     <ClCompile Include="PocketingData.cpp" />
+    <ClCompile Include="Processor.cpp" />
     <ClCompile Include="SawFinishing.cpp" />
     <ClCompile Include="SawFinishingData.cpp" />
     <ClCompile Include="Sawing.cpp" />
@@ -290,6 +292,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="DllMain.h" />
     <ClInclude Include="Drilling.h" />
     <ClInclude Include="DrillingData.h" />
+    <ClInclude Include="Estimator.h" />
     <ClInclude Include="Exit.h" />
     <ClInclude Include="Generator.h" />
     <ClInclude Include="GenMachining.h" />
@@ -314,6 +317,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="OutputConst.h" />
     <ClInclude Include="Pocketing.h" />
     <ClInclude Include="PocketingData.h" />
+    <ClInclude Include="Processor.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="SawFinishing.h" />
     <ClInclude Include="SawFinishingData.h" />
diff --git a/EgtMachKernel.vcxproj.filters b/EgtMachKernel.vcxproj.filters
index efe444a..0df8ddd 100644
--- a/EgtMachKernel.vcxproj.filters
+++ b/EgtMachKernel.vcxproj.filters
@@ -210,6 +210,12 @@
     <ClCompile Include="Mortising.cpp">
       <Filter>Source Files\Operations</Filter>
     </ClCompile>
+    <ClCompile Include="Processor.cpp">
+      <Filter>Source Files\Output</Filter>
+    </ClCompile>
+    <ClCompile Include="Estimator.cpp">
+      <Filter>Source Files\Output</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DllMain.h">
@@ -371,6 +377,12 @@
     <ClInclude Include="Mortising.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Processor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Estimator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtMachKernel.rc">
diff --git a/Estimator.cpp b/Estimator.cpp
new file mode 100644
index 0000000..10dcd76
--- /dev/null
+++ b/Estimator.cpp
@@ -0,0 +1,228 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2015-2018
+//----------------------------------------------------------------------------
+// File : Estimator.cpp           Data : 28.05.18          Versione : 1.9e6
+// Contenuto : Implementazione della classe Estimator.
+//
+//
+//
+// Modifiche : 28.10.15 DS Creazione modulo.
+//             26.02.16 DS Aggiunta gestione archi.
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "DllMain.h"
+#include "Estimator.h"
+#include "Machine.h"
+#include "OutputConst.h"
+#include "/EgtDev/Include/EGnFileUtils.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+static const string ERR_EXT = ".err" ;
+
+//----------------------------------------------------------------------------
+Estimator::Estimator( void)
+{
+}
+
+//----------------------------------------------------------------------------
+Estimator::~Estimator( void)
+{
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::Init( MachMgr* pMchMgr)
+{
+   return Processor::Init( pMchMgr) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::Run( const string& sCncFile, const std::string& sInfo)
+{
+  // emetto info di log
+   { string sOut = "Estimator Run : " + sCncFile ;
+     LOG_INFO( GetEMkLogger(), sOut.c_str()) ; }
+
+  // cancello l'eventuale file di uscita (e anche il file errore)
+   EraseFile( sCncFile) ;
+   string sErrFile = ChangeFileExtension( sCncFile, ERR_EXT) ;
+   EraseFile( sErrFile) ;
+
+  // lancio il processore
+   bool bOk = Processor::Run( sCncFile, sInfo) ;
+
+  // in caso di errore rinomino il file di output
+   if ( ! bOk)
+      RenameFile( sCncFile, sErrFile) ;
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnStart( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_START) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnEnd( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_END) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnProgramStart( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_PROGRAM_START) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnProgramEnd( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_PROGRAM_END) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnToolData( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_TOOL_DATA))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_TOOL_DATA) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnDispositionStart( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_DISPOSITION_START) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnDispositionEnd( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_DISPOSITION_END) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnTableData( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_TABLE_DATA))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_TABLE_DATA) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnFixtureData( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_FIXTURE_DATA))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_FIXTURE_DATA) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnRawMoveData( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_RAWMOVE_DATA))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_RAWMOVE_DATA) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnToolSelect( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_TOOL_SELECT) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnToolDeselect( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_TOOL_DESELECT) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnMachiningStart( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_MACHINING_START) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnMachiningEnd( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_MACHINING_END) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnPathStart( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_PATH_START))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_PATH_START) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnPathEnd( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_PATH_END))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_PATH_END) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnPathStartAux( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_PATH_START_AUX))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_PATH_START_AUX) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnPathEndAux( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_ESTIM_PATH_END_AUX))
+      return true ;
+   return m_pMachine->LuaCallFunction( ON_ESTIM_PATH_END_AUX) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnRapid( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_RAPID) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnLinear( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_LINEAR) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Estimator::CallOnArc( void)
+{
+   return m_pMachine->LuaCallFunction( ON_ESTIM_ARC) ;
+}
diff --git a/Estimator.h b/Estimator.h
new file mode 100644
index 0000000..0e394ca
--- /dev/null
+++ b/Estimator.h
@@ -0,0 +1,49 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2018-2018
+//----------------------------------------------------------------------------
+// File : Estimator.h           Data : 29.05.18          Versione : 1.9e6
+// Contenuto : Dichiarazione della classe Estimator.
+//
+//
+//
+// Modifiche : 29.05.18 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "Processor.h"
+
+//----------------------------------------------------------------------------
+class Estimator : public Processor
+{
+   public :
+      Estimator( void) ;
+      ~Estimator( void) ;
+      bool Init( MachMgr* pMchMgr) ;
+      bool Run( const std::string& sEstFile, const std::string& sInfo) ;
+
+   private :
+      bool CallOnStart( void) override ;
+      bool CallOnEnd( void) override ;
+      bool CallOnProgramStart( void) override ;
+      bool CallOnProgramEnd( void) override ;
+      bool CallOnToolData( void) override ;
+      bool CallOnDispositionStart( void) override ;
+      bool CallOnDispositionEnd( void) override ;
+      bool CallOnTableData( void) override ;
+      bool CallOnFixtureData( void) override ;
+      bool CallOnRawMoveData( void) override ;
+      bool CallOnToolSelect( void) override ;
+      bool CallOnToolDeselect( void) override ;
+      bool CallOnMachiningStart( void) override ;
+      bool CallOnMachiningEnd( void) override ;
+      bool CallOnPathStart( void) override ;
+      bool CallOnPathEnd( void) override ;
+      bool CallOnPathStartAux( void) override ;
+      bool CallOnPathEndAux( void) override ;
+      bool CallOnRapid( void) override ;
+      bool CallOnLinear( void) override ;
+      bool CallOnArc( void) override ;
+} ;
diff --git a/Generator.cpp b/Generator.cpp
index 5c23a48..e8125dd 100644
--- a/Generator.cpp
+++ b/Generator.cpp
@@ -1,8 +1,8 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2016
+//  EgalTech 2015-2018
 //----------------------------------------------------------------------------
-// File : Generator.cpp           Data : 26.02.16          Versione : 1.6n8
-// Contenuto : Implementazione della classe generator.
+// File : Generator.cpp           Data : 28.05.18          Versione : 1.9e6
+// Contenuto : Implementazione della classe Generator.
 //
 //
 //
@@ -15,57 +15,30 @@
 #include "stdafx.h"
 #include "DllMain.h"
 #include "Generator.h"
-#include "MachMgr.h"
-#include "Disposition.h"
-#include "Machining.h"
-#include "MachiningConst.h"
+#include "Machine.h"
 #include "OutputConst.h"
-#include "/EgtDev/Include/EMkToolConst.h"
-#include "/EgtDev/Include/EMkOperationConst.h"
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGnFileUtils.h"
 
 using namespace std ;
 
-//------------------------------ Errors --------------------------------------
-// 1001 = "Error with setup : xxx"
-// 1002 = "Error opening Cnc file"
-
 //----------------------------------------------------------------------------
 static const string ERR_EXT = ".err" ;
 
 //----------------------------------------------------------------------------
 Generator::Generator( void)
 {
-   m_pMchMgr = nullptr ;
-   m_pGeomDB = nullptr ;
-   m_pMachine = nullptr ;
-   m_AxesName.reserve( 8) ;
-   m_AxesToken.reserve( 8) ;
-   m_AxesVal.reserve( 8) ;
 }
 
 //----------------------------------------------------------------------------
 Generator::~Generator( void)
 {
-
 }
 
 //----------------------------------------------------------------------------
 bool
 Generator::Init( MachMgr* pMchMgr)
 {
-  // verifico ambiente
-   if ( pMchMgr == nullptr  ||  pMchMgr->GetContextId() == 0  ||
-        pMchMgr->GetGeomDB() == nullptr  ||  pMchMgr->GetCurrMachine() == nullptr)
-      return false ;
-   m_pMchMgr = pMchMgr ;
-   m_pGeomDB = m_pMchMgr->GetGeomDB() ;
-   m_pMachine = m_pMchMgr->GetCurrMachine() ;
-   m_sPrevTool.clear() ;
-   m_sTool.clear() ;
-   return true ;
+   return Processor::Init( pMchMgr) ;
 }
 
 //----------------------------------------------------------------------------
@@ -81,961 +54,165 @@ Generator::Run( const string& sCncFile, const std::string& sInfo)
    string sErrFile = ChangeFileExtension( sCncFile, ERR_EXT) ;
    EraseFile( sErrFile) ;
 
-  // verifico ci sia una macchinata corrente
-   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr  ||  m_pMachine == nullptr  ||
-        m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL)
-      return false ;
-   m_pMchMgr->ResetLastError() ;
+  // lancio il processore
+   bool bOk = Processor::Run( sCncFile, sInfo) ;
 
-  // forzo aggiornamento attrezzaggio della macchinata
-   m_pMchMgr->UpdateSetup() ;
-   if ( ! VerifySetup())
-      return false ;
-
-  // evento inizio esecuzione
-   bool bOk = true ;
-   if ( ! OnStart()) {
-      bOk = false ;
-      LOG_INFO( GetEMkLogger(), "OnStart error") ;
-   }
-
-  // apertura file di output ed evento inizio programma
-   if ( bOk  &&  ! OnProgramStart( m_pMachine->GetMachineName(), sCncFile, sInfo, m_pMchMgr->GetCurrSetupMgr().Exists())) {
-      bOk = false ;
-      LOG_INFO( GetEMkLogger(), "OnProgramStart error") ;
-   }
-
-  // emissione dati utensili
-   if ( bOk  &&  ! ProcessToolData()) {
-      bOk = false ;
-      LOG_INFO( GetEMkLogger(), "ProcessToolData error") ;
-   }
-
-  // ciclo su tutte le operazioni della macchinata
-   int nInd = 0 ;
-   int nOpId = m_pMchMgr->GetFirstActiveOperation() ;
-   while ( bOk  &&  nOpId != GDB_ID_NULL) {
-     // incremento l'indice della operazione
-      ++ nInd ;
-     // la prima operazione deve essere una disposizione
-      if ( nInd == 1) {
-         if ( m_pMchMgr->GetOperationType( nOpId) != OPER_DISP) {
-            bOk = false ;
-            continue ;
-         }
-      }
-     // processo l'operazione
-      int nType = m_pMchMgr->GetOperationType( nOpId) ;
-      if ( IsValidDispositionType( nType)) {
-         if ( ! ProcessDisposition( nOpId, nInd))
-            bOk = false ;
-      }
-      else if ( IsValidMachiningType( nType)) {
-         if ( ! ProcessMachining( nOpId, nInd))
-            bOk = false ;
-      }
-     // passo alla operazione successiva
-      nOpId = m_pMchMgr->GetNextActiveOperation( nOpId) ;
-   }
-
-  // evento fine programma
-   if ( bOk  &&  ! OnProgramEnd()) {
-      bOk = false ;
-      LOG_INFO( GetEMkLogger(), "OnProgramEnd error") ;
-   }
-  // chiudo il file di output
-   if ( ! m_pMachine->WriterClose())
-      bOk = false ;
-  // in caso di errore lo rinomino
+  // in caso di errore rinomino il file di output
    if ( ! bOk)
       RenameFile( sCncFile, sErrFile) ;
 
-  // evento fine esecuzione
-   if ( ! OnEnd()) {
-      bOk = false ;
-      LOG_INFO( GetEMkLogger(), "OnEnd error") ;
-   }
-
    return bOk ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::VerifySetup( void)
+Generator::CallOnStart( void)
 {
-  // se attrezzaggio non definito, nulla da verificare
-   if ( ! m_pMchMgr->GetCurrSetupMgr().Exists())
+   return m_pMachine->LuaCallFunction( ON_START) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Generator::CallOnEnd( void)
+{
+   return m_pMachine->LuaCallFunction( ON_END) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Generator::CallOnProgramStart( void)
+{
+   return m_pMachine->LuaCallFunction( ON_PROGRAM_START) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Generator::CallOnProgramEnd( void)
+{
+   return m_pMachine->LuaCallFunction( ON_PROGRAM_END) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Generator::CallOnToolData( void)
+{
+   if ( ! m_pMachine->LuaExistsFunction( ON_TOOL_DATA))
       return true ;
-
-  // lancio la verifica
-   STRVECTOR vsErr ;
-   if ( m_pMchMgr->VerifyCurrSetup( vsErr))
-      return true ;
-
-  // gestisco errore
-   string sErr = "Error with setup :" ;
-   for each( const auto& sTmp in vsErr)
-      sErr += " " + sTmp ;
-   m_pMchMgr->SetLastError( 1001, sErr) ;
-   return false ;
+   return m_pMachine->LuaCallFunction( ON_TOOL_DATA) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::ProcessDisposition( int nOpId, int nOpInd)
+Generator::CallOnDispositionStart( void)
 {
-  // Parametri della disposizione
-   Disposition* pDisp = GetDisposition( m_pGeomDB->GetUserObj( nOpId)) ;
-   if ( pDisp == nullptr)
-      return false ;
-
-  // Imposto la fase
-   int nPhase = pDisp->GetPhase() ;
-   m_pMchMgr->SetCurrPhase( nPhase) ;
-   bool bEmpty = pDisp->IsEmpty() ;
-   bool bSomeByHand = pDisp->GetSomeByHand() ;
-
-  // Se disposizione con movimenti macchina
-   if ( ! pDisp->IsEmpty()) {
-     // Recupero l'utensile della disposizione corrente
-      string sTool ; string sHead ; int nExit ; string sTcPos ;
-      if ( ! pDisp->GetToolData( sTool, sHead, nExit, sTcPos))
-         return false ;
-     // Se esiste utensile corrente e cambierà, lo scarico
-      if ( ! m_sTool.empty()  &&  m_sTool != sTool) {
-        // emetto deselezione vecchio utensile
-         if ( ! OnToolDeselect( sTool, sHead, nExit, sTcPos))
-            return false ;
-      }
-     // Aggiorno utensile e assi macchina
-      if ( ! UpdateDispTool( sTool, sHead, nExit)  ||  ! UpdateAxes())
-         return false ;
-     // Se utensile non definito o cambiato, emetto selezione nuovo utensile
-      if ( m_sTool.empty()  ||  m_sTool != m_sPrevTool) {
-         if ( ! OnToolSelect( sTool, sHead, nExit, sTcPos))
-            return false ;
-      }
-   }
-
-  // Emetto inizio disposizione
-   if ( ! OnDispositionStart( nOpId, nOpInd, nPhase, bEmpty, bSomeByHand))
-      return false ;
-
-  // Emetto dati tavola
-   string sTable ;
-   pDisp->GetTable( sTable) ;
-   Point3d ptOri1 ;
-   pDisp->GetTableRef1( ptOri1) ;
-   if ( ! OnTableData( sTable, ptOri1))
-      return false ;
-
-  // Emetto dati bloccaggi
-   for ( int i = 0 ;  ; ++ i) {
-      string sName ;
-      int nId ;
-      Point3d ptPos ;
-      double dAngDeg ;
-      double dMov ;
-      if ( pDisp->GetFixtureData( i, sName, nId, ptPos, dAngDeg, dMov)) {
-         if ( ! OnFixtureData( nId, i + 1, sName,  ptPos, dAngDeg, dMov))
-            return false ;
-      }
-      else
-         break ;
-   }
-
-  // Emetto movimenti sui grezzi
-   for ( int i = 0 ;  ; ++ i) {
-      int nRawId ;
-      int nType ;
-      Point3d ptPos ;
-      int nFlag ;
-      if ( pDisp->GetMoveRawData( i, nRawId, nType, ptPos, nFlag)) {
-         if ( ! OnRawMoveData( nRawId, i + 1, nType,  ptPos, nFlag))
-            return false ;
-      }
-      else
-         break ;
-   }
-   bool bOk = true ;
-
-  // Se disposizione con movimenti macchina
-   if ( ! pDisp->IsEmpty()) {
-     // Ciclo su tutti i percorsi CL della disposizione
-      int nClPathInd = 0 ;
-      int nClId = m_pGeomDB->GetFirstNameInGroup( nOpId, MCH_CL) ;
-      int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
-      while ( bOk  &&  nClPathId != GDB_ID_NULL) {
-         ++ nClPathInd ;
-        // processo il percorso di lavoro
-         if ( ! ProcessClPath( nClPathId, nClPathInd, nOpId, nOpInd))
-            bOk = false ;
-        // passo al percorso successivo
-         nClPathId = m_pGeomDB->GetNextGroup( nClPathId) ;
-      }
-   }
-
-  // Emetto fine disposizione
-   bOk = bOk && OnDispositionEnd() ;
-
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_DISPOSITION_START) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::ProcessMachining( int nOpId, int nOpInd)
+Generator::CallOnDispositionEnd( void)
 {
-  // Imposto come lavorazione corrente
-   if ( ! m_pMchMgr->SetCurrMachining( nOpId))
-      return false ;
-
-  // Verifico non sia vuota
-   if ( m_pMchMgr->IsMachiningEmpty())
-      return true ;
-
-  // Recupero l'utensile della lavorazione corrente
-   string sTuuid, sTool ;
-   if ( ! m_pMchMgr->GetMachiningParam( MPA_TUUID, sTuuid)  ||
-        ! m_pMchMgr->TdbGetToolFromUUID( sTuuid, sTool))
-      return false ;
-
-  // Se utensile cambierà
-   if ( ! m_sTool.empty()  &&  m_sTool != sTool) {
-     // recupero la testa del prossimo utensile (prima dall'attrezzaggio, poi dal DB utensili)
-      string sNextTcPos ; string sNextHead ; int nNextExit ;
-      if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( sTool, sNextTcPos, sNextHead, nNextExit)) {
-         if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
-            m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, sNextTcPos) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sNextHead) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nNextExit) ;
-         }
-        // ripristino l'utensile corrente
-         m_pMchMgr->TdbSetCurrTool( m_sTool) ;
-      }
-     // emetto deselezione vecchio utensile
-      if ( ! OnToolDeselect( sTool, sNextHead, nNextExit, sNextTcPos))
-         return false ;
-   }
-  // Aggiorno utensile e assi macchina
-   if ( ! UpdateTool( sTool)  ||  ! UpdateAxes())
-      return false ;
-  // Se utensile cambiato, emetto selezione nuovo utensile
-   if ( m_sTool != m_sPrevTool) {
-      string sTcPos ; string sHead ; int nExit ;
-      if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( m_sTool, sTcPos, sHead, nExit)) {
-         m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ;
-         m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ;
-         m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, sTcPos) ;
-      }
-      if ( ! OnToolSelect( sTool, sHead, nExit, sTcPos))
-         return false ;
-   }
-
-  // Recupero speed
-   double dSpeed ;
-   if ( ! m_pMchMgr->GetMachiningParam( MPA_SPEED, dSpeed))
-      return false ;
-
-  // Recupero punti di minimo e massimo ingombro
-   int nClId = m_pGeomDB->GetFirstNameInGroup( nOpId, MCH_CL) ;
-   Point3d ptMin, ptMax ;
-   m_pGeomDB->GetInfo( nClId, KEY_MMIN, ptMin) ;
-   m_pGeomDB->GetInfo( nClId, KEY_MMAX, ptMax) ;
-
-  // Emetto inizio lavorazione
-   if ( ! OnMachiningStart( nOpId, nOpInd, dSpeed, ptMin, ptMax))
-      return false ;
-
-  // Ciclo su tutti i percorsi CL della lavorazione
-   bool bOk = true ;
-   int nClPathInd = 0 ;
-   int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
-   while ( bOk  &&  nClPathId != GDB_ID_NULL) {
-      ++ nClPathInd ;
-     // processo il percorso di lavoro
-      if ( ! ProcessClPath( nClPathId, nClPathInd, nOpId, nOpInd))
-         bOk = false ;
-     // passo al percorso successivo
-      nClPathId = m_pGeomDB->GetNextGroup( nClPathId) ;
-   }
-
-  // Emetto fine lavorazione
-   bOk = bOk && OnMachiningEnd() ;
-
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_DISPOSITION_END) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd)
+Generator::CallOnTableData( void)
 {
-  // Recupero punti di inizio e fine del percorso
-   Point3d ptStart ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_START, ptStart) ;
-   Point3d ptEnd ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_END, ptEnd) ;
-  // Recupero versore estrusione associato al percorso (normale al piano di interpolazione)
-   Vector3d vtExtr ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_EXTR, vtExtr) ;
-  // Recupero punti di minimo e massimo ingombro
-   Point3d ptMin, ptMax ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_PMIN, ptMin) ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_PMAX, ptMax) ;
-  // Recupero massima elevazione
-   double dElev = 0 ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_ELEV, dElev) ;
-  // Recupero il numero di eventi ausiliari iniziali
-   int nAS = 0 ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_AS_TOT, nAS) ;
-  // Emetto inizio percorso di lavoro
-   if ( ! OnPathStart( nClPathId, nClPathInd, nAS, ptStart, ptEnd, vtExtr, ptMin, ptMax, dElev))
-      return false ;
-
-  // Emissione eventuali dati ausiliari di inizio
-  // processo gli eventi
-   for ( int i = 1 ; i <= nAS ; ++ i) {
-     // recupero i dati per l'evento 
-      string sAS ;
-      if ( ! m_pGeomDB->GetInfo( nClPathId, KEY_AS + ToString( i), sAS))
-         return false ;
-     // richiamo gestione evento ausiliario prima di inizio percorso di lavoro
-      if ( ! OnPathStartAux( i, sAS))
-         return false ;
-   }
-
-  // Ciclo su tutte le entità del percorso CL
-   bool bOk = true ;
-   int nEntInd = 0 ;
-   int nEntId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
-   while ( bOk  &&  nEntId != GDB_ID_NULL) {
-      ++ nEntInd ;
-     // processo l'entità
-      if ( ! ProcessClEnt( nEntId, nEntInd, nClPathId, nClPathInd, nOpId, nOpInd))
-         bOk = false ;
-     // passo all'entità successivo
-      nEntId = m_pGeomDB->GetNext( nEntId) ;
-   }
-
-  // Recupero il numero di eventi ausiliari finali
-   int nAE = 0 ;
-   m_pGeomDB->GetInfo( nClPathId, KEY_AE_TOT, nAE) ;
-
-  // Emetto fine percorso di lavoro
-   bOk = bOk && OnPathEnd( nAE) ;
-
-  // Emissione eventuali dati ausiliari di fine
-  // processo gli eventi
-   for ( int i = 1 ; i <= nAE ; ++ i) {
-     // recupero i dati per l'evento 
-      string sAE ;
-      if ( ! m_pGeomDB->GetInfo( nClPathId, KEY_AE + ToString( i), sAE))
-         return false ;
-     // richiamo gestione evento ausiliario dopo fine percorso di lavoro
-      if ( ! OnPathEndAux( i, sAE))
-         return false ;
-   }
-
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_TABLE_DATA) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd, int nOpId, int nOpInd)
+Generator::CallOnFixtureData( void)
 {
-  // Recupero i dati Cam
-   CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
-   if ( pCamData == nullptr  ||  pCamData->GetAxesStatus() != CamData::AS_OK)
-      return false ;
-   const DBLVECTOR& AxesEnd = pCamData->GetAxesVal() ;
-  // Emetto movimento
-   int nMove = pCamData->GetMoveType() ;
-   switch ( nMove) {
-   case 0 :      // rapido
-      if ( ! OnRapid( nMove, AxesEnd, pCamData->GetAxesMask(), pCamData->GetFlag()))
-         return false ;
-      break ;
-   case 1 :      // linea
-      if ( ! OnLinear( nMove, AxesEnd, pCamData->GetFeed(), pCamData->GetFlag()))
-         return false ;
-      break ;
-   case 2 :      // arco CW
-   case 3 :      // arco CCW
-      Point3d ptMid( AxesEnd[0], AxesEnd[1], AxesEnd[2]) ;
-      ptMid.Rotate( pCamData->GetAxesCen(), pCamData->GetAxesNormDir(), - pCamData->GetAxesAngCen() / 2) ;
-      if ( ! OnArc( nMove, AxesEnd, pCamData->GetAxesCen(), ptMid, pCamData->GetAxesRad(), pCamData->GetAxesAngCen(),
-                    pCamData->GetFeed(), pCamData->GetFlag()))
-         return false ;
-      break ;
-   }
-
-   return true ;
+   return m_pMachine->LuaCallFunction( ON_FIXTURE_DATA) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::UpdateTool( const string& sTool)
+Generator::CallOnRawMoveData( void)
 {
-  // Salvo l'utensile attuale come precedente
-   m_sPrevTool = m_sTool ;
-  // Se cambiato utensile ...
-   if ( sTool != m_sTool) {
-     // lo imposto come corrente
-      if ( ! m_pMchMgr->TdbSetCurrTool( sTool))
-         return false ;
-     // lo carico in macchina (se esiste attrezzaggio prendo i dati da questo)
-      string sTcPos ; string sHead ; int nExit ;
-      if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( sTool, sTcPos, sHead, nExit)) {
-         m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ;
-         m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ;
-      }
-      if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit))
-         return false ;
-      m_sTool = sTool ;
-   }
-   return true ;
+   return m_pMachine->LuaCallFunction( ON_RAWMOVE_DATA) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::UpdateDispTool( const string& sTool, const string& sHead, int nExit)
+Generator::CallOnToolSelect( void)
 {
-  // Salvo l'utensile attuale come precedente
-   m_sPrevTool = m_sTool ;
-  // Se non definito o cambiato ...
-   if ( sTool.empty()  ||  sTool != m_sTool) {
-     // lo carico in macchina
-      if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit))
-         return false ;
-      m_sTool = sTool ;
-   }
-   return true ;
+   return m_pMachine->LuaCallFunction( ON_TOOL_SELECT) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::UpdateAxes( void)
+Generator::CallOnToolDeselect( void)
 {
-  // Carico i nomi degli assi macchina attivi
-   return m_pMachine->GetAllCurrAxesName( m_AxesName) &&
-          m_pMachine->GetAllCurrAxesToken( m_AxesToken) ;
+   return m_pMachine->LuaCallFunction( ON_TOOL_DESELECT) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::OnStart( void)
+Generator::CallOnMachiningStart( void)
 {
-  // definisco tavola variabili globali
-   bool bOk = m_pMachine->LuaCreateGlobTable( GLOB_VAR) ;
-  // assegno versione
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_VER, GetEMkVer()) ;
-  // assegno valori di default
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_USETO1, false) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MODAL, false) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NUM, false) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NUMTOK, "N") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_LINENBR, 0) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_LINEINC, 1) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C1T, "I") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C2T, "J") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C3T, "K") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M1T, "I") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M2T, "J") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M3T, "K") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RRT, "R") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FT, "F") ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ST, "S") ;
-  // chiamo la funzione
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_START) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_MACHINING_START) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::OnEnd( void)
+Generator::CallOnMachiningEnd( void)
 {
-  // chiamo la funzione
-   bool bOk = m_pMachine->LuaCallFunction( ON_END) ;
-  // rimuovo tavola variabili globali
-   bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR) && bOk ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_MACHINING_END) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::OnProgramStart( const string& sMachName, const string& sCncFile, const string& sInfo, bool bSetup)
+Generator::CallOnPathStart( void)
 {
-  // apro il file di output
-   bool bOk = m_pMachine->WriterOpen( sCncFile) ;
-   if ( ! bOk)
-      m_pMchMgr->SetLastError( 1002, "Error opening Cnc file") ;
-  // assegno nome macchina
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MACHNAME, sMachName) ;
-  // assegno nome file
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FILE, sCncFile) ;
-  // assegno info
-   string sTxt = sInfo + " " + CurrDateTime() ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INFO, sTxt) ;
-  // assegno flag di presenza setup
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SETUP, bSetup) ;
-  // chiamo la funzione di inizio programma
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_PROGRAM_START) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_PATH_START) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::OnProgramEnd( void)
+Generator::CallOnPathEnd( void)
 {
-  // chiamo fine programma
-   bool bOk = m_pMachine->LuaCallFunction( ON_PROGRAM_END) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_PATH_END) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::ProcessToolData( void)
+Generator::CallOnPathStartAux( void)
 {
-   struct MyToolData {
-      string sName ;
-      string sHead ;
-      int    nExit ;
-      string sTcPos ;
-      int    nComp ;
-      double dDiam ;
-      double dTDiam ;
-      double dLen ;
-      double dTLen ;
-      double dMaxSpeed ;
-      MyToolData( void)
-         : sName(), sHead(), nExit( 0), sTcPos(), nComp(0), dDiam( 0), dLen( 0), dMaxSpeed( 0) {}
-   } ;
-   typedef vector<MyToolData>   TDATAVECTOR ;
-   TDATAVECTOR vTdata ;
-  // ciclo sulle lavorazioni per ricavare gli utensili utilizzati
-   int nOpId = m_pMchMgr->GetFirstActiveOperation() ;
-   while ( nOpId != GDB_ID_NULL) {
-     // processo l'operazione
-      int nType = m_pMchMgr->GetOperationType( nOpId) ;
-      if ( IsValidMachiningType( nType)) {
-        // Imposto come lavorazione corrente
-         if ( ! m_pMchMgr->SetCurrMachining( nOpId))
-            return false ;
-        // Recupero l'utensile della lavorazione corrente
-         string sTuuid, sTool ;
-         if ( ! m_pMchMgr->GetMachiningParam( MPA_TUUID, sTuuid)  ||
-              ! m_pMchMgr->TdbGetToolFromUUID( sTuuid, sTool))
-            return false ;
-        // Recupero i dati dell'utensile
-         MyToolData Tdata ;
-         if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
-            Tdata.sName = sTool ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, Tdata.sHead) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, Tdata.nExit) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, Tdata.sTcPos) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, Tdata.nComp) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, Tdata.dDiam) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, Tdata.dTDiam) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, Tdata.dLen) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, Tdata.dTLen) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, Tdata.dMaxSpeed) ;
-            vTdata.push_back( Tdata) ;
-         }
-      }
-     // passo alla operazione successiva
-      nOpId = m_pMchMgr->GetNextActiveOperation( nOpId) ;
-   }
-
-   bool bOk = true ;
-
-  // se definito attrezzaggio
-   if ( m_pMchMgr->GetCurrSetupMgr().Exists()) {
-     // verifico che tutti gli utensili siano attrezzati
-      for ( size_t i = 0 ;  i < vTdata.size() ; ++ i) {
-         if ( ! m_pMchMgr->GetCurrSetupMgr().FindTool( vTdata[i].sName)) {
-            string sErr = "Error : " + vTdata[i].sName + " missing in setup " ;
-            LOG_INFO( GetEMkLogger(), sErr.c_str())
-            bOk = false ;
-         }
-      }
-     // emetto l'elenco di tutti gli utensili attrezzati
-      string sTcPos ; string sHead ; int nExit ; string sTool ;
-      for ( int i = 1 ; m_pMchMgr->GetCurrSetupMgr().GetPosData( i, sTcPos, sHead , nExit, sTool); ++ i) {
-        // se nella posizione non c'è utensile, vado oltre 
-         if ( sTool.empty())
-            continue ;
-        // emetto i dati
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, sTool) ;
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, sHead) ;
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ;
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ;
-         if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
-            int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dMaxSpeed ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, nComp) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, dDiam) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, dTDiam) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, dLen) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, dTLen) ;
-            m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, dMaxSpeed) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, nComp) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, dDiam) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, dTDiam) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TLEN, dLen) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTLEN, dTLen) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, dMaxSpeed) ;
-         }
-         // se esiste, chiamo la funzione di emissione dati utensile
-         if ( m_pMachine->LuaExistsFunction( ON_TOOL_DATA))
-            bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_DATA) ;
-      }
-   }
-
-  // altrimenti emetto direttamente gli utensili
-   else {
-     // ordino l'elenco degli utensili
-      std::sort( vTdata.begin(), vTdata.end(), []( const MyToolData& a, const MyToolData& b)
-                                                 { if ( a.sHead == b.sHead)
-                                                      return a.nExit < b.nExit ;
-                                                   else
-                                                      return a.sHead < b.sHead ; }) ;
-     // emetto l'elenco degli utensili
-      string sPrevHead ; int nPrevExit = 0 ; string sPrevTcPos ; string sPrevTool ;
-      for ( size_t i = 0 ;  i < vTdata.size() ; ++ i) {
-        // se posizione diversa (testa o uscita o toolchanger)
-         if ( vTdata[i].sHead != sPrevHead  ||  vTdata[i].nExit != nPrevExit  ||
-              vTdata[i].sTcPos != sPrevTcPos) {
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, vTdata[i].sName) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, vTdata[i].sHead) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, vTdata[i].nExit) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, vTdata[i].sTcPos) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, vTdata[i].nComp) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, vTdata[i].dDiam) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, vTdata[i].dTDiam) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TLEN, vTdata[i].dLen) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTLEN, vTdata[i].dTLen) ;
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, vTdata[i].dMaxSpeed) ;
-           // se esiste, chiamo la funzione di emissione dati utensile
-            if ( m_pMachine->LuaExistsFunction( ON_TOOL_DATA))
-               bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_DATA) ;
-           // salvo dati correnti come precedenti
-            sPrevHead = vTdata[i].sHead ;
-            nPrevExit = vTdata[i].nExit ;
-            sPrevTool = vTdata[i].sName ;
-            sPrevTcPos = vTdata[i].sTcPos ;
-         }
-        // altrimenti
-         else {
-            if ( vTdata[i].sName != sPrevTool) {
-               string sErr = "Error : two tools in same position : " + sPrevTool + "<->" + vTdata[i].sName ;
-               LOG_INFO( GetEMkLogger(), sErr.c_str())
-               bOk = false ;
-            }
-         }
-      }
-   }
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnDispositionStart( int nOpId, int nOpInd, int nPhase, bool bEmpty, bool bSomeByHand)
-{
-  // assegno identificativo e indice disposizione
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPID, nOpId) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPIND, nOpInd) ;
-  // assegno nuovo indice di fase
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PHASE, nPhase) ;
-  // assegno flag disposizione passiva
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EMPTY, bEmpty) ;
-  // assegno flag disposizione con operazioni manuali
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SBH, bSomeByHand) ;
-  // chiamo la funzione di inizio disposizione
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_DISPOSITION_START) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnDispositionEnd( void)
-{
-  // chiamo la funzione di fine disposizione
-   bool bOk = m_pMachine->LuaCallFunction( ON_DISPOSITION_END) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnTableData( const string& sName, const Point3d& ptOri1)
-{
-  // assegno nome tavola e valore riferimento
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TABNAME, sName) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TABORI1, ptOri1) ;
-  // chiamo la funzione di gestione dati tavola
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_TABLE_DATA) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnFixtureData( int nFixId, int nFixInd, const string& sName, const Point3d& ptPos,
-                          double dAngDeg, double dMov)
-{
-  // assegno dati bloccaggio
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXID, nFixId) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXIND, nFixInd) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXNAME, sName) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXPOS, ptPos) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXANG, dAngDeg) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXMOB, dMov) ;
-  // chiamo la funzione di gestione dati bloccaggio
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_FIXTURE_DATA) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnRawMoveData( int nRawId, int RawMoveInd, int nType, const Point3d& ptPos, int nFlag)
-{
-  // assegno dati bloccaggio
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWID, nRawId) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWIND, RawMoveInd) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWTYPE, nType) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWPOS, ptPos) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWFLAG, nFlag) ;
-  // chiamo la funzione di gestione movimento del grezzo
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_RAWMOVE_DATA) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnToolSelect( const string& sTool, const string& sHead, int nExit, const string& sTcPos)
-{
-  // assegno il nome dell'utensile, la testa, l'uscita e l'eventuale posizione nel toolchanger
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, sTool) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, sHead) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ;
-  // assegno il token e il nome degli assi
-   int nNumAxes = int( m_AxesName.size()) ;
-   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
-      if ( i <= nNumAxes) {
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken(i), m_AxesToken[i-1]) ;
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisName(i), m_AxesName[i-1]) ;
-      }
-      else {
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken(i)) ;
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisName(i)) ;
-      }
-   }
-  // chiamo la funzione di selezione utensile
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_SELECT) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnToolDeselect( const std::string& sNextTool, const string& sNextHead, int nNextExit, const string& sNextTcPos)
-{
-  // assegno il prossimo utensile
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTTOOL, sNextTool) ;
-  // assegno la prossima testa
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTHEAD, sNextHead) ;
-  // assegno la prossima uscita
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTEXIT, nNextExit) ;
-  // assegno l'eventuale prossima posizione nel TC
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTTCPOS, sNextTcPos) ;
-  // chiamo la funzione di deselezione utensile
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_TOOL_DESELECT) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnMachiningStart( int nOpId, int nOpInd, double dSpeed, const Point3d& ptMin, const Point3d& ptMax)
-{
-  // assegno identificativo e indice lavorazione
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHID, nOpId) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHIND, nOpInd) ;
-  // assegno speed
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_S, dSpeed) ;
-  // assegno punti estremi dell'ingombro della lavorazione
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MMIN, ptMin) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MMAX, ptMax) ;
-  // chiamo la funzione di inizio lavorazione
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_MACHINING_START) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnMachiningEnd( void)
-{
-  // chiamo la funzione di fine lavorazione
-   bool bOk = m_pMachine->LuaCallFunction( ON_MACHINING_END) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd,
-                        const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax, double dElev)
-{
-  // assegno identificativo e indice percorso di lavorazione
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHID, nClPathId) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHIND, nClPathInd) ;
-  // assegno numero di dati ausiliari iniziali
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXTOT, nAS) ;
-  // assegno punti iniziale e finale e versore estrusione del percorso originale
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_START, ptStart) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_END, ptEnd) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXTR, vtExtr) ;
-  // assegno punti estremi dell'ingombro del percorso di lavorazione
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PMIN, ptMin) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PMAX, ptMax) ;
-  // assegno la massima elevazione
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ELEV, dElev) ;
-  // chiamo la funzione di inizio percorso di lavorazione
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_START) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::OnPathEnd( int nAE)
-{
-  // assegno numero di dati ausiliari finali
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXTOT, nAE) ;
-  // chiamo la funzione di fine percorso di lavorazione
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_END) ;
-   return bOk ;
-}
- 
-//----------------------------------------------------------------------------
-bool
-Generator::OnPathStartAux( int nInd, const string& sAS)
-{
-  // verifico esistenza funzione
    if ( ! m_pMachine->LuaExistsFunction( ON_PATH_START_AUX))
       return true ;
-  // assegno indice e valore dato ausiliario
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXIND, nInd) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUX, sAS) ;
-  // chiamo la funzione di emissione dato ausiliario ad inizio percorso di lavorazione
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_START_AUX) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_PATH_START_AUX) ;
 }
- 
+
 //----------------------------------------------------------------------------
 bool
-Generator::OnPathEndAux( int nInd, const string& sAE)
+Generator::CallOnPathEndAux( void)
 {
-  // verifico esistenza funzione
    if ( ! m_pMachine->LuaExistsFunction( ON_PATH_END_AUX))
       return true ;
-  // assegno indice e valore dato ausiliario
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXIND, nInd) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUX, sAE) ;
-  // chiamo la funzione di emissione dato ausiliario alla fine percorso di lavorazione
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_END_AUX) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_PATH_END_AUX) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::OnRapid( int nMove, const DBLVECTOR& AxesEnd, int nAxesMask, int nFlag)
+Generator::CallOnRapid( void)
 {
-  // cancello variabili estranee
-   ResetArcData() ;
-  // assegno il tipo di movimento
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
-  // assegno il valore degli assi
-   int nNumAxes = int( AxesEnd.size()) ;
-   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
-      if ( i <= nNumAxes)
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
-      else
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
-   }
-  // assegno la mascheratura degli assi
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MASK, nAxesMask) ;
-  // assegno il valore del flag
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ;
-  // chiamo la funzione di movimento in rapido
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_RAPID) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_RAPID) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::OnLinear( int nMove, const DBLVECTOR& AxesEnd, double dFeed, int nFlag)
+Generator::CallOnLinear( void)
 {
-  // cancello variabili estranee
-   ResetArcData() ;
-  // assegno il tipo di movimento
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
-  // assegno il valore degli assi
-   int nNumAxes = int( AxesEnd.size()) ;
-   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
-      if ( i <= nNumAxes)
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
-      else
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
-   }
-  // assegno il valore della feed
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_F, dFeed) ;
-  // assegno il valore del flag
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ;
-  // chiamo la funzione di movimento in rapido
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_LINEAR) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_LINEAR) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Generator::OnArc( int nMove, const DBLVECTOR& AxesEnd, const Point3d& ptCen, const Point3d& ptMid,
-                  double dRad, double dAngCen, double dFeed, int nFlag)
+Generator::CallOnArc( void)
 {
-  // assegno il tipo di movimento
-   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
-  // assegno il valore degli assi
-   int nNumAxes = int( AxesEnd.size()) ;
-   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
-      if ( i <= nNumAxes)
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
-      else
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
-   }
-  // assegno le coordinate del centro
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C1, ptCen.x) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C2, ptCen.y) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C3, ptCen.z) ; 
-  // assegno le coordinate del punto medio
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M1, ptMid.x) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M2, ptMid.y) ;
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M3, ptMid.z) ; 
-  // assegno il valore del raggio
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RR, dRad) ;
-  // assegno il valore dell'angolo al centro
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AC, dAngCen) ;
-  // assegno il valore della feed
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_F, dFeed) ;
-  // assegno il valore del flag
-   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ;
-  // chiamo la funzione di movimento in rapido
-   bOk = bOk && m_pMachine->LuaCallFunction( ON_ARC) ;
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Generator::ResetArcData( void)
-{
-  // reset dati arco
-   bool bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C1) ;
-   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C2) ;
-   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C3) ;
-   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_RR) ;
-   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_AC) ;
-   return bOk ;
+   return m_pMachine->LuaCallFunction( ON_ARC) ;
 }
diff --git a/Generator.h b/Generator.h
index fc97841..af0a659 100644
--- a/Generator.h
+++ b/Generator.h
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2018
 //----------------------------------------------------------------------------
-// File : Generator.h           Data : 28.10.15          Versione : 1.6j4
+// File : Generator.h           Data : 29.05.18          Versione : 1.8e6
 // Contenuto : Dichiarazione della classe Generator.
 //
 //
@@ -13,14 +13,10 @@
 
 #pragma once
 
-#include "CamData.h"
-
-class MachMgr ;
-class IGeomDB ;
-class Machine ;
+#include "Processor.h"
 
 //----------------------------------------------------------------------------
-class Generator
+class Generator : public Processor
 {
    public :
       Generator( void) ;
@@ -29,47 +25,25 @@ class Generator
       bool Run( const std::string& sCncFile, const std::string& sInfo) ;
 
    private :
-      bool VerifySetup( void) ;
-      bool ProcessDisposition( int nOpId, int nOpInd) ;
-      bool ProcessMachining( int nOpId, int nOpInd) ;
-      bool ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd) ;
-      bool ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd, int nOpId, int nOpInd) ;
-      bool UpdateTool( const std::string& sTool) ;
-      bool UpdateDispTool( const std::string& sTool, const std::string& sHead, int nExit) ;
-      bool UpdateAxes( void) ;
-      bool OnStart( void) ;
-      bool OnEnd( void) ;
-      bool OnProgramStart( const std::string& sMachName, const std::string& sCncFile, const std::string& sInfo, bool bSetup) ;
-      bool OnProgramEnd( void) ;
-      bool ProcessToolData( void) ;
-      bool OnToolSelect( const std::string& sTool, const std::string& sHead, int nExit, const std::string& sTcPos) ;
-      bool OnToolDeselect( const std::string& sNextTool, const std::string& sNextHead, int nNextExit, const std::string& sNextTcPos) ;
-      bool OnDispositionStart( int nOpId, int nOpInd, int nPhase, bool bEmpty, bool bSomeByHand) ;
-      bool OnDispositionEnd( void) ;
-      bool OnTableData( const std::string& sName, const Point3d& ptOri1) ;
-      bool OnFixtureData( int nFixId, int nFixInd, const std::string& sName,
-                          const Point3d& ptPos, double dAngDeg, double dMov) ;
-      bool OnRawMoveData( int nRawId, int RawMoveInd, int nType, const Point3d& ptPos, int nFlag) ;
-      bool OnMachiningStart( int nOpId, int nOpInd, double dSpeed, const Point3d& ptMin, const Point3d& ptMax) ;
-      bool OnMachiningEnd( void) ;
-      bool OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd,
-                        const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax, double dElev) ;
-      bool OnPathEnd( int nAE) ;
-      bool OnPathStartAux( int nInd, const std::string& sAS) ;
-      bool OnPathEndAux( int nInd, const std::string& sAE) ;
-      bool OnRapid( int nMove, const DBLVECTOR& AxesEnd, int nAxesMask, int nFlag) ;
-      bool OnLinear( int nMove, const DBLVECTOR& AxesEnd, double dFeed, int nFlag) ;
-      bool OnArc( int nMove, const DBLVECTOR& AxesEnd, const Point3d& ptCen, const Point3d& ptMid,
-                  double dRad, double dAngCen, double dFeed, int nFlag) ;
-      bool ResetArcData( void) ;
-
-   private :
-      MachMgr*      m_pMchMgr ;              // puntatore al gestore di tutte le lavorazioni
-      IGeomDB*      m_pGeomDB ;              // puntatore al DB geometrico
-      Machine*      m_pMachine ;             // puntatore alla macchina
-      std::string   m_sPrevTool ;            // nome dell'utensile precedente
-      std::string   m_sTool ;                // nome dell'utensile corrente
-      STRVECTOR     m_AxesName ;             // nomi degli assi macchina attivi
-      STRVECTOR     m_AxesToken ;            // token degli assi macchina attivi
-      DBLVECTOR     m_AxesVal ;              // valori degli assi macchina all'inizio del movimento corrente
+      bool CallOnStart( void) override ;
+      bool CallOnEnd( void) override ;
+      bool CallOnProgramStart( void) override ;
+      bool CallOnProgramEnd( void) override ;
+      bool CallOnToolData( void) override ;
+      bool CallOnDispositionStart( void) override ;
+      bool CallOnDispositionEnd( void) override ;
+      bool CallOnTableData( void) override ;
+      bool CallOnFixtureData( void) override ;
+      bool CallOnRawMoveData( void) override ;
+      bool CallOnToolSelect( void) override ;
+      bool CallOnToolDeselect( void) override ;
+      bool CallOnMachiningStart( void) override ;
+      bool CallOnMachiningEnd( void) override ;
+      bool CallOnPathStart( void) override ;
+      bool CallOnPathEnd( void) override ;
+      bool CallOnPathStartAux( void) override ;
+      bool CallOnPathEndAux( void) override ;
+      bool CallOnRapid( void) override ;
+      bool CallOnLinear( void) override ;
+      bool CallOnArc( void) override ;
 } ;
diff --git a/MachMgr.h b/MachMgr.h
index 488085e..2288d51 100644
--- a/MachMgr.h
+++ b/MachMgr.h
@@ -273,6 +273,7 @@ class MachMgr : public IMachMgr
       bool SimStop( void) override ;
      // Generation
       bool Generate( const std::string& sCncFile, const std::string& sInfo) override ;
+      bool Estimate( const std::string& sEstFile, const std::string& sInfo) override ;
      // Machine Calc
       bool SetCalcTable( const std::string& sTable) override ;
       bool SetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) override ;
diff --git a/MachMgrGeneration.cpp b/MachMgrGeneration.cpp
index b9ab9d1..03cd33b 100644
--- a/MachMgrGeneration.cpp
+++ b/MachMgrGeneration.cpp
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2018
 //----------------------------------------------------------------------------
-// File : MachMgrGeneration.cpp       Data : 28.10.15       Versione : 1.6j4
+// File : MachMgrGeneration.cpp       Data : 29.05.18       Versione : 1.8e6
 // Contenuto : Implementazione gestione generazione della classe MachMgr.
 //
 //
@@ -17,12 +17,13 @@
 #include "MachMgr.h"
 #include "MachConst.h"
 #include "Generator.h"
+#include "Estimator.h"
 
 using namespace std ;
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::Generate( const string& sCncFile, const std::string& sInfo)
+MachMgr::Generate( const string& sCncFile, const string& sInfo)
 {
   // inizializzazione generatore
    Generator genPP ;
@@ -38,3 +39,22 @@ MachMgr::Generate( const string& sCncFile, const std::string& sInfo)
 
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+MachMgr::Estimate( const string& sEstFile, const string& sInfo)
+{
+  // inizializzazione generatore
+   Estimator estPP ;
+   if ( ! estPP.Init( this)) {
+      LOG_ERROR( GetEMkLogger(), "Error on Estimate Init")
+      return false ;
+   }
+  // esecuzione della generazione
+   if ( ! estPP.Run( sEstFile, sInfo)) {
+      LOG_ERROR( GetEMkLogger(), "Error on Estimate Run")
+      return false ;
+   }
+
+   return true ;
+}
diff --git a/OutputConst.h b/OutputConst.h
index ea74198..01d6663 100644
--- a/OutputConst.h
+++ b/OutputConst.h
@@ -147,13 +147,13 @@ static const std::string ON_END = "OnEnd" ;
 static const std::string ON_PROGRAM_START = "OnProgramStart" ;
 static const std::string ON_PROGRAM_END = "OnProgramEnd" ;
 static const std::string ON_TOOL_DATA = "OnToolData" ;
-static const std::string ON_TOOL_SELECT = "OnToolSelect" ;
-static const std::string ON_TOOL_DESELECT = "OnToolDeselect" ;
 static const std::string ON_DISPOSITION_START = "OnDispositionStart" ;
 static const std::string ON_DISPOSITION_END = "OnDispositionEnd" ;
 static const std::string ON_TABLE_DATA = "OnTableData" ;
 static const std::string ON_FIXTURE_DATA = "OnFixtureData" ;
 static const std::string ON_RAWMOVE_DATA = "OnRawMoveData" ;
+static const std::string ON_TOOL_SELECT = "OnToolSelect" ;
+static const std::string ON_TOOL_DESELECT = "OnToolDeselect" ;
 static const std::string ON_MACHINING_START = "OnMachiningStart" ;
 static const std::string ON_MACHINING_END = "OnMachiningEnd" ;
 static const std::string ON_PATH_START = "OnPathStart" ;
@@ -163,6 +163,28 @@ static const std::string ON_PATH_END_AUX = "OnPathEndAux" ;
 static const std::string ON_RAPID = "OnRapid" ;
 static const std::string ON_LINEAR = "OnLinear" ;
 static const std::string ON_ARC = "OnArc" ;
+// Funzioni stima
+static const std::string ON_ESTIM_START = "OnEstimStart" ;
+static const std::string ON_ESTIM_END = "OnEstimEnd" ;
+static const std::string ON_ESTIM_PROGRAM_START = "OnEstimProgramStart" ;
+static const std::string ON_ESTIM_PROGRAM_END = "OnEstimProgramEnd" ;
+static const std::string ON_ESTIM_TOOL_DATA = "OnEstimToolData" ;
+static const std::string ON_ESTIM_DISPOSITION_START = "OnEstimDispositionStart" ;
+static const std::string ON_ESTIM_DISPOSITION_END = "OnEstimDispositionEnd" ;
+static const std::string ON_ESTIM_TABLE_DATA = "OnEstimTableData" ;
+static const std::string ON_ESTIM_FIXTURE_DATA = "OnEstimFixtureData" ;
+static const std::string ON_ESTIM_RAWMOVE_DATA = "OnEstimRawMoveData" ;
+static const std::string ON_ESTIM_TOOL_SELECT = "OnEstimToolSelect" ;
+static const std::string ON_ESTIM_TOOL_DESELECT = "OnEstimToolDeselect" ;
+static const std::string ON_ESTIM_MACHINING_START = "OnEstimMachiningStart" ;
+static const std::string ON_ESTIM_MACHINING_END = "OnEstimMachiningEnd" ;
+static const std::string ON_ESTIM_PATH_START = "OnEstimPathStart" ;
+static const std::string ON_ESTIM_PATH_END = "OnEstimPathEnd" ;
+static const std::string ON_ESTIM_PATH_START_AUX = "OnEstimPathStartAux" ;
+static const std::string ON_ESTIM_PATH_END_AUX = "OnEstimPathEndAux" ;
+static const std::string ON_ESTIM_RAPID = "OnEstimRapid" ;
+static const std::string ON_ESTIM_LINEAR = "OnEstimLinear" ;
+static const std::string ON_ESTIM_ARC = "OnEstimArc" ;
 // Funzioni simulazione
 static const std::string ON_SIMUL_START = "OnSimulStart" ;
 static const std::string ON_SIMUL_END = "OnSimulEnd" ;
diff --git a/Processor.cpp b/Processor.cpp
new file mode 100644
index 0000000..0bc8901
--- /dev/null
+++ b/Processor.cpp
@@ -0,0 +1,1024 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2018-2018
+//----------------------------------------------------------------------------
+// File : Processor.cpp           Data : 29.05.18          Versione : 1.9e6
+// Contenuto : Implementazione della classe Processor.
+//
+//
+//
+// Modifiche : 29.05.18 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "DllMain.h"
+#include "Processor.h"
+#include "MachMgr.h"
+#include "Disposition.h"
+#include "Machining.h"
+#include "MachiningConst.h"
+#include "OutputConst.h"
+#include "/EgtDev/Include/EMkToolConst.h"
+#include "/EgtDev/Include/EMkOperationConst.h"
+#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkStringUtils3d.h"
+#include "/EgtDev/Include/EGnFileUtils.h"
+
+using namespace std ;
+
+//------------------------------ Errors --------------------------------------
+// 1001 = "Error with setup : xxx"
+// 1002 = "Error opening Cnc file"
+
+//----------------------------------------------------------------------------
+static const string ERR_EXT = ".err" ;
+
+//----------------------------------------------------------------------------
+Processor::Processor( void)
+{
+   m_pMchMgr = nullptr ;
+   m_pGeomDB = nullptr ;
+   m_pMachine = nullptr ;
+   m_AxesName.reserve( 8) ;
+   m_AxesToken.reserve( 8) ;
+   m_AxesVal.reserve( 8) ;
+}
+
+//----------------------------------------------------------------------------
+Processor::~Processor( void)
+{
+
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::Init( MachMgr* pMchMgr)
+{
+  // verifico ambiente
+   if ( pMchMgr == nullptr  ||  pMchMgr->GetContextId() == 0  ||
+        pMchMgr->GetGeomDB() == nullptr  ||  pMchMgr->GetCurrMachine() == nullptr)
+      return false ;
+   m_pMchMgr = pMchMgr ;
+   m_pGeomDB = m_pMchMgr->GetGeomDB() ;
+   m_pMachine = m_pMchMgr->GetCurrMachine() ;
+   m_sPrevTool.clear() ;
+   m_sTool.clear() ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::Run( const string& sOutFile, const std::string& sInfo)
+{
+  // verifico ci sia una macchinata corrente
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr  ||  m_pMachine == nullptr  ||
+        m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL)
+      return false ;
+   m_pMchMgr->ResetLastError() ;
+
+  // forzo aggiornamento attrezzaggio della macchinata
+   m_pMchMgr->UpdateSetup() ;
+   if ( ! VerifySetup())
+      return false ;
+
+  // evento inizio esecuzione
+   bool bOk = true ;
+   if ( ! OnStart()) {
+      bOk = false ;
+      LOG_INFO( GetEMkLogger(), "OnStart error") ;
+   }
+
+  // apertura file di output ed evento inizio programma
+   if ( bOk  &&  ! OnProgramStart( m_pMachine->GetMachineName(), sOutFile, sInfo, m_pMchMgr->GetCurrSetupMgr().Exists())) {
+      bOk = false ;
+      LOG_INFO( GetEMkLogger(), "OnProgramStart error") ;
+   }
+
+  // emissione dati utensili
+   if ( bOk  &&  ! ProcessToolData()) {
+      bOk = false ;
+      LOG_INFO( GetEMkLogger(), "ProcessToolData error") ;
+   }
+
+  // ciclo su tutte le operazioni della macchinata
+   int nInd = 0 ;
+   int nOpId = m_pMchMgr->GetFirstActiveOperation() ;
+   while ( bOk  &&  nOpId != GDB_ID_NULL) {
+     // incremento l'indice della operazione
+      ++ nInd ;
+     // la prima operazione deve essere una disposizione
+      if ( nInd == 1) {
+         if ( m_pMchMgr->GetOperationType( nOpId) != OPER_DISP) {
+            bOk = false ;
+            continue ;
+         }
+      }
+     // processo l'operazione
+      int nType = m_pMchMgr->GetOperationType( nOpId) ;
+      if ( IsValidDispositionType( nType)) {
+         if ( ! ProcessDisposition( nOpId, nInd))
+            bOk = false ;
+      }
+      else if ( IsValidMachiningType( nType)) {
+         if ( ! ProcessMachining( nOpId, nInd))
+            bOk = false ;
+      }
+     // passo alla operazione successiva
+      nOpId = m_pMchMgr->GetNextActiveOperation( nOpId) ;
+   }
+
+  // evento fine programma
+   if ( bOk  &&  ! OnProgramEnd()) {
+      bOk = false ;
+      LOG_INFO( GetEMkLogger(), "OnProgramEnd error") ;
+   }
+  // chiudo il file di output
+   if ( ! m_pMachine->WriterClose())
+      bOk = false ;
+
+  // evento fine esecuzione
+   if ( ! OnEnd()) {
+      bOk = false ;
+      LOG_INFO( GetEMkLogger(), "OnEnd error") ;
+   }
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::VerifySetup( void)
+{
+  // se attrezzaggio non definito, nulla da verificare
+   if ( ! m_pMchMgr->GetCurrSetupMgr().Exists())
+      return true ;
+
+  // lancio la verifica
+   STRVECTOR vsErr ;
+   if ( m_pMchMgr->VerifyCurrSetup( vsErr))
+      return true ;
+
+  // gestisco errore
+   string sErr = "Error with setup :" ;
+   for each( const auto& sTmp in vsErr)
+      sErr += " " + sTmp ;
+   m_pMchMgr->SetLastError( 1001, sErr) ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::ProcessDisposition( int nOpId, int nOpInd)
+{
+  // Parametri della disposizione
+   Disposition* pDisp = GetDisposition( m_pGeomDB->GetUserObj( nOpId)) ;
+   if ( pDisp == nullptr)
+      return false ;
+
+  // Imposto la fase
+   int nPhase = pDisp->GetPhase() ;
+   m_pMchMgr->SetCurrPhase( nPhase) ;
+   bool bEmpty = pDisp->IsEmpty() ;
+   bool bSomeByHand = pDisp->GetSomeByHand() ;
+
+  // Se disposizione con movimenti macchina
+   if ( ! pDisp->IsEmpty()) {
+     // Recupero l'utensile della disposizione corrente
+      string sTool ; string sHead ; int nExit ; string sTcPos ;
+      if ( ! pDisp->GetToolData( sTool, sHead, nExit, sTcPos))
+         return false ;
+     // Se esiste utensile corrente e cambierà, lo scarico
+      if ( ! m_sTool.empty()  &&  m_sTool != sTool) {
+        // emetto deselezione vecchio utensile
+         if ( ! OnToolDeselect( sTool, sHead, nExit, sTcPos))
+            return false ;
+      }
+     // Aggiorno utensile e assi macchina
+      if ( ! UpdateDispTool( sTool, sHead, nExit)  ||  ! UpdateAxes())
+         return false ;
+     // Se utensile non definito o cambiato, emetto selezione nuovo utensile
+      if ( m_sTool.empty()  ||  m_sTool != m_sPrevTool) {
+         if ( ! OnToolSelect( sTool, sHead, nExit, sTcPos))
+            return false ;
+      }
+   }
+
+  // Emetto inizio disposizione
+   if ( ! OnDispositionStart( nOpId, nOpInd, nPhase, bEmpty, bSomeByHand))
+      return false ;
+
+  // Emetto dati tavola
+   string sTable ;
+   pDisp->GetTable( sTable) ;
+   Point3d ptOri1 ;
+   pDisp->GetTableRef1( ptOri1) ;
+   if ( ! OnTableData( sTable, ptOri1))
+      return false ;
+
+  // Emetto dati bloccaggi
+   for ( int i = 0 ;  ; ++ i) {
+      string sName ;
+      int nId ;
+      Point3d ptPos ;
+      double dAngDeg ;
+      double dMov ;
+      if ( pDisp->GetFixtureData( i, sName, nId, ptPos, dAngDeg, dMov)) {
+         if ( ! OnFixtureData( nId, i + 1, sName,  ptPos, dAngDeg, dMov))
+            return false ;
+      }
+      else
+         break ;
+   }
+
+  // Emetto movimenti sui grezzi
+   for ( int i = 0 ;  ; ++ i) {
+      int nRawId ;
+      int nType ;
+      Point3d ptPos ;
+      int nFlag ;
+      if ( pDisp->GetMoveRawData( i, nRawId, nType, ptPos, nFlag)) {
+         if ( ! OnRawMoveData( nRawId, i + 1, nType,  ptPos, nFlag))
+            return false ;
+      }
+      else
+         break ;
+   }
+   bool bOk = true ;
+
+  // Se disposizione con movimenti macchina
+   if ( ! pDisp->IsEmpty()) {
+     // Ciclo su tutti i percorsi CL della disposizione
+      int nClPathInd = 0 ;
+      int nClId = m_pGeomDB->GetFirstNameInGroup( nOpId, MCH_CL) ;
+      int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
+      while ( bOk  &&  nClPathId != GDB_ID_NULL) {
+         ++ nClPathInd ;
+        // processo il percorso di lavoro
+         if ( ! ProcessClPath( nClPathId, nClPathInd, nOpId, nOpInd))
+            bOk = false ;
+        // passo al percorso successivo
+         nClPathId = m_pGeomDB->GetNextGroup( nClPathId) ;
+      }
+   }
+
+  // Emetto fine disposizione
+   bOk = bOk && OnDispositionEnd() ;
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::ProcessMachining( int nOpId, int nOpInd)
+{
+  // Imposto come lavorazione corrente
+   if ( ! m_pMchMgr->SetCurrMachining( nOpId))
+      return false ;
+
+  // Verifico non sia vuota
+   if ( m_pMchMgr->IsMachiningEmpty())
+      return true ;
+
+  // Recupero l'utensile della lavorazione corrente
+   string sTuuid, sTool ;
+   if ( ! m_pMchMgr->GetMachiningParam( MPA_TUUID, sTuuid)  ||
+        ! m_pMchMgr->TdbGetToolFromUUID( sTuuid, sTool))
+      return false ;
+
+  // Se utensile cambierà
+   if ( ! m_sTool.empty()  &&  m_sTool != sTool) {
+     // recupero la testa del prossimo utensile (prima dall'attrezzaggio, poi dal DB utensili)
+      string sNextTcPos ; string sNextHead ; int nNextExit ;
+      if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( sTool, sNextTcPos, sNextHead, nNextExit)) {
+         if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, sNextTcPos) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sNextHead) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nNextExit) ;
+         }
+        // ripristino l'utensile corrente
+         m_pMchMgr->TdbSetCurrTool( m_sTool) ;
+      }
+     // emetto deselezione vecchio utensile
+      if ( ! OnToolDeselect( sTool, sNextHead, nNextExit, sNextTcPos))
+         return false ;
+   }
+  // Aggiorno utensile e assi macchina
+   if ( ! UpdateTool( sTool)  ||  ! UpdateAxes())
+      return false ;
+  // Se utensile cambiato, emetto selezione nuovo utensile
+   if ( m_sTool != m_sPrevTool) {
+      string sTcPos ; string sHead ; int nExit ;
+      if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( m_sTool, sTcPos, sHead, nExit)) {
+         m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ;
+         m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ;
+         m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, sTcPos) ;
+      }
+      if ( ! OnToolSelect( sTool, sHead, nExit, sTcPos))
+         return false ;
+   }
+
+  // Recupero speed
+   double dSpeed ;
+   if ( ! m_pMchMgr->GetMachiningParam( MPA_SPEED, dSpeed))
+      return false ;
+
+  // Recupero punti di minimo e massimo ingombro
+   int nClId = m_pGeomDB->GetFirstNameInGroup( nOpId, MCH_CL) ;
+   Point3d ptMin, ptMax ;
+   m_pGeomDB->GetInfo( nClId, KEY_MMIN, ptMin) ;
+   m_pGeomDB->GetInfo( nClId, KEY_MMAX, ptMax) ;
+
+  // Emetto inizio lavorazione
+   if ( ! OnMachiningStart( nOpId, nOpInd, dSpeed, ptMin, ptMax))
+      return false ;
+
+  // Ciclo su tutti i percorsi CL della lavorazione
+   bool bOk = true ;
+   int nClPathInd = 0 ;
+   int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
+   while ( bOk  &&  nClPathId != GDB_ID_NULL) {
+      ++ nClPathInd ;
+     // processo il percorso di lavoro
+      if ( ! ProcessClPath( nClPathId, nClPathInd, nOpId, nOpInd))
+         bOk = false ;
+     // passo al percorso successivo
+      nClPathId = m_pGeomDB->GetNextGroup( nClPathId) ;
+   }
+
+  // Emetto fine lavorazione
+   bOk = bOk && OnMachiningEnd() ;
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd)
+{
+  // Recupero punti di inizio e fine del percorso
+   Point3d ptStart ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_START, ptStart) ;
+   Point3d ptEnd ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_END, ptEnd) ;
+  // Recupero versore estrusione associato al percorso (normale al piano di interpolazione)
+   Vector3d vtExtr ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_EXTR, vtExtr) ;
+  // Recupero punti di minimo e massimo ingombro
+   Point3d ptMin, ptMax ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_PMIN, ptMin) ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_PMAX, ptMax) ;
+  // Recupero massima elevazione
+   double dElev = 0 ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_ELEV, dElev) ;
+  // Recupero il numero di eventi ausiliari iniziali
+   int nAS = 0 ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_AS_TOT, nAS) ;
+  // Emetto inizio percorso di lavoro
+   if ( ! OnPathStart( nClPathId, nClPathInd, nAS, ptStart, ptEnd, vtExtr, ptMin, ptMax, dElev))
+      return false ;
+
+  // Emissione eventuali dati ausiliari di inizio
+  // processo gli eventi
+   for ( int i = 1 ; i <= nAS ; ++ i) {
+     // recupero i dati per l'evento 
+      string sAS ;
+      if ( ! m_pGeomDB->GetInfo( nClPathId, KEY_AS + ToString( i), sAS))
+         return false ;
+     // richiamo gestione evento ausiliario prima di inizio percorso di lavoro
+      if ( ! OnPathStartAux( i, sAS))
+         return false ;
+   }
+
+  // Ciclo su tutte le entità del percorso CL
+   bool bOk = true ;
+   int nEntInd = 0 ;
+   int nEntId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
+   while ( bOk  &&  nEntId != GDB_ID_NULL) {
+      ++ nEntInd ;
+     // processo l'entità
+      if ( ! ProcessClEnt( nEntId, nEntInd, nClPathId, nClPathInd, nOpId, nOpInd))
+         bOk = false ;
+     // passo all'entità successivo
+      nEntId = m_pGeomDB->GetNext( nEntId) ;
+   }
+
+  // Recupero il numero di eventi ausiliari finali
+   int nAE = 0 ;
+   m_pGeomDB->GetInfo( nClPathId, KEY_AE_TOT, nAE) ;
+
+  // Emetto fine percorso di lavoro
+   bOk = bOk && OnPathEnd( nAE) ;
+
+  // Emissione eventuali dati ausiliari di fine
+  // processo gli eventi
+   for ( int i = 1 ; i <= nAE ; ++ i) {
+     // recupero i dati per l'evento 
+      string sAE ;
+      if ( ! m_pGeomDB->GetInfo( nClPathId, KEY_AE + ToString( i), sAE))
+         return false ;
+     // richiamo gestione evento ausiliario dopo fine percorso di lavoro
+      if ( ! OnPathEndAux( i, sAE))
+         return false ;
+   }
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd, int nOpId, int nOpInd)
+{
+  // Recupero i dati Cam
+   CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
+   if ( pCamData == nullptr  ||  pCamData->GetAxesStatus() != CamData::AS_OK)
+      return false ;
+   const DBLVECTOR& AxesEnd = pCamData->GetAxesVal() ;
+  // Emetto movimento
+   int nMove = pCamData->GetMoveType() ;
+   switch ( nMove) {
+   case 0 :      // rapido
+      if ( ! OnRapid( nMove, AxesEnd, pCamData->GetAxesMask(), pCamData->GetFlag()))
+         return false ;
+      break ;
+   case 1 :      // linea
+      if ( ! OnLinear( nMove, AxesEnd, pCamData->GetFeed(), pCamData->GetFlag()))
+         return false ;
+      break ;
+   case 2 :      // arco CW
+   case 3 :      // arco CCW
+      Point3d ptMid( AxesEnd[0], AxesEnd[1], AxesEnd[2]) ;
+      ptMid.Rotate( pCamData->GetAxesCen(), pCamData->GetAxesNormDir(), - pCamData->GetAxesAngCen() / 2) ;
+      if ( ! OnArc( nMove, AxesEnd, pCamData->GetAxesCen(), ptMid, pCamData->GetAxesRad(), pCamData->GetAxesAngCen(),
+                    pCamData->GetFeed(), pCamData->GetFlag()))
+         return false ;
+      break ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::UpdateTool( const string& sTool)
+{
+  // Salvo l'utensile attuale come precedente
+   m_sPrevTool = m_sTool ;
+  // Se cambiato utensile ...
+   if ( sTool != m_sTool) {
+     // lo imposto come corrente
+      if ( ! m_pMchMgr->TdbSetCurrTool( sTool))
+         return false ;
+     // lo carico in macchina (se esiste attrezzaggio prendo i dati da questo)
+      string sTcPos ; string sHead ; int nExit ;
+      if ( ! m_pMchMgr->GetCurrSetupMgr().GetToolData( sTool, sTcPos, sHead, nExit)) {
+         m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ;
+         m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ;
+      }
+      if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit))
+         return false ;
+      m_sTool = sTool ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::UpdateDispTool( const string& sTool, const string& sHead, int nExit)
+{
+  // Salvo l'utensile attuale come precedente
+   m_sPrevTool = m_sTool ;
+  // Se non definito o cambiato ...
+   if ( sTool.empty()  ||  sTool != m_sTool) {
+     // lo carico in macchina
+      if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit))
+         return false ;
+      m_sTool = sTool ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::UpdateAxes( void)
+{
+  // Carico i nomi degli assi macchina attivi
+   return m_pMachine->GetAllCurrAxesName( m_AxesName) &&
+          m_pMachine->GetAllCurrAxesToken( m_AxesToken) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnStart( void)
+{
+  // definisco tavola variabili globali
+   bool bOk = m_pMachine->LuaCreateGlobTable( GLOB_VAR) ;
+  // assegno versione
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_VER, GetEMkVer()) ;
+  // assegno valori di default
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_USETO1, false) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MODAL, false) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NUM, false) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NUMTOK, "N") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_LINENBR, 0) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_LINEINC, 1) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C1T, "I") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C2T, "J") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C3T, "K") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M1T, "I") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M2T, "J") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M3T, "K") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RRT, "R") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FT, "F") ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ST, "S") ;
+  // chiamo la funzione
+   bOk = bOk && CallOnStart() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnEnd( void)
+{
+  // chiamo la funzione
+   bool bOk = CallOnEnd() ;
+  // rimuovo tavola variabili globali
+   bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR) && bOk ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnProgramStart( const string& sMachName, const string& sCncFile, const string& sInfo, bool bSetup)
+{
+  // apro il file di output
+   bool bOk = m_pMachine->WriterOpen( sCncFile) ;
+   if ( ! bOk)
+      m_pMchMgr->SetLastError( 1002, "Error opening Cnc file") ;
+  // assegno nome macchina
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MACHNAME, sMachName) ;
+  // assegno nome file
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FILE, sCncFile) ;
+  // assegno info
+   string sTxt = sInfo + " " + CurrDateTime() ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INFO, sTxt) ;
+  // assegno flag di presenza setup
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SETUP, bSetup) ;
+  // chiamo la funzione di inizio programma
+   bOk = bOk && CallOnProgramStart() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnProgramEnd( void)
+{
+  // chiamo fine programma
+   bool bOk = CallOnProgramEnd() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::ProcessToolData( void)
+{
+   struct MyToolData {
+      string sName ;
+      string sHead ;
+      int    nExit ;
+      string sTcPos ;
+      int    nComp ;
+      double dDiam ;
+      double dTDiam ;
+      double dLen ;
+      double dTLen ;
+      double dMaxSpeed ;
+      MyToolData( void)
+         : sName(), sHead(), nExit( 0), sTcPos(), nComp(0), dDiam( 0), dLen( 0), dMaxSpeed( 0) {}
+   } ;
+   typedef vector<MyToolData>   TDATAVECTOR ;
+   TDATAVECTOR vTdata ;
+  // ciclo sulle lavorazioni per ricavare gli utensili utilizzati
+   int nOpId = m_pMchMgr->GetFirstActiveOperation() ;
+   while ( nOpId != GDB_ID_NULL) {
+     // processo l'operazione
+      int nType = m_pMchMgr->GetOperationType( nOpId) ;
+      if ( IsValidMachiningType( nType)) {
+        // Imposto come lavorazione corrente
+         if ( ! m_pMchMgr->SetCurrMachining( nOpId))
+            return false ;
+        // Recupero l'utensile della lavorazione corrente
+         string sTuuid, sTool ;
+         if ( ! m_pMchMgr->GetMachiningParam( MPA_TUUID, sTuuid)  ||
+              ! m_pMchMgr->TdbGetToolFromUUID( sTuuid, sTool))
+            return false ;
+        // Recupero i dati dell'utensile
+         MyToolData Tdata ;
+         if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
+            Tdata.sName = sTool ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, Tdata.sHead) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, Tdata.nExit) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, Tdata.sTcPos) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, Tdata.nComp) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, Tdata.dDiam) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, Tdata.dTDiam) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, Tdata.dLen) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, Tdata.dTLen) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, Tdata.dMaxSpeed) ;
+            vTdata.push_back( Tdata) ;
+         }
+      }
+     // passo alla operazione successiva
+      nOpId = m_pMchMgr->GetNextActiveOperation( nOpId) ;
+   }
+
+   bool bOk = true ;
+
+  // se definito attrezzaggio
+   if ( m_pMchMgr->GetCurrSetupMgr().Exists()) {
+     // verifico che tutti gli utensili siano attrezzati
+      for ( size_t i = 0 ;  i < vTdata.size() ; ++ i) {
+         if ( ! m_pMchMgr->GetCurrSetupMgr().FindTool( vTdata[i].sName)) {
+            string sErr = "Error : " + vTdata[i].sName + " missing in setup " ;
+            LOG_INFO( GetEMkLogger(), sErr.c_str())
+            bOk = false ;
+         }
+      }
+     // emetto l'elenco di tutti gli utensili attrezzati
+      string sTcPos ; string sHead ; int nExit ; string sTool ;
+      for ( int i = 1 ; m_pMchMgr->GetCurrSetupMgr().GetPosData( i, sTcPos, sHead , nExit, sTool); ++ i) {
+        // se nella posizione non c'è utensile, vado oltre 
+         if ( sTool.empty())
+            continue ;
+        // emetto i dati
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, sTool) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, sHead) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ;
+         if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
+            int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dMaxSpeed ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, nComp) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, dDiam) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, dTDiam) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, dLen) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, dTLen) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, dMaxSpeed) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, nComp) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, dDiam) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, dTDiam) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TLEN, dLen) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTLEN, dTLen) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, dMaxSpeed) ;
+         }
+         // chiamo la funzione di emissione dati utensile
+         bOk = bOk && CallOnToolData() ;
+      }
+   }
+
+  // altrimenti emetto direttamente gli utensili
+   else {
+     // ordino l'elenco degli utensili
+      std::sort( vTdata.begin(), vTdata.end(), []( const MyToolData& a, const MyToolData& b)
+                                                 { if ( a.sHead == b.sHead)
+                                                      return a.nExit < b.nExit ;
+                                                   else
+                                                      return a.sHead < b.sHead ; }) ;
+     // emetto l'elenco degli utensili
+      string sPrevHead ; int nPrevExit = 0 ; string sPrevTcPos ; string sPrevTool ;
+      for ( size_t i = 0 ;  i < vTdata.size() ; ++ i) {
+        // se posizione diversa (testa o uscita o toolchanger)
+         if ( vTdata[i].sHead != sPrevHead  ||  vTdata[i].nExit != nPrevExit  ||
+              vTdata[i].sTcPos != sPrevTcPos) {
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, vTdata[i].sName) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, vTdata[i].sHead) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, vTdata[i].nExit) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, vTdata[i].sTcPos) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, vTdata[i].nComp) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, vTdata[i].dDiam) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, vTdata[i].dTDiam) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TLEN, vTdata[i].dLen) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTLEN, vTdata[i].dTLen) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SMAX, vTdata[i].dMaxSpeed) ;
+           // se esiste, chiamo la funzione di emissione dati utensile
+            bOk = bOk && CallOnToolData() ;
+           // salvo dati correnti come precedenti
+            sPrevHead = vTdata[i].sHead ;
+            nPrevExit = vTdata[i].nExit ;
+            sPrevTool = vTdata[i].sName ;
+            sPrevTcPos = vTdata[i].sTcPos ;
+         }
+        // altrimenti
+         else {
+            if ( vTdata[i].sName != sPrevTool) {
+               string sErr = "Error : two tools in same position : " + sPrevTool + "<->" + vTdata[i].sName ;
+               LOG_INFO( GetEMkLogger(), sErr.c_str())
+               bOk = false ;
+            }
+         }
+      }
+   }
+
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnDispositionStart( int nOpId, int nOpInd, int nPhase, bool bEmpty, bool bSomeByHand)
+{
+  // assegno identificativo e indice disposizione
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPID, nOpId) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_DISPIND, nOpInd) ;
+  // assegno nuovo indice di fase
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PHASE, nPhase) ;
+  // assegno flag disposizione passiva
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EMPTY, bEmpty) ;
+  // assegno flag disposizione con operazioni manuali
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_SBH, bSomeByHand) ;
+  // chiamo la funzione di inizio disposizione
+   bOk = bOk && CallOnDispositionStart() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnDispositionEnd( void)
+{
+  // chiamo la funzione di fine disposizione
+   bool bOk = CallOnDispositionEnd() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnTableData( const string& sName, const Point3d& ptOri1)
+{
+  // assegno nome tavola e valore riferimento
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TABNAME, sName) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TABORI1, ptOri1) ;
+  // chiamo la funzione di gestione dati tavola
+   bOk = bOk && CallOnTableData() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnFixtureData( int nFixId, int nFixInd, const string& sName, const Point3d& ptPos,
+                          double dAngDeg, double dMov)
+{
+  // assegno dati bloccaggio
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXID, nFixId) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXIND, nFixInd) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXNAME, sName) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXPOS, ptPos) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXANG, dAngDeg) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FIXMOB, dMov) ;
+  // chiamo la funzione di gestione dati bloccaggio
+   bOk = bOk && CallOnFixtureData() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnRawMoveData( int nRawId, int RawMoveInd, int nType, const Point3d& ptPos, int nFlag)
+{
+  // assegno dati bloccaggio
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWID, nRawId) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWIND, RawMoveInd) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWTYPE, nType) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWPOS, ptPos) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RAWFLAG, nFlag) ;
+  // chiamo la funzione di gestione movimento del grezzo
+   bOk = bOk && CallOnRawMoveData() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnToolSelect( const string& sTool, const string& sHead, int nExit, const string& sTcPos)
+{
+  // assegno il nome dell'utensile, la testa, l'uscita e l'eventuale posizione nel toolchanger
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TOOL, sTool) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, sHead) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ;
+  // assegno il token e il nome degli assi
+   int nNumAxes = int( m_AxesName.size()) ;
+   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
+      if ( i <= nNumAxes) {
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken(i), m_AxesToken[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisName(i), m_AxesName[i-1]) ;
+      }
+      else {
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken(i)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisName(i)) ;
+      }
+   }
+  // chiamo la funzione di selezione utensile
+   bOk = bOk && CallOnToolSelect() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnToolDeselect( const std::string& sNextTool, const string& sNextHead, int nNextExit, const string& sNextTcPos)
+{
+  // assegno il prossimo utensile
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTTOOL, sNextTool) ;
+  // assegno la prossima testa
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTHEAD, sNextHead) ;
+  // assegno la prossima uscita
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTEXIT, nNextExit) ;
+  // assegno l'eventuale prossima posizione nel TC
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_NEXTTCPOS, sNextTcPos) ;
+  // chiamo la funzione di deselezione utensile
+   bOk = bOk && CallOnToolDeselect() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnMachiningStart( int nOpId, int nOpInd, double dSpeed, const Point3d& ptMin, const Point3d& ptMax)
+{
+  // assegno identificativo e indice lavorazione
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHID, nOpId) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MCHIND, nOpInd) ;
+  // assegno speed
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_S, dSpeed) ;
+  // assegno punti estremi dell'ingombro della lavorazione
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MMIN, ptMin) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MMAX, ptMax) ;
+  // chiamo la funzione di inizio lavorazione
+   bOk = bOk && CallOnMachiningStart() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnMachiningEnd( void)
+{
+  // chiamo la funzione di fine lavorazione
+   bool bOk = CallOnMachiningEnd() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd,
+                        const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax, double dElev)
+{
+  // assegno identificativo e indice percorso di lavorazione
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHID, nClPathId) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PATHIND, nClPathInd) ;
+  // assegno numero di dati ausiliari iniziali
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXTOT, nAS) ;
+  // assegno punti iniziale e finale e versore estrusione del percorso originale
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_START, ptStart) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_END, ptEnd) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXTR, vtExtr) ;
+  // assegno punti estremi dell'ingombro del percorso di lavorazione
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PMIN, ptMin) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_PMAX, ptMax) ;
+  // assegno la massima elevazione
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ELEV, dElev) ;
+  // chiamo la funzione di inizio percorso di lavorazione
+   bOk = bOk && CallOnPathStart() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnPathEnd( int nAE)
+{
+  // assegno numero di dati ausiliari finali
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXTOT, nAE) ;
+  // chiamo la funzione di fine percorso di lavorazione
+   bOk = bOk && CallOnPathEnd() ;
+   return bOk ;
+}
+ 
+//----------------------------------------------------------------------------
+bool
+Processor::OnPathStartAux( int nInd, const string& sAS)
+{
+  // assegno indice e valore dato ausiliario
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXIND, nInd) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUX, sAS) ;
+  // chiamo la funzione di emissione dato ausiliario ad inizio percorso di lavorazione
+   bOk = bOk && CallOnPathStartAux() ;
+   return bOk ;
+}
+ 
+//----------------------------------------------------------------------------
+bool
+Processor::OnPathEndAux( int nInd, const string& sAE)
+{
+  // assegno indice e valore dato ausiliario
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUXIND, nInd) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AUX, sAE) ;
+  // chiamo la funzione di emissione dato ausiliario alla fine percorso di lavorazione
+   bOk = bOk && CallOnPathEndAux() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnRapid( int nMove, const DBLVECTOR& AxesEnd, int nAxesMask, int nFlag)
+{
+  // cancello variabili estranee
+   ResetArcData() ;
+  // assegno il tipo di movimento
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
+  // assegno il valore degli assi
+   int nNumAxes = int( AxesEnd.size()) ;
+   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
+      if ( i <= nNumAxes)
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
+      else
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
+   }
+  // assegno la mascheratura degli assi
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MASK, nAxesMask) ;
+  // assegno il valore del flag
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ;
+  // chiamo la funzione di movimento in rapido
+   bOk = bOk && CallOnRapid() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnLinear( int nMove, const DBLVECTOR& AxesEnd, double dFeed, int nFlag)
+{
+  // cancello variabili estranee
+   ResetArcData() ;
+  // assegno il tipo di movimento
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
+  // assegno il valore degli assi
+   int nNumAxes = int( AxesEnd.size()) ;
+   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
+      if ( i <= nNumAxes)
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
+      else
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
+   }
+  // assegno il valore della feed
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_F, dFeed) ;
+  // assegno il valore del flag
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ;
+  // chiamo la funzione di movimento in rapido
+   bOk = bOk && CallOnLinear() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::OnArc( int nMove, const DBLVECTOR& AxesEnd, const Point3d& ptCen, const Point3d& ptMid,
+                  double dRad, double dAngCen, double dFeed, int nFlag)
+{
+  // assegno il tipo di movimento
+   bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
+  // assegno il valore degli assi
+   int nNumAxes = int( AxesEnd.size()) ;
+   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
+      if ( i <= nNumAxes)
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
+      else
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
+   }
+  // assegno le coordinate del centro
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C1, ptCen.x) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C2, ptCen.y) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C3, ptCen.z) ; 
+  // assegno le coordinate del punto medio
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M1, ptMid.x) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M2, ptMid.y) ;
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_M3, ptMid.z) ; 
+  // assegno il valore del raggio
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_RR, dRad) ;
+  // assegno il valore dell'angolo al centro
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_AC, dAngCen) ;
+  // assegno il valore della feed
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_F, dFeed) ;
+  // assegno il valore del flag
+   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG, nFlag) ;
+  // chiamo la funzione di movimento in rapido
+   bOk = bOk && CallOnArc() ;
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Processor::ResetArcData( void)
+{
+  // reset dati arco
+   bool bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C1) ;
+   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C2) ;
+   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_C3) ;
+   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_M1) ;
+   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_M2) ;
+   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_M3) ;
+   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_RR) ;
+   bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_AC) ;
+   return bOk ;
+}
diff --git a/Processor.h b/Processor.h
new file mode 100644
index 0000000..674dcd6
--- /dev/null
+++ b/Processor.h
@@ -0,0 +1,98 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2018-2018
+//----------------------------------------------------------------------------
+// File : Processor.h           Data : 29.05.18          Versione : 1.9e6
+// Contenuto : Dichiarazione della classe Processor.
+//
+//
+//
+// Modifiche : 29.05.18 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "CamData.h"
+
+class MachMgr ;
+class IGeomDB ;
+class Machine ;
+
+//----------------------------------------------------------------------------
+class Processor
+{
+   public :
+      Processor( void) ;
+      ~Processor( void) ;
+      bool Init( MachMgr* pMchMgr) ;
+      bool Run( const std::string& sCncFile, const std::string& sInfo) ;
+
+   private :
+      bool VerifySetup( void) ;
+      bool ProcessDisposition( int nOpId, int nOpInd) ;
+      bool ProcessMachining( int nOpId, int nOpInd) ;
+      bool ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd) ;
+      bool ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd, int nOpId, int nOpInd) ;
+      bool UpdateTool( const std::string& sTool) ;
+      bool UpdateDispTool( const std::string& sTool, const std::string& sHead, int nExit) ;
+      bool UpdateAxes( void) ;
+      bool OnStart( void) ;
+      bool OnEnd( void) ;
+      bool OnProgramStart( const std::string& sMachName, const std::string& sCncFile, const std::string& sInfo, bool bSetup) ;
+      bool OnProgramEnd( void) ;
+      bool ProcessToolData( void) ;
+      bool OnToolSelect( const std::string& sTool, const std::string& sHead, int nExit, const std::string& sTcPos) ;
+      bool OnToolDeselect( const std::string& sNextTool, const std::string& sNextHead, int nNextExit, const std::string& sNextTcPos) ;
+      bool OnDispositionStart( int nOpId, int nOpInd, int nPhase, bool bEmpty, bool bSomeByHand) ;
+      bool OnDispositionEnd( void) ;
+      bool OnTableData( const std::string& sName, const Point3d& ptOri1) ;
+      bool OnFixtureData( int nFixId, int nFixInd, const std::string& sName,
+                          const Point3d& ptPos, double dAngDeg, double dMov) ;
+      bool OnRawMoveData( int nRawId, int RawMoveInd, int nType, const Point3d& ptPos, int nFlag) ;
+      bool OnMachiningStart( int nOpId, int nOpInd, double dSpeed, const Point3d& ptMin, const Point3d& ptMax) ;
+      bool OnMachiningEnd( void) ;
+      bool OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd,
+                        const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax, double dElev) ;
+      bool OnPathEnd( int nAE) ;
+      bool OnPathStartAux( int nInd, const std::string& sAS) ;
+      bool OnPathEndAux( int nInd, const std::string& sAE) ;
+      bool OnRapid( int nMove, const DBLVECTOR& AxesEnd, int nAxesMask, int nFlag) ;
+      bool OnLinear( int nMove, const DBLVECTOR& AxesEnd, double dFeed, int nFlag) ;
+      bool OnArc( int nMove, const DBLVECTOR& AxesEnd, const Point3d& ptCen, const Point3d& ptMid,
+                  double dRad, double dAngCen, double dFeed, int nFlag) ;
+      bool ResetArcData( void) ;
+
+   protected :
+      virtual bool CallOnStart( void) = 0 ;
+      virtual bool CallOnEnd( void) = 0 ;
+      virtual bool CallOnProgramStart( void) = 0 ;
+      virtual bool CallOnProgramEnd( void) = 0 ;
+      virtual bool CallOnToolData( void) = 0 ;
+      virtual bool CallOnDispositionStart( void) = 0 ;
+      virtual bool CallOnDispositionEnd( void) = 0 ;
+      virtual bool CallOnTableData( void) = 0 ;
+      virtual bool CallOnFixtureData( void) = 0 ;
+      virtual bool CallOnRawMoveData( void) = 0 ;
+      virtual bool CallOnToolSelect( void) = 0 ;
+      virtual bool CallOnToolDeselect( void) = 0 ;
+      virtual bool CallOnMachiningStart( void) = 0 ;
+      virtual bool CallOnMachiningEnd( void) = 0 ;
+      virtual bool CallOnPathStart( void) = 0 ;
+      virtual bool CallOnPathEnd( void) = 0 ;
+      virtual bool CallOnPathStartAux( void) = 0 ;
+      virtual bool CallOnPathEndAux( void) = 0 ;
+      virtual bool CallOnRapid( void) = 0 ;
+      virtual bool CallOnLinear( void) = 0 ;
+      virtual bool CallOnArc( void) = 0 ;
+
+   protected :
+      MachMgr*      m_pMchMgr ;              // puntatore al gestore di tutte le lavorazioni
+      IGeomDB*      m_pGeomDB ;              // puntatore al DB geometrico
+      Machine*      m_pMachine ;             // puntatore alla macchina
+      std::string   m_sPrevTool ;            // nome dell'utensile precedente
+      std::string   m_sTool ;                // nome dell'utensile corrente
+      STRVECTOR     m_AxesName ;             // nomi degli assi macchina attivi
+      STRVECTOR     m_AxesToken ;            // token degli assi macchina attivi
+      DBLVECTOR     m_AxesVal ;              // valori degli assi macchina all'inizio del movimento corrente
+} ;
diff --git a/Sawing.cpp b/Sawing.cpp
index 7c28122..fe84e5b 100644
--- a/Sawing.cpp
+++ b/Sawing.cpp
@@ -1744,7 +1744,7 @@ Sawing::GenerateLineCl( const ICurveLine* pLine, const Vector3d& vtTool, const V
          if ( AddLinearMove( ptP2) == GDB_ID_NULL)
             return false ;
         // movimento di lato
-         SetFeed( ( IsEven( i) ? GetBackFeed() : GetFeed())) ;
+         SetFeed( ( i == 0 ? GetBackFeed() : GetFeed())) ;
          if ( AddLinearMove( ptP3) == GDB_ID_NULL)
             return false ;
       }     
diff --git a/SawingData.h b/SawingData.h
index c4a49aa..5103e34 100644
--- a/SawingData.h
+++ b/SawingData.h
@@ -28,7 +28,7 @@ struct SawingData : public MachiningData
    double      m_dStartFeed ;      // velocità di lavorazione iniziale ( se 0 da utensile)
    double      m_dEndFeed ;        // velocità di lavorazione finale ( se 0 da utensile)
    double      m_dTipFeed ;        // velocità di lavorazione di testa ( se 0 da utensile)
-   double      m_dBackFeed ;       // velocità di lavorazione al ritorno ( se 0 da utensile)
+   double      m_dBackFeed ;       // velocità di lavorazione dell'ultimo ritorno ( se 0 da utensile)
    double      m_dOffsR ;          // offset radiale ( se UNKNOWN_PAR da utensile)
    double      m_dOffsL ;          // offset longitudinale ( se UNKNOWN_PAR da utensile)
    bool        m_bInvert ;         // flag di inversione direzione lavorazione