/***********************************************************************************************************************
*
* 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);
}