661 lines
25 KiB
C++
661 lines
25 KiB
C++
/***********************************************************************************************************************
|
|
*
|
|
* Copyright (c) 2010 - 2025 by Tech Soft 3D, Inc.
|
|
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
|
|
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
|
|
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
|
|
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
|
|
* scope and manner of such use.
|
|
*
|
|
***********************************************************************************************************************/
|
|
|
|
#include <A3DSDKIncludes.h>
|
|
#include "PRC2XML.h"
|
|
|
|
|
|
|
|
//######################################################################################################################
|
|
static void stvAddModifier(int iModifier, _TiXmlElement* setting)
|
|
{
|
|
switch(iModifier)
|
|
{
|
|
case KEA3DGDTModifierNone: setting->SetAttribute("m_eModifier", "none"); break;
|
|
case KEA3DGDTModifierMax: setting->SetAttribute("m_eModifier", "maximum material condition"); break;
|
|
case KEA3DGDTModifierMin: setting->SetAttribute("m_eModifier", "least material condition"); break;
|
|
case KEA3DGDTModifierProj: setting->SetAttribute("m_eModifier", "projected tolerance zone"); break;
|
|
case KEA3DGDTModifierFree: setting->SetAttribute("m_eModifier", "free state"); break;
|
|
case KEA3DGDTModifierRfs: setting->SetAttribute("m_eModifier", "regardless of feature size"); break;
|
|
case KEA3DGDTModifierTangent: setting->SetAttribute("m_eModifier", "tangent plane"); break;
|
|
case KEA3DGDTModifierST: setting->SetAttribute("m_eModifier", "statical"); break;
|
|
default: setting->SetAttribute("m_eModifier", "unexpected"); break;
|
|
}
|
|
}
|
|
|
|
//######################################################################################################################
|
|
static void stvAddGDTType(int itype, _TiXmlElement* setting)
|
|
{
|
|
switch(itype)
|
|
{
|
|
case KEA3DGDTTypeNone: setting->SetAttribute("m_eType", "none"); break;
|
|
case KEA3DGDTTypeStraightness: setting->SetAttribute("m_eType", "Straightness"); break;
|
|
case KEA3DGDTTypeFlatness: setting->SetAttribute("m_eType", "Flatness"); break;
|
|
case KEA3DGDTTypeCircularity: setting->SetAttribute("m_eType", "Circularity"); break;
|
|
case KEA3DGDTTypeCylindricity: setting->SetAttribute("m_eType", "Cylindricity"); break;
|
|
case KEA3DGDTTypeLineProfile: setting->SetAttribute("m_eType", "Profile of a line"); break;
|
|
case KEA3DGDTTypeSurfaceProfile: setting->SetAttribute("m_eType", "Profile of a surface"); break;
|
|
case KEA3DGDTTypeAngularity: setting->SetAttribute("m_eType", "Angularity"); break;
|
|
case KEA3DGDTTypePerpendicularity: setting->SetAttribute("m_eType", "Perpendicularity"); break;
|
|
case KEA3DGDTTypeParallelism: setting->SetAttribute("m_eType", "Parallel"); break;
|
|
case KEA3DGDTTypePosition: setting->SetAttribute("m_eType", "Positional"); break;
|
|
case KEA3DGDTTypeConcentricity: setting->SetAttribute("m_eType", "Concentricity"); break;
|
|
case KEA3DGDTTypeSymmetry: setting->SetAttribute("m_eType", "Symmetric"); break;
|
|
case KEA3DGDTTypeCircularRunout: setting->SetAttribute("m_eType", "Circular run out"); break;
|
|
case KEA3DGDTTypeTotalRunout: setting->SetAttribute("m_eType", "Total run out"); break;
|
|
default: setting->SetAttribute("m_eType", "unexpected"); break;
|
|
}
|
|
}
|
|
|
|
static A3DStatus stTraverseFCFDraftingIndicator(const A3DMDFCFDraftingIndicatorData& sData, _TiXmlElement* indicator);
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseDraftingRow(const A3DMDFCFDraftingRow *psRow, _TiXmlElement* setting)
|
|
{
|
|
A3DMDFCFDraftingRowData sData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCFDraftingRowData, sData);
|
|
|
|
_TiXmlElement* drft_row = new _TiXmlElement("A3DMDFCFDraftingRowData");
|
|
setting->LinkEndChild(drft_row);
|
|
|
|
A3DStatus iRet = A3DMDFCFDraftingRowGet(psRow, &sData);
|
|
if(iRet != A3D_SUCCESS)
|
|
{
|
|
drft_row->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return iRet;
|
|
}
|
|
|
|
stvAddGDTType(sData.m_eType, drft_row);
|
|
|
|
_TiXmlElement* row_boxes = new _TiXmlElement("A3DMDFCFDraftingRowData");
|
|
drft_row->LinkEndChild(row_boxes);
|
|
if(sData.m_uiNumberOfTextsInBoxes == 0)
|
|
row_boxes->SetAttribute("error", "no box");
|
|
|
|
A3DUns32 i;
|
|
char sName[20];
|
|
for(i = 0; i < sData.m_uiNumberOfTextsInBoxes; ++i)
|
|
{
|
|
if(sData.m_ppcTextsInBoxes[i] == NULL)
|
|
{
|
|
row_boxes->SetAttribute("error", "no text in box");
|
|
continue;
|
|
}
|
|
sprintf_s(sName, sizeof(sName) - 1, "box_%u", i);
|
|
row_boxes->SetAttribute(sName, sData.m_ppcTextsInBoxes[i]);
|
|
}
|
|
if (sData.m_uiNumberOfIndicators)
|
|
{
|
|
_TiXmlElement* indicators = new _TiXmlElement("m_ppIndicators");
|
|
drft_row->LinkEndChild(indicators);
|
|
for (i = 0; i < sData.m_uiNumberOfIndicators; ++i)
|
|
{
|
|
A3DMDFCFDraftingIndicatorData sIndicatorData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCFDraftingIndicatorData, sIndicatorData);
|
|
iRet = A3DMDFCFDraftingIndicatorGet(sData.m_ppIndicators[i], &sIndicatorData);
|
|
if (iRet == A3D_SUCCESS)
|
|
{
|
|
_TiXmlElement* indicator = new _TiXmlElement("A3DMDFCFIndicatorData");
|
|
indicators->LinkEndChild(indicator);
|
|
stTraverseFCFDraftingIndicator(sIndicatorData, indicator);
|
|
A3DMDFCFDraftingIndicatorGet(nullptr, &sIndicatorData);
|
|
}
|
|
else
|
|
{
|
|
drft_row->SetAttribute("error", "A3DMDFCFIndicatorGet");
|
|
}
|
|
}
|
|
}
|
|
return A3DMDFCFDraftingRowGet(NULL, &sData);
|
|
}
|
|
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseDatumReference(const char* pcTitle, A3DMDFCFRowDatum* psDatum, _TiXmlElement* drw_row)
|
|
{
|
|
_TiXmlElement* datum_ref = new _TiXmlElement(pcTitle);
|
|
drw_row->LinkEndChild(datum_ref);
|
|
|
|
A3DMDFCFRowDatumData sDatumData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCFRowDatumData, sDatumData);
|
|
|
|
A3DStatus iRet = A3DMDFCFRowDatumGet(psDatum, &sDatumData);
|
|
if(iRet != A3D_SUCCESS)
|
|
{
|
|
drw_row->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return A3D_SUCCESS;
|
|
}
|
|
|
|
datum_ref->SetAttribute("m_pcDatum", sDatumData.m_pcDatum?sDatumData.m_pcDatum : "null");
|
|
stvAddModifier(sDatumData.m_eModifier, datum_ref);
|
|
|
|
if(sDatumData.m_pLinkedItem)
|
|
traverseLinkedItem(sDatumData.m_pLinkedItem, datum_ref);
|
|
A3DMDFCFRowDatum* pNext = nullptr;
|
|
if ((pNext = sDatumData.m_pNext)!= nullptr)
|
|
{
|
|
A3DMDFCFRowDatumGet(nullptr, &sDatumData);
|
|
return stTraverseDatumReference("next", pNext, datum_ref);
|
|
}
|
|
|
|
return A3DMDFCFRowDatumGet(nullptr, &sDatumData);
|
|
}
|
|
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseRowToleranceValue(const A3DMDFCFToleranceValueData& sToleranceData, _TiXmlElement* semantic_value)
|
|
{
|
|
A3DStatus iRet = A3D_SUCCESS;
|
|
// value
|
|
if (sToleranceData.m_eValueType == KEA3DGDTValueNone)
|
|
semantic_value->SetAttribute("m_eValueType", "none");
|
|
else if (sToleranceData.m_eValueType == KEA3DGDTValueDiameter)
|
|
semantic_value->SetAttribute("m_eValueType", "diameter");
|
|
else if (sToleranceData.m_eValueType == KEA3DGDTValueRadius)
|
|
semantic_value->SetAttribute("m_eValueType", "radius");
|
|
else if (sToleranceData.m_eValueType == KEA3DGDTValueSpherical)
|
|
semantic_value->SetAttribute("m_eValueType", "spherical");
|
|
else
|
|
semantic_value->SetAttribute("m_eValueType", "unexpected");
|
|
|
|
|
|
// modifier
|
|
stvAddModifier(sToleranceData.m_eModifier, semantic_value);
|
|
semantic_value->SetAttribute("m_bFreeState", sToleranceData.m_bFreeState ? "true" : "false");
|
|
semantic_value->SetAttribute("m_bStatistical", sToleranceData.m_bStatistical ? "true" : "false");
|
|
|
|
|
|
// main value
|
|
if (sToleranceData.m_sValue.m_bIsValue)
|
|
{
|
|
if (sToleranceData.m_sValue.m_pcValue == NULL)
|
|
semantic_value->SetAttribute("m_sValue.m_pcValue", "NULL");
|
|
else
|
|
semantic_value->SetAttribute("m_sValue.m_pcValue", sToleranceData.m_sValue.m_pcValue);
|
|
}
|
|
else
|
|
semantic_value->SetDoubleAttribute("m_sValue.m_dValue", sToleranceData.m_sValue.m_dValue);
|
|
|
|
// tolerance per unit
|
|
if (sToleranceData.m_psTolerancePerUnit)
|
|
{
|
|
_TiXmlElement* tol_per_unit = new _TiXmlElement("m_psTolerancePerUnit");
|
|
semantic_value->LinkEndChild(tol_per_unit);
|
|
|
|
A3DMDFCTolerancePerUnitData sTolerancePerUnitData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCTolerancePerUnitData, sTolerancePerUnitData);
|
|
|
|
iRet = A3DMDFCTolerancePerUnitGet(sToleranceData.m_psTolerancePerUnit, &sTolerancePerUnitData);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
tol_per_unit->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return iRet;
|
|
}
|
|
|
|
tol_per_unit->SetDoubleAttribute("m_dUnitLengthOrAreaFirstValue", sTolerancePerUnitData.m_dUnitLengthOrAreaFirstValue);
|
|
if (sTolerancePerUnitData.m_pdUnitAreaSecondLength)
|
|
tol_per_unit->SetDoubleAttribute("m_pdUnitAreaSecondLength", *sTolerancePerUnitData.m_pdUnitAreaSecondLength);
|
|
|
|
if (sTolerancePerUnitData.m_psRefinementZone)
|
|
{
|
|
_TiXmlElement* tol_per_unit_ref = new _TiXmlElement("m_psRefinementZone");
|
|
tol_per_unit->LinkEndChild(tol_per_unit_ref);
|
|
|
|
A3DMDFCValueData sValueData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCValueData, sValueData);
|
|
|
|
iRet = A3DMDFCValueGet(sTolerancePerUnitData.m_psRefinementZone, &sValueData);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
tol_per_unit_ref->SetAttribute("refinement_zone_error", iRet);
|
|
return iRet;
|
|
}
|
|
|
|
if (sValueData.m_bIsValue)
|
|
{
|
|
if (sValueData.m_pcValue == NULL)
|
|
tol_per_unit_ref->SetAttribute("m_sValue.m_pcValue", "NULL");
|
|
else
|
|
tol_per_unit_ref->SetAttribute("m_sValue.m_pcValue", sValueData.m_pcValue);
|
|
}
|
|
else
|
|
tol_per_unit_ref->SetDoubleAttribute("m_sValue.m_dValue", sValueData.m_dValue);
|
|
|
|
CHECK_RET(A3DMDFCValueGet(NULL, &sValueData));
|
|
}
|
|
|
|
CHECK_RET(A3DMDFCTolerancePerUnitGet(NULL, &sTolerancePerUnitData));
|
|
}
|
|
|
|
// projected zone
|
|
if (sToleranceData.m_psProjectedZone)
|
|
{
|
|
_TiXmlElement* proj_zone = new _TiXmlElement("m_psProjectedZone");
|
|
semantic_value->LinkEndChild(proj_zone);
|
|
|
|
A3DMDFCProjectedZoneData sProjectedZoneData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCProjectedZoneData, sProjectedZoneData);
|
|
|
|
iRet = A3DMDFCProjectedZoneGet(sToleranceData.m_psProjectedZone, &sProjectedZoneData);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
proj_zone->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return iRet;
|
|
}
|
|
|
|
if (sProjectedZoneData.m_sLength.m_bIsValue)
|
|
{
|
|
if (sProjectedZoneData.m_sLength.m_pcValue == NULL)
|
|
proj_zone->SetAttribute("m_sLength.m_pcValue", "NULL");
|
|
else
|
|
proj_zone->SetAttribute("m_sLength.m_pcValue", sProjectedZoneData.m_sLength.m_pcValue);
|
|
}
|
|
else
|
|
proj_zone->SetDoubleAttribute("m_sLength.m_dValue", sProjectedZoneData.m_sLength.m_dValue);
|
|
|
|
if (sProjectedZoneData.m_pdPosition)
|
|
proj_zone->SetDoubleAttribute("m_pdPosition", *sProjectedZoneData.m_pdPosition);
|
|
CHECK_RET(A3DMDFCProjectedZoneGet(NULL, &sProjectedZoneData));
|
|
}
|
|
|
|
// profile tolerance offset
|
|
if (sToleranceData.m_psProfileTolerance)
|
|
{
|
|
_TiXmlElement* prof_tolerance = new _TiXmlElement("m_psProfileTolerance");
|
|
semantic_value->LinkEndChild(prof_tolerance);
|
|
|
|
A3DMDFCValueData sValueData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCValueData, sValueData);
|
|
|
|
iRet = A3DMDFCValueGet(sToleranceData.m_psProfileTolerance, &sValueData);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
prof_tolerance->SetAttribute("profile_tolerance_error", iRet);
|
|
return iRet;
|
|
}
|
|
|
|
if (sValueData.m_bIsValue)
|
|
{
|
|
if (sValueData.m_pcValue == NULL)
|
|
prof_tolerance->SetAttribute("m_sValue.m_pcValue", "NULL");
|
|
else
|
|
prof_tolerance->SetAttribute("m_sValue.m_pcValue", sValueData.m_pcValue);
|
|
}
|
|
else
|
|
prof_tolerance->SetDoubleAttribute("m_dValue", sValueData.m_dValue);
|
|
|
|
CHECK_RET(A3DMDFCValueGet(NULL, &sValueData));
|
|
}
|
|
|
|
// maximum bonus
|
|
if (sToleranceData.m_psMaximumBonus)
|
|
{
|
|
_TiXmlElement* max_bonus = new _TiXmlElement("m_psMaximumBonus");
|
|
semantic_value->LinkEndChild(max_bonus);
|
|
A3DMDFCValueData sValueData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCValueData, sValueData);
|
|
iRet = A3DMDFCValueGet(sToleranceData.m_psMaximumBonus, &sValueData);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
max_bonus->SetAttribute("maximum_bonus_error", iRet);
|
|
return iRet;
|
|
}
|
|
if (sValueData.m_bIsValue)
|
|
{
|
|
if (sValueData.m_pcValue == NULL)
|
|
max_bonus->SetAttribute("m_sValue.m_pcValue", "NULL");
|
|
else
|
|
max_bonus->SetAttribute("m_sValue.m_pcValue", sValueData.m_pcValue);
|
|
}
|
|
else
|
|
max_bonus->SetDoubleAttribute("m_dValue", sValueData.m_dValue);
|
|
|
|
CHECK_RET(A3DMDFCValueGet(NULL, &sValueData));
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseDrawingRow(const A3DMDFCFDrawingRowData& sData, _TiXmlElement* drw_row)
|
|
{
|
|
A3DStatus iRet;
|
|
|
|
// row type
|
|
stvAddGDTType(sData.m_eType, drw_row);
|
|
|
|
drw_row->SetAttribute("m_pcValue", sData.m_pcValue ? sData.m_pcValue : "null");
|
|
|
|
// references
|
|
if(sData.m_psPrimaryRef)
|
|
stTraverseDatumReference("m_psPrimaryRef", sData.m_psPrimaryRef, drw_row);
|
|
if(sData.m_psSecondaryRef)
|
|
stTraverseDatumReference("m_psSecondaryRef", sData.m_psSecondaryRef, drw_row);
|
|
if(sData.m_psTertiaryRef)
|
|
stTraverseDatumReference("m_psTertiaryRef", sData.m_psTertiaryRef, drw_row);
|
|
|
|
if(sData.m_psSemanticValue == NULL)
|
|
{
|
|
return A3D_SUCCESS;
|
|
}
|
|
|
|
// semantic tolerance value
|
|
_TiXmlElement* semantic_value = new _TiXmlElement("m_psSemanticValue");
|
|
drw_row->LinkEndChild(semantic_value);
|
|
|
|
A3DMDFCFToleranceValueData sSemanticData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCFToleranceValueData, sSemanticData);
|
|
|
|
iRet = A3DMDFCFToleranceValueGet(sData.m_psSemanticValue, &sSemanticData);
|
|
if(iRet != A3D_SUCCESS)
|
|
{
|
|
semantic_value->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return iRet;
|
|
}
|
|
stTraverseRowToleranceValue(sSemanticData, semantic_value);
|
|
|
|
_TiXmlElement* semantic_value2 = new _TiXmlElement("m_psNextSemanticValue");
|
|
drw_row->LinkEndChild(semantic_value2);
|
|
|
|
A3DMDFCFToleranceValueData sSemanticData2;
|
|
A3D_INITIALIZE_DATA(A3DMDFCFToleranceValueData, sSemanticData2);
|
|
|
|
iRet = A3DMDFCFToleranceValueGet(sSemanticData.m_psNext, &sSemanticData2);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
semantic_value2->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
CHECK_RET(A3DMDFCFToleranceValueGet(NULL, &sSemanticData));
|
|
return iRet;
|
|
}
|
|
|
|
drw_row->SetAttribute("m_pcNextValue", sSemanticData2.m_sValue.m_pcValue ? sSemanticData2.m_sValue.m_pcValue : "null");
|
|
stTraverseRowToleranceValue(sSemanticData2, semantic_value2);
|
|
CHECK_RET(A3DMDFCFToleranceValueGet(NULL, &sSemanticData2));
|
|
CHECK_RET(A3DMDFCFToleranceValueGet(NULL, &sSemanticData));
|
|
|
|
return iRet;
|
|
}
|
|
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseFCFDraftingIndicator(const A3DMDFCFDraftingIndicatorData& sData, _TiXmlElement* indicator)
|
|
{
|
|
// type
|
|
if (sData.m_eType == kA3DFCFIndicatorType_Undef)
|
|
indicator->SetAttribute("m_eType", "none");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_DirectionFeature)
|
|
indicator->SetAttribute("m_eType", "direction_feature");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_CollectionPlane)
|
|
indicator->SetAttribute("m_eType", "collection_plane");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_IntersectionPlane)
|
|
indicator->SetAttribute("m_eType", "intersection_plane");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_OrientationPlane)
|
|
indicator->SetAttribute("m_eType", "orientation_plane");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_Text)
|
|
indicator->SetAttribute("m_eType", "text");
|
|
else
|
|
indicator->SetAttribute("m_eType", "unexpected");
|
|
|
|
char sName[20];
|
|
for (unsigned i = 0; i < sData.m_uiNumberOfTexts; ++i)
|
|
{
|
|
if (sData.m_ppcTexts[i] != nullptr)
|
|
{
|
|
sprintf(sName, "m_pctext_%u", i);
|
|
indicator->SetAttribute(sName, sData.m_ppcTexts[i]);
|
|
}
|
|
}
|
|
return A3D_SUCCESS;
|
|
}
|
|
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseFCFIndicator(const A3DMDFCFIndicatorData& sData, _TiXmlElement* indicator)
|
|
{
|
|
// type
|
|
if (sData.m_eType == kA3DFCFIndicatorType_Undef)
|
|
indicator->SetAttribute("m_eType", "none");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_DirectionFeature)
|
|
indicator->SetAttribute("m_eType", "direction_feature");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_CollectionPlane)
|
|
indicator->SetAttribute("m_eType", "collection_plane");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_IntersectionPlane)
|
|
indicator->SetAttribute("m_eType", "intersection_plane");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_OrientationPlane)
|
|
indicator->SetAttribute("m_eType", "orientation_plane");
|
|
else if (sData.m_eType == kA3DFCFIndicatorType_Text)
|
|
indicator->SetAttribute("m_eType", "text");
|
|
else
|
|
indicator->SetAttribute("m_eType", "unexpected");
|
|
|
|
// symbol
|
|
if (sData.m_eSymbol == kA3DFCFIndicatorSymbol_Undef)
|
|
indicator->SetAttribute("m_eSymbol", "none");
|
|
else if (sData.m_eSymbol == kA3DFCFIndicatorSymbol_Angularity)
|
|
indicator->SetAttribute("m_eSymbol", "angularity");
|
|
else if (sData.m_eSymbol == kA3DFCFIndicatorSymbol_Perpendicularity)
|
|
indicator->SetAttribute("m_eSymbol", "perpendicularity");
|
|
else if (sData.m_eSymbol == kA3DFCFIndicatorSymbol_Parallelism)
|
|
indicator->SetAttribute("m_eSymbol", "parallelism");
|
|
else if (sData.m_eSymbol == kA3DFCFIndicatorSymbol_Symmetry)
|
|
indicator->SetAttribute("m_eSymbol", "symmetry");
|
|
else if (sData.m_eSymbol == kA3DFCFIndicatorSymbol_Runout)
|
|
indicator->SetAttribute("m_eSymbol", "runout");
|
|
else
|
|
indicator->SetAttribute("m_eSymbol", "unexpected");
|
|
|
|
// datum
|
|
if (sData.m_pDatum)
|
|
stTraverseDatumReference("m_pDatum", sData.m_pDatum, indicator);
|
|
|
|
if (sData.m_pcText && sData.m_eType == kA3DFCFIndicatorType_Text)
|
|
indicator->SetAttribute("m_pcText", sData.m_pcText);
|
|
|
|
for (unsigned i = 0; i < sData.m_uiNumberOfLinkedItems; ++i)
|
|
{
|
|
if (sData.m_ppLinkedItems[i])
|
|
traverseLinkedItem(sData.m_ppLinkedItems[i], indicator);
|
|
}
|
|
return A3D_SUCCESS;
|
|
}
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseFeatureControlFrameData(const A3DMDFeatureControlFrameData& sFeatureControlFrameData,
|
|
_TiXmlElement* setting)
|
|
{
|
|
A3DUns32 r;
|
|
A3DEEntityType eType = kA3DTypeUnknown;
|
|
A3DStatus iRet;
|
|
|
|
_TiXmlElement* fcf = new _TiXmlElement("A3DMDFeatureControlFrameData");
|
|
setting->LinkEndChild(fcf);
|
|
|
|
_TiXmlElement* rows = new _TiXmlElement("m_ppRows");
|
|
fcf->LinkEndChild(rows);
|
|
for(r = 0; r < sFeatureControlFrameData.m_uiNumberOfRows; ++r)
|
|
{
|
|
iRet = A3DEntityGetType(sFeatureControlFrameData.m_ppRows[r], &eType);
|
|
if(iRet != A3D_SUCCESS)
|
|
{
|
|
rows->SetAttribute("error_A3DEntityGetType", iRet);
|
|
continue;
|
|
}
|
|
|
|
A3DMDFCFDrawingRowData sDrawingRowData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCFDrawingRowData, sDrawingRowData);
|
|
|
|
iRet = A3DMDFCFSemanticRowGet(sFeatureControlFrameData.m_ppRows[r], &sDrawingRowData);
|
|
if(iRet == A3D_SUCCESS)
|
|
{
|
|
_TiXmlElement* drw_row = new _TiXmlElement("A3DMDFCFDrawingRowData");
|
|
rows->LinkEndChild(drw_row);
|
|
stTraverseDrawingRow(sDrawingRowData, drw_row);
|
|
A3DMDFCFDrawingRowGet(NULL, &sDrawingRowData);
|
|
}
|
|
else
|
|
{
|
|
if(eType != kA3DTypeMDFCFDraftingRow)
|
|
rows->SetAttribute("error", "FCFRow");
|
|
else
|
|
stTraverseDraftingRow((const A3DMDFCFDraftingRow*) sFeatureControlFrameData.m_ppRows[r], rows);
|
|
}
|
|
|
|
}
|
|
if (sFeatureControlFrameData.m_uiNumberOfIndicators)
|
|
{
|
|
_TiXmlElement* indicators = new _TiXmlElement("m_ppIndicators");
|
|
fcf->LinkEndChild(indicators);
|
|
for (r = 0; r < sFeatureControlFrameData.m_uiNumberOfIndicators; ++r)
|
|
{
|
|
A3DMDFCFIndicatorData sIndicatorData;
|
|
A3D_INITIALIZE_DATA(A3DMDFCFIndicatorData, sIndicatorData);
|
|
iRet = A3DMDFCFIndicatorGet(sFeatureControlFrameData.m_ppIndicators[r], &sIndicatorData);
|
|
if (iRet == A3D_SUCCESS)
|
|
{
|
|
_TiXmlElement* indicator = new _TiXmlElement("A3DMDFCFIndicatorData");
|
|
indicators->LinkEndChild(indicator);
|
|
stTraverseFCFIndicator(sIndicatorData, indicator);
|
|
A3DMDFCFIndicatorGet(nullptr, &sIndicatorData);
|
|
}
|
|
else
|
|
{
|
|
fcf->SetAttribute("error", "A3DMDFCFIndicatorGet");
|
|
}
|
|
}
|
|
}
|
|
return A3D_SUCCESS;
|
|
}
|
|
|
|
//######################################################################################################################
|
|
static A3DStatus stTraverseToleranceSize(const A3DMDToleranceSize* pToleranceSize, _TiXmlElement* setting)
|
|
{
|
|
A3DMDToleranceSizeData sToleranceSizeData;
|
|
A3D_INITIALIZE_DATA(A3DMDToleranceSizeData, sToleranceSizeData);
|
|
|
|
_TiXmlElement* toleranceSize = new _TiXmlElement("A3DMDToleranceSizeData");
|
|
setting->LinkEndChild(toleranceSize);
|
|
|
|
_TiXmlElement* values = new _TiXmlElement("m_ppTolSizeValue");
|
|
toleranceSize->LinkEndChild(values);
|
|
|
|
A3DStatus iRet = A3DMDToleranceSizeGet(pToleranceSize, &sToleranceSizeData);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
toleranceSize->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return iRet;
|
|
}
|
|
|
|
for (A3DUns32 i = 0; i < sToleranceSizeData.m_uiNumberOfSizeValues; ++i)
|
|
{
|
|
traverseToleranceSizeValue(sToleranceSizeData.m_ppTolSizeValue[i], toleranceSize);
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
//######################################################################################################################
|
|
A3DStatus traverseMarkupGDT(const A3DMarkupGDT* psMarkup, _TiXmlElement* setting)
|
|
{
|
|
A3DMarkupGDTData sData;
|
|
A3D_INITIALIZE_DATA(A3DMarkupGDTData, sData);
|
|
|
|
_TiXmlElement* markup_gdt = new _TiXmlElement("A3DMarkupGDTData");
|
|
setting->LinkEndChild(markup_gdt);
|
|
|
|
A3DStatus iRet = A3DMarkupGDTGet(psMarkup, &sData);
|
|
if(iRet != A3D_SUCCESS)
|
|
{
|
|
markup_gdt->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return iRet;
|
|
}
|
|
|
|
markup_gdt->SetAttribute("m_pcAboveText", sData.m_pcAboveText ? sData.m_pcAboveText : "null");
|
|
markup_gdt->SetAttribute("m_pcBelowText", sData.m_pcBelowText ? sData.m_pcBelowText : "null");
|
|
markup_gdt->SetAttribute("m_pcBeforeText", sData.m_pcBeforeText ? sData.m_pcBeforeText : "null");
|
|
markup_gdt->SetAttribute("m_pcAfterText", sData.m_pcAfterText ? sData.m_pcAfterText : "null");
|
|
|
|
A3DUns32 i;
|
|
char sName[20];
|
|
A3DEEntityType eType = kA3DTypeUnknown;
|
|
_TiXmlElement* tolerance = NULL;
|
|
for (i = 0; i < sData.m_uiNumberOfMarkupTolerances; ++i)
|
|
{
|
|
sprintf_s(sName, sizeof(sName)-1,"A3DMDTolerance_%u", i);
|
|
tolerance = new _TiXmlElement(sName);
|
|
markup_gdt->LinkEndChild(tolerance);
|
|
iRet = A3DEntityGetType(sData.m_ppsMarkupTolerances[i], &eType);
|
|
if (iRet != A3D_SUCCESS)
|
|
{
|
|
tolerance->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
continue;
|
|
}
|
|
if (eType == kA3DTypeMDFeatureControlFrame)
|
|
{
|
|
// semantic data
|
|
A3DMDFeatureControlFrameData sFCFData;
|
|
A3D_INITIALIZE_DATA(A3DMDFeatureControlFrameData, sFCFData);
|
|
|
|
iRet = A3DMDSemanticFeatureControlFrameGet(sData.m_ppsMarkupTolerances[i], &sFCFData);
|
|
if (iRet == A3D_SUCCESS)
|
|
{
|
|
_TiXmlElement* semantic_data = new _TiXmlElement("SEMANTIC_DATA");
|
|
tolerance->LinkEndChild(semantic_data);
|
|
stTraverseFeatureControlFrameData(sFCFData, semantic_data);
|
|
A3DMDSemanticFeatureControlFrameGet(NULL, &sFCFData);
|
|
}
|
|
else if (A3DMDFeatureControlFrameGet(sData.m_ppsMarkupTolerances[i], &sFCFData) == A3D_SUCCESS)
|
|
{
|
|
stTraverseFeatureControlFrameData(sFCFData, tolerance);
|
|
A3DMDFeatureControlFrameGet(NULL, &sFCFData);
|
|
}
|
|
else
|
|
tolerance->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
}
|
|
else if (eType == kA3DTypeMDToleranceSize)
|
|
{
|
|
stTraverseToleranceSize(sData.m_ppsMarkupTolerances[i], tolerance);
|
|
}
|
|
else
|
|
{
|
|
tolerance->SetAttribute("eType", "unexpected");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// text properties
|
|
traverseMarkupTextProperties(sData.m_pTextProperties, setting);
|
|
|
|
return A3DMarkupGDTGet(NULL, &sData);
|
|
}
|
|
|
|
//######################################################################################################################
|
|
A3DStatus traverseMarkupDatum(const A3DMarkupDatum* psMarkup, _TiXmlElement* setting)
|
|
{
|
|
A3DMarkupDatumData sMarkupData;
|
|
A3D_INITIALIZE_DATA(A3DMarkupDatumData, sMarkupData);
|
|
_TiXmlElement* markup_datum = new _TiXmlElement("A3DMarkupDatumData");
|
|
setting->LinkEndChild(markup_datum);
|
|
A3DStatus iRet = A3DMarkupDatumGet(psMarkup, &sMarkupData);
|
|
if(iRet != A3D_SUCCESS)
|
|
{
|
|
markup_datum->SetAttribute("error", A3DMiscGetErrorMsg(iRet));
|
|
return iRet;
|
|
}
|
|
markup_datum->SetAttribute("m_pcUpText", sMarkupData.m_pcUpText?sMarkupData.m_pcUpText:"NULL");
|
|
markup_datum->SetAttribute("m_pcDownText", sMarkupData.m_pcDownText?sMarkupData.m_pcDownText:"NULL");
|
|
|
|
markup_datum->SetAttribute("m_bTarget", sMarkupData.m_bTarget ? "true" : "false");
|
|
markup_datum->SetAttribute("m_bDiameter", sMarkupData.m_bDiameter ? "true" : "false");
|
|
markup_datum->SetAttribute("m_bIndividual", sMarkupData.m_bIndividual ? "true" : "false");
|
|
|
|
|
|
markup_datum->SetAttribute("m_pcAboveText", sMarkupData.m_pcAboveText ? sMarkupData.m_pcAboveText : "null");
|
|
markup_datum->SetAttribute("m_pcBelowText", sMarkupData.m_pcBelowText ? sMarkupData.m_pcBelowText : "null");
|
|
markup_datum->SetAttribute("m_pcBeforeText", sMarkupData.m_pcBeforeText ? sMarkupData.m_pcBeforeText : "null");
|
|
markup_datum->SetAttribute("m_pcAfterText", sMarkupData.m_pcAfterText ? sMarkupData.m_pcAfterText : "null");
|
|
|
|
traverseMarkupTextProperties(sMarkupData.m_pTextProperties, markup_datum);
|
|
return A3DMarkupDatumGet(NULL, &sMarkupData);
|
|
}
|