diff --git a/ChiselingData.cpp b/ChiselingData.cpp index 2533511..1451858 100644 --- a/ChiselingData.cpp +++ b/ChiselingData.cpp @@ -287,7 +287,7 @@ ChiselingData::VerifySolCh( int nVal) const bool ChiselingData::VerifyWorkSide( int nVal) const { - return ( nVal == MILL_WS_LEFT || nVal == MILL_WS_RIGHT) ; + return ( nVal == CHISEL_WS_LEFT || nVal == CHISEL_WS_RIGHT) ; } //---------------------------------------------------------------------------- diff --git a/EgtMachKernel.vcxproj b/EgtMachKernel.vcxproj index c5a8311..8169c16 100644 --- a/EgtMachKernel.vcxproj +++ b/EgtMachKernel.vcxproj @@ -251,6 +251,7 @@ copy $(TargetPath) \EgtProg\Dll64 + @@ -302,6 +303,7 @@ copy $(TargetPath) \EgtProg\Dll64 + diff --git a/EgtMachKernel.vcxproj.filters b/EgtMachKernel.vcxproj.filters index a5b0ac7..4d65e60 100644 --- a/EgtMachKernel.vcxproj.filters +++ b/EgtMachKernel.vcxproj.filters @@ -192,6 +192,9 @@ Source Files\Machinings + + Source Files\Machinings + @@ -332,6 +335,9 @@ Header Files + + Header Files + diff --git a/PocketingData.cpp b/PocketingData.cpp new file mode 100644 index 0000000..4382239 --- /dev/null +++ b/PocketingData.cpp @@ -0,0 +1,642 @@ +//---------------------------------------------------------------------------- +// EgalTech 2017-2017 +//---------------------------------------------------------------------------- +// File : PocketingData.cpp Data : 03.02.17 Versione : 1.8b1 +// Contenuto : Implementazione struttura dati lavorazione di svuotatura. +// +// +// +// Modifiche : 02.03.17 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +//--------------------------- Include ---------------------------------------- +#include "stdafx.h" +#include "PocketingData.h" +#include "MachiningDataFactory.h" +#include "MachiningConst.h" +#include "/EgtDev/Include/EmkToolConst.h" +#include "/EgtDev/Include/EmkSimuGenConst.h" +#include "/EgtDev/Include/EGnStringUtils.h" +#include +#include + +using namespace std ; + +//---------------------------------------------------------------------------- +enum nPocketingKey { + KEY_DH = 0, + KEY_F, + KEY_FE, + KEY_FS, + KEY_FT, + KEY_INV, + KEY_LITG, + KEY_LITY, + KEY_LOTG, + KEY_LOTY, + KEY_NAME, + KEY_NNS, + KEY_NNU, + KEY_OL, + KEY_OR, + KEY_PS, + KEY_S, + KEY_SA, + KEY_SCC, + KEY_SS, + KEY_ST, + KEY_SUBTYPE, + KEY_TNAME, + KEY_TUUID, + KEY_UUID, + KEY_ZZZ} ; // rappresenta il numero di elementi + +static const std::array sPocketingKey = { + "DH", + "F", + "FE", + "FS", + "FT", + "INV", + "LITG", + "LITY", + "LOTG", + "LOTY", + "NAME", + "NNS", + "NNU", + "OL", + "OR", + "PS", + "S", + "SA", + "SCC", + "SS", + "ST", + "SUB", + "TN", + "TU", + "UUID"} ; + +//---------------------------------------------------------------------------- +MCHDATA_REGISTER( MT_POCKETING, "POCKETING", PocketingData) ; + +//---------------------------------------------------------------------------- +PocketingData* +PocketingData::Clone( void) const +{ + // alloco oggetto + PocketingData* pMdata = new(nothrow) PocketingData ; + // copio i dati + if ( pMdata != nullptr) { + if ( ! pMdata->CopyFrom( this)) { + delete pMdata ; + return nullptr ; + } + } + return pMdata ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::CopyFrom( const MachiningData* pMdata) +{ + // è inutile copiare se sorgente coincide con destinazione + if ( pMdata == this) + return true ; + // la sorgente deve essere dello stesso tipo + const PocketingData* pSdata = GetPocketingData( pMdata) ; + if ( pSdata == nullptr) + return false ; + // eseguo copia + m_Uuid = pSdata->m_Uuid ; + m_sName = pSdata->m_sName ; + m_ToolUuid = pSdata->m_ToolUuid ; + m_sToolName = pSdata->m_sToolName ; + m_nSolCh = pSdata->m_nSolCh ; + m_dSpeed = pSdata->m_dSpeed ; + m_dFeed = pSdata->m_dFeed ; + m_dEndFeed = pSdata->m_dEndFeed ; + m_dStartFeed = pSdata->m_dStartFeed ; + m_dTipFeed = pSdata->m_dTipFeed ; + m_dOffsL = pSdata->m_dOffsL ; + m_dOffsR = pSdata->m_dOffsR ; + m_bInvert = pSdata->m_bInvert ; + m_sDepth = pSdata->m_sDepth ; + m_dStartPos = pSdata->m_dStartPos ; + m_dStep = pSdata->m_dStep ; + m_dSideStep = pSdata->m_dSideStep ; + m_nSubType = pSdata->m_nSubType ; + m_dSideAngle = pSdata->m_dSideAngle ; + m_nLeadInType = pSdata->m_nLeadInType ; + m_dLiTang = pSdata->m_dLiTang ; + m_nLeadOutType = pSdata->m_nLeadOutType ; + m_dLoTang = pSdata->m_dLoTang ; + m_sSysNotes = pSdata->m_sSysNotes ; + m_sUserNotes = pSdata->m_sUserNotes ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::SameAs(const MachiningData* pMdata) const +{ + // se coincide con altro -> uguali + if ( pMdata == this) + return true ; + // se sono di tipo diverso -> diversi + const PocketingData* pSdata = GetPocketingData( pMdata) ; + if ( pSdata == nullptr) + return false ; + // confronto termine a termine + return ( m_Uuid == pSdata->m_Uuid && + m_sName == pSdata->m_sName && + m_ToolUuid == pSdata->m_ToolUuid && + m_sToolName == pSdata->m_sToolName && + m_nSolCh == pSdata->m_nSolCh && + abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR && + abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR && + abs( m_dEndFeed - pSdata->m_dEndFeed) < EPS_MACH_LEN_PAR && + abs( m_dStartFeed - pSdata->m_dStartFeed) < EPS_MACH_LEN_PAR && + abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR && + abs( m_dOffsL - pSdata->m_dOffsL) < EPS_MACH_LEN_PAR && + abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR && + m_bInvert == pSdata->m_bInvert && + m_sDepth == pSdata->m_sDepth && + abs( m_dStartPos - pSdata->m_dStartPos) < EPS_MACH_LEN_PAR && + abs( m_dStep - pSdata->m_dStep) < EPS_MACH_LEN_PAR && + abs( m_dSideStep - pSdata->m_dSideStep) < EPS_MACH_LEN_PAR && + m_nSubType == pSdata->m_nSubType && + abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR && + m_nLeadInType == pSdata->m_nLeadInType && + abs( m_dLiTang - pSdata->m_dLiTang) < EPS_MACH_LEN_PAR && + m_nLeadOutType == pSdata->m_nLeadOutType && + abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR && + m_sSysNotes == pSdata->m_sSysNotes && + m_sUserNotes == pSdata->m_sUserNotes) ; +} + +//---------------------------------------------------------------------------- +int +PocketingData::GetSize( void) const +{ + // in debug verifico validità ultimo campo + assert( sPocketingKey[KEY_UUID] == "UUID") ; + return KEY_ZZZ ; +} +//---------------------------------------------------------------------------- +string +PocketingData::GetTitle( void) const +{ + return MCHDATA_GETNAME( PocketingData) ; +} + +//---------------------------------------------------------------------------- +int +FindPocketingKey( const string& sKey) +{ + auto TheRange = equal_range( sPocketingKey.cbegin(), sPocketingKey.cend(), sKey) ; + if ( TheRange.first == TheRange.second) + return - 1 ; + return int( TheRange.first - sPocketingKey.cbegin()) ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::FromString( const string& sString, int& nKey) +{ + // separo chiave da valore + string sKey, sVal ; + SplitFirst( sString, "=", sKey, sVal) ; + // riconosco la chiave + nKey = FindPocketingKey( ToUpper( sKey)) ; + bool bOk = ( nKey >= 0) ; + switch ( nKey) { + case KEY_DH : + m_sDepth = sVal ; + if ( m_sDepth.empty()) + m_sDepth = "0" ; + break ; + case KEY_F : + bOk = ::FromString( sVal, m_dFeed) ; + break ; + case KEY_FE : + bOk = ::FromString( sVal, m_dEndFeed) ; + break ; + case KEY_FS : + bOk = ::FromString( sVal, m_dStartFeed) ; + break ; + case KEY_FT : + bOk = ::FromString( sVal, m_dTipFeed) ; + break ; + case KEY_INV : + bOk = ::FromString( sVal, m_bInvert) ; + break ; + case KEY_LITG : + bOk = ::FromString( sVal, m_dLiTang) ; + break ; + case KEY_LITY : + bOk = ::FromString( sVal, m_nLeadInType) ; + break ; + case KEY_LOTG : + bOk = ::FromString( sVal, m_dLoTang) ; + break ; + case KEY_LOTY : + bOk = ::FromString( sVal, m_nLeadOutType) ; + break ; + case KEY_NAME : + m_sName = sVal ; + bOk = ! m_sName.empty() ; + break ; + case KEY_NNS : + m_sSysNotes = sVal ; + break ; + case KEY_NNU : + m_sUserNotes = sVal ; + break ; + case KEY_OL : + bOk = ::FromString( sVal, m_dOffsL) ; + break ; + case KEY_OR : + bOk = ::FromString( sVal, m_dOffsR) ; + break ; + case KEY_PS : + bOk = ::FromString( sVal, m_dStartPos) ; + break ; + case KEY_S : + bOk = ::FromString( sVal, m_dSpeed) ; + break ; + case KEY_SA : + bOk = ::FromString( sVal, m_dSideAngle) ; + break ; + case KEY_SCC : + bOk = ::FromString( sVal, m_nSolCh) ; + break ; + case KEY_SS : + bOk = ::FromString( sVal, m_dSideStep) ; + break ; + case KEY_ST : + bOk = ::FromString( sVal, m_dStep) ; + break ; + case KEY_SUBTYPE : + bOk = ::FromString( sVal, m_nSubType) ; + break ; + case KEY_TNAME : + m_sToolName = sVal ; + break ; + case KEY_TUUID : + bOk = ::FromString( sVal, m_ToolUuid) ; + break ; + case KEY_UUID : + bOk = ::FromString( sVal, m_Uuid) ; + break ; + default : + bOk = false ; + break ; + } + return bOk ; +} + +//---------------------------------------------------------------------------- +string +PocketingData::ToString( int nInd) const +{ + switch ( nInd) { + case KEY_DH : return ( sPocketingKey[KEY_DH] + "=" + m_sDepth) ; + case KEY_F : return ( sPocketingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; + case KEY_FE : return ( sPocketingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; + case KEY_FS : return ( sPocketingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ; + case KEY_FT : return ( sPocketingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; + case KEY_INV : return ( sPocketingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; + case KEY_LITG : return ( sPocketingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ; + case KEY_LITY : return ( sPocketingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ; + case KEY_LOTG : return ( sPocketingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ; + case KEY_LOTY : return ( sPocketingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ; + case KEY_NAME : return ( sPocketingKey[KEY_NAME] + "=" + m_sName) ; + case KEY_NNS : return ( sPocketingKey[KEY_NNS] + "=" + m_sSysNotes) ; + case KEY_NNU : return ( sPocketingKey[KEY_NNU] + "=" + m_sUserNotes) ; + case KEY_OL : return ( sPocketingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ; + case KEY_OR : return ( sPocketingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ; + case KEY_PS : return ( sPocketingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ; + case KEY_S : return ( sPocketingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ; + case KEY_SA : return ( sPocketingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ; + case KEY_SCC : return ( sPocketingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; + case KEY_SS : return ( sPocketingKey[KEY_SS] + "=" + ::ToString( m_dSideStep)) ; + case KEY_ST : return ( sPocketingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ; + case KEY_SUBTYPE : return ( sPocketingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ; + case KEY_TNAME : return ( sPocketingKey[KEY_TNAME] + "=" + m_sToolName) ; + case KEY_TUUID : return ( sPocketingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; + case KEY_UUID : return ( sPocketingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; + default : return "" ; + } +} + +//---------------------------------------------------------------------------- +bool +PocketingData::IsOptional( int nKey) const +{ + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::VerifySolCh( int nVal) const +{ + return IsValidOperationScc( nVal) ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::VerifySubType( int nVal) const +{ + return ( nVal == POCKET_SUB_ZIGZAG || nVal == POCKET_SUB_ONEWAY || + nVal == POCKET_SUB_SPIRALIN || nVal == POCKET_SUB_SPIRALOUT) ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::VerifyLeadInType( int nVal) const +{ + return ( nVal == POCKET_LI_NONE || nVal == POCKET_LI_GLIDE || + nVal == POCKET_LI_ZIGZAG || nVal == POCKET_LI_HELIX) ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::VerifyLeadOutType( int nVal) const +{ + return ( nVal == POCKET_LO_NONE || nVal == MILL_LO_GLIDE) ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const +{ + if ( pToolsMgr == nullptr) + return false ; + pTdata = pToolsMgr->GetTool( sVal) ; + if ( pTdata == nullptr) + return false ; + if ( ( pTdata->m_nType & TF_MILL) == 0) + return false ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const +{ + if ( pToolsMgr == nullptr) + return false ; + pTdata = pToolsMgr->GetTool( m_ToolUuid) ; + return ( pTdata != nullptr) ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::SetParam( int nType, bool bVal) +{ + switch ( nType) { + case MPA_INVERT : + m_bInvert = bVal ; + return true ; + } + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::SetParam( int nType, int nVal) +{ + switch ( nType) { + case MPA_LEADINTYPE : + if ( ! VerifyLeadInType( nVal)) + return false ; + m_nLeadInType = nVal ; + return true ; + case MPA_LEADOUTTYPE : + if ( ! VerifyLeadOutType( nVal)) + return false ; + m_nLeadOutType = nVal ; + return true ; + case MPA_SCC : + if ( ! VerifySolCh( nVal)) + return false ; + m_nSolCh = nVal ; + return true ; + case MPA_SUBTYPE : + if ( ! VerifySubType( nVal)) + return false ; + m_nSubType = nVal ; + return true ; + } + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::SetParam( int nType, double dVal) +{ + switch ( nType) { + case MPA_SPEED : + m_dSpeed = dVal ; + return true ; + case MPA_FEED : + m_dFeed = dVal ; + return true ; + case MPA_STARTFEED : + m_dStartFeed = dVal ; + return true ; + case MPA_ENDFEED : + m_dEndFeed = dVal ; + return true ; + case MPA_TIPFEED : + m_dTipFeed = dVal ; + return true ; + case MPA_OFFSL : + m_dOffsL = dVal ; + return true ; + case MPA_OFFSR : + m_dOffsR = dVal ; + return true ; + case MPA_DEPTH : + m_sDepth = ::ToString( dVal) ; + return true ; + case MPA_STARTPOS : + m_dStartPos = dVal ; + return true ; + case MPA_STEP : + m_dStep = dVal ; + return true ; + case MPA_SIDESTEP : + m_dSideStep = dVal ; + return true ; + case MPA_SIDEANGLE : + m_dSideAngle = dVal ; + return true ; + case MPA_LITANG : + m_dLiTang = dVal ; + return true ; + case MPA_LOTANG : + m_dLoTang = dVal ; + return true ; + } + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::SetParam( int nType, const string& sVal) +{ + switch ( nType) { + case MPA_NAME : + m_sName = sVal ; + return true ; + case MPA_TOOL : + m_sToolName = sVal ; + return true ; + case MPA_DEPTH_STR : + m_sDepth = sVal ; + return true ; + case MPA_TUUID : + return ::FromString( sVal, m_ToolUuid) ; + case MPA_UUID : + return ::FromString( sVal, m_Uuid) ; + case MPA_SYSNOTES : + m_sSysNotes = sVal ; + return true ; + case MPA_USERNOTES : + m_sUserNotes = sVal ; + return true ; + } + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::ResetTool( void) +{ + m_sToolName.clear() ; + m_ToolUuid.Clear() ; + return true ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::GetParam( int nType, bool& bVal) const +{ + switch ( nType) { + case MPA_INVERT : + bVal = m_bInvert ; + return true ; + } + bVal = false ; + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::GetParam( int nType, int& nVal) const +{ + switch ( nType) { + case MPA_TYPE : + nVal = MT_POCKETING ; + return true ; + case MPA_SUBTYPE : + nVal = m_nSubType ; + return true ; + case MPA_LEADINTYPE : + nVal = m_nLeadInType ; + return true ; + case MPA_LEADOUTTYPE : + nVal = m_nLeadOutType ; + return true ; + case MPA_SCC : + nVal = m_nSolCh ; + return true ; + } + nVal = 0 ; + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::GetParam( int nType, double& dVal) const +{ + switch ( nType) { + case MPA_SPEED : + dVal = m_dSpeed ; + return true ; + case MPA_FEED : + dVal = m_dFeed ; + return true ; + case MPA_STARTFEED : + dVal = m_dStartFeed ; + return true ; + case MPA_ENDFEED : + dVal = m_dEndFeed ; + return true ; + case MPA_TIPFEED : + dVal = m_dTipFeed ; + return true ; + case MPA_OFFSL : + dVal = m_dOffsL ; + return true ; + case MPA_OFFSR : + dVal = m_dOffsR ; + return true ; + case MPA_STARTPOS : + dVal = m_dStartPos ; + return true ; + case MPA_STEP : + dVal = m_dStep ; + return true ; + case MPA_SIDESTEP : + dVal = m_dSideStep ; + return true ; + case MPA_SIDEANGLE : + dVal = m_dSideAngle ; + return true ; + case MPA_LITANG : + dVal = m_dLiTang ; + return true ; + case MPA_LOTANG : + dVal = m_dLoTang ; + return true ; + } + dVal = 0 ; + return false ; +} + +//---------------------------------------------------------------------------- +bool +PocketingData::GetParam( int nType, string& sVal) const +{ + switch ( nType) { + case MPA_NAME : + sVal = m_sName ; + return true ; + case MPA_TOOL : + sVal = m_sToolName ; + return true ; + case MPA_DEPTH_STR : + sVal = m_sDepth ; + return true ; + case MPA_TUUID : + sVal = ::ToString( m_ToolUuid) ; + return true ; + case MPA_UUID : + sVal = ::ToString( m_Uuid) ; + return true ; + case MPA_SYSNOTES : + sVal = m_sSysNotes ; + return true ; + case MPA_USERNOTES : + sVal = m_sUserNotes ; + return true ; + } + sVal = "" ; + return false ; +} diff --git a/PocketingData.h b/PocketingData.h new file mode 100644 index 0000000..aae7f25 --- /dev/null +++ b/PocketingData.h @@ -0,0 +1,82 @@ +//---------------------------------------------------------------------------- +// EgalTech 2017-2017 +//---------------------------------------------------------------------------- +// File : PocketingData.h Data : 03.02.17 Versione : 1.8b11 +// Contenuto : Dichiarazione della struct PocketingData e costanti associate. +// +// +// +// Modifiche : 03.02.17 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + +#include "MachiningData.h" + +//---------------------------------------------------------------------------- +struct PocketingData : public MachiningData +{ + EgtUUID m_ToolUuid ; // identificativo universale dell'utensile + std::string m_sToolName ; // nome dell'utensile + int m_nSolCh ; // criterio scelta soluzione (quando possibili molteplici) + double m_dSpeed ; // velocità di rotazione (+ se CCW, - se CW) ( se 0 da utensile) + double m_dFeed ; // velocità di lavorazione normale ( se 0 da utensile) + double m_dStartFeed ; // velocità di lavorazione iniziale ( se 0 da utensile) + double m_dEndFeed ; // velocità di lavorazione finale ( se 0 da utensile) + double m_dTipFeed ; // velocità di lavorazione di testa ( se 0 da utensile) + double m_dOffsR ; // offset radiale ( se UNKNOWN_PAR da utensile) + double m_dOffsL ; // offset longitudinale ( se UNKNOWN_PAR da utensile) + bool m_bInvert ; // flag di inversione direzione lavorazione + std::string m_sDepth ; // affondamento (espressione numerica) + double m_dStartPos ; // quota di inizio lavorazione (sempre >= 0) + double m_dStep ; // passo di affondamento (0=nessun passo) + double m_dSideStep ; // distanza tra le passate + int m_nSubType ; // tipo di lavorazione ( ZigZag, OneWay, SpiralIn, SpiralOut) + double m_dSideAngle ; // angolo dello ZigZag da X+ locale + int m_nLeadInType ; // tipo di attacco (nessuno, lineare, tangente, inseguimento) + double m_dLiTang ; // distanza tangente da inizio attacco + int m_nLeadOutType ; // tipo di uscita (come attacco, nessuno, lineare, tangente, inseguimento) + double m_dLoTang ; // distanza tangente verso fine uscita + std::string m_sSysNotes ; // note interne + std::string m_sUserNotes ; // note dell'utente + + PocketingData( void) + : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0), + m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), m_bInvert( false), + m_dStartPos( 0), m_dStep( 0), m_dSideStep( 0), m_nSubType( 0), m_dSideAngle( 0), + m_nLeadInType( 0), m_dLiTang( 0), + m_nLeadOutType( 0), m_dLoTang( 0) {} + PocketingData* Clone( void) const override ; + bool CopyFrom( const MachiningData* pMdata) override ; + bool SameAs(const MachiningData* pMdata) const override ; + int GetType( void) const override + { return MT_POCKETING ; } + int GetSize( void) const override ; + std::string GetTitle( void) const override ; + bool FromString( const std::string& sString, int& nKey) override ; + std::string ToString( int nInd) const override ; + bool IsOptional( int nKey) const override ; + bool SetParam( int nType, bool bVal) override ; + bool SetParam( int nType, int nVal) override ; + bool SetParam( int nType, double dVal) override ; + bool SetParam( int nType, const std::string& sVal) override ; + bool ResetTool( void) override ; + bool GetParam( int nType, bool& bVal) const override; + bool GetParam( int nType, int& nVal) const override ; + bool GetParam( int nType, double& dVal) const override ; + bool GetParam( int nType, std::string& sVal) const override ; + bool GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const override ; + bool VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const override ; + bool VerifySolCh( int nVal) const ; + bool VerifySubType( int nVal) const ; + bool VerifyLeadInType( int nVal) const ; + bool VerifyLeadOutType( int nVal) const ; +} ; + +//---------------------------------------------------------------------------- +inline const PocketingData* GetPocketingData( const MachiningData* pMdata) + { return (dynamic_cast( pMdata)) ; } +inline PocketingData* GetPocketingData( MachiningData* pMdata) + { return (dynamic_cast( pMdata)) ; }