diff --git a/ChiselingData.cpp b/ChiselingData.cpp
new file mode 100644
index 0000000..2533511
--- /dev/null
+++ b/ChiselingData.cpp
@@ -0,0 +1,510 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2017-2017
+//----------------------------------------------------------------------------
+// File : ChiselingData.cpp       Data : 03.02.17          Versione : 1.8b1
+// Contenuto : Implementazione struttura dati lavorazione di foratura.
+//
+//
+//
+// Modifiche : 03.02.17 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "ChiselingData.h"
+#include "MachiningDataFactory.h"
+#include "MachiningConst.h"
+#include "/EgtDev/Include/EmkToolConst.h"
+#include "/EgtDev/Include/EmkSimuGenConst.h"
+#include "/EgtDev/Include/EGnStringUtils.h"
+#include <array>
+#include <cassert>
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+enum nChiselingKey {
+   KEY_DH = 0,
+   KEY_EAL,
+   KEY_F,
+   KEY_FE,
+   KEY_FT,
+   KEY_INV,
+   KEY_NAME,
+   KEY_NNS,
+   KEY_NNU,
+   KEY_PR,
+   KEY_PS,
+   KEY_SCC,
+   KEY_ST,
+   KEY_TNAME,
+   KEY_TUUID,
+   KEY_UUID,
+   KEY_WS,
+   KEY_ZZZ} ;        // rappresenta il numero di elementi
+
+static const std::array<std::string,KEY_ZZZ> sChiselingKey = {
+   "DH",
+   "EAL",
+   "F",
+   "FE",
+   "FT",
+   "INV",
+   "NAME",
+   "NNS",
+   "NNU",
+   "PR",
+   "PS",
+   "SCC",
+   "ST",
+   "TN",
+   "TU",
+   "UUID",
+   "WS"} ;
+
+//----------------------------------------------------------------------------
+MCHDATA_REGISTER( MT_CHISELING, "CHISELING", ChiselingData) ;
+
+//----------------------------------------------------------------------------
+ChiselingData*
+ChiselingData::Clone( void) const
+{
+  // alloco oggetto
+   ChiselingData* pDdata = new(nothrow) ChiselingData ;
+  // copio i dati
+   if ( pDdata != nullptr) {
+      if ( ! pDdata->CopyFrom( this)) {
+         delete pDdata ;
+         return nullptr ;
+      }
+   }
+   return pDdata ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::CopyFrom( const MachiningData* pMdata)
+{
+  // è inutile copiare se sorgente coincide con destinazione
+   if ( pMdata == this)
+      return true ;
+  // la sorgente deve essere dello stesso tipo
+   const ChiselingData* pDdata = GetChiselingData( pMdata) ;
+   if ( pDdata == nullptr)
+      return false ;
+  // eseguo copia
+   m_Uuid = pDdata->m_Uuid ;
+   m_sName = pDdata->m_sName ;
+   m_nSolCh = pDdata->m_nSolCh ;
+   m_ToolUuid = pDdata->m_ToolUuid ;
+   m_sToolName = pDdata->m_sToolName ;
+   m_dFeed = pDdata->m_dFeed ;
+   m_dEndFeed = pDdata->m_dEndFeed ;
+   m_dTipFeed = pDdata->m_dTipFeed ;
+   m_nWorkSide = pDdata->m_nWorkSide ;
+   m_bInvert = pDdata->m_bInvert ;
+   m_sDepth = pDdata->m_sDepth ;
+   m_dStartPos = pDdata->m_dStartPos ;
+   m_dStep = pDdata->m_dStep ;
+   m_dReturnPos = pDdata->m_dReturnPos ;
+   m_dEndAddLen = pDdata->m_dEndAddLen ;
+   m_sSysNotes = pDdata->m_sSysNotes ;
+   m_sUserNotes = pDdata->m_sUserNotes ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::SameAs(const MachiningData* pMdata) const
+{
+  // se coincide con altro -> uguali
+   if ( pMdata == this)
+      return true ;
+  // se sono di tipo diverso -> diversi
+   const ChiselingData* pDdata = GetChiselingData( pMdata) ;
+   if ( pDdata == nullptr)
+      return false ;
+  // confronto termine a termine
+   return ( m_Uuid == pDdata->m_Uuid  &&
+            m_sName == pDdata->m_sName  &&
+            m_ToolUuid == pDdata->m_ToolUuid  &&
+            m_sToolName == pDdata->m_sToolName  &&
+            m_nSolCh == pDdata->m_nSolCh  &&
+            abs( m_dFeed - pDdata->m_dFeed) < EPS_MACH_LEN_PAR  &&
+            abs( m_dEndFeed - pDdata->m_dEndFeed) < EPS_MACH_LEN_PAR  &&
+            abs( m_dTipFeed - pDdata->m_dTipFeed) < EPS_MACH_LEN_PAR  &&
+            m_nWorkSide == pDdata->m_nWorkSide  &&
+            m_bInvert == pDdata->m_bInvert  &&
+            m_sDepth == pDdata->m_sDepth  &&
+            abs( m_dStartPos - pDdata->m_dStartPos) < EPS_MACH_LEN_PAR  &&
+            abs( m_dStep - pDdata->m_dStep) < EPS_MACH_LEN_PAR  &&
+            abs( m_dReturnPos - pDdata->m_dReturnPos) < EPS_MACH_LEN_PAR  &&
+            abs( m_dEndAddLen - pDdata->m_dEndAddLen) < EPS_MACH_LEN_PAR  &&
+            m_sSysNotes == pDdata->m_sSysNotes  &&
+            m_sUserNotes == pDdata->m_sUserNotes) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ChiselingData::GetSize( void) const
+{
+  // in debug verifico validità ultimo campo
+   assert( sChiselingKey[KEY_UUID] == "UUID") ;
+   return KEY_ZZZ ;
+}
+//----------------------------------------------------------------------------
+string
+ChiselingData::GetTitle( void) const
+{
+   return MCHDATA_GETNAME( ChiselingData) ;
+}
+
+//----------------------------------------------------------------------------
+int
+FindChiselingKey( const string& sKey)
+{
+   auto TheRange = equal_range( sChiselingKey.cbegin(), sChiselingKey.cend(), sKey) ;
+   if ( TheRange.first == TheRange.second)
+      return - 1 ;
+   return int( TheRange.first - sChiselingKey.cbegin()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::FromString( const string& sString, int& nKey)
+{
+  // separo chiave da valore
+   string sKey, sVal ;
+   SplitFirst( sString, "=", sKey, sVal) ;
+  // riconosco la chiave
+   nKey = FindChiselingKey( ToUpper( sKey)) ;
+   bool bOk = ( nKey >= 0) ;
+   switch ( nKey) {
+   case KEY_DH :
+      m_sDepth = sVal ;
+      if ( m_sDepth.empty())
+         m_sDepth = "TH" ;
+      break ;
+   case KEY_EAL :
+      bOk = ::FromString( sVal, m_dEndAddLen) ;
+      break ;
+   case KEY_F :
+      bOk = ::FromString( sVal, m_dFeed) ;
+      break ;
+   case KEY_FE :
+      bOk = ::FromString( sVal, m_dEndFeed) ;
+      break ;
+   case KEY_FT :
+      bOk = ::FromString( sVal, m_dTipFeed) ;
+      break ;
+   case KEY_INV :
+      bOk = ::FromString( sVal, m_bInvert) ;
+      break ;
+   case KEY_NAME :
+      m_sName = sVal ;
+      bOk = ! m_sName.empty() ;
+      break ;
+   case KEY_NNS :
+      m_sSysNotes = sVal ;
+      break ;
+   case KEY_NNU :
+      m_sUserNotes = sVal ;
+      break ;
+   case KEY_PR :
+      bOk = ::FromString( sVal, m_dReturnPos) ;
+      break ;
+   case KEY_PS :
+      bOk = ::FromString( sVal, m_dStartPos) ;
+      break ;
+   case KEY_SCC :
+      bOk = ::FromString( sVal, m_nSolCh) ;
+      break ;
+   case KEY_ST :
+      bOk = ::FromString( sVal, m_dStep) ;
+      break ;
+   case KEY_TNAME :
+      m_sToolName = sVal ;
+      break ;
+   case KEY_TUUID :
+      bOk = ::FromString( sVal, m_ToolUuid) ;
+      break ;
+   case KEY_UUID :
+      bOk = ::FromString( sVal, m_Uuid) ;
+      break ;
+   case KEY_WS :
+      bOk = ::FromString( sVal, m_nWorkSide) ;
+      break ;
+   default :
+      bOk = false ;
+      break ;
+   }
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+string
+ChiselingData::ToString( int nKey) const
+{
+   switch ( nKey) {
+   case KEY_DH : return ( sChiselingKey[KEY_DH] + "=" + m_sDepth) ;
+   case KEY_EAL : return ( sChiselingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ;
+   case KEY_F : return ( sChiselingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
+   case KEY_FE : return ( sChiselingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
+   case KEY_FT : return ( sChiselingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
+   case KEY_INV : return ( sChiselingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
+   case KEY_NAME : return ( sChiselingKey[KEY_NAME] + "=" + m_sName) ;
+   case KEY_NNS : return ( sChiselingKey[KEY_NNS] + "=" + m_sSysNotes) ;
+   case KEY_NNU : return ( sChiselingKey[KEY_NNU] + "=" + m_sUserNotes) ;
+   case KEY_PR : return ( sChiselingKey[KEY_PR] + "=" + ::ToString( m_dReturnPos)) ;
+   case KEY_PS : return ( sChiselingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
+   case KEY_SCC : return ( sChiselingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
+   case KEY_ST : return ( sChiselingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
+   case KEY_TNAME : return ( sChiselingKey[KEY_TNAME] + "=" + m_sToolName) ;
+   case KEY_TUUID : return ( sChiselingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
+   case KEY_UUID : return ( sChiselingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
+   case KEY_WS : return ( sChiselingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
+   default : return "" ;
+   }
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::IsOptional( int nKey) const
+{
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::VerifySolCh( int nVal) const
+{
+   return IsValidOperationScc( nVal) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::VerifyWorkSide( int nVal) const
+{
+   return ( nVal == MILL_WS_LEFT  ||  nVal == MILL_WS_RIGHT) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const
+{
+   if ( pToolsMgr == nullptr)
+      return false ;
+   pTdata =  pToolsMgr->GetTool( sVal) ;
+   if ( pTdata == nullptr)
+      return false ;
+   if ( pTdata->m_nType != TT_CHISEL_STD)
+      return false ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
+{
+   if ( pToolsMgr == nullptr)
+      return false ;
+   pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
+   return ( pTdata != nullptr) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::SetParam( int nType, bool bVal)
+{
+   switch ( nType) {
+   case MPA_INVERT :
+      m_bInvert = bVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::SetParam( int nType, int nVal)
+{
+   switch ( nType) {
+   case MPA_WORKSIDE :
+      if ( ! VerifyWorkSide( nVal))
+         return false ;
+      m_nWorkSide = nVal ;
+      return true ;
+   case MPA_SCC :
+      if ( ! VerifySolCh( nVal))
+         return false ;
+      m_nSolCh = nVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::SetParam( int nType, double dVal)
+{
+   switch ( nType) {
+   case MPA_FEED :
+      m_dFeed = dVal ;
+      return true ;
+   case MPA_ENDFEED :
+      m_dEndFeed = dVal ;
+      return true ;
+   case MPA_TIPFEED :
+      m_dTipFeed = dVal ;
+      return true ;
+   case MPA_DEPTH :
+      m_sDepth = ::ToString( dVal) ;
+      return true ;
+   case MPA_STARTPOS :
+      m_dStartPos = dVal ;
+      return true ;
+   case MPA_STEP :
+      m_dStep = dVal ;
+      return true ;
+   case MPA_RETURNPOS :
+      m_dReturnPos = dVal ;
+      return true ;
+   case MPA_ENDADDLEN :
+      m_dEndAddLen = dVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::SetParam( int nType, const string& sVal)
+{
+   switch ( nType) {
+   case MPA_NAME :
+      m_sName = sVal ;
+      return true ;
+   case MPA_TOOL :
+      m_sToolName = sVal ;
+      return true ;
+   case MPA_DEPTH_STR :
+      m_sDepth = sVal ;
+      return true ;
+   case MPA_TUUID :
+      return ::FromString( sVal, m_ToolUuid) ;
+   case MPA_UUID :
+      return ::FromString( sVal, m_Uuid) ;
+   case MPA_SYSNOTES :
+      m_sSysNotes = sVal ;
+      return true ;
+   case MPA_USERNOTES :
+      m_sUserNotes = sVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::ResetTool( void)
+{
+   m_sToolName.clear() ;
+   m_ToolUuid.Clear() ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::GetParam( int nType, bool& bVal) const
+{
+   switch ( nType) {
+   case MPA_INVERT :
+      bVal = m_bInvert ;
+      return true ;
+   }
+   bVal = false ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::GetParam( int nType, int& nVal) const
+{
+   switch ( nType) {
+   case MPA_TYPE :
+      nVal = MT_CHISELING ;
+      return true ;
+   case MPA_WORKSIDE :
+      nVal = m_nWorkSide ;
+      return true ;
+   case MPA_SCC :
+      nVal = m_nSolCh ;
+      return true ;
+   }
+   nVal = 0 ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::GetParam( int nType, double& dVal) const
+{
+   switch ( nType) {
+   case MPA_FEED :
+      dVal = m_dFeed ;
+      return true ;
+   case MPA_ENDFEED :
+      dVal = m_dEndFeed ;
+      return true ;
+   case MPA_TIPFEED :
+      dVal = m_dTipFeed ;
+      return true ;
+   case MPA_STARTPOS :
+      dVal = m_dStartPos ;
+      return true ;
+   case MPA_STEP :
+      dVal = m_dStep ;
+      return true ;
+   case MPA_RETURNPOS :
+      dVal = m_dReturnPos ;
+      return true ;
+   case MPA_ENDADDLEN :
+      dVal = m_dEndAddLen ;
+      return true ;
+   }
+   dVal = 0 ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ChiselingData::GetParam( int nType, string& sVal) const
+{
+   switch ( nType) {
+   case MPA_NAME :
+      sVal = m_sName ;
+      return true ;
+   case MPA_TOOL :
+      sVal = m_sToolName ;
+      return true ;
+   case MPA_DEPTH_STR :
+      sVal = m_sDepth ;
+      return true ;
+   case MPA_TUUID :
+      sVal = ::ToString( m_ToolUuid) ;
+      return true ;
+   case MPA_UUID :
+      sVal = ::ToString( m_Uuid) ;
+      return true ;
+   case MPA_SYSNOTES :
+      sVal = m_sSysNotes ;
+      return true ;
+   case MPA_USERNOTES :
+      sVal = m_sUserNotes ;
+      return true ;
+   }
+   sVal = "" ;
+   return false ;
+}
diff --git a/ChiselingData.h b/ChiselingData.h
new file mode 100644
index 0000000..12a333a
--- /dev/null
+++ b/ChiselingData.h
@@ -0,0 +1,70 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2017-2017
+//----------------------------------------------------------------------------
+// File : ChiselingData.h           Data : 03.02.17         Versione : 1.8b1
+// Contenuto : Dichiarazione della struct ChiselingData e costanti associate.
+//
+//
+//
+// Modifiche : 03.02.17 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "MachiningData.h"
+
+//----------------------------------------------------------------------------
+struct ChiselingData : public MachiningData
+{
+   EgtUUID     m_ToolUuid ;        // identificativo universale dell'utensile
+   std::string m_sToolName ;       // nome dell'utensile
+   int         m_nSolCh ;          // criterio scelta soluzione (quando possibili molteplici)
+   double      m_dFeed ;           // velocità di lavorazione normale  ( se 0 da utensile)
+   double      m_dEndFeed ;        // velocità di lavorazione finale  ( se 0 da utensile)
+   double      m_dTipFeed ;        // velocità di lavorazione di sfondamento  ( se 0 da utensile)
+   bool        m_bInvert ;         // flag di inversione direzione lavorazione per casi passanti
+   int         m_nWorkSide ;       // lato di lavoro (destra, sinistra)
+   std::string m_sDepth ;          // affondamento (espressione numerica)
+   double      m_dStartPos ;       // quota di inizio lavorazione (sempre >= 0)
+   double      m_dStep ;           // passo di affondamento (0=nessun passo)
+   double      m_dReturnPos ;      // quota di ritorno (+=fuori, -=dentro)
+   double      m_dEndAddLen ;      // lunghezza di traslazione finale
+   std::string m_sSysNotes ;       // note interne
+   std::string m_sUserNotes ;      // note dell'utente
+
+   ChiselingData( void)
+      : m_ToolUuid(), m_nSolCh( 0), m_dFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0),
+        m_bInvert( false), m_nWorkSide( 2), m_dStartPos( 0),
+        m_dStep( 0), m_dReturnPos( 0), m_dEndAddLen( 0) {}
+   ChiselingData* Clone( void) const override ;
+   bool CopyFrom( const MachiningData* pMdata) override ;
+   bool SameAs(const MachiningData* pMdata) const override  ;
+   int  GetType( void) const override
+           { return MT_CHISELING ; }
+   int  GetSize( void) const override ;
+   std::string GetTitle( void) const override ;
+   bool FromString( const std::string& sString, int& nKey) override ;
+   std::string ToString( int nKey) const override ;
+   bool IsOptional( int nKey) const override ;
+   bool SetParam( int nType, bool bVal) override ;
+   bool SetParam( int nType, int nVal) override ;
+   bool SetParam( int nType, double dVal) override ;
+   bool SetParam( int nType, const std::string& sVal) override ;
+   bool ResetTool( void) override ;
+   bool GetParam( int nType, bool& bVal) const override ;
+   bool GetParam( int nType, int& nVal) const override ;
+   bool GetParam( int nType, double& dVal) const override ;
+   bool GetParam( int nType, std::string& sVal) const override ;
+   bool GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const override ;
+   bool VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const override ;
+   bool VerifySolCh( int nVal) const ;
+   bool VerifyWorkSide( int nVal) const ;
+} ;
+
+//----------------------------------------------------------------------------
+inline const ChiselingData* GetChiselingData( const MachiningData* pMdata)
+               { return (dynamic_cast<const ChiselingData*>( pMdata)) ; }
+inline ChiselingData* GetChiselingData( MachiningData* pMdata)
+               { return (dynamic_cast<ChiselingData*>( pMdata)) ; }
diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index 692fc6d..7657fa4 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/EgtMachKernel.vcxproj b/EgtMachKernel.vcxproj
index c9174a6..c5a8311 100644
--- a/EgtMachKernel.vcxproj
+++ b/EgtMachKernel.vcxproj
@@ -210,6 +210,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
   <ItemGroup>
     <ClCompile Include="Axis.cpp" />
     <ClCompile Include="CamData.cpp" />
+    <ClCompile Include="ChiselingData.cpp" />
     <ClCompile Include="Disposition.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
@@ -277,6 +278,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EMkMachMgr.h" />
     <ClInclude Include="Axis.h" />
     <ClInclude Include="CamData.h" />
+    <ClInclude Include="ChiselingData.h" />
     <ClInclude Include="Disposition.h" />
     <ClInclude Include="DllMain.h" />
     <ClInclude Include="Drilling.h" />
diff --git a/EgtMachKernel.vcxproj.filters b/EgtMachKernel.vcxproj.filters
index 8024174..a5b0ac7 100644
--- a/EgtMachKernel.vcxproj.filters
+++ b/EgtMachKernel.vcxproj.filters
@@ -189,6 +189,9 @@
     <ClCompile Include="SetupMgr.cpp">
       <Filter>Source Files\Tools</Filter>
     </ClCompile>
+    <ClCompile Include="ChiselingData.cpp">
+      <Filter>Source Files\Machinings</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DllMain.h">
@@ -326,6 +329,9 @@
     <ClInclude Include="SetupMgr.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="ChiselingData.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtMachKernel.rc">