Dario Sassi
1d25de4caa
- aggiunti due parametri nelle lavorazioni di tagli con lama (DB versione 1011).
919 lines
27 KiB
C++
919 lines
27 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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 <array>
|
|
#include <cassert>
|
|
|
|
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<string,KEY_ZZZ> 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 ;
|
|
}
|