Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
EgtMachKernel/MachMgrDBTools.cpp
T
Dario Sassi 40f1e051a4 EgtMachKernel 3.1d3 : 
- piccole razionalizzazioni.
2026-04-09 09:47:25 +02:00

953 lines
34 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// 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 "ToolUserNotesConst.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 sMachineDir, sMachineName ;
if ( ! GetCurrMachineDir( sMachineDir) || ! GetCurrMachineName( sMachineName))
return false ;
sToolDir = sMachineDir + "\\" + TOOLS_DIR ;
return true ;
}
//----------------------------------------------------------------------------
bool
MachMgr::TdbGetToolHolderDir( string& sToolHolderDir) const
{
string sMachineDir, sMachineName ;
if ( ! GetCurrMachineDir( sMachineDir) || ! GetCurrMachineName( sMachineName))
return false ;
sToolHolderDir = sMachineDir + "\\" + 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 dStemDiam = 0 ;
pTdata->GetParam( TPA_STEMDIAM, dStemDiam) ;
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) ;
double dTipFeed = 0 ;
pTdata->GetParam( TPA_TIPFEED, dTipFeed) ;
string sUserNotes ;
pTdata->GetParam( TPA_USERNOTES, sUserNotes) ;
string sSysNotes ;
pTdata->GetParam( TPA_SYSNOTES, sSysNotes) ;
// 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) ;
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TIPFEED", dTipFeed) ;
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.USERNOTES", sUserNotes) ;
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.SYSNOTES", sSysNotes) ;
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.STEMDIAM", dStemDiam) ;
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 ;
case TT_PROBE :
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.STEMDIAM", dStemDiam) ;
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.HEIGHT", 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) ;
}
}
// altrimenti per visualizzazione
else if ( bOk) {
// Nascondo oggetto/i Carter
int nSolidId = ExeGetFirstNameInGroup( ExeGetFirstGroupInGroup( GDB_ID_ROOT), "SOLID") ;
int nCarterId = ExeGetFirstNameInGroup( nSolidId, "Carter") ;
while ( nCarterId != GDB_ID_NULL) {
ExeSetStatus( { nCarterId}, GDB_ST_OFF) ;
nCarterId = ExeGetNextName( nCarterId, "Carter") ;
}
}
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) ;
double dSpeed = 0 ;
pTdata->GetParam( TPA_SPEED, dSpeed) ;
string sUserNotes ;
pTdata->GetParam( TPA_USERNOTES, sUserNotes) ;
// 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) ;
bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.SPEED", dSpeed) ;
bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.USERNOTES", sUserNotes) ;
// 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 "" ;
case TT_PROBE :
return PROBEMAKER_KEY ;
}
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()) ;
}
else if ( nType == TT_PROBE) {
string sKey2 = sKey + ":PROBE" ;
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, TUN_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) ;
}
Reference in New Issue View Git Blame Copy Permalink