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