DarioS
cdbc4bfb63
- aggiunta gestione quota di base del tool holder ( se negativa indica spazio libero su testa).
911 lines
32 KiB
C++
911 lines
32 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : MachMgrDBTools.cpp Data : 17.09.15 Versione : 1.6i7
|
|
// Contenuto : Implementazione gestione DB utensili della classe MachMgr.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 17.09.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "DllMain.h"
|
|
#include "MachMgr.h"
|
|
#include "/EgtDev/Include/EXeConst.h"
|
|
#include "/EgtDev/Include/EGnFileUtils.h"
|
|
#include "/EgtDev/Include/EgtIniFile.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetToolNewName( string& sName) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// verifico nome ed eventualmente lo modifico per renderlo nuovo
|
|
return pTsMgr->GetToolNewName( sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbAddTool( const string& sName, int nType)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// aggiungo l'utensile al DB utensili
|
|
return pTsMgr->AddTool( sName, nType) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbCopyTool( const string& sSource, const string& sName)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// copio l'utensile nel DB utensili
|
|
return pTsMgr->CopyTool( sSource, sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbRemoveTool( const string& sName)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// rimuovo l'utensile dal DB utensili
|
|
return pTsMgr->RemoveTool( sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetFirstTool( int nFamily, string& sName, int& nType) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// cerco il primo utensile della famiglia nel DB utensili
|
|
return pTsMgr->GetFirstTool( nFamily, sName, nType) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetNextTool( int nFamily, string& sName, int& nType) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// cerco il successivo utensile della famiglia nel DB utensili
|
|
return pTsMgr->GetNextTool( nFamily, sName, nType) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetToolFromUUID( const string& sTuuid, string& sName) const
|
|
{
|
|
// pulisco il parametro di ritorno
|
|
sName.clear() ;
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// cerco l'utensile con l'UUID, se trovato ne restituisco il nome
|
|
EgtUUID Tuuid ;
|
|
if ( ! FromString( sTuuid, Tuuid))
|
|
return false ;
|
|
const ToolData* pTdata = pTsMgr->GetTool( Tuuid) ;
|
|
if ( pTdata == nullptr)
|
|
return false ;
|
|
sName = pTdata->m_sName ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrTool( const string& sName)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// imposto l'utensile corrente
|
|
return pTsMgr->SetCurrTool( sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSaveCurrTool( void)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// salvo l'utensile corrente
|
|
return pTsMgr->SaveCurrTool() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbIsCurrToolModified( void) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// verifico se l'utensile corrente è stato modificato
|
|
return pTsMgr->IsCurrToolModified() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolParam( int nType, bool bVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolParam( nType, bVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolParam( int nType, int nVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolParam( nType, nVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolParam( int nType, double dVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolParam( nType, dVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolParam( int nType, const string& sVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolParam( nType, sVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolValInNotes( int nType, const string& sKey, bool bVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolValInNotes( nType, sKey, bVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolValInNotes( int nType, const string& sKey, int nVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolValInNotes( nType, sKey, nVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolValInNotes( int nType, const string& sKey, double dVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolValInNotes( nType, sKey, dVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSetCurrToolValInNotes( int nType, const string& sKey, const std::string& sVal)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// assegno il parametro
|
|
return pTsMgr->SetCurrToolValInNotes( nType, sKey, sVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbRemoveCurrToolValInNotes( int nType, const string& sKey)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// leggo il parametro
|
|
return pTsMgr->RemoveCurrToolValInNotes( nType, sKey) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolParam( int nType, bool& bVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero il parametro
|
|
return pTsMgr->GetCurrToolParam( nType, bVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolParam( int nType, int& nVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero il parametro
|
|
return pTsMgr->GetCurrToolParam( nType, nVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolParam( int nType, double& dVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero il parametro
|
|
return pTsMgr->GetCurrToolParam( nType, dVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolParam( int nType, string& sVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero il parametro
|
|
return pTsMgr->GetCurrToolParam( nType, sVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolValInNotes( int nType, const string& sKey, bool& bVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// leggo il parametro
|
|
return pTsMgr->GetCurrToolValInNotes( nType, sKey, bVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolValInNotes( int nType, const string& sKey, int& nVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// leggo il parametro
|
|
return pTsMgr->GetCurrToolValInNotes( nType, sKey, nVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolValInNotes( int nType, const string& sKey, double& dVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// leggo il parametro
|
|
return pTsMgr->GetCurrToolValInNotes( nType, sKey, dVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolValInNotes( int nType, const string& sKey, string& sVal) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// leggo il parametro
|
|
return pTsMgr->GetCurrToolValInNotes( nType, sKey, sVal) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolMaxDepth( double& dMaxDepth) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero la sicurezza da aggiungere al massimo affondamento
|
|
MachiningsMgr* pMsMgr = GetCurrMachiningsMgr() ;
|
|
if ( pMsMgr == nullptr)
|
|
return false ;
|
|
double dSafe = pMsMgr->GetMaxDepthSafe() ;
|
|
// recupero il massimo affondamento
|
|
return pTsMgr->GetCurrToolMaxDepth( dSafe, dMaxDepth) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolThDiam( double& dThDiam) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero il diametro del portautensili
|
|
return pTsMgr->GetCurrToolThDiam( dThDiam) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetCurrToolThLength( double& dThLen) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero la lunghezza del portautensili
|
|
return pTsMgr->GetCurrToolThLength( dThLen) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
MachMgr::TdbCurrToolDraw( int nGenCtx, int nToolCtx) const
|
|
{
|
|
// imposto contesto generale
|
|
if ( ! ExeSetCurrentContext( nGenCtx))
|
|
return TD_INT_ERR ;
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return TD_INT_ERR ;
|
|
// recupero il direttorio degli utensili
|
|
string sToolDir ;
|
|
TdbGetToolDir( sToolDir) ;
|
|
// recupero i dati dell'utensile corrente
|
|
const ToolData* pTdata = pTsMgr->GetCurrTool() ;
|
|
if ( pTdata == nullptr)
|
|
return TD_INT_ERR ;
|
|
string sDraw ;
|
|
pTdata->GetParam( TPA_DRAW, sDraw) ;
|
|
if ( sDraw.empty()) {
|
|
string sUuid ;
|
|
pTdata->GetParam( TPA_UUID, sUuid) ;
|
|
sDraw = sUuid + ".nge" ;
|
|
}
|
|
string sDrawPath = sToolDir + "\\" + sDraw ;
|
|
int nErr = 0 ;
|
|
// Se è disegno standard, lo ricreo
|
|
if ( IsUUID( GetFileTitleEgt( sDraw))) {
|
|
// Eseguo disegno
|
|
nErr = UpdateStandardToolDraw( pTdata, nGenCtx, nToolCtx, false) ;
|
|
}
|
|
// altrimenti è disegno custom, lo modifico
|
|
else {
|
|
// Carico e aggiorno il disegno dell'utensile
|
|
if ( ExeSetCurrentContext( nToolCtx) && ExeOpenFile( sDrawPath))
|
|
nErr = UpdateCustomToolDraw( pTdata, nGenCtx, nToolCtx, false) ;
|
|
else
|
|
nErr = TD_CUSTOMDRAW_ERR ;
|
|
}
|
|
return nErr ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbReload( void)
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// ricarico il db utensili
|
|
return pTsMgr->Reload() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbSave( void) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// verifico e aggiorno i disegni degli utensili
|
|
UpdateAllToolDraws() ;
|
|
// se non ci sono state modifiche, esco subito
|
|
if ( ! pTsMgr->GetModified())
|
|
return true ;
|
|
// salvo il db utensili
|
|
if ( ! pTsMgr->Save())
|
|
return false ;
|
|
// se macchina caricata, ne scarico e ricarico tutti gli utensili
|
|
if ( IsCurrMachineLoaded()) {
|
|
Machine* pMach = GetCurrMachine() ;
|
|
if ( pMach != nullptr) {
|
|
pMach->UnloadAllTools() ;
|
|
pMach->LoadAllTools() ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetToolDir( string& sToolDir) const
|
|
{
|
|
string sMachineName ;
|
|
if ( ! GetCurrMachineName( sMachineName))
|
|
return false ;
|
|
sToolDir = m_sMachinesDir + "\\" + sMachineName + "\\" + TOOLS_DIR ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbGetToolHolderDir( string& sToolHolderDir) const
|
|
{
|
|
string sMachineName ;
|
|
if ( ! GetCurrMachineName( sMachineName))
|
|
return false ;
|
|
sToolHolderDir = m_sMachinesDir + "\\" + sMachineName + "\\" + TOOLHOLDERS_DIR ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::UpdateAllToolDraws( void) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero il direttorio degli utensili
|
|
string sToolDir ;
|
|
TdbGetToolDir( sToolDir) ;
|
|
// aggiorno il disegno degli utensili ( mancanti o modificati)
|
|
UUIDVECTOR vUuidMod = pTsMgr->GetUtModified() ;
|
|
string sName ; int nType ;
|
|
bool bNext = pTsMgr->GetFirstTool( TF_ALL, sName, nType) ;
|
|
while ( bNext) {
|
|
// dati dell'utensile
|
|
const ToolData* pTdata = pTsMgr->GetTool( sName) ;
|
|
// verifico se modificato
|
|
EgtUUID UuidTool = pTdata->m_Uuid ;
|
|
auto iIter = find( vUuidMod.begin(), vUuidMod.end(), UuidTool) ;
|
|
bool bModif = ( iIter != vUuidMod.end()) ;
|
|
if ( bModif)
|
|
vUuidMod.erase( iIter) ;
|
|
// verifico se non esiste il disegno associato
|
|
string sDraw ; pTdata->GetParam( TPA_DRAW, sDraw) ;
|
|
bool bNoDraw = ( ! sDraw.empty() && ! ExistsFile( sToolDir + "\\" + sDraw)) ;
|
|
// se modificato o senza disegno, ne lancio la creazione e aggiorno dati portautensile
|
|
if ( bModif || bNoDraw) {
|
|
double dTHoldBase = 0, dTHoldLen = 0, dTHoldDiam = 0 ;
|
|
UpdateToolDraw( UuidTool, dTHoldBase, dTHoldLen, dTHoldDiam) ;
|
|
pTsMgr->SetCurrTool( sName) ;
|
|
pTsMgr->UpdateCurrToolHolderData( dTHoldBase, dTHoldLen, dTHoldDiam) ;
|
|
pTsMgr->SaveCurrTool() ;
|
|
pTsMgr->SetCurrTool( "") ;
|
|
}
|
|
// passo al successivo
|
|
bNext = pTsMgr->GetNextTool( TF_ALL, sName, nType) ;
|
|
}
|
|
// nel vettore sono rimasti solo gli utensili cancellati, ne elimino i disegni
|
|
for ( const auto& UuidTool : vUuidMod) {
|
|
string sDrawPath = sToolDir + "\\" + ToString( UuidTool) + ".nge" ;
|
|
EraseFile( sDrawPath) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::UpdateToolDraw( const EgtUUID& UuidTool, double& dTHoldBase, double& dTHoldLen, double& dTHoldDiam) const
|
|
{
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
// recupero il direttorio degli utensili
|
|
string sToolDir ;
|
|
TdbGetToolDir( sToolDir) ;
|
|
// recupero l'utensile
|
|
const ToolData* pTdata = pTsMgr->GetTool( UuidTool) ;
|
|
// se non esiste, esco
|
|
if ( pTdata == nullptr)
|
|
return false ;
|
|
// Recupero il nome del disegno dell'utensile
|
|
string sDraw ;
|
|
pTdata->GetParam( TPA_DRAW, sDraw) ;
|
|
if ( sDraw.empty())
|
|
return true ;
|
|
// Determino la path del disegno
|
|
string sDrawPath = sToolDir + "\\" + sDraw ;
|
|
// Recupero contesto generale e creo contesto per il disegno utensile
|
|
int nGenCtx = ExeGetCurrentContext() ;
|
|
int nToolCtx = ExeInitContext() ;
|
|
bool bOk = ( nToolCtx != 0) ;
|
|
// Se è disegno standard, lo ricreo
|
|
if ( IsUUID( GetFileTitleEgt( sDraw))) {
|
|
// Eseguo disegno
|
|
bOk = bOk && ( UpdateStandardToolDraw( pTdata, nGenCtx, nToolCtx, true) == 0) ;
|
|
}
|
|
// altrimenti è disegno custom, lo modifico
|
|
else {
|
|
// Carico e aggiorno il disegno dell'utensile
|
|
bOk = bOk && ExeOpenFile( sDrawPath) ;
|
|
bOk = bOk && ( UpdateCustomToolDraw( pTdata, nGenCtx, nToolCtx, true) == 0) ;
|
|
}
|
|
// Salvo il disegno
|
|
ExeSetCurrentContext( nToolCtx) ;
|
|
bOk = bOk && ExeSaveFile( sDrawPath, GDB_SV_BIN) ;
|
|
// Recupero i dati del portautensile
|
|
int nToolId = ExeGetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
if ( ! ExeGetInfo( nToolId, TTH_BASE, dTHoldBase))
|
|
dTHoldBase = 0 ;
|
|
if ( ! ExeGetInfo( nToolId, TTH_LEN, dTHoldLen))
|
|
dTHoldLen = 0 ;
|
|
if ( ! ExeGetInfo( nToolId, TTH_DIAM, dTHoldDiam))
|
|
dTHoldDiam = 0 ;
|
|
// Ripristino il contesto originale
|
|
ExeSetCurrentContext( nGenCtx) ;
|
|
ExeDeleteContext( nToolCtx) ;
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolCtx, bool bToSave) const
|
|
{
|
|
// Imposto contesto generale
|
|
if ( ! ExeSetCurrentContext( nGenCtx))
|
|
return TD_INT_ERR ;
|
|
// Verifico esista macchina corrente
|
|
Machine* pMch = GetCurrMachine() ;
|
|
if ( pMch == nullptr)
|
|
return TD_INT_ERR ;
|
|
// Recupero file Ini della macchina
|
|
string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
|
|
// Recupero i dati dell'utensile
|
|
int nType = TT_NONE ;
|
|
pTdata->GetParam( TPA_TYPE, nType) ;
|
|
string sHeadName ;
|
|
pTdata->GetParam( TPA_HEAD, sHeadName) ;
|
|
int nExit = 0 ;
|
|
pTdata->GetParam( TPA_EXIT, nExit) ;
|
|
double dLen = 0 ;
|
|
pTdata->GetParam( TPA_LEN, dLen) ;
|
|
double dTotLen = 0 ;
|
|
pTdata->GetParam( TPA_TOTLEN, dTotLen) ;
|
|
double dDiam = 0 ;
|
|
pTdata->GetParam( TPA_DIAM, dDiam) ;
|
|
double dTotDiam = 0 ;
|
|
pTdata->GetParam( TPA_TOTDIAM, dTotDiam) ;
|
|
double dDist = 0 ;
|
|
pTdata->GetParam( TPA_DIST, dDist) ;
|
|
double dMaxMat = 0 ;
|
|
pTdata->GetParam( TPA_MAXMAT, dMaxMat) ;
|
|
double dCornRad = 0 ;
|
|
pTdata->GetParam( TPA_CORNRAD, dCornRad) ;
|
|
double dSideAng = 0 ;
|
|
pTdata->GetParam( TPA_SIDEANG, dSideAng) ;
|
|
double dThick = 0 ;
|
|
pTdata->GetParam( TPA_THICK, dThick) ;
|
|
double dCore = 0 ;
|
|
pTdata->GetParam( TPA_CORE, dCore) ;
|
|
if ( dCore < EPS_SMALL && ( nType == TT_SAW_STD || nType == TT_SAW_FLAT))
|
|
dCore = ( dLen >= dThick ? dThick - 1 : 2 * dLen - dThick) ;
|
|
double dSpeed = 0 ;
|
|
pTdata->GetParam( TPA_SPEED, dSpeed) ;
|
|
string sUserNotes ;
|
|
pTdata->GetParam( TPA_USERNOTES, sUserNotes) ;
|
|
// Recupero la path dell'eventuale portautensile
|
|
string sThPath = GetToolHolderPath( sHeadName, nExit, nType, sUserNotes) ;
|
|
// Carico generatore disegno utensile
|
|
string sMaker = GetPrivateProfileStringUtf8( TOOLS_SEC.c_str(), GetToolMakerKeyFromType( nType).c_str(), "", sMachIni.c_str()) ;
|
|
if ( sMaker.empty())
|
|
return TD_TOOLMAKER_ERR ;
|
|
// Imposto contesto per il disegno utensile
|
|
if ( ! ExeSetCurrentContext( nToolCtx))
|
|
return TD_INT_ERR ;
|
|
// Acquisisco il programma lua di creazione disegno utensile
|
|
if ( ! ExeLuaExecFile( m_sToolMakersDir + "\\" + sMaker))
|
|
return TD_INT_ERR ;
|
|
// Assegno i dati utensile
|
|
bool bOk = ExeLuaSetGlobIntVar( "TOOL.TYPE", nType) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.SPEED", dSpeed) ;
|
|
switch ( nType) {
|
|
case TT_DRILL_STD :
|
|
case TT_DRILL_LONG :
|
|
case TT_CHISEL_STD :
|
|
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.TOOLHOLDER", sThPath) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TOTLEN", dTotLen) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.MAXMAT", dMaxMat) ;
|
|
break ;
|
|
case TT_SAW_STD :
|
|
case TT_SAW_FLAT :
|
|
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.TOOLHOLDER", sThPath) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORE", dCore) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.THICK", dThick) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.MAXMAT", dMaxMat) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORNRAD", dCornRad) ;
|
|
break ;
|
|
case TT_MILL_STD :
|
|
case TT_MILL_NOTIP :
|
|
case TT_MILL_POLISHING :
|
|
case TT_WATERJET :
|
|
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.TOOLHOLDER", sThPath) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TOTLEN", dTotLen) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TOTDIAM", dTotDiam) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.MAXMAT", dMaxMat) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.HEIGHT", dThick) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.SIDEANG", dSideAng) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORNRAD", dCornRad) ;
|
|
break ;
|
|
case TT_MORTISE_STD :
|
|
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.TOOLHOLDER", sThPath) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIST", dDist) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.MAXMAT", dMaxMat) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.THICK", dThick) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORNRAD", dCornRad) ;
|
|
break ;
|
|
default :
|
|
return TD_INT_ERR ;
|
|
}
|
|
// Eseguo creazione utensile
|
|
bOk = bOk && ExeLuaCallFunction( "CreateTool") ;
|
|
// Recupero errore
|
|
int nErr = TD_INT_ERR ;
|
|
if ( ! ExeLuaGetGlobIntVar( "TOOL.ERR", &nErr) || nErr != 0)
|
|
return nErr ;
|
|
// Se per salvataggio
|
|
if ( bOk && bToSave) {
|
|
// Nascondo layer ausiliario
|
|
int nAuxId = ExeGetFirstNameInGroup( ExeGetFirstGroupInGroup( GDB_ID_ROOT), "AUX") ;
|
|
ExeSetStatus( { nAuxId}, GDB_ST_OFF) ;
|
|
// Se lama devo ruotare -90 deg attorno a Z+
|
|
if ( nType == TT_SAW_STD || nType == TT_SAW_FLAT) {
|
|
int nPartId = ExeGetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
ExeRotate( { nPartId}, ORIG, Z_AX, -90, RTY_GLOB) ;
|
|
}
|
|
}
|
|
return ( bOk ? 0 : TD_INT_ERR) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
MachMgr::UpdateCustomToolDraw( const ToolData* pTdata, int nGenCtx, int nToolCtx, bool bToSave) const
|
|
{
|
|
// Imposto contesto generale
|
|
if ( ! ExeSetCurrentContext( nGenCtx))
|
|
return TD_INT_ERR ;
|
|
// Recupero i dati dell'utensile
|
|
int nType = TT_NONE ;
|
|
pTdata->GetParam( TPA_TYPE, nType) ;
|
|
double dLen = 0 ;
|
|
pTdata->GetParam( TPA_LEN, dLen) ;
|
|
double dDiam = 0 ;
|
|
pTdata->GetParam( TPA_DIAM, dDiam) ;
|
|
double dDist = 0 ;
|
|
pTdata->GetParam( TPA_DIST, dDist) ;
|
|
// Imposto contesto per il disegno utensile
|
|
if ( ! ExeSetCurrentContext( nToolCtx))
|
|
return TD_INT_ERR ;
|
|
// Acquisisco il programma lua di aggiornamento disegno utensile
|
|
bool bOk = ExeLuaExecFile( m_sToolMakersDir + "\\" + "ToolAdjust.lua") ;
|
|
// Assegno i dati utensile
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ;
|
|
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIST", dDist) ;
|
|
// Eseguo aggiornamento utensile
|
|
bOk = bOk && ExeLuaCallFunction( "AdjustCustomTool") ;
|
|
// Recupero errore
|
|
int nErr = TD_INT_ERR ;
|
|
if ( ! ExeLuaGetGlobIntVar( "TOOL.ERR", &nErr) || nErr != 0)
|
|
return nErr ;
|
|
return ( bOk ? 0 : TD_INT_ERR) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
MachMgr::GetToolMakerKeyFromType( int nType) const
|
|
{
|
|
switch ( nType) {
|
|
case TT_DRILL_STD :
|
|
case TT_DRILL_LONG :
|
|
return DRILLMAKER_KEY ;
|
|
case TT_SAW_STD :
|
|
case TT_SAW_FLAT :
|
|
return SAWBLADEMAKER_KEY ;
|
|
case TT_MILL_STD :
|
|
case TT_MILL_NOTIP :
|
|
case TT_MILL_POLISHING :
|
|
return MILLMAKER_KEY ;
|
|
case TT_MORTISE_STD :
|
|
return MORTISEMAKER_KEY ;
|
|
case TT_CHISEL_STD :
|
|
return CHISELMAKER_KEY ;
|
|
case TT_WATERJET :
|
|
return WATERJETMAKER_KEY ;
|
|
case TT_COMPO :
|
|
return "" ;
|
|
}
|
|
return "" ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
MachMgr::GetToolHolderPath( const string& sHeadName, int nExit, int nType, const std::string& sUserNotes) const
|
|
{
|
|
// Verifiche su testa e uscita
|
|
if ( sHeadName.empty() || nExit == 0)
|
|
return "" ;
|
|
// Verifico esista macchina corrente
|
|
Machine* pMch = GetCurrMachine() ;
|
|
if ( pMch == nullptr)
|
|
return "" ;
|
|
// Recupero il direttorio dei portautensili
|
|
string sToolHolderDir ;
|
|
if ( ! TdbGetToolHolderDir( sToolHolderDir))
|
|
return "" ;
|
|
// Recupero file Ini della macchina
|
|
string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
|
|
// Recupero nome portautensile
|
|
string sToolHolder ;
|
|
// Da sezione ToolHolder di Ini di macchina
|
|
string sKey = sHeadName + "." + ToString( nExit) ;
|
|
if ( nType == TT_SAW_STD) {
|
|
string sKey2 = sKey + ":SAW_STD" ;
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ;
|
|
}
|
|
else if ( nType == TT_SAW_FLAT) {
|
|
string sKey2 = sKey + ":SAW_FLAT" ;
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ;
|
|
}
|
|
else if ( nType == TT_MILL_NOTIP) {
|
|
string sKey2 = sKey + ":MILL_NOTIP" ;
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ;
|
|
}
|
|
else if ( nType == TT_MILL_POLISHING) {
|
|
string sKey2 = sKey + ":MILL_POLISHING" ;
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ;
|
|
}
|
|
if ( sToolHolder.empty())
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey.c_str(), "", sMachIni.c_str()) ;
|
|
// Se non trovato, provo da sezione Tools di Ini di macchina
|
|
if ( sToolHolder.empty()) {
|
|
if ( nType == TT_DRILL_STD || nType == TT_DRILL_LONG)
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLS_SEC.c_str(), DRILLHOLDER_KEY.c_str(), "", sMachIni.c_str()) ;
|
|
else if ( nType == TT_SAW_STD || nType == TT_SAW_FLAT)
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLS_SEC.c_str(), SAWBLADEHOLDER_KEY.c_str(), "", sMachIni.c_str()) ;
|
|
else if ( nType == TT_MILL_STD || nType == TT_MILL_NOTIP || nType == TT_MILL_POLISHING)
|
|
sToolHolder = GetPrivateProfileStringUtf8( TOOLS_SEC.c_str(), MILLHOLDER_KEY.c_str(), "", sMachIni.c_str()) ;
|
|
}
|
|
// Verifico se sovrascritto da nota dell'utensile
|
|
string sVal ;
|
|
if ( ! sUserNotes.empty() &&
|
|
GetValInNotes( sUserNotes, "TH", sVal) &&
|
|
ExistsFile( sToolHolderDir + "\\" + sVal))
|
|
sToolHolder = sVal ;
|
|
// Se non trovato ancora, esco
|
|
if ( sToolHolder.empty())
|
|
return "" ;
|
|
// Restituisco la path
|
|
return ( sToolHolderDir + "\\" + sToolHolder) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbExport( const STRVECTOR& vsToolsNames, const string& sOutFile) const
|
|
{
|
|
if ( vsToolsNames.empty())
|
|
return true ;
|
|
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr)
|
|
return false ;
|
|
|
|
return pTsMgr->Export( vsToolsNames, sOutFile) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbToBeImported( const string& sFile, STRVECTOR& vsToolsNames, INTVECTOR& vToolsTypes) const
|
|
{
|
|
if ( ! ExistsFile( sFile)){
|
|
LOG_ERROR( GetEMkLogger(), "TdbToBeImported Error : File does not exist") ;
|
|
return false ;
|
|
}
|
|
|
|
// recupero il gestore di utensili della macchina corrente
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr){
|
|
LOG_ERROR( GetEMkLogger(), "TdbToBeImported Error : no current ToolsMgr") ;
|
|
return false ;
|
|
}
|
|
|
|
return pTsMgr->ToBeImported( sFile, vsToolsNames, vToolsTypes) ;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
MachMgr::TdbImport( const string& sFile, const STRVECTOR& vsToolsToImport, const STRVECTOR& vsToolsNames, STRVECTOR& vsImported)
|
|
{
|
|
if ( vsToolsToImport.empty())
|
|
return true ;
|
|
|
|
if ( ! ExistsFile( sFile)) {
|
|
LOG_ERROR( GetEMkLogger(), "TdbImport Error : File does not exist") ;
|
|
return false ;
|
|
}
|
|
|
|
if ( vsToolsToImport.size() != vsToolsNames.size())
|
|
return false ;
|
|
|
|
ToolsMgr* pTsMgr = GetCurrToolsMgr() ;
|
|
if ( pTsMgr == nullptr) {
|
|
LOG_ERROR( GetEMkLogger(), "TdbImport Error : no current ToolsMgr") ;
|
|
return false ;
|
|
}
|
|
|
|
return pTsMgr->Import( sFile, vsToolsToImport, vsToolsNames, vsImported) ;
|
|
}
|