//---------------------------------------------------------------------------- // EgalTech 2015-2015 //---------------------------------------------------------------------------- // File : SawingData.cpp Data : 05.06.15 Versione : 1.6f1 // Contenuto : Implementazione struttura dati lavorazione di taglio di lama. // // // // Modifiche : 05.06.15 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "SawingData.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 nSawingKey { KEY_AB = 0, KEY_AI, KEY_APPR, KEY_CRV, KEY_DH, KEY_EAL, KEY_F, KEY_FA, KEY_FB, KEY_FE, KEY_FS, KEY_FT, KEY_HS, KEY_INV, KEY_LETY, KEY_LIEL, KEY_LITG, KEY_LITY, KEY_LOTY, KEY_NAME, KEY_NNS, KEY_NNU, KEY_OL, KEY_OR, KEY_PS, KEY_S, KEY_SA, KEY_SAL, KEY_SCC, KEY_SL, KEY_ST, KEY_STB, KEY_STEA, KEY_STIA, KEY_STSA, KEY_STSAB, KEY_STY, KEY_TNAME, KEY_TUUID, KEY_UUID, KEY_WS, KEY_ZZZ} ; // rappresenta il numero di elementi static const array sSawingKey = { "AB", "AI", "APPR", "CRV", "DH", "EAL", "F", "FA", "FB", "FE", "FS", "FT", "HS", "INV", "LETY", "LIEL", "LITG", "LITY", "LOTY", "NAME", "NNS", "NNU", "OL", "OR", "PS", "S", "SA", "SAL", "SCC", "SL", "ST", "STB", "STEA", "STIA", "STSA", "STSAB", "STY", "TN", "TU", "UUID", "WS"} ; //---------------------------------------------------------------------------- MCHDATA_REGISTER( MT_SAWING, "SAWING", SawingData) ; //---------------------------------------------------------------------------- SawingData* SawingData::Clone( void) const { // alloco oggetto SawingData* pSdata = new(nothrow) SawingData ; // copio i dati if ( pSdata != nullptr) { if ( ! pSdata->CopyFrom( this)) { delete pSdata ; return nullptr ; } } return pSdata ; } //---------------------------------------------------------------------------- bool SawingData::CopyFrom( const MachiningData* pMdata) { // è inutile copiare se sorgente coincide con destinazione if ( pMdata == this) return true ; // la sorgente deve essere dello stesso tipo const SawingData* pSdata = GetSawingData( 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_sBlockedAxis = pSdata->m_sBlockedAxis ; m_sInitAngs = pSdata->m_sInitAngs ; 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_dBackFeed = pSdata->m_dBackFeed ; m_dSideAngFeed = pSdata->m_dSideAngFeed ; m_dOffsL = pSdata->m_dOffsL ; m_dOffsR = pSdata->m_dOffsR ; m_bInvert = pSdata->m_bInvert ; m_nWorkSide = pSdata->m_nWorkSide ; m_nHeadSide = pSdata->m_nHeadSide ; m_sDepth = pSdata->m_sDepth ; m_dStartPos = pSdata->m_dStartPos ; m_dStep = pSdata->m_dStep ; m_dStepBack = pSdata->m_dStepBack ; m_dStepLast = pSdata->m_dStepLast ; m_dStepSideAng = pSdata->m_dStepSideAng ; m_dStepSideAngBack = pSdata->m_dStepSideAngBack ; m_dStepExtArc = pSdata->m_dStepExtArc ; m_dStepIntArc = pSdata->m_dStepIntArc ; m_nStepType = pSdata->m_nStepType ; m_dSideAngle = pSdata->m_dSideAngle ; m_dStartAddLen = pSdata->m_dStartAddLen ; m_dEndAddLen = pSdata->m_dEndAddLen ; m_nLeadInType = pSdata->m_nLeadInType ; m_dLiTang = pSdata->m_dLiTang ; m_dLiElev = pSdata->m_dLiElev ; m_nExtLinkType = pSdata->m_nExtLinkType ; m_nLeadOutType = pSdata->m_nLeadOutType ; m_nCurveUse = pSdata->m_nCurveUse ; m_dApprox = pSdata->m_dApprox ; m_sSysNotes = pSdata->m_sSysNotes ; m_sUserNotes = pSdata->m_sUserNotes ; return true ; } //---------------------------------------------------------------------------- bool SawingData::SameAs(const MachiningData* pMdata) const { // se coincide con altro -> uguali if ( pMdata == this) return true ; // se sono di tipo diverso -> diversi const SawingData* pSdata = GetSawingData( 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_sBlockedAxis == pSdata->m_sBlockedAxis && m_sInitAngs == pSdata->m_sInitAngs && m_nSolCh == pSdata->m_nSolCh && AreSameAngValue( m_dSpeed, pSdata->m_dSpeed) && AreSameLenValue( m_dFeed, pSdata->m_dFeed) && AreSameLenValue( m_dEndFeed, pSdata->m_dEndFeed) && AreSameLenValue( m_dStartFeed, pSdata->m_dStartFeed) && AreSameLenValue( m_dTipFeed, pSdata->m_dTipFeed) && AreSameLenValue( m_dBackFeed, pSdata->m_dBackFeed) && AreSameLenValue( m_dSideAngFeed, pSdata->m_dSideAngFeed) && AreSameLenValue( m_dOffsL, pSdata->m_dOffsL) && AreSameLenValue( m_dOffsR, pSdata->m_dOffsR) && m_bInvert == pSdata->m_bInvert && m_nWorkSide == pSdata->m_nWorkSide && m_nHeadSide == pSdata->m_nHeadSide && m_sDepth == pSdata->m_sDepth && AreSameLenValue( m_dStartPos, pSdata->m_dStartPos) && AreSameLenValue( m_dStep, pSdata->m_dStep) && AreSameLenValue( m_dStepBack, pSdata->m_dStepBack) && AreSameLenValue( m_dStepLast, pSdata->m_dStepLast) && AreSameLenValue( m_dStepSideAng, pSdata->m_dStepSideAng) && AreSameLenValue( m_dStepSideAngBack, pSdata->m_dStepSideAngBack) && AreSameLenValue( m_dStepExtArc, pSdata->m_dStepExtArc) && AreSameLenValue( m_dStepIntArc, pSdata->m_dStepIntArc) && m_nStepType == pSdata->m_nStepType && AreSameLenValue( m_dSideAngle, pSdata->m_dSideAngle) && AreSameLenValue( m_dStartAddLen, pSdata->m_dStartAddLen) && AreSameLenValue( m_dEndAddLen, pSdata->m_dEndAddLen) && m_nLeadInType == pSdata->m_nLeadInType && AreSameLenValue( m_dLiElev, pSdata->m_dLiElev) && AreSameLenValue( m_dLiTang, pSdata->m_dLiTang) && m_nExtLinkType == pSdata->m_nExtLinkType && m_nLeadOutType == pSdata->m_nLeadOutType && m_nCurveUse == pSdata->m_nCurveUse && AreSameLenValue( m_dApprox, pSdata->m_dApprox) && m_sSysNotes == pSdata->m_sSysNotes && m_sUserNotes == pSdata->m_sUserNotes) ; } //---------------------------------------------------------------------------- int SawingData::GetSize( void) const { // in debug verifico validità ultimo campo assert( sSawingKey[KEY_WS] == "WS") ; return KEY_ZZZ ; } //---------------------------------------------------------------------------- string SawingData::GetTitle( void) const { return MCHDATA_GETNAME( SawingData) ; } //---------------------------------------------------------------------------- int FindSawingKey( const string& sKey) { auto TheRange = equal_range( sSawingKey.cbegin(), sSawingKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sSawingKey.cbegin()) ; } //---------------------------------------------------------------------------- bool SawingData::FromString( const string& sString, int& nKey) { // separo chiave da valore string sKey, sVal ; SplitFirst( sString, "=", sKey, sVal) ; // riconosco la chiave nKey = FindSawingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { case KEY_AB : m_sBlockedAxis = sVal ; break ; case KEY_AI : m_sInitAngs = sVal ; break ; case KEY_APPR : bOk = ::FromString( sVal, m_dApprox) ; break ; case KEY_CRV : bOk = ::FromString( sVal, m_nCurveUse) ; break ; case KEY_DH : m_sDepth = sVal ; if ( m_sDepth.empty()) m_sDepth = "0" ; break ; case KEY_EAL : bOk = ::FromString( sVal, m_dEndAddLen) ; break ; case KEY_F : bOk = ::FromString( sVal, m_dFeed) ; break ; case KEY_FA : bOk = ::FromString( sVal, m_dSideAngFeed) ; break ; case KEY_FB : bOk = ::FromString( sVal, m_dBackFeed) ; 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_HS : bOk = ::FromString( sVal, m_nHeadSide) ; break ; case KEY_INV : bOk = ::FromString( sVal, m_bInvert) ; break ; case KEY_LETY : bOk = ::FromString( sVal, m_nExtLinkType) ; break ; case KEY_LIEL : bOk = ::FromString( sVal, m_dLiElev) ; break ; case KEY_LITG : bOk = ::FromString( sVal, m_dLiTang) ; break ; case KEY_LITY : bOk = ::FromString( sVal, m_nLeadInType) ; 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_SAL : bOk = ::FromString( sVal, m_dStartAddLen) ; break ; case KEY_SCC : bOk = ::FromString( sVal, m_nSolCh) ; break ; case KEY_SL : bOk = ::FromString( sVal, m_dStepLast) ; break ; case KEY_ST : bOk = ::FromString( sVal, m_dStep) ; break ; case KEY_STB : bOk = ::FromString( sVal, m_dStepBack) ; break ; case KEY_STEA : bOk = ::FromString( sVal, m_dStepExtArc) ; break ; case KEY_STIA : bOk = ::FromString( sVal, m_dStepIntArc) ; break ; case KEY_STSA : bOk = ::FromString( sVal, m_dStepSideAng) ; break ; case KEY_STSAB : bOk = ::FromString( sVal, m_dStepSideAngBack) ; break ; case KEY_STY : bOk = ::FromString( sVal, m_nStepType) ; 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 ; case KEY_WS : bOk = ::FromString( sVal, m_nWorkSide) ; break ; default : bOk = false ; break ; } return bOk ; } //---------------------------------------------------------------------------- string SawingData::ToString( int nInd) const { switch ( nInd) { case KEY_AB : return ( sSawingKey[KEY_AB] + "=" + m_sBlockedAxis) ; case KEY_AI : return ( sSawingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_APPR : return ( sSawingKey[KEY_APPR] + "=" + ::ToString( m_dApprox)) ; case KEY_CRV : return ( sSawingKey[KEY_CRV] + "=" + ::ToString( m_nCurveUse)) ; case KEY_DH : return ( sSawingKey[KEY_DH] + "=" + m_sDepth) ; case KEY_EAL : return ( sSawingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; case KEY_F : return ( sSawingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; case KEY_FA : return ( sSawingKey[KEY_FA] + "=" + ::ToString( m_dSideAngFeed)) ; case KEY_FB : return ( sSawingKey[KEY_FB] + "=" + ::ToString( m_dBackFeed)) ; case KEY_FE : return ( sSawingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ; case KEY_FS : return ( sSawingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ; case KEY_FT : return ( sSawingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; case KEY_HS : return ( sSawingKey[KEY_HS] + "=" + ::ToString( m_nHeadSide)) ; case KEY_INV : return ( sSawingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; case KEY_LETY : return ( sSawingKey[KEY_LETY] + "=" + ::ToString( m_nExtLinkType)) ; case KEY_LIEL : return ( sSawingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ; case KEY_LITG : return ( sSawingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ; case KEY_LITY : return ( sSawingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ; case KEY_LOTY : return ( sSawingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ; case KEY_NAME : return ( sSawingKey[KEY_NAME] + "=" + m_sName) ; case KEY_NNS : return ( sSawingKey[KEY_NNS] + "=" + m_sSysNotes) ; case KEY_NNU : return ( sSawingKey[KEY_NNU] + "=" + m_sUserNotes) ; case KEY_OL : return ( sSawingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ; case KEY_OR : return ( sSawingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ; case KEY_PS : return ( sSawingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ; case KEY_S : return ( sSawingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ; case KEY_SA : return ( sSawingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ; case KEY_SAL : return ( sSawingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ; case KEY_SCC : return ( sSawingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; case KEY_SL : return ( sSawingKey[KEY_SL] + "=" + ::ToString( m_dStepLast)) ; case KEY_ST : return ( sSawingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ; case KEY_STB : return ( sSawingKey[KEY_STB] + "=" + ::ToString( m_dStepBack)) ; case KEY_STEA : return ( sSawingKey[KEY_STEA] + "=" + ::ToString( m_dStepExtArc)) ; case KEY_STIA : return ( sSawingKey[KEY_STIA] + "=" + ::ToString( m_dStepIntArc)) ; case KEY_STSA : return ( sSawingKey[KEY_STSA] + "=" + ::ToString( m_dStepSideAng)) ; case KEY_STSAB : return ( sSawingKey[KEY_STSAB] + "=" + ::ToString( m_dStepSideAngBack)) ; case KEY_STY : return ( sSawingKey[KEY_STY] + "=" + ::ToString( m_nStepType)) ; case KEY_TNAME : return ( sSawingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sSawingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sSawingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; case KEY_WS : return ( sSawingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ; default : return "" ; } } //---------------------------------------------------------------------------- bool SawingData::IsOptional( int nKey) const { return ( nKey == KEY_AB || nKey == KEY_AI || nKey == KEY_F || nKey == KEY_FA || nKey == KEY_FB || nKey == KEY_FE || nKey == KEY_FS || nKey == KEY_FT || nKey == KEY_NNS || nKey == KEY_NNU || nKey == KEY_OL || nKey == KEY_OR || nKey == KEY_S || nKey == KEY_SCC || nKey == KEY_SL || nKey == KEY_STB || nKey == KEY_STEA || nKey == KEY_STIA || nKey == KEY_STSA || nKey == KEY_STSAB || nKey == KEY_LIEL || nKey == KEY_LITG) ; } //---------------------------------------------------------------------------- bool SawingData::VerifySolCh( int nVal) const { return IsValidOperationScc( nVal) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyWorkSide( int nVal) const { return ( nVal == SAW_WS_CENTER || nVal == SAW_WS_LEFT || nVal == SAW_WS_RIGHT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyHeadSide( int nVal) const { return ( nVal == SAW_HS_LEFT || nVal == SAW_HS_RIGHT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyStepType( int nVal) const { return ( nVal == SAW_ST_ZIGZAG || nVal == SAW_ST_ONEWAY || nVal == SAW_ST_TOANDFROM) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyLeadInType( int nVal) const { return ( nVal == SAW_LI_STRICT || nVal == SAW_LI_CENT || nVal == SAW_LI_OUT || nVal == SAW_LI_EXT_CENT || nVal == SAW_LI_EXT_OUT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyExtLinkType( int nVal) const { return ( nVal == SAW_EL_CENT || nVal == SAW_EL_EXT_PREV || nVal == SAW_EL_EXT_NEXT || nVal == SAW_EL_EXT_BOTH) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyLeadOutType( int nVal) const { return ( nVal == SAW_LO_STRICT || nVal == SAW_LO_CENT || nVal == SAW_LO_OUT || nVal == SAW_LO_EXT_CENT || nVal == SAW_LO_EXT_OUT) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyCurveUse( int nVal) const { return ( nVal == SAW_CRV_SKIP || nVal == SAW_CRV_APPROX || nVal == SAW_CRV_CONVEX || nVal == SAW_CRV_KEEP) ; } //---------------------------------------------------------------------------- bool SawingData::VerifySideAngle( double dVal) const { const double MAX_SIDE_ANG = 75.0 + EPS_ANG_SMALL ; const double AUTO_SIDE_ANG = 99 ; return ( ( dVal > - MAX_SIDE_ANG && dVal < MAX_SIDE_ANG) || abs( dVal - AUTO_SIDE_ANG) < EPS_ANG_SMALL) ; } //---------------------------------------------------------------------------- bool SawingData::VerifyTool( const ToolsMgr* pToolsMgr, const 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_SAWBLADE) == 0) return false ; return true ; } //---------------------------------------------------------------------------- bool SawingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const { if ( pToolsMgr == nullptr) return false ; pTdata = pToolsMgr->GetTool( m_ToolUuid) ; return ( pTdata != nullptr) ; } //---------------------------------------------------------------------------- bool SawingData::SetParam( int nType, bool bVal) { switch ( nType) { case MPA_INVERT : m_bInvert = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::SetParam( int nType, int nVal) { switch ( nType) { case MPA_WORKSIDE : if ( ! VerifyWorkSide( nVal)) return false ; m_nWorkSide = nVal ; return true ; case MPA_HEADSIDE : if ( ! VerifyHeadSide( nVal)) return false ; m_nHeadSide = nVal ; return true ; case MPA_STEPTYPE : if ( ! VerifyStepType( nVal)) return false ; m_nStepType = nVal ; return true ; case MPA_LEADINTYPE : if ( ! VerifyLeadInType( nVal)) return false ; m_nLeadInType = nVal ; return true ; case MPA_EXTLINKTYPE : if ( ! VerifyExtLinkType( nVal)) return false ; m_nExtLinkType = nVal ; return true ; case MPA_LEADOUTTYPE : if ( ! VerifyLeadOutType( nVal)) return false ; m_nLeadOutType = nVal ; return true ; case MPA_CURVEUSE : if ( ! VerifyCurveUse( nVal)) return false ; m_nCurveUse = nVal ; return true ; case MPA_SCC : if ( ! VerifySolCh( nVal)) return false ; m_nSolCh = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::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_BACKFEED : m_dBackFeed = dVal ; return true ; case MPA_SIDEANGFEED : m_dSideAngFeed = 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_STEPBACK : m_dStepBack = dVal ; return true ; case MPA_STEPLAST : m_dStepLast = dVal ; return true ; case MPA_STEPEXTARC : m_dStepExtArc = dVal ; return true ; case MPA_STEPINTARC : m_dStepIntArc = dVal ; return true ; case MPA_STEPSIDEANG : m_dStepSideAng = dVal ; return true ; case MPA_STEPSIDEANGBACK : m_dStepSideAngBack = dVal ; return true ; case MPA_SIDEANGLE : if ( ! VerifySideAngle( dVal)) return false ; m_dSideAngle = dVal ; return true ; case MPA_STARTADDLEN : m_dStartAddLen = dVal ; return true ; case MPA_ENDADDLEN : m_dEndAddLen = dVal ; return true ; case MPA_APPROX : m_dApprox = dVal ; return true ; case MPA_LIELEV : m_dLiElev = dVal ; return true ; case MPA_LITANG : m_dLiTang = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::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 ; case MPA_INITANGS : m_sInitAngs = sVal ; return true ; case MPA_BLOCKEDAXIS : m_sBlockedAxis = sVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool SawingData::ResetTool( void) { m_sToolName.clear() ; m_ToolUuid.Clear() ; return true ; } //---------------------------------------------------------------------------- bool SawingData::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_bInvert ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool SawingData::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_SAWING ; return true ; case MPA_WORKSIDE : nVal = m_nWorkSide ; return true ; case MPA_HEADSIDE : nVal = m_nHeadSide ; return true ; case MPA_STEPTYPE : nVal = m_nStepType ; return true ; case MPA_LEADINTYPE : nVal = m_nLeadInType ; return true ; case MPA_EXTLINKTYPE : nVal = m_nExtLinkType ; return true ; case MPA_LEADOUTTYPE : nVal = m_nLeadOutType ; return true ; case MPA_CURVEUSE : nVal = m_nCurveUse ; return true ; case MPA_SCC : nVal = m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SawingData::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_BACKFEED : dVal = m_dBackFeed ; return true ; case MPA_SIDEANGFEED : dVal = m_dSideAngFeed ; 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_STEPBACK : dVal = m_dStepBack ; return true ; case MPA_STEPLAST : dVal = m_dStepLast ; return true ; case MPA_STEPEXTARC : dVal = m_dStepExtArc ; return true ; case MPA_STEPINTARC : dVal = m_dStepIntArc ; return true ; case MPA_STEPSIDEANG : dVal = m_dStepSideAng ; return true ; case MPA_STEPSIDEANGBACK : dVal = m_dStepSideAngBack ; return true ; case MPA_SIDEANGLE : dVal = m_dSideAngle ; return true ; case MPA_STARTADDLEN : dVal = m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_dEndAddLen ; return true ; case MPA_APPROX : dVal = m_dApprox ; return true ; case MPA_LIELEV : dVal = m_dLiElev ; return true ; case MPA_LITANG : dVal = m_dLiTang ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool SawingData::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 ; case MPA_INITANGS : sVal = m_sInitAngs ; return true ; case MPA_BLOCKEDAXIS : sVal = m_sBlockedAxis ; return true ; } sVal = "" ; return false ; }