//---------------------------------------------------------------------------- // EgalTech 2019-2019 //---------------------------------------------------------------------------- // File : WaterJettingData.cpp Data : 08.07.19 Versione : 2.1g2 // Contenuto : Implementazione struttura dati lavorazione di taglio water jet. // // // // Modifiche : 08.07.19 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "WaterJettingData.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 nWaterJetting { KEY_AB = 0, KEY_AI, KEY_CSL, KEY_CSP, KEY_EAL, KEY_ECT, KEY_F, KEY_FA, KEY_FT, KEY_HPT, KEY_ICT, KEY_INV, KEY_LICL, KEY_LIH, KEY_LIHR, KEY_LIPR, KEY_LITG, KEY_LITY, KEY_LOCL, KEY_LOPR, KEY_LOTG, KEY_LOTY, KEY_LPT, KEY_NAME, KEY_NNS, KEY_NNU, KEY_OR, KEY_OVL, KEY_PRB, KEY_PRBMAX, KEY_PRBMIN, KEY_S, KEY_SA, KEY_SAL, KEY_SCC, KEY_THREF, KEY_TNAME, KEY_TUUID, KEY_UUID, KEY_WS, KEY_ZZZ} ; // rappresenta il numero di elementi static const array sWaterJettingKey = { "AB", "AI", "CSL", "CSP", "EAL", "ECT", "F", "FA", "FT", "HPT", "ICT", "INV", "LICL", "LIH", "LIHR", "LIPR", "LITG", "LITY", "LOCL", "LOPR", "LOTG", "LOTY", "LPT", "NAME", "NNS", "NNU", "OR", "OVL", "PRB", "PRBMAX", "PRBMIN", "S", "SA", "SAL", "SCC", "THREF", "TN", "TU", "UUID", "WS"} ; //---------------------------------------------------------------------------- MCHDATA_REGISTER( MT_WATERJETTING, "WATERJETTING", WaterJettingData) ; //---------------------------------------------------------------------------- WaterJettingData* WaterJettingData::Clone( void) const { // alloco oggetto WaterJettingData* pMdata = new(nothrow) WaterJettingData ; // copio i dati if ( pMdata != nullptr) { if ( ! pMdata->CopyFrom( this)) { delete pMdata ; return nullptr ; } } return pMdata ; } //---------------------------------------------------------------------------- bool WaterJettingData::CopyFrom( const MachiningData* pMdata) { // è inutile copiare se sorgente coincide con destinazione if ( pMdata == this) return true ; // la sorgente deve essere dello stesso tipo const WaterJettingData* pSdata = GetWaterJettingData( 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_dTipFeed = pSdata->m_dTipFeed ; m_dThickRef = pSdata->m_dThickRef ; m_dOffsR = pSdata->m_dOffsR ; m_bInvert = pSdata->m_bInvert ; m_nWorkSide = pSdata->m_nWorkSide ; m_dOverlap = pSdata->m_dOverlap ; m_dSideAngle = pSdata->m_dSideAngle ; m_dForwardAngle = pSdata->m_dForwardAngle ; m_dStartAddLen = pSdata->m_dStartAddLen ; m_dEndAddLen = pSdata->m_dEndAddLen ; m_bProbing = pSdata->m_bProbing ; m_dProbingMinDist = pSdata->m_dProbingMinDist ; m_dProbingMaxDist = pSdata->m_dProbingMaxDist ; m_nExtCornerType = pSdata->m_nExtCornerType ; m_nIntCornerType = pSdata->m_nIntCornerType ; m_dCornerSlowLen = pSdata->m_dCornerSlowLen ; m_nCornerSlowPerc = pSdata->m_nCornerSlowPerc ; m_nLeadInType = pSdata->m_nLeadInType ; m_dLiTang = pSdata->m_dLiTang ; m_dLiPerp = pSdata->m_dLiPerp ; m_dLiCompLen = pSdata->m_dLiCompLen ; m_bLiHole = pSdata->m_bLiHole ; m_dLiHoleRad = pSdata->m_dLiHoleRad ; m_nLpTurns = pSdata->m_nLpTurns ; m_nHpTurns = pSdata->m_nHpTurns ; m_nLeadOutType = pSdata->m_nLeadOutType ; m_dLoTang = pSdata->m_dLoTang ; m_dLoPerp = pSdata->m_dLoPerp ; m_dLoCompLen = pSdata->m_dLoCompLen ; m_sSysNotes = pSdata->m_sSysNotes ; m_sUserNotes = pSdata->m_sUserNotes ; return true ; } //---------------------------------------------------------------------------- bool WaterJettingData::SameAs( const MachiningData* pMdata) const { // se coincide con altro -> uguali if ( pMdata == this) return true ; // se sono di tipo diverso -> diversi const WaterJettingData* pSdata = GetWaterJettingData( 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 && abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR && abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR && abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR && abs( m_dThickRef - pSdata->m_dThickRef) < EPS_MACH_LEN_PAR && abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR && m_bInvert == pSdata->m_bInvert && m_nWorkSide == pSdata->m_nWorkSide && abs( m_dOverlap - pSdata->m_dOverlap) < EPS_MACH_LEN_PAR && abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR && abs( m_dForwardAngle - pSdata->m_dForwardAngle) < EPS_MACH_ANG_PAR && abs( m_dStartAddLen - pSdata->m_dStartAddLen) < EPS_MACH_LEN_PAR && abs( m_dEndAddLen - pSdata->m_dEndAddLen) < EPS_MACH_LEN_PAR && m_bProbing == pSdata->m_bProbing && abs( m_dProbingMinDist - pSdata->m_dProbingMinDist) < EPS_MACH_LEN_PAR && abs( m_dProbingMaxDist - pSdata->m_dProbingMaxDist) < EPS_MACH_LEN_PAR && m_nExtCornerType == pSdata->m_nExtCornerType && m_nIntCornerType == pSdata->m_nIntCornerType && abs( m_dCornerSlowLen - pSdata->m_dCornerSlowLen) < EPS_MACH_LEN_PAR && m_nCornerSlowPerc == pSdata->m_nCornerSlowPerc && m_nLeadInType == pSdata->m_nLeadInType && abs( m_dLiTang - pSdata->m_dLiTang) < EPS_MACH_LEN_PAR && abs( m_dLiPerp - pSdata->m_dLiPerp) < EPS_MACH_LEN_PAR && abs( m_dLiCompLen - pSdata->m_dLiCompLen) < EPS_MACH_LEN_PAR && m_bLiHole == pSdata->m_bLiHole && abs( m_dLiHoleRad - pSdata->m_dLiHoleRad) < EPS_MACH_LEN_PAR && m_nLpTurns == pSdata->m_nLpTurns && m_nHpTurns == pSdata->m_nHpTurns && m_nLeadOutType == pSdata->m_nLeadOutType && abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR && abs( m_dLoPerp - pSdata->m_dLoPerp) < EPS_MACH_LEN_PAR && abs( m_dLoCompLen - pSdata->m_dLoCompLen) < EPS_MACH_LEN_PAR && m_sSysNotes == pSdata->m_sSysNotes && m_sUserNotes == pSdata->m_sUserNotes) ; } //---------------------------------------------------------------------------- int WaterJettingData::GetSize( void) const { // in debug verifico validità ultimo campo assert( sWaterJettingKey[KEY_WS] == "WS") ; return KEY_ZZZ ; } //---------------------------------------------------------------------------- string WaterJettingData::GetTitle( void) const { return MCHDATA_GETNAME( WaterJettingData) ; } //---------------------------------------------------------------------------- int FindWaterJettingKey( const string& sKey) { auto TheRange = equal_range( sWaterJettingKey.cbegin(), sWaterJettingKey.cend(), sKey) ; if ( TheRange.first == TheRange.second) return - 1 ; return int( TheRange.first - sWaterJettingKey.cbegin()) ; } //---------------------------------------------------------------------------- bool WaterJettingData::FromString( const string& sString, int& nKey) { // separo chiave da valore string sKey, sVal ; SplitFirst( sString, "=", sKey, sVal) ; // riconosco la chiave nKey = FindWaterJettingKey( ToUpper( sKey)) ; bool bOk = ( nKey >= 0) ; switch ( nKey) { case KEY_AB : m_sBlockedAxis = sVal ; break ; case KEY_AI : m_sInitAngs = sVal ; break ; case KEY_CSL : bOk = ::FromString( sVal, m_dCornerSlowLen) ; break ; case KEY_CSP : bOk = ::FromString( sVal, m_nCornerSlowPerc) ; break ; case KEY_EAL : bOk = ::FromString( sVal, m_dEndAddLen) ; break ; case KEY_ECT : bOk = ::FromString( sVal, m_nExtCornerType) ; break ; case KEY_F : bOk = ::FromString( sVal, m_dFeed) ; break ; case KEY_FA : bOk = ::FromString( sVal, m_dForwardAngle) ; break ; case KEY_FT : bOk = ::FromString( sVal, m_dTipFeed) ; break ; case KEY_HPT : bOk = ::FromString( sVal, m_nHpTurns) ; break ; case KEY_ICT : bOk = ::FromString( sVal, m_nIntCornerType) ; break ; case KEY_INV : bOk = ::FromString( sVal, m_bInvert) ; break ; case KEY_LICL : bOk = ::FromString( sVal, m_dLiCompLen) ; break ; case KEY_LIH : bOk = ::FromString( sVal, m_bLiHole) ; break ; case KEY_LIHR : bOk = ::FromString( sVal, m_dLiHoleRad) ; break ; case KEY_LIPR : bOk = ::FromString( sVal, m_dLiPerp) ; break ; case KEY_LITG : bOk = ::FromString( sVal, m_dLiTang) ; break ; case KEY_LITY : bOk = ::FromString( sVal, m_nLeadInType) ; break ; case KEY_LOCL : bOk = ::FromString( sVal, m_dLoCompLen) ; break ; case KEY_LOPR : bOk = ::FromString( sVal, m_dLoPerp) ; break ; case KEY_LOTG : bOk = ::FromString( sVal, m_dLoTang) ; break ; case KEY_LOTY : bOk = ::FromString( sVal, m_nLeadOutType) ; break ; case KEY_LPT : bOk = ::FromString( sVal, m_nLpTurns) ; 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_OR : bOk = ::FromString( sVal, m_dOffsR) ; break ; case KEY_PRB : bOk = ::FromString( sVal, m_bProbing) ; break ; case KEY_PRBMAX : bOk = ::FromString( sVal, m_dProbingMaxDist) ; break ; case KEY_PRBMIN : bOk = ::FromString( sVal, m_dProbingMinDist) ; break ; case KEY_OVL : bOk = ::FromString( sVal, m_dOverlap) ; 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_THREF : bOk = ::FromString( sVal, m_dThickRef) ; 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 WaterJettingData::ToString( int nInd) const { switch ( nInd) { case KEY_AB : return ( sWaterJettingKey[KEY_AB] + "=" + m_sBlockedAxis) ; case KEY_AI : return ( sWaterJettingKey[KEY_AI] + "=" + m_sInitAngs) ; case KEY_CSL : return ( sWaterJettingKey[KEY_CSL] + "=" + ::ToString( m_dCornerSlowLen)) ; case KEY_CSP : return ( sWaterJettingKey[KEY_CSP] + "=" + ::ToString( m_nCornerSlowPerc)) ; case KEY_EAL : return ( sWaterJettingKey[KEY_EAL] + "=" + ::ToString( m_dEndAddLen)) ; case KEY_ECT : return ( sWaterJettingKey[KEY_ECT] + "=" + ::ToString( m_nExtCornerType)) ; case KEY_F : return ( sWaterJettingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ; case KEY_FA : return ( sWaterJettingKey[KEY_FA] + "=" + ::ToString( m_dForwardAngle)) ; case KEY_FT : return ( sWaterJettingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ; case KEY_HPT : return ( sWaterJettingKey[KEY_HPT] + "=" + ::ToString( m_nHpTurns)) ; case KEY_ICT : return ( sWaterJettingKey[KEY_ICT] + "=" + ::ToString( m_nIntCornerType)) ; case KEY_INV : return ( sWaterJettingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ; case KEY_LICL : return ( sWaterJettingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ; case KEY_LIH : return ( sWaterJettingKey[KEY_LIH] + "=" + ::ToString( m_bLiHole)) ; case KEY_LIHR : return ( sWaterJettingKey[KEY_LIHR] + "=" + ::ToString( m_dLiHoleRad)) ; case KEY_LIPR : return ( sWaterJettingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ; case KEY_LITG : return ( sWaterJettingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ; case KEY_LITY : return ( sWaterJettingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ; case KEY_LOCL : return ( sWaterJettingKey[KEY_LOCL] + "=" + ::ToString( m_dLoCompLen)) ; case KEY_LOPR : return ( sWaterJettingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ; case KEY_LOTG : return ( sWaterJettingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ; case KEY_LOTY : return ( sWaterJettingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ; case KEY_LPT : return ( sWaterJettingKey[KEY_LPT] + "=" + ::ToString( m_nLpTurns)) ; case KEY_NAME : return ( sWaterJettingKey[KEY_NAME] + "=" + m_sName) ; case KEY_NNS : return ( sWaterJettingKey[KEY_NNS] + "=" + m_sSysNotes) ; case KEY_NNU : return ( sWaterJettingKey[KEY_NNU] + "=" + m_sUserNotes) ; case KEY_OR : return ( sWaterJettingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ; case KEY_OVL : return ( sWaterJettingKey[KEY_OVL] + "=" + ::ToString( m_dOverlap)) ; case KEY_PRB : return ( sWaterJettingKey[KEY_PRB] + "=" + ::ToString( m_bProbing)) ; case KEY_PRBMAX : return ( sWaterJettingKey[KEY_PRBMAX] + "=" + ::ToString( m_dProbingMaxDist)) ; case KEY_PRBMIN : return ( sWaterJettingKey[KEY_PRBMIN] + "=" + ::ToString( m_dProbingMinDist)) ; case KEY_S : return ( sWaterJettingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ; case KEY_SA : return ( sWaterJettingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ; case KEY_SAL : return ( sWaterJettingKey[KEY_SAL] + "=" + ::ToString( m_dStartAddLen)) ; case KEY_SCC : return ( sWaterJettingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ; case KEY_THREF : return ( sWaterJettingKey[KEY_THREF] + "=" + ::ToString( m_dThickRef)) ; case KEY_TNAME : return ( sWaterJettingKey[KEY_TNAME] + "=" + m_sToolName) ; case KEY_TUUID : return ( sWaterJettingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ; case KEY_UUID : return ( sWaterJettingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ; case KEY_WS : return ( sWaterJettingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ; default : return "" ; } } //---------------------------------------------------------------------------- bool WaterJettingData::IsOptional( int nKey) const { return ( nKey == KEY_FA || nKey == KEY_PRB || nKey == KEY_PRBMAX || nKey == KEY_PRBMIN || nKey == KEY_ECT || nKey == KEY_ICT || nKey == KEY_CSL || nKey == KEY_CSP || nKey == KEY_LIH || nKey == KEY_LIHR || nKey == KEY_LPT || nKey == KEY_HPT || nKey == KEY_THREF) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifySolCh( int nVal) const { return IsValidOperationScc( nVal) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifyWorkSide( int nVal) const { return ( nVal == WJET_WS_CENTER || nVal == WJET_WS_LEFT || nVal == WJET_WS_RIGHT) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifyExtCornerType( int nVal) const { return ( nVal == WJET_EC_NONE || nVal == WJET_EC_SLOW || nVal == WJET_EC_LOOP) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifyIntCornerType( int nVal) const { return ( nVal == WJET_IC_NONE || nVal == WJET_IC_SLOW || nVal == WJET_IC_SLOW_FULL) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifyCornerSlowPerc( int nVal) const { return ( nVal >= 0 && nVal <= 100) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifyLeadInType( int nVal) const { return ( nVal == WJET_LI_NONE || nVal == WJET_LI_LINEAR || nVal == WJET_LI_TANGENT) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifyLeadOutType( int nVal) const { return ( nVal == WJET_LO_NONE || nVal == WJET_LO_LINEAR || nVal == WJET_LO_TANGENT || nVal == WJET_LO_AS_LI) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifySideAngle( double dVal) const { const double MAX_SIDE_ANG = 60.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 WaterJettingData::VerifyForwardAngle( double dVal) const { const double MAX_FORW_ANG = 30.0 + EPS_ANG_SMALL ; const double AUTO_FORW_ANG = 99 ; return ( ( dVal > - EPS_ZERO && dVal < MAX_FORW_ANG) || abs( dVal - AUTO_FORW_ANG) < EPS_ANG_SMALL) ; } //---------------------------------------------------------------------------- bool WaterJettingData::VerifyThickRef( double dVal) const { const double MIN_THICKREF = 1 ; return ( abs( dVal) < EPS_SMALL || dVal >= MIN_THICKREF) ; } //---------------------------------------------------------------------------- bool WaterJettingData::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_WATERJET) == 0) return false ; return true ; } //---------------------------------------------------------------------------- bool WaterJettingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const { if ( pToolsMgr == nullptr) return false ; pTdata = pToolsMgr->GetTool( m_ToolUuid) ; return ( pTdata != nullptr) ; } //---------------------------------------------------------------------------- bool WaterJettingData::SetParam( int nType, bool bVal) { switch ( nType) { case MPA_INVERT : m_bInvert = bVal ; return true ; case MPA_PROBING : m_bProbing = bVal ; return true ; case MPA_LIHOLE : m_bLiHole = bVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool WaterJettingData::SetParam( int nType, int nVal) { switch ( nType) { case MPA_WORKSIDE : if ( ! VerifyWorkSide( nVal)) return false ; m_nWorkSide = nVal ; return true ; case MPA_EXTCORNERTYPE : if ( ! VerifyExtCornerType( nVal)) return false ; m_nExtCornerType = nVal ; break ; case MPA_INTCORNERTYPE : if ( ! VerifyIntCornerType( nVal)) return false ; m_nIntCornerType = nVal ; break ; case MPA_CORNERSLOWPERC : if ( ! VerifyCornerSlowPerc( nVal)) return false ; m_nCornerSlowPerc = nVal ; break ; 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_LPTURNS : m_nLpTurns = nVal ; break ; case MPA_HPTURNS : m_nHpTurns = nVal ; break ; case MPA_SCC : if ( ! VerifySolCh( nVal)) return false ; m_nSolCh = nVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool WaterJettingData::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_TIPFEED : m_dTipFeed = dVal ; return true ; case MPA_THICKREF : if ( ! VerifyThickRef( dVal)) return false ; m_dThickRef = dVal ; return true ; case MPA_OFFSR : m_dOffsR = dVal ; return true ; case MPA_OVERL : m_dOverlap = dVal ; return true ; case MPA_SIDEANGLE : if ( ! VerifySideAngle( dVal)) return false ; m_dSideAngle = dVal ; return true ; case MPA_FORWARDANGLE : if ( ! VerifyForwardAngle( dVal)) return false ; m_dForwardAngle = dVal ; return true ; case MPA_STARTADDLEN : m_dStartAddLen = dVal ; return true ; case MPA_ENDADDLEN : m_dEndAddLen = dVal ; return true ; case MPA_PROBINGMINDIST : m_dProbingMinDist = dVal ; return true ; case MPA_PROBINGMAXDIST : m_dProbingMaxDist = dVal ; return true ; case MPA_CORNERSLOWLEN : m_dCornerSlowLen = dVal ; return true ; case MPA_LITANG : m_dLiTang = dVal ; return true ; case MPA_LIPERP : m_dLiPerp = dVal ; return true ; case MPA_LICOMPLEN : m_dLiCompLen = dVal ; return true ; case MPA_LIHOLERAD : m_dLiHoleRad = dVal ; return true ; case MPA_LOTANG : m_dLoTang = dVal ; return true ; case MPA_LOPERP : m_dLoPerp = dVal ; return true ; case MPA_LOCOMPLEN : m_dLoCompLen = dVal ; return true ; } return false ; } //---------------------------------------------------------------------------- bool WaterJettingData::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_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 WaterJettingData::ResetTool( void) { m_sToolName.clear() ; m_ToolUuid.Clear() ; return true ; } //---------------------------------------------------------------------------- bool WaterJettingData::GetParam( int nType, bool& bVal) const { switch ( nType) { case MPA_INVERT : bVal = m_bInvert ; return true ; case MPA_PROBING : bVal = m_bProbing ; return true ; case MPA_LIHOLE : bVal = m_bLiHole ; return true ; } bVal = false ; return false ; } //---------------------------------------------------------------------------- bool WaterJettingData::GetParam( int nType, int& nVal) const { switch ( nType) { case MPA_TYPE : nVal = MT_WATERJETTING ; return true ; case MPA_WORKSIDE : nVal = m_nWorkSide ; return true ; case MPA_EXTCORNERTYPE : nVal = m_nExtCornerType ; return true ; case MPA_INTCORNERTYPE : nVal = m_nIntCornerType ; return true ; case MPA_CORNERSLOWPERC : nVal = m_nCornerSlowPerc ; return true ; case MPA_LEADINTYPE : nVal = m_nLeadInType ; return true ; case MPA_LEADOUTTYPE : nVal = m_nLeadOutType ; return true ; case MPA_LPTURNS : nVal = m_nLpTurns ; return true ; case MPA_HPTURNS : nVal = m_nHpTurns ; return true ; case MPA_SCC : nVal = m_nSolCh ; return true ; } nVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool WaterJettingData::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_TIPFEED : dVal = m_dTipFeed ; return true ; case MPA_THICKREF : dVal = m_dThickRef ; return true ; case MPA_OFFSR : dVal = m_dOffsR ; return true ; case MPA_OVERL : dVal = m_dOverlap ; return true ; case MPA_SIDEANGLE : dVal = m_dSideAngle ; return true ; case MPA_FORWARDANGLE : dVal = m_dForwardAngle ; return true ; case MPA_STARTADDLEN : dVal = m_dStartAddLen ; return true ; case MPA_ENDADDLEN : dVal = m_dEndAddLen ; return true ; case MPA_PROBINGMINDIST : dVal = m_dProbingMinDist ; return true ; case MPA_PROBINGMAXDIST : dVal = m_dProbingMaxDist ; return true ; case MPA_CORNERSLOWLEN : dVal = m_dCornerSlowLen ; return true ; case MPA_LITANG : dVal = m_dLiTang ; return true ; case MPA_LIPERP : dVal = m_dLiPerp ; return true ; case MPA_LICOMPLEN : dVal = m_dLiCompLen ; return true ; case MPA_LIHOLERAD : dVal = m_dLiHoleRad ; return true ; case MPA_LOTANG : dVal = m_dLoTang ; return true ; case MPA_LOPERP : dVal = m_dLoPerp ; return true ; case MPA_LOCOMPLEN : dVal = m_dLoCompLen ; return true ; } dVal = 0 ; return false ; } //---------------------------------------------------------------------------- bool WaterJettingData::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_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 ; }