//----------------------------------------------------------------------------
//  EgalTech 2015-2016
//----------------------------------------------------------------------------
// File : Generator.cpp           Data : 26.02.16          Versione : 1.6n8
// Contenuto : Implementazione della classe generator.
//
//
//
// Modifiche : 28.10.15 DS Creazione modulo.
//             26.02.16 DS Aggiunta gestione archi.
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "DllMain.h"
#include "Generator.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 ;

//----------------------------------------------------------------------------
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 ;
}

//----------------------------------------------------------------------------
bool
Generator::Run( const string& sCncFile, const std::string& sInfo)
{
  // emetto info di log
   { string sOut = "Generator 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) ;

  // verifico ci sia una macchinata corrente
   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr  ||  m_pMachine == nullptr  ||
        m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL)
      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)) {
      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
   if ( ! bOk)
      RenameFile( sCncFile, sErrFile) ;

  // evento fine esecuzione
   if ( ! OnEnd()) {
      bOk = false ;
      LOG_INFO( GetEMkLogger(), "OnEnd error") ;
   }

   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::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 utensile cambierà
      if ( ! m_sTool.empty()  &&  m_sTool != sTool) {
        // emetto deselezione vecchio utensile
         if ( ! OnToolDeselect( sHead, nExit, sTcPos))
            return false ;
      }
     // Aggiorno utensile e assi macchina
      if ( ! UpdateDispTool( sTool, sHead, nExit)  ||  ! UpdateAxes())
         return false ;
     // Se utensile cambiato, emetto selezione nuovo utensile
      if ( 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
Generator::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
      string sNextHead ; int nNextExit ; string sNextTcPos ;
      if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
         m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sNextHead) ;
         m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nNextExit) ;
         m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, sNextTcPos) ;
      }
     // ripristino l'utensile corrente
      m_pMchMgr->TdbSetCurrTool( m_sTool) ;
     // emetto deselezione vecchio utensile
      if ( ! OnToolDeselect( 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 sHead ; m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ;
      int nExit ; m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ;
      string sTcPos ; 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 ;

  // Emetto inizio lavorazione
   if ( ! OnMachiningStart( nOpId, nOpInd, dSpeed))
      return false ;

  // Ciclo su tutti i percorsi CL della lavorazione
   bool bOk = true ;
   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 lavorazione
   bOk = bOk && OnMachiningEnd() ;

   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd)
{
  // Recupero punto di inizio del percorso
   Point3d ptStart ;
   m_pGeomDB->GetInfo( nClPathId, KEY_START, ptStart) ;
  // Recupero versore estrusione associato al percorso (normale al piano di interpolazione)
   Vector3d vtExtr ;
   m_pGeomDB->GetInfo( nClPathId, KEY_EXTR, vtExtr) ;
  // Emetto inizio percorso di lavoro
   if ( ! OnPathStart( nClPathId, nClPathInd, ptStart, vtExtr))
      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) ;
   }

  // Emetto fine percorso di lavoro
   bOk = bOk && OnPathEnd() ;

   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::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
      if ( ! OnArc( nMove, AxesEnd, pCamData->GetAxesCen(), pCamData->GetAxesRad(), pCamData->GetAxesAngCen(),
                    pCamData->GetFeed(), pCamData->GetFlag()))
         return false ;
      break ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
Generator::UpdateTool( const string& sTool)
{
  // Salvo l'utensile attuale come precedente
   m_sPrevTool = m_sTool ;
  // Se cambiato ...
   if ( sTool != m_sTool) {
     // lo imposto come corrente
      if ( ! m_pMchMgr->TdbSetCurrTool( sTool))
         return false ;
     // lo carico in macchina
      string sHead ; m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, sHead) ;
      int nExit ; m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, nExit) ;
      if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit))
         return false ;
      m_sTool = sTool ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Generator::UpdateDispTool( const string& sTool, const string& sHead, int nExit)
{
  // Salvo l'utensile attuale come precedente
   m_sPrevTool = m_sTool ;
  // Se cambiato ...
   if ( sTool != m_sTool) {
     // lo carico in macchina
      if ( ! m_pMchMgr->SetCalcTool( sTool, sHead, nExit))
         return false ;
      m_sTool = sTool ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
Generator::UpdateAxes( void)
{
  // Carico i nomi degli assi macchina attivi
   return m_pMachine->GetAllCurrAxesName( m_AxesName) &&
          m_pMachine->GetAllCurrAxesToken( m_AxesToken) ;
}

//----------------------------------------------------------------------------
bool
Generator::OnStart( void)
{
  // definisco tavola variabili globali
   bool bOk = m_pMachine->LuaCreateGlobTable( GLOB_VAR) ;
  // 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_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 ;
}

//----------------------------------------------------------------------------
bool
Generator::OnEnd( void)
{
  // chiamo la funzione
   bool bOk = m_pMachine->LuaCallFunction( ON_END) ;
  // rimuovo tavola variabili globali
   bOk = m_pMachine->LuaResetGlobVar( GLOB_VAR) && bOk ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::OnProgramStart( const string& sMachName, const string& sCncFile, const string& sInfo)
{
  // apro il file di output
   bool bOk = m_pMachine->WriterOpen( sCncFile) ;
   if ( ! bOk)
      LOG_INFO( GetEMkLogger(), "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) ;
  // chiamo la funzione di inizio programma
   bOk = bOk && m_pMachine->LuaCallFunction( ON_PROGRAM_START) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::OnProgramEnd( void)
{
  // chiamo fine programma
   bool bOk = m_pMachine->LuaCallFunction( ON_PROGRAM_END) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::ProcessToolData( void)
{
   struct MyToolData {
      string sName ;
      string sHead ;
      int    nExit ;
      string sTcPos ;
      int    nComp ;
      double dDiam ;
      double dLen ;
      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_LEN, Tdata.dLen) ;
            m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, Tdata.dMaxSpeed) ;
            vTdata.push_back( Tdata) ;
         }
      }
     // passo alla operazione successiva
      nOpId = m_pMchMgr->GetNextActiveOperation( nOpId) ;
   }
  // 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
   bool bOk = true ;
   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_TLEN, vTdata[i].dLen) ;
         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 string& sNextHead, int nNextExit, const string& sNextTcPos)
{
  // assegno la prossima testa
   bool 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)
{
  // 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) ;
  // 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, const Point3d& ptStart, const Vector3d& vtExtr)
{
  // 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 punto iniziale e versore estrusione
   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_START, ptStart) ;
   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXTR, vtExtr) ;
  // chiamo la funzione di inizio percorso di lavorazione
   bOk = bOk && m_pMachine->LuaCallFunction( ON_PATH_START) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::OnPathEnd( void)
{
  // chiamo la funzione di fine percorso di lavorazione
   bool bOk = m_pMachine->LuaCallFunction( ON_PATH_END) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::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 && m_pMachine->LuaCallFunction( ON_RAPID) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::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 && m_pMachine->LuaCallFunction( ON_LINEAR) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
Generator::OnArc( int nMove, const DBLVECTOR& AxesEnd, const Point3d& ptCen, 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 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 ;
}