#include "stdafx.h"
#include "AecDbBaseStair.h"
#include "AcGiViewDraw.h"
#include "acdbx3dsolid.h"
#include "ImpMD5.h"

extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
static const Adesk::UInt16 kColorByLayer   = 256;

const CString AecDbBaseStair::KEY_REST_PTL = _T("KEY_REST_PTL");
const CString AecDbBaseStair::KEY_REST_PTW = _T("KEY_REST_PTW");
const CString AecDbBaseStair::KEY_REST_PTML = _T("KEY_REST_PTML");
const CString AecDbBaseStair::KEY_REST_PTMW = _T("KEY_REST_PTMW");
const CString AecDbBaseStair::KEY_STEEPMS = _T("KEY_STEEPMS");
const CString AecDbBaseStair::KEY_STEEP2S = _T("KEY_STEEP2S");

const CString AecDbBaseStair::KEY_SYMMETRY = _T("SYMTRY");
const CString AecDbBaseStair::KEY_1STEPS = _T("1STEPS");
const CString AecDbBaseStair::KEY_1STEPW = _T("1STEPW");

//const CString AecDbBaseStair::KEY_STEP2S = _T("STEP2S");
const CString AecDbBaseStair::KEY_2STEPW = _T("2STEPW");

const CString AecDbBaseStair::KEY_STEP3S = _T("STEP3S");
const CString AecDbBaseStair::KEY_STEP3W = _T("STEP3W");

const CString AecDbBaseStair::KEY_STEP4S = _T("STEP4S");
const CString AecDbBaseStair::KEY_STEP4W = _T("STEP4W");


ACRX_DXF_DEFINE_MEMBERS (AecDbBaseStair, AecDbEwPipeBase,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_BASESTAIR,
						 "AecDbBaseStair"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")

AecDbBaseStair::AecDbBaseStair(void)
{
	m_mapSpecXData.SetAt(KEY_NAME,_T("梯"));
}

AecDbBaseStair::~AecDbBaseStair(void)
{
	deleteContainerOfStd(m_pipes);
	deleteContainerOfStd(m_solids);
}

void AecDbBaseStair::SetLineStairData(const LineStair& data)
{
	AssertWriteEnabled();

	//set section; 底层设置section,用于绘制管子
	//路径单独设置
	//bar数据key方式保存
	SetSection(data.bar.dD,data.bar.dt);

	//bar
	m_mapSpecXData.SetAt(PIPE_D,data.bar.dD);
	m_mapSpecXData.SetAt(PIPE_THICK,data.bar.dt);
	m_mapSpecXData.SetAt(KEY_HEIGHT1,data.bar.dH1);
	m_mapSpecXData.SetAt(KEY_HEIGHT2,data.bar.dH);
	m_mapSpecXData.SetAt(KEY_SP,data.bar.dP);

	//底板
	m_mapSpecXData.SetAt(KEY_STEEPH,data.dSteepH);
	m_mapSpecXData.SetAt(KEY_STEEPT,data.dSteept);
	m_mapSpecXData.SetAt(KEY_STEEPW,data.dSteepW);
	m_mapSpecXData.SetAt(KEY_STEEPS1,data.nSteepS);

	m_mapSpecXData.SetAt(KEY_SIDET,data.dSidet);
	m_mapSpecXData.SetAt(KEY_SIDEW,data.dSideW);
	m_mapSpecXData.SetAt(KEY_Width,data.dW);
	m_mapSpecXData.SetAt(KEY_HEIGHT,data.dH);
	m_mapSpecXData.SetAt(KEY_SYMBOL,data.nSymbol);

	m_mapSpecXData.SetAt(KEY_LBEAM,data.bLBeam);
	m_mapSpecXData.SetAt(KEY_RBEAM,data.bRBeam);
	m_mapSpecXData.SetAt(KEY_SLOPE,data.bSlope);
	m_mapSpecXData.SetAt(KEY_NONSLIP,data.bNonslip);
	m_mapSpecXData.SetAt(KEY_SLOPEBASE,data.bSlopeBase);
	m_mapSpecXData.SetAt(KEY_SINSLAB,data.bShowInSlab3d);
	m_mapSpecXData.SetAt(KEY_GUARDBAR,data.bGuardBar);

	m_mapSpecXData.SetAt(KEY_BOMEL,data.dBomEl);
	m_mapSpecXData.SetAt(KEY_START,data.bBomSta);
	m_mapSpecXData.SetAt(KEY_TOPEL,data.dTopEl);

	m_mapSpecXData.SetAt(KEY_MATERIAL,data.m_sMaterial);
	m_mapSpecXData.SetAt(KEY_FACTORY,data.m_sFactory);
	m_mapSpecXData.SetAt(KEY_NO,data.m_sNo);
}

void AecDbBaseStair::GetLineStairData(LineStair& data) const
{
	assertReadEnabled();

	//bar
	m_mapSpecXData.GetAt(PIPE_D,data.bar.dD);
	m_mapSpecXData.GetAt(PIPE_THICK,data.bar.dt);
	m_mapSpecXData.GetAt(KEY_HEIGHT1,data.bar.dH1);
	data.bar.dH = 900;//补错
	m_mapSpecXData.GetAt(KEY_HEIGHT2,data.bar.dH);
	m_mapSpecXData.GetAt(KEY_SP,data.bar.dP);

	//底板
	m_mapSpecXData.GetAt(KEY_STEEPH,data.dSteepH);
	m_mapSpecXData.GetAt(KEY_STEEPT,data.dSteept);
	m_mapSpecXData.GetAt(KEY_STEEPW,data.dSteepW);
	m_mapSpecXData.GetAt(KEY_STEEPS1,data.nSteepS);

	m_mapSpecXData.GetAt(KEY_SIDET,data.dSidet);
	m_mapSpecXData.GetAt(KEY_SIDEW,data.dSideW);
	m_mapSpecXData.GetAt(KEY_Width,data.dW);
	m_mapSpecXData.GetAt(KEY_HEIGHT,data.dH);
	m_mapSpecXData.GetAt(KEY_SYMBOL,data.nSymbol);

	m_mapSpecXData.GetAt(KEY_LBEAM,data.bLBeam);
	m_mapSpecXData.GetAt(KEY_RBEAM,data.bRBeam);
	m_mapSpecXData.GetAt(KEY_SLOPE,data.bSlope);
	m_mapSpecXData.GetAt(KEY_NONSLIP,data.bNonslip);
	m_mapSpecXData.GetAt(KEY_SLOPEBASE,data.bSlopeBase);
	m_mapSpecXData.GetAt(KEY_SINSLAB,data.bShowInSlab3d);
	m_mapSpecXData.GetAt(KEY_GUARDBAR,data.bGuardBar);

	m_mapSpecXData.GetAt(KEY_BOMEL,data.dBomEl);
	m_mapSpecXData.GetAt(KEY_START,data.bBomSta);
	m_mapSpecXData.GetAt(KEY_TOPEL,data.dTopEl);

	CString sTemp;
	m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
	_tcscpy(data.m_sMaterial,sTemp);

	m_mapSpecXData.GetAt(KEY_FACTORY,sTemp);
	_tcscpy(data.m_sFactory,sTemp);

	m_mapSpecXData.GetAt(KEY_NO,sTemp);
	_tcscpy(data.m_sNo,sTemp);
}

void AecDbBaseStair::SetSFPXStair(const SFPXStair &data)
{
	AssertWriteEnabled();

	//路径单独设置
	//bar数据key方式保存
	SetSection(data.dGarSize[0], data.dGarSize[1], 0);

	m_mapSpecXData.SetAt(KEY_H, data.dH);
	m_mapSpecXData.SetAt(KEY_STEEPS1, data.nSteepS);
	m_mapSpecXData.SetAt(KEY_STEEPH, data.dSteepH);
	m_mapSpecXData.SetAt(KEY_STEEPW, data.dSteepW);
	m_mapSpecXData.SetAt(KEY_STEEPS2, data.nSteepsS);
	m_mapSpecXData.SetAt(AecDbBaseStair::KEY_STEEPMS, data.nSteepMs);
	m_mapSpecXData.SetAt(AecDbBaseStair::KEY_STEEP2S, data.nSteep2s);
	m_mapSpecXData.SetAt(KEY_SSTEEPS, data.nSSteeps);
	m_mapSpecXData.SetAt(KEY_STAIRTW, data.dStairTW);
	m_mapSpecXData.SetAt(KEY_STAIRSW, data.dStairSW);
	m_mapSpecXData.SetAt(KEY_STAIRMW, data.dStairMW);

	//矩形转角
	m_mapSpecXData.SetAt(KEY_SYMMETRY, data.bSymmetry);	//是否对称
	m_mapSpecXData.SetAt(KEY_1STEPS, data.n1SteepS);	//一跑步数
	m_mapSpecXData.SetAt(KEY_1STEPW, data.d1SteepW);		//一跑段宽

	//m_mapSpecXData.SetAt(KEY_STEP2S,data.nSteep2s);		//二跑步数
	m_mapSpecXData.SetAt(KEY_2STEPW,data.d2SteepW);		//二跑段宽

	m_mapSpecXData.SetAt(KEY_STEP3S,data.nSteep3s);		//三跑步数
	m_mapSpecXData.SetAt(KEY_STEP3W,data.d3SteepW);		//三跑段宽

	m_mapSpecXData.SetAt(KEY_STEP4S,data.nSteep4s);		//四跑步数
	m_mapSpecXData.SetAt(KEY_STEP4W,data.d4SteepW);		//四跑段宽

	m_mapSpecXData.SetAt(KEY_WELLW, data.dWell);
	m_mapSpecXData.SetAt(KEY_LBEAM, data.bLBeam);
	m_mapSpecXData.SetAt(KEY_RBEAM, data.bRBeam);
	m_mapSpecXData.SetAt(KEY_UPSIDE, data.nUpSide);
	m_mapSpecXData.SetAt(KEY_STEEPAGN, data.nSteepAlign);
	m_mapSpecXData.SetAt(KEY_FLOORSHOW, data.nFloorShow);
	m_mapSpecXData.SetAt(KEY_DimUpFlag, data.bDimUpstair);
	m_mapSpecXData.SetAt(KEY_RSTSHAPE, data.nRestShape);

	m_mapSpecXData.SetAt(KEY_RESTSHOW, data.bShowRestPtw);
	m_mapSpecXData.SetAt(KEY_RESTPTW, data.dRestPtW);
	m_mapSpecXData.SetAt(KEY_STIFFNW, data.dStiffnW);
	m_mapSpecXData.SetAt(KEY_STIFFNH, data.dStiffnH);
	m_mapSpecXData.SetAt(KEY_SLABT, data.dSbThick);

	m_mapSpecXData.SetAt(KEY_OUTSHR, data.bOutSideHRail);
	m_mapSpecXData.SetAt(KEY_OUTSRL, data.bOutSideRail);
	m_mapSpecXData.SetAt(KEY_INSRAIL, data.bInsideRail);
	m_mapSpecXData.SetAt(KEY_BOMEL, data.dBomEl);
	m_mapSpecXData.SetAt(KEY_BARH, data.dBarH);
	m_mapSpecXData.SetAt(KEY_GARSIZE0, data.dGarSize[0]);
	m_mapSpecXData.SetAt(KEY_GARSIZE1, data.dGarSize[1]);

	m_mapSpecXData.SetAt(KEY_GAREXT, data.dGarExt);
	m_mapSpecXData.SetAt(KEY_ZGAREXT, data.dZGarExt);

	m_mapSpecXData.SetAt(KEY_GSHAPE, data.nGShape);
	m_mapSpecXData.SetAt(KEY_GARMAT, data.szGarMat);

	m_mapSpecXData.SetAt(KEY_BARSP, data.dBarSp);
	m_mapSpecXData.SetAt(KEY_BARSIZE0, data.dBarSize[0]);
	m_mapSpecXData.SetAt(KEY_BARSIZE1, data.dBarSize[1]);
	m_mapSpecXData.SetAt(KEY_BARSIDE, data.dBarSide);

	m_mapSpecXData.SetAt(KEY_BSHAPE, data.nBShape);
	m_mapSpecXData.SetAt(KEY_BARMAT, data.szBarMat);

	m_mapSpecXData.SetAt(AecDbBaseStair::KEY_REST_PTL, data.dRestPtL);
	m_mapSpecXData.SetAt(AecDbBaseStair::KEY_REST_PTW, data.dRestPtW);

	m_mapSpecXData.SetAt(AecDbBaseStair::KEY_REST_PTML, data.dRestPtML);
	m_mapSpecXData.SetAt(AecDbBaseStair::KEY_REST_PTMW, data.dRestPtMW);
}

void AecDbBaseStair::GetSFPXStair(SFPXStair &data) const
{
	assertReadEnabled();

	m_mapSpecXData.GetAt(KEY_H, data.dH);
	m_mapSpecXData.GetAt(KEY_STEEPS1, data.nSteepS);
	m_mapSpecXData.GetAt(KEY_STEEPH, data.dSteepH);
	m_mapSpecXData.GetAt(KEY_STEEPW, data.dSteepW);
	m_mapSpecXData.GetAt(KEY_STEEPS2, data.nSteepsS);
	m_mapSpecXData.GetAt(KEY_SSTEEPS, data.nSSteeps);
	m_mapSpecXData.GetAt(AecDbBaseStair::KEY_STEEPMS, data.nSteepMs);
	m_mapSpecXData.GetAt(AecDbBaseStair::KEY_STEEP2S, data.nSteep2s);
	m_mapSpecXData.GetAt(KEY_STAIRTW, data.dStairTW);
	m_mapSpecXData.GetAt(KEY_STAIRSW, data.dStairSW);
	m_mapSpecXData.GetAt(KEY_STAIRMW, data.dStairMW);
	m_mapSpecXData.GetAt(KEY_WELLW, data.dWell);
	m_mapSpecXData.GetAt(KEY_LBEAM, data.bLBeam);
	m_mapSpecXData.GetAt(KEY_RBEAM, data.bRBeam);
	m_mapSpecXData.GetAt(KEY_UPSIDE, data.nUpSide);
	m_mapSpecXData.GetAt(KEY_STEEPAGN, data.nSteepAlign);
	m_mapSpecXData.GetAt(KEY_FLOORSHOW, data.nFloorShow);
	m_mapSpecXData.GetAt(KEY_DimUpFlag, data.bDimUpstair);
	m_mapSpecXData.GetAt(KEY_RSTSHAPE, data.nRestShape);

	//矩形转角
	m_mapSpecXData.GetAt(KEY_SYMMETRY, data.bSymmetry);		//是否对称
	m_mapSpecXData.GetAt(KEY_1STEPS, data.n1SteepS);		//一跑步数
	m_mapSpecXData.GetAt(KEY_1STEPW, data.d1SteepW);		//一跑段宽

	//m_mapSpecXData.GetAt(KEY_STEP2S, data.nSteep2s);		//二跑步数
	m_mapSpecXData.GetAt(KEY_2STEPW, data.d2SteepW);		//二跑段宽

	m_mapSpecXData.GetAt(KEY_STEP3S, data.nSteep3s);		//三跑步数
	m_mapSpecXData.GetAt(KEY_STEP3W, data.d3SteepW);		//三跑段宽

	m_mapSpecXData.GetAt(KEY_STEP4S, data.nSteep4s);		//四跑步数
	m_mapSpecXData.GetAt(KEY_STEP4W, data.d4SteepW);		//四跑段宽

	m_mapSpecXData.GetAt(KEY_STIFFNW, data.dStiffnW);
	m_mapSpecXData.GetAt(KEY_STIFFNH, data.dStiffnH);
	m_mapSpecXData.GetAt(KEY_SLABT, data.dSbThick);

	m_mapSpecXData.GetAt(KEY_OUTSHR, data.bOutSideHRail);
	m_mapSpecXData.GetAt(KEY_OUTSRL, data.bOutSideRail);
	m_mapSpecXData.GetAt(KEY_INSRAIL, data.bInsideRail);
	m_mapSpecXData.GetAt(KEY_BOMEL, data.dBomEl);
	m_mapSpecXData.GetAt(KEY_BARH, data.dBarH);
	m_mapSpecXData.GetAt(KEY_GARSIZE0, data.dGarSize[0]);
	m_mapSpecXData.GetAt(KEY_GARSIZE1, data.dGarSize[1]);

	m_mapSpecXData.GetAt(KEY_GAREXT, data.dGarExt);
	m_mapSpecXData.GetAt(KEY_ZGAREXT, data.dZGarExt);

	m_mapSpecXData.GetAt(KEY_GSHAPE, data.nGShape);
	m_mapSpecXData.GetAt(KEY_GARMAT, data.szGarMat);

	m_mapSpecXData.GetAt(KEY_BARSP, data.dBarSp);
	m_mapSpecXData.GetAt(KEY_BARSIZE0, data.dBarSize[0]);
	m_mapSpecXData.GetAt(KEY_BARSIZE1, data.dBarSize[1]);
	m_mapSpecXData.GetAt(KEY_BARSIDE, data.dBarSide);

	m_mapSpecXData.GetAt(KEY_BSHAPE, data.nBShape);
	m_mapSpecXData.GetAt(KEY_BARMAT, data.szBarMat);


	m_mapSpecXData.GetAt(AecDbBaseStair::KEY_REST_PTL, data.dRestPtL);
	m_mapSpecXData.GetAt(AecDbBaseStair::KEY_REST_PTW, data.dRestPtW);

	m_mapSpecXData.GetAt(AecDbBaseStair::KEY_REST_PTML, data.dRestPtML);
	m_mapSpecXData.GetAt(AecDbBaseStair::KEY_REST_PTMW, data.dRestPtMW);
}

Acad::ErrorStatus AecDbBaseStair::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = AecDbEwPipeBase::dwgInFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	return pFiler->filerStatus();
}

Acad::ErrorStatus AecDbBaseStair::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();

	//----- Save parent class information first.
	Acad::ErrorStatus es = AecDbEwPipeBase::dwgOutFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	return pFiler->filerStatus();
}

Acad::ErrorStatus AecDbBaseStair::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBaseStair::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOk;
}

void AecDbBaseStair::subList() const
{
	assertReadEnabled();
	acutPrintf(_T("\n直段楼梯"));
	AecDbEwPipeBase::subList();
}

Acad::ErrorStatus AecDbBaseStair::subTransformBy(const AcGeMatrix3d& xform)
{
	AecDbEwPipeBase::subTransformBy(xform);

	double dBomEl = 0;
	m_mapSpecXData.GetAt(KEY_BOMEL,dBomEl);

	AcGePoint3d pt(0,0,dBomEl);
	pt.transformBy(xform);

	m_mapSpecXData.SetAt(KEY_BOMEL,pt.z);

	dBomEl = 0;
	m_mapSpecXData.GetAt(KEY_TOPEL,dBomEl);

	pt.set(0,0,dBomEl);
	pt.transformBy(xform);

	m_mapSpecXData.SetAt(KEY_TOPEL,pt.z);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbBaseStair::subGetGripPoints(AcDbGripDataPtrArray &grips,
	const double curViewUnitSize,
	const int gripSize,
	const AcGeVector3d &curViewDir,
	const int bitflags) const
{
	Acad::ErrorStatus es = AecDbEwPipeBase::subGetGripPoints(grips, curViewUnitSize, gripSize, curViewDir, bitflags);

	//调用基类加入单击修改
	SubAddHitEditGrip(grips);

	return es;
}

Acad::ErrorStatus AecDbBaseStair::subMoveGripPointsAt(const AcDbVoidPtrArray &appData, const AcGeVector3d &offset, const int bitflags)
{
	Acad::ErrorStatus es = AecDbEwPipeBase::subMoveGripPointsAt(appData, offset, bitflags);
	
	if (HitOnGripEdit(appData))
	{
		return Acad::eOk;
	}

	return es;
}

Acad::ErrorStatus AecDbBaseStair::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBaseStair::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();
	return Acad::eOk;
}

int AecDbBaseStair::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray&  arRegPtrs) const
{
	AcGeVector3d vtLn = ptTo - ptFr;
	AcGeVector3d vtNorm = vtLn.crossProduct(vtViewDir);

	AcGePlane plan;
	plan.set(ptFr,vtNorm);

	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	if (Get3DBuffer().length() == 0)
	{
		AcGiViewDraw dc(NULL,NULL);
		Draw3d(dc);
	}

	AcDbEntity* pEnt = NULL;
	AcDb3dSolid* pSolid = NULL;

	AcDbVoidPtrArray arRegPtrsT;

	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);

		pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			//投影法
			OrthoProjected3DSolid(pSolid,plan,xform,arRegPtrsT);
		}
	}

	for (int i = 0;i < arRegPtrsT.length();i++)
	{
		pEnt = (AcDbEntity*)arRegPtrsT.at(i);
		pEnt->setLayer(layerId());
		pEnt->setColorIndex(kColorByLayer);
		arRegPtrs.append(pEnt);
	}

	return arRegPtrs.length();
}

SHJson::WValue& AecDbBaseStair::ToJson(bool bExprotGeo) const
{
	using namespace SHJson;
	assertReadEnabled();

	WValue &v = AecDbEwPipeBase::ToJson(bExprotGeo);

	if (bExprotGeo)
	{
		AecDbBaseStair *pNew = (AecDbBaseStair*)clone();
		AcDbCurve *pCurve = pNew->GetNativeCurve();
		if (pCurve)
		{
			AcGePoint3d ptS(AcGePoint3d::kOrigin);
			pCurve->getStartPoint(ptS);
			AcGeMatrix3d mat;
			mat.setToTranslation(-ptS.asVector());
			pCurve->transformBy(mat);
			pNew->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_MAJBR, AcGeVector3d::kXAxis);
		}

		pNew->Clean3DBuffer();
		AcGiViewDraw dc;
		pNew->Draw3d(dc);

		WValue ar;
		ar.SetArray();

		for (size_t i(0); i < pNew->m_solids.size(); ++i)
		{
			AcDbX3dSolid *pSolid(pNew->m_solids[i]);
			if (!pSolid) continue;
			WValue &x = pSolid->ToJson();
			pushBack(ar, x);
		}
		if (!pNew->m_solids.empty())
			addMember(v, _T("__solids__"), ar);

		ar.SetArray();
		for (size_t i(0); i < pNew->m_pipes.size(); ++i)
		{
			AecDbEwPipeBase *pPipe(pNew->m_pipes[i]);
			if (!pPipe) continue;
			WValue &x = pPipe->ToJson();
			pushBack(ar, x);
		}
		if (!pNew->m_pipes.empty())
			addMember(v, _T("__pipes__"), ar);
		DELETE_PTR(pNew);
	}

	return v;
}

bool AecDbBaseStair::ByJson(const SHJson::WValue &v)
{
	return false;
}

CString AecDbBaseStair::getUniqueNameBySFPXData() const
{
	SFPXStair data;
	::memset(&data, 0, sizeof(SFPXStair));
	GetSFPXStair(data);

	::memset(&data.nSSteeps, 0, sizeof(int));
	::memset(&data.nFloorShow, 0, sizeof(int));		//层显示类型
	::memset(&data.bDimUpstair, 0, sizeof(int));	//标注上楼方向
	::memset(&data.dBomEl, 0, sizeof(double));		//楼梯底部标高
	::memset(data.szGarMat, 0, sizeof(TCHAR) * 256);//材质
	::memset(data.szBarMat, 0, sizeof(TCHAR) * 256);//材质

	return ImpMD5(&data, sizeof(SFPXStair)).toString16W().c_str();
}

CString AecDbBaseStair::getUniqueNameByLineStairData() const
{
	LineStair data;
	::memset(&data, 0, sizeof(LineStair));
	GetLineStairData(data);

	::memset(data.bar.m_sFactory, 0, sizeof(TCHAR) * 256);
	::memset(data.bar.m_sMaterial, 0, sizeof(TCHAR) * 256);
	::memset(data.bar.m_sNo, 0, sizeof(TCHAR) * 256);
	::memset(&data.bar.dBomEl, 0, sizeof(double));
	::memset(&data.bar.bVerDraw, 0, sizeof(int));

	::memset(&data.dTopEl, 0, sizeof(double));
	::memset(&data.dBomEl, 0, sizeof(double));
	::memset(&data.nSymbol, 0, sizeof(int));
	::memset(data.m_sFactory, 0, sizeof(TCHAR) * 256);
	::memset(data.m_sMaterial, 0, sizeof(TCHAR) * 256);
	::memset(data.m_sNo, 0, sizeof(TCHAR) * 256);

	return ImpMD5(&data, sizeof(LineStair)).toString16W().c_str();
}

#include "HlrCutOption.h"
void AecDbBaseStair::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
	, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
	, AcArray<AcDbEntity *> &output) const
{
	HlrCutOption::ProcessHlrResult(this
		, FALSE
		, .0
		, HlrCutOption::getHlrBLK_STAIR()
		, ar
		, preAr
		, output);
}