#include "StdAfx.h"
#include "StdArx.h"
#include "CoreTools.h"
#include "KTCadUtility.h"
#include "KTCADUtilityEx.h"
#include "DXCHDlg.h"
#include "ZJCHDlg.h"
#include "ZXLTDlg.h"
#include "FZPDDlg.h"
#include "FZYTDlg.h"
#include "YHLTDlg.h"
#include "SFPXLTDlg.h"
#include "CSFZJLTDlg.h"
#include "CNewLineType.h"
#include "Base64.h"
#include "SFSPDlg.h"
#include "JCLTDlg.h"
#include "SJLTDlg.h"
#include "CJXZJDlg.h"
#include "JDLTDlg.h"
#include "FZTJDlg.h"
#include "FZSSDlg.h"
#include "AcPolylineJig.h"
#include "AecDb3dRoadAxisLine.h"
#include "FZSS2Dlg.h"
#include "HZMQDlg.h"
#include "CRJZDlg.h"
#include "AecDbEarthWorm.h"
#include "AecDbColumn.h"
#include "BZJJDlg.h"
#include "CGZZZDlg.h"

DLLIMPEXP bool GetDoubleClickEnt(LPCTSTR pszCmd, AcDbObjectId& id);
DLLIMPEXP AcDbArc* FormatArc(AcGePoint3d& ptGe1,AcGePoint3d& ptGe2,AcGePoint3d& ptGe3);
AcGePoint3d DLLIMPEXP MidPoint(AcGePoint3d& pt1,AcGePoint3d& pt2);
DLLIMPEXP AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts, int nCount);

namespace
{
	bool isLineWallCorner(const AcDbObjectIdArray& idS)
	{
		if (idS.length() < 1) return false;

		AcDbObjectId idA, idB;
		idA = idS.at(0);
		idB = idS.at(1);

		AcDbEntity* pEntA(NULL), * pEntB(NULL);
		if (Acad::eOk != acdbOpenAcDbEntity(pEntA, idA, AcDb::kForRead))
		{
			return false;
		}
		AecDbXWall* pWallA = AecDbXWall::cast(pEntA);
		if (!pWallA)
		{
			pEntA->close();
			return false;
		}
		AcDbCurve* pCurveA = pWallA->GetBaseCurve(true);
		pEntA->close();
		if (!pCurveA)
		{
			return false;
		}
		AcDbLine* pLine = AcDbLine::cast(pCurveA);
		if (!pLine)
		{
			DELETE_PTR(pCurveA);
			return false;
		}

		if (Acad::eOk != acdbOpenAcDbEntity(pEntB, idB, AcDb::kForRead))
		{
			DELETE_PTR(pCurveA);
			return false;
		}
		AecDbXWall* pWallB = AecDbXWall::cast(pEntB);
		if (!pWallB)
		{
			DELETE_PTR(pCurveA);
			pEntB->close();
			return false;
		}
		AcDbCurve* pCurveB = pWallB->GetBaseCurve(true);
		pEntB->close();
		if (!pCurveB)
		{
			DELETE_PTR(pCurveA);
			return false;
		}
		pLine = AcDbLine::cast(pCurveB);
		if (!pLine)
		{
			DELETE_PTR(pCurveA);
			DELETE_PTR(pCurveB);
			return false;
		}

		DELETE_PTR(pCurveA);
		DELETE_PTR(pCurveB);		

		return true;
	}

	AcDbObjectId GetWallAB(const AcDbObjectIdArray& idS
		, const AcGePoint3d& pt
		, const WallData& data)
	{
		AcDbObjectId bkID(AcDbObjectId::kNull);

		if (idS.length() < 1) return bkID;

		AcDbObjectId idA, idB, id;
		idA = idS.at(0);
		idB = idS.at(1);

		AcDbEntity* pEntA(NULL), * pEntB(NULL);
		if (Acad::eOk != acdbOpenAcDbEntity(pEntA, idA, AcDb::kForRead))
		{
			return bkID;
		}
		AecDbXWall* pWallA = AecDbXWall::cast(pEntA);
		if (!pWallA)
		{
			pEntA->close();
			return bkID;
		}
		AcDbCurve* pCurveA = pWallA->GetBaseCurve(true);
		pEntA->close();
		if (!pCurveA)
		{
			return bkID;
		}
		
		if (Acad::eOk != acdbOpenAcDbEntity(pEntB, idB, AcDb::kForRead))
		{
			DELETE_PTR(pCurveA);
			return bkID;
		}
		AecDbXWall* pWallB = AecDbXWall::cast(pEntB);
		if (!pWallB)
		{
			DELETE_PTR(pCurveA);
			pEntB->close();
			return bkID;
		}
		AcDbCurve* pCurveB = pWallB->GetBaseCurve(true);
		pEntB->close();
		if (!pCurveB)
		{
			DELETE_PTR(pCurveA);
			return bkID;
		}		

		AcGePoint3d ptA, ptB;
		pCurveA->getClosestPointTo(pt, ptA, true);
		double dDistA = pt.distanceTo(ptA);
		pCurveB->getClosestPointTo(pt, ptB, true);
		double dDistB = pt.distanceTo(ptB);
		
		if ((dDistA - data.dThick * .5) < 1e-6)
		{
			id = idA;
		}
		else
		{
			id = idB;
		}

		DELETE_PTR(pCurveA);
		DELETE_PTR(pCurveB);

		return id;
	}

	double GetWallThick(const AcDbObjectId& id)
	{
		AcDbEntity* pEnt(NULL);
		if (Acad::eOk != acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
		{
			return 0;
		}
		AecDbXWall* pWall = AecDbXWall::cast(pEnt);
		if (!pWall)
		{
			pEnt->close();
			return 0;
		}
		WallData data;
		::memset(&data, 0, sizeof(WallData));
		pWall->GetWallData(data);
		pEnt->close();
		return data.dThick;
	}

	void CutWall(AcDbObjectId& id, const AcGePoint3d& ptInt, const double dDist, const WallData& data)
	{
		AcDbEntity* pEnt(NULL);
		if (Acad::eOk != acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
		{
			return;
		}
		AecDbXWall* pWall = AecDbXWall::cast(pEnt);
		if (!pWall)
		{
			pEnt->close();
			return;
		}
		AcDbCurve* pCurve = pWall->GetBaseCurve(true);
		if (!pCurve)
		{
			pEnt->close();
			return;
		}

		AcGePoint3d ptS, ptE, pt, ptCut;
		pCurve->getClosestPointTo(ptInt, pt, true);
		double dDistCut(.0), dDistSE(.0);
		pCurve->getStartPoint(ptS);
		pCurve->getEndPoint(ptE);
		dDistSE = ptS.distanceTo(ptE);
		AcDbLine* pL(NULL);
		if (pt.distanceTo(ptS) < pt.distanceTo(ptE))
		{
			pL = AcDbLine::cast(pCurve);
			if (!pL)
			{
				pEnt->close();
				DELETE_PTR(pCurve);
				return;
			}

			dDistCut = ptS.distanceTo(pt);
			pL->getPointAtDist(dDist + dDistCut, ptCut);
			pL->setStartPoint(ptCut);
			pL->setEndPoint(ptE);

			Acad::ErrorStatus es = pWall->SetBaseCurve(pL);
			if (es != eOk)
			{
				pEnt->close();
				DELETE_PTR(pCurve);
				return;
			}
		}
		else
		{
			pL = AcDbLine::cast(pCurve);
			if (!pL)
			{
				pEnt->close();
				DELETE_PTR(pCurve);
				return;
			}

			pL->setStartPoint(ptS);
			dDistCut = ptE.distanceTo(pt);
			pL->getPointAtDist(dDistSE - dDist - dDistCut, ptCut);
			pL->setEndPoint(ptCut);

			Acad::ErrorStatus es = pWall->SetBaseCurve(pL);
			if (es != eOk)
			{
				pWall->close();
				pEnt->close();
				DELETE_PTR(pCurve);
				return;
			}
		}

		pEnt->close();
	}

	AcDbLine* IsPtOnLine(const AcDbVoidPtrArray& arReg, const AcGePoint3d& pt, const double& dLen)
	{
		if (arReg.length() < 1) return NULL;

		AcDbEntity* pSubEnt(NULL);
		AcDbLine* pLine(NULL);
		double dDist, dLenSE;
		AcGePoint3d ptOnLine, ptS, ptE;
		double dLenGe[6];
		for (int i(0); i < arReg.length(); i++)
		{
			pSubEnt = (AcDbEntity*)arReg.at(i);
			pLine = AcDbLine::cast(pSubEnt);
			pLine->getStartPoint(ptS);
			pLine->getEndPoint(ptE);
			dLenSE = ptS.distanceTo(ptE);
			dLenGe[i] = dLenSE;
			dDist = dLenSE - dLen;
			if (fabs(dLenSE - dLen) < 1e-6)
			{
				return pLine;
			}
		}

		return NULL;
	}

	AcDbLine* ModifyLineLen(AcDbLine* pLine, const AcGePoint3d& ptC, const double& dLen)
	{
		if (!pLine) return NULL;

		double dLenS, dLenE, dLen1, dLen2;
		AcGePoint3d ptS, ptE, pt;
		AcGeVector3d vecSE;
		
		AcDbLine* pNewLine = (AcDbLine*)pLine->clone();
		if (!pNewLine) return NULL;

		pNewLine->getStartPoint(ptS);
		pNewLine->getEndPoint(ptE);
		
		dLen1 = ptS.distanceTo(ptE);
		
		dLenS = ptC.distanceTo(ptS);
		dLenE = ptC.distanceTo(ptE);
		
		if (dLenS < dLenE)
		{			
			pNewLine->setStartPoint(ptC);
			
			vecSE = (pt - ptE).normalize();
			pt = ptC - vecSE * dLen;
			pNewLine->setEndPoint(pt);
		}
		else
		{
			pNewLine->setEndPoint(ptC);
			
			vecSE = (ptC - ptS).normalize();
			pt = ptC - vecSE * dLen;
			pNewLine->setStartPoint(pt);
		}
		
		dLen2 = ptS.distanceTo(ptE);

		return pNewLine;
	}

	bool IsLineStaByPt(AcDbLine* pLine, const AcGePoint3d& ptC)
	{
		if (!pLine) return false;
		
		AcGePoint3d ptS;
		AcDbLine* pNewLine = (AcDbLine*)pLine->clone();
		pNewLine->getStartPoint(ptS);
		double dDist = ptC.distanceTo(ptS);
		if (fabs(dDist) < 1e-6)
		{
			return true;
		}

		return false;
	}
}

static void FreeBuffer(int n, AcDbVoidPtrArray& arEntPtrs)
{
	AcDbEntity* pEnt = NULL;
	while (arEntPtrs.length() > n)
	{
		pEnt = (AcDbEntity*)arEntPtrs.last();
		pEnt->erase();
		pEnt->close();
		DELETE_PTR(pEnt);
		arEntPtrs.removeLast();
	}
}

void CR_SCGXCmdFnc()
{
}

AcGePoint3d GetArcMidPoint(AcDbArc* pArc)
{
	double dSta = 0.0,dEnd = 0.0;
	pArc->getStartParam(dSta);
	pArc->getEndParam(dEnd);

	AcGePoint3d ptMid;
	pArc->getPointAtParam((dSta + dEnd) / 2.0,ptMid);

	return ptMid;
}

AcDbCurve* GetHeadCurve(AcDbVoidPtrArray& arCurPtrs,AcGePoint3d& ptNear)
{
	AcGePoint3d ptOn;
	AcDbCurve* pCurve = NULL,*pNear = NULL;

	double dMax = 9999999.0,dLen = 0,dMin = 0;
	AcGeVector3d vt;
	for(int i = 0;i < arCurPtrs.length();i++)
	{
		pCurve = (AcDbCurve*)arCurPtrs.at(i);
		pCurve->getClosestPointTo(ptNear,ptOn);

		vt = ptOn - ptNear;
		vt.z = 0.0;

		dLen = vt.length();
		if (dLen < dMax)
		{
			dMin = dLen;
			pNear = pCurve;
		}
		else
		{
			if (dLen < dMin)
			{
				dMin = dLen;
				pNear = pCurve;
			}
		}
	}
	return pNear;
}

void Trim(AcDbCurve* pCurve1,const AcGePoint3d& ptOn)
{
	AcDbLine* pLn = AcDbLine::cast(pCurve1);
	if (pLn != NULL)
	{
		AcGePoint3d pt1 = pLn->startPoint();
		AcGePoint3d pt2 = pLn->endPoint();
		if (pt1.distanceTo(ptOn) < pt2.distanceTo(ptOn))
		{
			//剪去sta端
			pLn->setStartPoint(ptOn);
		}	
		else
		{
			//剪去end端
			pLn->setEndPoint(ptOn);
		}
	}

	AcDbArc* pArc = AcDbArc::cast(pCurve1);
	if (pArc != NULL)
	{
		AcGePoint3d pt1,pt2;
		pArc->getClosestPointTo(ptOn,pt1);

		AcGePoint3dArray arPts;
		arPts.append(pt1);

		AcDbVoidPtrArray arArc;
		pArc->getSplitCurves(arPts,arArc);

		if (arArc.length() == 2)
		{
			AcDbArc* pArc1 = AcDbArc::cast((AcDbEntity*)arArc.first());
			AcDbArc* pArc2 = AcDbArc::cast((AcDbEntity*)arArc.last());

			double dAng1 = fabs(pArc1->endAngle() - pArc1->startAngle());
			double dAng2 = fabs(pArc2->endAngle() - pArc2->startAngle());

			if (dAng1 > dAng2)
			{
				pArc->setStartAngle(pArc1->startAngle());
				pArc->setEndAngle(pArc1->endAngle());
			}
			else
			{
				pArc->setStartAngle(pArc2->startAngle());
				pArc->setEndAngle(pArc2->endAngle());
			}
			delete pArc1;
			delete pArc2;
		}
		else if(arArc.isEmpty())
		{
			AcGePoint3d pt1,pt2;
			pArc->getStartPoint(pt1);
			pArc->getEndPoint(pt2);

			double dDis1 = ptOn.distanceTo(pt1);
			double dDis2 = ptOn.distanceTo(pt2);

			pArc->extend( (dDis1 < dDis2 ) ? Adesk::kTrue : Adesk::kFalse,ptOn);
		}
	}
}

void Trim(AcDbCurve* pCurve1,AcGePoint3d ptE1,AcDbCurve* pCurve2,AcGePoint3d ptE2)
{
	AcGePoint3dArray arPts;
	pCurve1->intersectWith(pCurve2,AcDb::kExtendBoth,arPts);

	//距离Mid(ptE1,ptE2)最近
	AcGePoint3d ptGe;
	AcGePoint3d ptMid = MidPoint(ptE1,ptE2);

	int nIndex = -1;
	double dMin = 9999999.0,dDis = 0;
	for(int i = 0;i < arPts.length();i++)
	{
		ptGe = arPts.at(i);
		dDis = ptGe.distanceTo(ptMid);

		if (dDis < dMin)
		{
			dMin = dDis;
			nIndex = i;
		}
	}
	if (nIndex != -1)
	{
		ptGe = arPts.at(nIndex);
		Trim(pCurve1,ptGe);
		Trim(pCurve2,ptGe);
	}
}

bool MakeConnect(AcDbVoidPtrArray& arCurPtrs,AcDbCurve* pHead,double dMinDis)
{
	//只考虑直线和圆弧
	AcDbCurve* pCurve = NULL;
	AcGePoint3dArray arPts;
	AcGePoint3d ptInt,ptS1,ptE1,ptS2,ptE2;

	bool bContinue = false;
	for(int i = 0;i < arCurPtrs.length();i++)
	{
		pCurve = (AcDbCurve*)arCurPtrs.at(i);

		arPts.removeAll();
		pCurve->intersectWith(pHead,AcDb::kOnBothOperands,arPts);

		if (arPts.isEmpty())//不相交
		{
			//取两头端点最近距离
			pHead->getStartPoint(ptS1);
			pHead->getEndPoint(ptE1);

			pCurve->getStartPoint(ptS2);
			pCurve->getEndPoint(ptE2);

			//如果距离小于dMinDis
			double d1 = ptS1.distanceTo(ptS2);
			double d2 = ptS1.distanceTo(ptE2);
			double d3 = ptE1.distanceTo(ptS2);
			double d4 = ptE1.distanceTo(ptE2);

			//在最近端相互延长Trim
			if (d1 < dMinDis)
			{
				Trim(pHead,ptS1,pCurve,ptS2);
				bContinue = true;
			}

			if (d2 < dMinDis)
			{
				Trim(pHead,ptS1,pCurve,ptE2);
				bContinue = true;
			}

			if (d3 < dMinDis)
			{
				Trim(pHead,ptE1,pCurve,ptS2);
				bContinue = true;
			}

			if (d4 < dMinDis)
			{
				Trim(pHead,ptE1,pCurve,ptE2);
				bContinue = true;
			}

			if (bContinue)
			{
				pHead = pCurve;
				arCurPtrs.removeAt(i);
				break;
			}
		}
		else//相交,裁剪,只认一个交点
		{
			ptInt = arPts.first();
			Trim(pHead,ptInt);
			Trim(pCurve,ptInt);

			bContinue = true;
			pHead = pCurve;
			arCurPtrs.removeAt(i);
			break;
		}
	}

	if (bContinue && !arCurPtrs.isEmpty())
	{
		MakeConnect(arCurPtrs,pHead,dMinDis);
	}
	return true;
}

void TestPoint(AcGePoint3d& ptOn)
{
	AcDbCircle *pCir = new AcDbCircle;
	pCir->setCenter(ptOn);
	pCir->setRadius(10.0);
	pCir->setColorIndex(1);
	CoreTools::AddToModelSpace(pCir, true);
}

typedef struct PointParam
{
	AcGePoint3d ptOn;
	double dParam;
}POINTPARAM;


static bool ComparePtparam(PointParam ptParam1, PointParam ptParam2)
{
	if (ptParam1.dParam - ptParam2.dParam < 1.e-10)
	{
		return true;
	}
	return false;
}

void SortPoints(AcGePoint3dArray &points, AcDbCurve *pLine)
{
	PointParam ptParam;
	std::vector<PointParam> points2;

	for (int i = 0; i < points.length(); i++)
	{
		ptParam.ptOn = points.at(i);
		pLine->getParamAtPoint(points.at(i), ptParam.dParam);
		points2.push_back(ptParam);
	}
	std::sort(points2.begin(), points2.end(), ComparePtparam);

	points.setLogicalLength(0);
	std::vector<PointParam>::iterator it;
	for (it = points2.begin(); it < points2.end(); it++)
	{
		points.append((*it).ptOn);
	}
}


AcDbCurve* GetPathOnWall(AcDbObjectIdArray& arWallIds,WallData& wallData,AcGeVector3d& vtDir,BOOL bPickDir = FALSE)
{
	ads_point pt1,pt2;
	AcDbObjectId id;

	int nRes = acedGetPoint(NULL,_T("\n请在墙上选择起始点位置:"),pt1);
	if (nRes == RTNORM)
	{
		nRes = acedGetPoint(NULL,_T("\n请在墙上选择终点位置:"),pt2);
		if (nRes == RTNORM)
		{
			ads_name ent,ss;

			resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
			while(nRes == RTNORM)
			{
				nRes = CKTCadUtility::SelectEntities(_T("\n请顺序选择经过的墙<退出>:"), ss, pRb);
			}
			acutRelRb(pRb);

#if ARX <= 20
			long nLen = 0;
#else
			Adesk::Int32 nLen = 0;
#endif			
			acedSSLength(ss,&nLen);
			for(int n = 0;n < nLen;n++)
			{
				acedSSName(ss,n,ent);
				acdbGetObjectId(id,ent);
				arWallIds.append(id);
			}
			acedSSFree(ss);

			if (arWallIds.isEmpty())
				return NULL;
		}
	}

	ads_point pt11,pt22;
	acdbUcs2Wcs(pt1,pt11,false);
	acdbUcs2Wcs(pt2,pt22,false);

	if (bPickDir)
	{
		ads_point pt3,pt33;
		nRes = acedGetPoint(pt1,_T("\n请拾取点确认墙侧方向:"),pt3);
		if (nRes == RTNORM)
		{
			acdbUcs2Wcs(pt3,pt33,false);
			vtDir = asPnt3d(pt33) - asPnt3d(pt11);
			vtDir.normalize();
		}
		else
		{
			acutPrintf(_T("\n错误!没有指定墙侧方向!"));
			return NULL;
		}
	}

	double dWallThick = 9999;
	AcDbVoidPtrArray arCurPtrs,arReslt;
	AcDbEntity* pEnt = NULL;
	AcDbCurve* pCurve = NULL;
	for(int i = 0;i < arWallIds.length();i++)
	{
		id = arWallIds.at(i);
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
		{
			AecDbXWall* pWall = AecDbXWall::cast(pEnt);
			if (pWall != NULL)
			{
				pWall->GetWallData(wallData);
				dWallThick = __min(dWallThick,wallData.dThick);
				pCurve = pWall->GetBaseCurve(true);
				arCurPtrs.append(pCurve);
			}
			pEnt->close();
		}
	}

	//找 pt1 点最近的线
	AcDbVoidPtrArray arCurPtrsNew;
	AcDbCurve* pHead = GetHeadCurve(arCurPtrs,asPnt3d(pt11));
	if (pHead != NULL)
	{
		//首位连接
		arCurPtrsNew.append(arCurPtrs);

		arCurPtrs.remove(pHead);
		MakeConnect(arCurPtrs,pHead,wallData.dThick);
	}

	AcDbCurve* pPath = KTCADUtilityEx::ConvertBoundCurve(arCurPtrsNew,arReslt);
	if (pPath != NULL)
	{
		AcGePoint3d ptOn1,ptOn2;
		Acad::ErrorStatus es1,es2;

		es1 = pPath->getClosestPointTo(asPnt3d(pt11),ptOn1);
		es2 = pPath->getClosestPointTo(asPnt3d(pt22),ptOn2);

		//TestPoint(ptOn1);
		//TestPoint(ptOn2);

		if (es1 == Acad::eOk && es2 == Acad::eOk)
		{
			AcDbPolyline *pPl = AcDbPolyline::cast(pPath);
			if (pPl != NULL)
			{
				AcGePoint3dArray arPts;
				arPts.append(ptOn1);
				arPts.append(ptOn2);
				SortPoints(arPts, pPath);

				AcDbVoidPtrArray arSegPtrs;
				pPl->getSplitCurves(arPts, arSegPtrs);

				AcGePoint3d ptS, ptE;
				AcDbCurve *pCrvT = NULL;
				for (int n = 0;n < arSegPtrs.length();n++)
				{
					pCrvT = (AcDbCurve *)arSegPtrs.at(n);

					pCrvT->getStartPoint(ptS);
					pCrvT->getEndPoint(ptE);

					if (arPts.find(ptS) != -1 &&
						arPts.find(ptE) != -1)
					{
						delete pPath;
						pPath = pCrvT;

						arSegPtrs.removeAt(n);
						while (!arSegPtrs.isEmpty())
						{
							pCrvT = (AcDbCurve *)arSegPtrs.first();
							arSegPtrs.removeFirst();
							delete pCrvT;
						}
						return pPath;
					}
				}
			}
			else
			{
				Trim(pPath,ptOn1);
				Trim(pPath,ptOn2);
			}
			return pPath;
		}
		delete pPath;
		pPath = NULL;
	}
	return NULL;
}

AcDbCurve* GetPathOnWall(AcDbObjectIdArray& arWallIds,WallData& wallData,ads_point pt1,ads_point pt2)
{
	ads_point pt11,pt22;
	acdbUcs2Wcs(pt1,pt11,false);
	acdbUcs2Wcs(pt2,pt22,false);

	AcDbObjectId id;
	double dWallThick = 9999;
	AcDbVoidPtrArray arCurPtrs,arReslt;
	AcDbEntity* pEnt = NULL;
	AcDbCurve* pCurve = NULL;
	for(int i = 0;i < arWallIds.length();i++)
	{
		id = arWallIds.at(i);
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
		{
			AecDbXWall* pWall = AecDbXWall::cast(pEnt);
			if (pWall != NULL)
			{
				pWall->GetWallData(wallData);
				dWallThick = __min(dWallThick,wallData.dThick);
				pCurve = pWall->GetBaseCurve(true);
				arCurPtrs.append(pCurve);
			}
			pEnt->close();
		}
	}

	//找 pt1 点最近的线
	AcDbVoidPtrArray arCurPtrsNew;
	AcDbCurve* pHead = GetHeadCurve(arCurPtrs,asPnt3d(pt11));
	if (pHead != NULL)
	{
		//首位连接
		arCurPtrsNew.append(arCurPtrs);

		arCurPtrs.remove(pHead);
		MakeConnect(arCurPtrs,pHead,wallData.dThick);
	}

	AcDbCurve* pPath = KTCADUtilityEx::ConvertBoundCurve(arCurPtrsNew,arReslt);
	if (pPath != NULL)
	{
		AcGePoint3d ptOn1,ptOn2;
		Acad::ErrorStatus es1,es2;

		es1 = pPath->getClosestPointTo(asPnt3d(pt11),ptOn1);
		es2 = pPath->getClosestPointTo(asPnt3d(pt22),ptOn2);

		if (es1 == Acad::eOk && es2 == Acad::eOk)
		{
			AcDbPolyline *pPl = AcDbPolyline::cast(pPath);
			if (pPl != NULL)
			{
				AcGePoint3dArray arPts;
				arPts.append(ptOn1);
				arPts.append(ptOn2);

				AcDbVoidPtrArray arSegPtrs;
				pPl->getSplitCurves(arPts, arSegPtrs);

				AcGePoint3d ptS, ptE;
				AcDbCurve *pCrvT = NULL;
				for (int n = 0; n < arSegPtrs.length(); n++)
				{
					pCrvT = (AcDbCurve *)arSegPtrs.at(n);

					pCrvT->getStartPoint(ptS);
					pCrvT->getEndPoint(ptE);

					if (arPts.find(ptS) != -1 &&
						arPts.find(ptE) != -1)
					{
						delete pPath;
						pPath = pCrvT;

						arSegPtrs.removeAt(n);
						while (!arSegPtrs.isEmpty())
						{
							pCrvT = (AcDbCurve *)arSegPtrs.first();
							arSegPtrs.removeFirst();
							delete pCrvT;
						}
						return pPath;
					}
				}
			}
			else
			{
				Trim(pPath, ptOn1);
				Trim(pPath, ptOn2);
			}
			return pPath;
		}
		delete pPath;
		pPath = NULL;
	}
	return NULL;
}

extern void MakeConnect(AcDbCurve *pLast, AcDbCurve *pNext);
void AR_TESTCmdFnc()
{
	/*AcDbObjectIdArray arWallIds;
	WallData wallData;
	AcGeVector3d vtDir(0,0,0);

	AcDbCurve* pPl = GetPathOnWall(arWallIds,wallData,vtDir,0);
	if (pPl != NULL)
	{
		pPl->setColorIndex(4);
		CoreTools::AddToModelSpace(pPl);
	}*/

	ads_name ent1,ent2;
	ads_point pt;
	int nRes = acedEntSel(_T("\npick line or arc 1:"), ent1, pt);
	if (nRes == RTNORM)
	{
		nRes = acedEntSel(_T("\npick line or arc 2:"), ent2, pt);
		if (nRes == RTNORM)
		{
			AcDbObjectId id1, id2;
			acdbGetObjectId(id1, ent1);
			acdbGetObjectId(id2, ent2);

			AcDbEntity *pEnt1 = NULL, *pEnt2 = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, id1, AcDb::kForWrite))
			{
				if (Acad::eOk == acdbOpenAcDbEntity(pEnt2, id2, AcDb::kForWrite))
				{
					AcDbCurve *pCr1 = AcDbCurve::cast(pEnt1);
					AcDbCurve *pCr2 = AcDbCurve::cast(pEnt2);

					if (pCr1 != NULL && pCr2 != NULL)
					{
						MakeConnect(pCr1, pCr2);
					}

					pEnt2->close();
				}
				pEnt1->close();
			}
		}
	}
}

//带型窗户
void PL_DXCHCmdFnc()
{
	AcDbObjectIdArray arIds;
	WallData wallData;
	AcGeVector3d vtDir(0,0,0);

	AcDbCurve* pPath = GetPathOnWall(arIds,wallData,vtDir,TRUE);
	if (pPath == NULL)
		return;

	CAcModuleResourceOverride myResources;
	CDXCHDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		OpeningData data;
		memset(&data,0,sizeof(OpeningData));
		dlg.GetOpeningData(data);
		data.dThick = wallData.dThick;
		data.dBomEl += wallData.dBomEl;

		if (pPath != NULL)
		{
			AcDbPolyline* pPl = AcDbPolyline::cast(pPath);
			if (pPl != NULL)
			{
				AcDbObjectId idWall;
				AecDbZLineXOpening* pZXOpening = new AecDbZLineXOpening;
				pZXOpening->SetOpeningData(data,arIds);
				pZXOpening->GetSpecialtyData()->SetAt(KEY_StartDir,vtDir);

				AcGePoint3d ptV;
				AcGePoint3dArray arPts;
				for(int i = 0;i < pPl->numVerts();i++)
				{
					pPl->getPointAt(i,ptV);
					arPts.append(ptV);
				}

				pZXOpening->SetZLinePoints(arPts);

				AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_WIN"));
				pZXOpening->setLayer(idLayer);

				AecComplexCurve win2d;
				pZXOpening->GetStandardDraw2d(win2d,false);
				

				AcDbObjectId idOpen;
				idOpen = CoreTools::AddToModelSpace(pZXOpening,true);

				for(int i = 0;i < arIds.length();i++)
				{
					idWall = arIds.at(i);

					AcDbEntity* pEnt = NULL;
					if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idWall,AcDb::kForWrite))
					{ 
						AecDbXWall* pWall = AecDbXWall::cast(pEnt);
						if (pWall != NULL)
						{
							pWall->AppendAssocPart(idOpen);
							//去掉,影响墙体三维显示
							//pWall->SubtractDraw2d(win2d);
						}
						pEnt->close();
					}
				}
			}
		}
		else
		{
			//
			acutPrintf(_T("连接墙线有误!"));
		}
		delete pPath;
	}
}

//绘制幕墙
void PL_HZMQCmdFnc()
{
	CAcModuleResourceOverride myResources;
	CHZMQDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		OpeningData data;
		memset(&data, 0, sizeof(OpeningData));
		dlg.GetOpeningData(data);
		data.dBomEl += data.dXData[5];

		AcPolylineJig jig;
		jig.InitStatusRecsFor2DLineSegs();
		if (jig.DoIt())
		{
			AcDbObjectId id = jig.GetRoadAxisLineId();

			AcDbEntity *pEnt = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
			{
				AecDb3dRoadAxisLine *pRoadAxLn = AecDb3dRoadAxisLine::cast(pEnt);
				if (pRoadAxLn != NULL)
				{
					AcDbPolyline* pPl = pRoadAxLn->ConvertTo2dPline();
					if (pPl != NULL)
					{
						AcGeVector3d vtDir(0, 0, 0);
						AcDbObjectId idWall;
						AcDbObjectIdArray arIds;

						AecDbGlassCurtainWall *pZXOpening = new AecDbGlassCurtainWall;
						pZXOpening->SetOpeningData(data, arIds);
						pZXOpening->GetSpecialtyData()->SetAt(KEY_StartDir, vtDir);

						AcGePoint3d ptV;
						AcGePoint3dArray arPts;
						for (int i = 0; i < pPl->numVerts(); i++)
						{
							pPl->getPointAt(i, ptV);
							pPl->getBulgeAt(i, ptV.z);
							arPts.append(ptV);
						}

						pZXOpening->SetZLinePoints(arPts);

						AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_WIN"));
						pZXOpening->setLayer(idLayer);

						AecComplexCurve win2d;
						pZXOpening->GetStandardDraw2d(win2d, false);

						AcDbObjectId idOpen;
						idOpen = CoreTools::AddToModelSpace(pZXOpening, true);
					}
				}

				//TEST
				//pEnt->erase();
				pEnt->setColorIndex(1);
				pEnt->close();
			}
		}
	}
}

//直角窗户
void PL_ZJCHCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CZJCHDlg dlg;
	if (IDOK == dlg.DoModal() )
	{
		ads_point pt0,pt1,pt2;
		int nRes = acedGetPoint(NULL,_T("\n请选取两墙体的墙角<退出>"),pt1);
		if (nRes == RTNORM)
		{
			ads_point ptL,ptR;
			ads_point_set(pt1, ptL);
			ads_point_set(pt1, ptR);
			ptL[X] -= CoreTools::PixelToWcs(10);
			ptL[Y] -= CoreTools::PixelToWcs(10);
			ptR[X] += CoreTools::PixelToWcs(10);
			ptR[Y] += CoreTools::PixelToWcs(10);

			//AecDbXWall
			ads_name ss,ent;
			TCHAR szBuf[256];
			struct resbuf eb1;
			eb1.restype = 0;
			_tcscpy(szBuf, _T("AEC_DBWALL"));
			eb1.resval.rstring = szBuf;
			eb1.rbnext = NULL;

			acedSSGet(_T("C"), ptL, ptR, &eb1, ss);
			Adesk::Int32 lLen = 0;
			acedSSLength(ss, &lLen);

			AcDbObjectIdArray idWalls;
			if (lLen == 2)
			{
				AcDbObjectId id;
				acedSSName(ss,0,ent);
				acdbGetObjectId(id,ent);
				idWalls.append(id);

				acedSSName(ss,1,ent);
				acdbGetObjectId(id,ent);
				idWalls.append(id);
			}
			else
			{
				acutPrintf(_T("\n选择的位置没有选到墙角的两面墙体!"));
				return;
			}
			acedSSFree(ss);

			OpeningData data;
			memset(&data, 0, sizeof(OpeningData));
			dlg.GetOpeningData(data);
				
			//acedsse
			nRes = acedGetPoint(pt1,_T("\n请选择转角距离1<1000>"),pt0);
			if (nRes == RTNORM)
			{
				nRes = acedGetPoint(pt1,_T("\n请选择转角距离2<1000>"),pt2);
				if (nRes == RTNORM)
				{
					WallData wallData;
					double dWallThick = 0;
					AcDbEntity* pEnt = NULL;

					if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idWalls.first(),AcDb::kForRead))
					{
						AecDbXWall* pWall = AecDbXWall::cast(pEnt);
						if (pWall != NULL)
						{
							pWall->GetWallData(wallData);
						}
						pEnt->close();
					}

					AcDbCurve* pPath = GetPathOnWall(idWalls,wallData,pt0,pt2);
					if (pPath != NULL)
					{
						AcDbPolyline* pPl = AcDbPolyline::cast(pPath);
						if (pPl != NULL)
						{
							data.dThick = wallData.dThick;
							AcDbObjectId idWall;
							AecDbZLineXOpening* pZXOpening = new AecDbZLineXOpening;
							pZXOpening->SetOpeningData(data,idWalls);

							AcGeVector3d vtDir(0,0,0);
							pZXOpening->GetSpecialtyData()->SetAt(KEY_StartDir,vtDir);

							AcGePoint3d ptV;
							AcGePoint3dArray arPts;
							for(int i = 0;i < pPl->numVerts();i++)
							{
								pPl->getPointAt(i,ptV);
								arPts.append(ptV);
							}

							pZXOpening->SetZLinePoints(arPts);

							AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_WIN"));
							pZXOpening->setLayer(idLayer);

							AecComplexCurve win2d;
							pZXOpening->GetStandardDraw2d(win2d,false);

							AcDbObjectId idOpen;
							idOpen = CoreTools::AddToModelSpace(pZXOpening,true);

							for(int i = 0;i < idWalls.length();i++)
							{
								idWall = idWalls.at(i);

								AcDbEntity* pEnt = NULL;
								if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idWall,AcDb::kForWrite))
								{
									AecDbXWall* pWall = AecDbXWall::cast(pEnt);
									if (pWall != NULL)
									{
										pWall->AppendAssocPart(idOpen);
										pWall->SubtractDraw2d(win2d);
									}
									pEnt->close();
								}
							}
						}
						delete pPath;
					}
				}
			}
		}
	}
}

//直线楼梯
void PL_ZXLTCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CZXLTDlg dlg;
	if (IDOK == dlg.DoModal() )
	{
		LineStair data;
		memset(&data,0,sizeof(LineStair));
		
		ads_point pt1,pt2;
		int nRes = acedGetPoint(NULL,_T("\n选择楼梯起点位置:"),pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1,_T("\n选择楼梯放置方向:"),pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2,pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"),dDis);
					return;
				}

				AcGePoint3d ptGe1,ptGe2;

				ads_point pt11,pt22;
				acdbUcs2Wcs(pt1,pt11,false);
				acdbUcs2Wcs(pt2,pt22,false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				ptGe1.z = dlg.m_dBomEl;
				ptGe2.z = dlg.m_dBomEl + data.nSteepS * data.dSteepH;

				dlg.GetLineStairData(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"),true);

				AecDbLineSegStair* pLnStair = new AecDbLineSegStair;
				pLnStair->setLayer(idLayStair);

				pLnStair->SetLineStairData(data);
				pLnStair->SetSection(data.bar.dD,0.0);
				pLnStair->SetBaseCurve(&ln);

				pLnStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE,0);
				CKTCadUtility::AddToBlockTableRecord(pLnStair);
				pLnStair->close();
			}
		}
	}
}

void PL_FZPDCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CFZPDDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		AscentData data;
		memset(&data,0,sizeof(AscentData));

		dlg.GetAscentData(data);

		ads_point pt0,pt1;
		int nRes = acedGetPoint(NULL,_T("\n选择坡道放置起点:"),pt0);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt0,_T("\n选择坡道放置终点:"),pt1);
			if (nRes == RTNORM)
			{
				ads_point pt00,pt11;
				acdbUcs2Wcs(pt0,pt00,false);
				acdbUcs2Wcs(pt1,pt11,false);

				AecDbAscent* pAsent = new AecDbAscent;
				pAsent->SetAscentData(data);
				pAsent->SetBaseCurve(asPnt3d(pt00),asPnt3d(pt11));

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"),true);
				pAsent->setLayer(idLayStair);

				CKTCadUtility::AddToBlockTableRecord(pAsent);
				pAsent->close();
			}
		}
	}
}

void PL_FZYTCmdFnc()
{
	AcDbObjectIdArray arIds;
	WallData wallData;
	AcGeVector3d vtDir(0,0,0);

	AcDbCurve* pPath = GetPathOnWall(arIds,wallData,vtDir,TRUE);
	if (pPath == NULL)
		return;

	CAcModuleResourceOverride myResources;
	CFZYTDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		BalconyData data;
		memset(&data,0,sizeof(BalconyData));
		dlg.GetBalconyData(data);
		data.dBomEl += wallData.dBomEl;
		data.dRailWidth += wallData.dThick * .5;

		//LINE,POLYLINE
		if (pPath != NULL)
		{
			AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_BALCONY"),true);

			AecDbBalcony* pBalcony = new AecDbBalcony;

			if (idLayer.isValid())
				pBalcony->setLayer(idLayer);

			pBalcony->SetBalconyData(data);
			pBalcony->SetBaseCurve(pPath);

			pBalcony->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_StartDir,vtDir);
			pBalcony->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_2DSTYLE,0);

			AcDbObjectId idBny = CoreTools::AddToModelSpace(pBalcony);

			DELETE_PTR(pPath);
		}
	}
}

void DBL_AEC_DBASCENT()
{
	//阳台双击
}

//放置台阶
void PL_FZTJCmdFnc()
{
	//从墙上依次选择路径点,和带型窗户类似
	AcDbObjectIdArray arIds;
	WallData wallData;
	AcGeVector3d vtDir(0, 0, 0);

	AcDbCurve* pPath = GetPathOnWall(arIds, wallData, vtDir, TRUE);
	if (pPath == NULL)
		return;

	CAcModuleResourceOverride myResources;
	CFZTJDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		XStepData data;
		memset(&data, 0, sizeof(XStepData));
		dlg.GetXStepData(data);
		data.dBaseEl += wallData.dBomEl;

		//根据路径，和外方向创建台阶
		AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_BALCONY"), true);
		AecDbXStep* pXStep = new AecDbXStep;

		if (idLayer.isValid())
			pXStep->setLayer(idLayer);

		pXStep->SetXStepData(data);
		pXStep->SetBaseCurve(pPath);

		pXStep->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_StartDir, vtDir);
		pXStep->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_2DSTYLE, 0);

		AcDbObjectId idBny = CoreTools::AddToModelSpace(pXStep);

		DELETE_PTR(pPath);
	}
}

//双击台阶
void DBL_AEC_DBXSTEP()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBXSTEP"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbXStep, pXStep)
		if (pXStep)
		{
			XStepData data;
			::memset(&data, 0, sizeof(XStepData));
			pXStep->GetXStepData(data);
			CAcModuleResourceOverride myResources;
			CFZTJDlg dlg;
			dlg.SetXStepData(data);
			if (IDOK == dlg.DoModal())
			{
				::memset(&data, 0, sizeof(XStepData));
				dlg.GetXStepData(data);
				pXStep->SetXStepData(data);
			}
		}
		OPENOBJ_END()
	}
}

//放置散水
void PL_FZSSCmdFnc()
{
	CAcModuleResourceOverride myResources;
	CFZSSDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		AcGeVector3d vtDir(0, 0, 0);

		AcPolylineJig jig;
		jig.InitStatusRecsForPolyline();
		if (jig.DoIt())
		{
			AcDbObjectId id = jig.GetRoadAxisLineId();

			AcDbEntity *pEnt = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
			{
				AecDb3dRoadAxisLine *pRoadAxLn = AecDb3dRoadAxisLine::cast(pEnt);
				if (pRoadAxLn != NULL)
				{
					AcDbPolyline* pPl = pRoadAxLn->ConvertTo2dPline();
					if (pPl != NULL)
					{
						pPl->setClosed(Adesk::kTrue);
						AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_BALCONY"), true);

						AecDbXApron *pApron = new AecDbXApron;
						pApron->setLayer(idLayer);

						pApron->SetBaseCurve(pPl);
						pApron->SetSection(10, 10, 0);//占位
						pApron->SetConstantWidth(dlg.m_dW);
						pApron->SetInsideThick(dlg.m_dInThick);
						pApron->SetOutSideThick(dlg.m_dOutThick);
						pApron->SetOffsetFromWall(dlg.m_dOffFrWall);
						pApron->GetSpecialtyData()->SetAt(KEY_BOMEL, dlg.m_dEl);
						pApron->GetSpecialtyData()->SetAt(KEY_StartDir, vtDir);
						
						AcDbObjectId idBny = CoreTools::AddToModelSpace(pApron);
						delete pPl;
					}
				}
				pEnt->erase();
				pEnt->close();
			}
		}
	}
}

//双击散水
void DBL_AEC_DBXAPRON()
{
	//使用 CFZSS2Dlg 修改每段宽度
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBXAPRON"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbXApron, pApron)
		if (!pApron)
		{			
			return;
		}

		double dInThick = pApron->GetInsideThick();
		double dOutThick = pApron->GetOutSideThick();
		double dOffFrWall = pApron->GetOffsetFromWall();
		double dEl(.0);
		pApron->GetSpecialtyData()->GetAt(KEY_BOMEL, dEl);

		std::vector<double> arWidthd;
		arWidthd.clear();
		int nCount = pApron->GetWidthSegCount();
		double dW(.0);
		for (int i(0); i < nCount; ++i)
		{
			dW = pApron->GetWidth(i);
			arWidthd.push_back(dW);
		}

		CAcModuleResourceOverride myResources;
		CFZSS2Dlg dlg(arWidthd, dOffFrWall, dEl, dInThick, dOutThick);
		if (dlg.DoModal() != IDOK)
		{
			return;
		}
		std::vector<CString> arWidths;
		arWidths.clear();
		dlg.getUserInputData(arWidths);
		for (int i(0); i < arWidths.size(); ++i)
		{
			dW = _ttof(arWidths.at(i));
			pApron->SetWidth(i, dW);
		}

		OPENOBJ_END()
	}
}

void AR_YHLTCmdFnc()
{
	CAcModuleResourceOverride myResources;
	
	CYHLTDlg dlg;
	if (IDOK != dlg.DoModal()) return;

	SFPXStair data;
	memset(&data, 0, sizeof(SFPXStair));

	ads_point pt1, pt2;
	int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
	if (nRes != RTNORM) return;

	nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
	if (nRes != RTNORM) return;

	double dDis = acutDistance(pt2, pt1);
	if (dDis < 1.0)
	{
		acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
		return;
	}

	AcGePoint3d ptGe1, ptGe2;

	ads_point pt11, pt22;
	acdbUcs2Wcs(pt1, pt11, false);
	acdbUcs2Wcs(pt2, pt22, false);

	ptGe1 = asPnt3d(pt11);
	ptGe2 = asPnt3d(pt22);

	ptGe1.z = dlg.m_dBomEl;
	ptGe2.z = dlg.m_dBomEl + data.nSteepS * data.dSteepH;

	dlg.GetSFPXStair(data);

	AcDbLine ln;
	ln.setStartPoint(ptGe1);
	ln.setEndPoint(ptGe2);

	AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

	AecDbArcSegStair* pArcStair = new AecDbArcSegStair;
	pArcStair->setLayer(idLayStair);

	pArcStair->SetSFPXStair(data);
	pArcStair->SetSection(data.dGarSize[0], 0.0);
	pArcStair->SetBaseCurve(&ln);

	pArcStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
	CKTCadUtility::AddToBlockTableRecord(pArcStair);
	pArcStair->close();
}

void PL_SFPXCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CSFPXLTDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		SFPXStair data;
		memset(&data, 0, sizeof(SFPXStair));

		ads_point pt1, pt2;
		int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2, pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
					return;
				}

				AcGePoint3d ptGe1, ptGe2;

				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				dlg.GetSFPXStair(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

				AecDbParaLlelStair *pLnStair = new AecDbParaLlelStair;
				pLnStair->setLayer(idLayStair);

				pLnStair->SetSFPXStair(data);
				pLnStair->SetSection(data.dBarSize[0], 0.0);
				pLnStair->SetBaseCurve(&ln);

				pLnStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
				CKTCadUtility::AddToBlockTableRecord(pLnStair);
				pLnStair->close();
			}
		}
	}
}

void PL_SFZJCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CSFZJLTDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		SFPXStair data;
		memset(&data, 0, sizeof(SFPXStair));

		ads_point pt1, pt2;
		int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2, pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
					return;
				}

				AcGePoint3d ptGe1, ptGe2;

				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				dlg.GetSFPXStair(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

				AecDbCornerStair *pLnStair = new AecDbCornerStair;
				pLnStair->setLayer(idLayStair);

				pLnStair->SetSFPXStair(data);
				pLnStair->SetSection(data.dBarSize[0], 0.0);
				pLnStair->SetBaseCurve(&ln);

				pLnStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
				CKTCadUtility::AddToBlockTableRecord(pLnStair);
				pLnStair->close();
			}
		}
	}
}

void PL_SPSPCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CSFSPLTDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		SFSPStair data;
		memset(&data, 0, sizeof(SFSPStair));

		ads_point pt1, pt2;
		int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2, pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
					return;
				}

				AcGePoint3d ptGe1, ptGe2;

				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				dlg.GetSFSPStair(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

				AecDbDoubleMulStair *pStair = new AecDbDoubleMulStair;
				pStair->setLayer(idLayStair);

				pStair->SetSFPXStair(data);
				pStair->SetSection(data.dBarSize[0], 0.0);
				pStair->SetBaseCurve(&ln);

				pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
				CKTCadUtility::AddToBlockTableRecord(pStair);
				pStair->close();
			}
		}
	}
}

void PL_JCLTCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CJCLTDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		SFSPStair data;
		memset(&data, 0, sizeof(SFSPStair));

		ads_point pt1, pt2;
		int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2, pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
					return;
				}

				AcGePoint3d ptGe1, ptGe2;

				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				dlg.GetSFPXStair(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

				AecDbScissorsStair *pStair = new AecDbScissorsStair;
				pStair->setLayer(idLayStair);

				pStair->SetSFPXStair(data);
				pStair->SetSection(data.dBarSize[0], 0.0);
				pStair->SetBaseCurve(&ln);

				pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
				CKTCadUtility::AddToBlockTableRecord(pStair);
				pStair->close();
			}
		}
	}
}

void PL_shltCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CNewLineType dlg;
	if (dlg.DoModal() == IDOK)
	{
		CString ss;
		CString sLtName(dlg.m_sName), sLtDesc, sLtWord(dlg.m_sWord), sLtStyle(dlg.m_sTextStyle);
		double dLineSpace(dlg.m_dLineL), dSpace1(dlg.m_dSpace1), dSpace2(dlg.m_dSpace2)
			, dS(dlg.m_dS), dR(dlg.m_dR), dX(dlg.m_dX), dY(dlg.m_dY);

		sLtDesc.Format(_T("%s----%s----%s----%s----%s----%s----%s"), sLtName
			, sLtWord
			, sLtWord
			, sLtWord
			, sLtWord
			, sLtWord
			, sLtWord);

		ss.Format(_T("*%s,%s\nA,%.2f,%.2f,[\"%s\",%s,S=%.2f,R=%.2f,X=%.2f,Y=%.2f],%.2f"), sLtName
			, sLtDesc
			, dLineSpace
			, dSpace1
			, sLtWord
			, sLtStyle
			, dS
			, dR
			, dX
			, dY
			, dSpace2 );

		std::string str = Base64::unicode2Ansii(ss, CP_UTF8);

		CString path = CoreTools::getSystemTemporaryFolder() + _T("\\shlt.lin");
		CFile file;
		if (file.Open(path, CFile::modeReadWrite | CFile::modeCreate))
		{
			file.Write(str.c_str(), str.size() * sizeof(char));
			file.Close();
			CoreTools::loadLineType(CoreTools::getSystemTemporaryFolder(), sLtName);
		}
		return;
	}
}

//剪刀楼梯
void PL_JDLTCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CJDLTDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		SFSPStair data;
		memset(&data, 0, sizeof(SFSPStair));

		ads_point pt1, pt2;
		int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2, pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
					return;
				}

				AcGePoint3d ptGe1, ptGe2;

				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				dlg.GetSFPXStair(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

				AecDbCrossStair *pStair = new AecDbCrossStair;
				pStair->setLayer(idLayStair);

				pStair->SetSFPXStair(data);
				pStair->SetSection(data.dBarSize[0], 0.0);
				pStair->SetBaseCurve(&ln);

				pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
				CKTCadUtility::AddToBlockTableRecord(pStair);
				pStair->close();
			}
		}
	}
}

//三角楼梯
void PL_SJLTCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CSJLTDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		SFSPStair data;
		memset(&data, 0, sizeof(SFSPStair));

		ads_point pt1, pt2;
		int nRes = acedGetPoint(NULL, _T("\n选择三角楼梯一边起点位置:"), pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1,  _T("\n选择三角楼梯一边终点位置:"), pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2, pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
					return;
				}

				AcGePoint3d ptGe1, ptGe2;

				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				dlg.GetSFPXStair(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

				AecDbTriangleStair *pStair = new AecDbTriangleStair;
				pStair->setLayer(idLayStair);

				pStair->SetSFPXStair(data);
				pStair->SetSection(data.dBarSize[0], 0.0);
				pStair->SetBaseCurve(&ln);

				pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
				CKTCadUtility::AddToBlockTableRecord(pStair);
				pStair->close();
			}
		}
	}
}

//矩形转角
void PL_JXZJCmdFnc()
{
	CAcModuleResourceOverride myResources;

	CJXZJDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		SFSPStair data;
		memset(&data, 0, sizeof(SFSPStair));

		ads_point pt1, pt2;
		int nRes = acedGetPoint(NULL, _T("\n选择矩形转角楼梯一边起点位置:"), pt1);
		if (nRes == RTNORM)
		{
			nRes = acedGetPoint(pt1, _T("\n选择矩形转角楼梯一边终点位置:"), pt2);
			if (nRes == RTNORM)
			{
				double dDis = acutDistance(pt2, pt1);
				if (dDis < 1.0)
				{
					acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
					return;
				}

				AcGePoint3d ptGe1, ptGe2;

				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				ptGe1 = asPnt3d(pt11);
				ptGe2 = asPnt3d(pt22);

				dlg.GetSFPXStair(data);

				AcDbLine ln;
				ln.setStartPoint(ptGe1);
				ln.setEndPoint(ptGe2);

				AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);

				AecDbRectCornerStair *pStair = new AecDbRectCornerStair;
				pStair->setLayer(idLayStair);

				pStair->SetSFPXStair(data);
				pStair->SetSection(data.dBarSize[0], 0.0);
				pStair->SetBaseCurve(&ln);

				pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
				CKTCadUtility::AddToBlockTableRecord(pStair);
				pStair->close();
			}
		}
	}
}

void PL_DPLTCmdFnc()
{

}

//取中心位置为做块的插入位置
bool MakeBlockRecord(AcDbVoidPtrArray& arEntPtrs,AcDbObjectId& idRec,AcGePoint3d& ptIns,CString& sNameSet,AcDbDatabase* pDb = NULL)
{
	if (pDb == NULL)
		pDb = acdbCurDwg();

	AcGeVector3d vtMove = ptIns.asVector();
	vtMove.negate();

	AcGeMatrix3d xform;
	xform.setToTranslation(vtMove);

	//名称必须唯一,待定
	CString sName;

	AcDbBlockTableRecord *pRec = new AcDbBlockTableRecord;
	pRec->setName(_T("*U"));
	pRec->setOrigin(AcGePoint3d::kOrigin);

	AcDbEntity* pEnt(NULL);
	for (int i = 0; i < arEntPtrs.length(); i++)
	{
		pEnt = (AcDbEntity *)arEntPtrs.at(i);
		pEnt->transformBy(xform);
		pRec->appendAcDbEntity(pEnt);
		pEnt->close();
	}
	arEntPtrs.removeAll();

	AcDbBlockTable *pTbl = NULL;
	if (Acad::eOk == pDb->getBlockTable(pTbl, AcDb::kForWrite))
	{
		pTbl->add(idRec, pRec);
		pTbl->close();

		TCHAR szHd[17];
		idRec.handle().getIntoAsciiBuffer(szHd);

		if (sNameSet.CompareNoCase(_T("*U")) == 0 )
		{
			//内部分配的名称
			LPCTSTR pszName = NULL;
			pRec->getName(pszName);
			sNameSet = pszName;
		}
		else
		{
			sName.Format(_T("%s@%s"), sNameSet, szHd);
			Acad::ErrorStatus es = pRec->setName(sName);
		}
		pRec->close();
	}
	return idRec.isValid();
}

//插入角柱
void PL_CRJZCmdFnc()
{
	/*
	//  1.请选择墙体的内侧角点: ptInt
		// != 2 
		// ss --> ids

	//  1.1 验证选择是 2 直线墙
	    if ( !IsLineWallCorner(idS,ptInt))
		{
		//。。。
		}

	    //请选择墙体1上一点(长度A): ptA
		//请选择墙体2上一点(长度B): ptB

		2. 通过 ptA,ptB 分出 墙A id 墙B id
		   2.1 提取墙的属性后,立刻关闭
		   GetWallAB(idS,ptA,idA,idB);

		   s----a------ e b1
		             |
					 |
					 |b   b-b1 < wall.t.05
					 vt1 = a - s
					 vt2 = a - e
					 vt1.isparll(vt2 )  vt1.dotpr(vt2) < 1.e-10

 		   AcDbCurve* pBaseCrv = ;
		   ptBaseCrv->getcloseto(ptA,ptA1,true);


		   //提取idA,idB 的数据 和 ptInt,到 ptA,ptB的长度

		   dlg.Set...).
		3. 弹出对话框 ,填入从墙提取的需要的数据


		3.1 确定 创建柱子
		  3.2 根据ptA 裁剪 墙A ，根据 ptB裁剪墙B
		     此处重复，可以方法重调用
			 CutWall(idA,ptInt,dlg.m_dA);
			 CutWall(idB,ptInt,dlg.m_dB);

			 -------------------+
			 ptS,ptE;
			if ( ptS.distanceto(ptInt) < ptE.distanceto(ptE) )
			{

			}

	*/

	ads_point ptInt;
	int nRes = acedGetPoint(NULL, _T("\n请选择墙体的内侧角点:"), ptInt);
	if (nRes != RTNORM)
	{
		return;
	}
	
	double dSize = CoreTools::PixelToWcs(5);//5
	ads_point pt1, pt2;
	ads_point_set(ptInt, pt1);
	ads_point_set(ptInt, pt2);
	pt1[X] -= dSize;
	pt1[Y] -= dSize;
	pt2[X] += dSize;
	pt2[Y] += dSize;

	//得到墙体
	ads_name ss, ent;
	struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
	nRes = acedSSGet(_T("C"), pt1, pt2, pRb, ss);
	acutRelRb(pRb);
	if (nRes != RTNORM)
	{
		return;
	}

	Adesk::Int32 nLen = 0;
	acedSSLength(ss, &nLen);
	if (nLen != 2)
	{
		acedSSFree(ss);
		return;
	}
	
	AcDbObjectId id, idLay;
	AcDbObjectIdArray arWallIds;
	arWallIds.removeAll();
	acedSSLength(ss, &nLen);
	for (int n = 0; n < nLen; n++)
	{
		acedSSName(ss, n, ent);
		acdbGetObjectId(id, ent);

		arWallIds.append(id);
	}
	
	bool b = isLineWallCorner(arWallIds);
	if (!b)
	{
		acedSSFree(ss);
		return;
	}

	acedSSName(ss, 0, ent);
	acdbGetObjectId(id, ent);
	acedSSFree(ss);

	AcDbEntity* pEnt(NULL);
	if (Acad::eOk != acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
	{
		return;
	}

	idLay = pEnt->layerId();
	AecDbXWall* pWall = AecDbXWall::cast(pEnt);
	if (!pWall)
	{
		pEnt->close();//2023-8-1
		return;
	}
	
	WallData data;
	::memset(&data, 0, sizeof(WallData));
	pWall->GetWallData(data);
	pEnt->close();

	nRes = acedGetPoint(ptInt, _T("\n请选择墙体1上一点(长度A):"), pt1);
	if (nRes != RTNORM)
	{
		return;
	}
	nRes = acedGetPoint(ptInt, _T("\n请选择墙体2上一点(长度B):"), pt2);
	if (nRes != RTNORM)
	{
		return;
	}

	ads_point ptWInt, ptW1, ptW2;
	acdbUcs2Wcs(ptInt, ptWInt, false);
	acdbUcs2Wcs(pt1, ptW1, false);
	acdbUcs2Wcs(pt2, ptW2, false);

	AcGeVector3d vt, Z(AcGeVector3d::kZAxis);
	AcGePoint3d ptGe[3];
	ptGe[0] = asPnt3d(ptW1);
	ptGe[1] = asPnt3d(ptWInt);
	ptGe[2] = asPnt3d(ptW2);

	AcDbObjectId idA, idB;
	idA = GetWallAB(arWallIds, ptGe[0], data);
	idB = GetWallAB(arWallIds, ptGe[2], data);

	double dThickA = GetWallThick(idA);
	double dThickB = GetWallThick(idB);

	double dDistA = ptGe[1].distanceTo(ptGe[0]);
	double dDistB = ptGe[1].distanceTo(ptGe[2]);
	ColumnParam ColParam;
	memset(&ColParam, 0, sizeof(ColumnParam));
	ColParam.m_dBomEl = data.dBomEl;
	ColParam.m_dH = data.dH;
	ColParam.m_dSizes[0] = dDistA;
	ColParam.m_dSizes[1] = dDistB;
	ColParam.m_dSizes[2] = dThickA;//墙A 厚度 2023-8-1
	ColParam.m_dSizes[3] = dThickB;//墙B 厚度 2023-8-1
	
	AcDbRegion *pReg = CCRJZDlg::makeRegion(ptGe[1], ptGe[0], ptGe[2], dThickA, dThickB);
	if (!pReg)
	{
		return;
	}

	/*...  参考如下
	pRegAll 角点为0,0点造region, 并且做成块
	ptPos角点*/
	
	/*AcDbRegion* pRegClone = (AcDbRegion*)pReg->clone();
	if (!pRegClone)
	{
		DELETE_PTR(pReg);
		return;
	}*/

	//弹出对话框
	CAcModuleResourceOverride myResources;
	CCRJZDlg dlg;
	dlg.SetColumnParam(ColParam);
	dlg.setColumnReg(pReg);
	if (IDOK != dlg.DoModal())
	{
		DELETE_PTR(pReg);
		return;
	}

	CutWall(idA, ptGe[1], dDistA, data);
	CutWall(idB, ptGe[1], dDistB, data);

	AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_COLU"));

	AecDbColumn* pCol = new AecDbColumn;
	pCol->setLayer(idLayer);
	pCol->SetSection(pReg, AcGePoint3d::kOrigin);

	AcGePoint3d ptSta, ptEnd;
	ptSta = ptGe[1];
	ptSta.z = ColParam.m_dBomEl;
	ptEnd = ptGe[1];
	ptEnd.z = ColParam.m_dBomEl + ColParam.m_dH;
	AcDbLine ln;
	ln.setStartPoint(ptSta);
	ln.setEndPoint(ptEnd);
	pCol->SetBaseCurve(&ln);

	AcGeMatrix3d mat;
	mat.setToTranslation(-ptGe[1].asVector());
	ptGe[0].transformBy(mat);
	ptGe[1].transformBy(mat);
	ptGe[2].transformBy(mat);
	pCol->GetSpecialtyData()->SetAt(CCRJZDlg::_JZ_PT_A, ptGe[0]);
	pCol->GetSpecialtyData()->SetAt(CCRJZDlg::_JZ_PT_INNER, ptGe[1]);
	pCol->GetSpecialtyData()->SetAt(CCRJZDlg::_JZ_PT_B, ptGe[2]);

	//pCol->GetSpecialtyData()->SetAt(KEY_NO,pCol->m_sGUID);
	pCol->GetSpecialtyData()->SetAt(KEY_MATERIAL, ColParam.m_sMaterial);
	pCol->GetSpecialtyData()->SetAt(KEY_SHAPE, 6);//6 ColParam.m_nShape

	//Section 已经按照ref做了旋转
	pCol->GetSpecialtyData()->SetAt(KEY_ROTATION, 0.0);//ColParam.m_dRotAngle * PI / 180.0);
	pCol->GetSpecialtyData()->SetAt(KEY_ROTATIONBK, ColParam.m_dRotAngle);

	pCol->GetSpecialtyData()->SetAt(KEY_SIZE1, ColParam.m_dSizes[0]);
	pCol->GetSpecialtyData()->SetAt(KEY_SIZE2, ColParam.m_dSizes[1]);
	pCol->GetSpecialtyData()->SetAt(KEY_SIZE3, ColParam.m_dSizes[2]);
	pCol->GetSpecialtyData()->SetAt(KEY_SIZE4, ColParam.m_dSizes[3]);

	//pCol->GetSpecialtyData()->SetAt(AecDbColumn::KEY_COL_MODEL, ColParam.m_sModel);// 会出错

	//结构信息
	pCol->GetSpecialtyData()->SetAt(KEY_SECTION_HATCH, dlg.m_sHatch);

	// 匿名块
	AcDbEntity* pSubEnt(NULL);
	AcDbVoidPtrArray arEnt, arReg;
	arEnt.removeAll();
	arReg.removeAll();
	pReg->explode(arReg);
	DELETE_PTR(pReg);
	for (int i(0); i < arReg.length(); i++)
	{
		pSubEnt = (AcDbEntity*)arReg.at(i);
		arEnt.append(pSubEnt);
	}

	//2023-8-1
	CString sNameSet = _T("*U");
	MakeBlockRecord(arEnt, ColParam.m_idRec, ptGe[1], sNameSet);
	_tcscpy(ColParam.m_sBlockName, (LPCTSTR)sNameSet);

	pCol->GetSpecialtyData()->SetAt(KEY_BLOCKNAME, ColParam.m_sBlockName);

	CKTCadUtility::AddToBlockTableRecord(pCol);
	
	pCol->close();
}

//选择闭合pl线创建柱子
void PL_GZZZCmdFnc()
{
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE"), 0);

	ads_name ent;
	ads_point adsPt;
	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择柱子投影闭合Pl线:"), ent, pRb, adsPt);
	acutRelRb(pRb);
	if (nRes != RTNORM)
	{
		return;
	}

	ads_point ptCen;
	nRes = acedGetPoint(NULL, _T("\n请从投影闭合Pl线上选择柱子插入基点:"), ptCen);
	if (nRes != RTNORM)
	{
		return;
	}

	//弹出柱子界面
	CAcModuleResourceOverride myResources;
	CGZZZDlg dlg;
	if (IDOK == dlg.DoModal())
	{
		ColumnParam ColParam;
		memset(&ColParam, 0, sizeof(ColumnParam));
		ColParam.m_dBomEl = dlg.m_dBomEl;
		ColParam.m_dH = dlg.m_dH;
		_tcscpy(ColParam.m_sMaterial, dlg.m_sMaterial);
		_tcscpy(ColParam.m_sModel, dlg.m_sModel);

		AcDbObjectId id;
		acdbGetObjectId(id, ent);

		AcDbVoidPtrArray arCrv, arReg;

		AcDbEntity *pEnt = NULL;
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
		{
			AcDbPolyline *pPl = AcDbPolyline::cast(pEnt);
			if (pPl != NULL)
			{
				pPl->setElevation(0);
				arCrv.append(pPl->clone());
				AcDbRegion::createFromCurves(arCrv, arReg);
			}
			pEnt->close();
		}

		if (arReg.isEmpty())
		{
			acutPrintf(_T("\n创建柱子截面失败!请检查选择的曲线是否是闭合pl线!"));
			return;
		}


		ads_point pt2;
		acdbUcs2Wcs(ptCen, pt2, false);
		AcGeVector3d vt = asPnt3d(pt2).asVector();
		vt.z = 0.0;

		CString sNameSet = _T("*U");
		MakeBlockRecord(arCrv, ColParam.m_idRec, asPnt3d(pt2), sNameSet);
		_tcscpy(ColParam.m_sBlockName, (LPCTSTR)sNameSet);

		AcGeMatrix3d xM;
		xM.setToTranslation(vt);

		AcDbRegion *pReg = (AcDbRegion *)arReg.first();
		pReg->transformBy(xM);

		AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_COLU"));

		AecDbColumn *pCol = new AecDbColumn;
		pCol->setLayer(idLayer);
		pCol->SetSection(pReg, AcGePoint3d::kOrigin);

		AcGePoint3d ptSta, ptEnd;
		ptSta = asPnt3d(pt2);
		ptSta.z = ColParam.m_dBomEl;
		ptEnd = ptSta;
		ptEnd.z = ColParam.m_dBomEl + ColParam.m_dH;
		AcDbLine ln;
		ln.setStartPoint(ptSta);
		ln.setEndPoint(ptEnd);
		pCol->SetBaseCurve(&ln);
		pCol->SetSection(pReg, AcGePoint3d::kOrigin);

		//pCol->GetSpecialtyData()->SetAt(KEY_NO,pCol->m_sGUID);
		pCol->GetSpecialtyData()->SetAt(KEY_MATERIAL, ColParam.m_sMaterial);
		pCol->GetSpecialtyData()->SetAt(KEY_SHAPE, 7);//6 ColParam.m_nShape
		pCol->GetSpecialtyData()->SetAt(KEY_BLOCKNAME, ColParam.m_sBlockName);

		//Section 已经按照ref做了旋转
		pCol->GetSpecialtyData()->SetAt(KEY_ROTATION, 0.0);//ColParam.m_dRotAngle * PI / 180.0);
		pCol->GetSpecialtyData()->SetAt(KEY_ROTATIONBK, ColParam.m_dRotAngle);

		//pCol->GetSpecialtyData()->SetAt(AecDbColumn::KEY_COL_MODEL, ColParam.m_sModel);// 会出错

		//结构信息
		pCol->GetSpecialtyData()->SetAt(KEY_SECTION_HATCH, dlg.m_sHatch);

		CKTCadUtility::AddToBlockTableRecord(pCol);

		pCol->close();
	}
}

//柱子底座
void PL_ZZDZCmdFnc()
{
	void implement_ZZDZ();
	implement_ZZDZ();
}

//布置洁具
void PL_BZJJCmdFnc()
{
	void implement_BZJJ();
	implement_BZJJ();
}

//布置隔板
void PL_BZGBCmdFnc()
{
	void implement_BZGB();
	implement_BZGB();
}

//布置隔间
void PL_BZGJCmdFnc()
{
	void implement_BZGJ();
	implement_BZGJ();
}

// 基线对齐
void PL_JXDQCmdFnc()
{
	ads_name ent;
	ads_point adsPt, adsPtSelect;
	struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择墙体:"), ent, pRb, adsPt);
	acutRelRb(pRb);
	if (nRes != RTNORM)
	{
		return;
	}

	nRes = acedGetPoint(NULL, _T("\n请选择基线对齐点:"), adsPtSelect);
	if (nRes != RTNORM)
	{
		return;
	}

	AcDbObjectId idWall;
	Acad::ErrorStatus es = acdbGetObjectId(idWall, ent);
	if (es != Acad::eOk)
	{
		return;
	}

	AcGePoint3d pt(asPnt3d(adsPtSelect));
	CoreTools::UCS2WCS(pt, pt);

	AcDbEntity* pEnt(NULL);
	if (Acad::eOk != acdbOpenAcDbEntity(pEnt, idWall, AcDb::kForWrite))
	{
		return;
	}

	AecDbXWall* pWall = AecDbXWall::cast(pEnt);
	if (!pWall)
	{
		pEnt->close();
		return;
	}
	WallData data;
	pWall->GetWallData(data);

	AcDbCurve* pCurve = pWall->GetBaseCurve();
	if (!pCurve)
	{
		pWall->close();
		return;
	}

	AcDbLine* pL(NULL);
	AcDbArc* pArc(NULL);
	AcDbCircle* pCir(NULL);
	pL = AcDbLine::cast(pCurve);
	pArc = AcDbArc::cast(pCurve);
	pCir = AcDbCircle::cast(pCurve);
	if (!pL && !pArc && !pCir)
	{
		acutPrintf(_T("\n存在除直线、弧线、圆形之外的曲线类型！"));
		DELETE_PTR(pCurve);
		pWall->close();
		return;
	}

	AcGePoint3d ptCurve;
	es = pCurve->getClosestPointTo(pt, ptCurve);
	if (es != Acad::eOk)
	{
		DELETE_PTR(pCurve);
		pWall->close();
		return;
	}
	double dDist = ptCurve.distanceTo(pt);
	AcGeVector3d vt = (ptCurve - pt).normalize();

	if (pL)
	{
		AcGeMatrix3d mat;
		mat.setTranslation(-vt * dDist);
		pCurve->transformBy(mat);

		es = pWall->SetBaseCurve(pCurve);
		if (es != Acad::eOk)
		{
			DELETE_PTR(pCurve);
			pWall->close();
			return;
		}
		
		DELETE_PTR(pL);
		DELETE_PTR(pArc);
		DELETE_PTR(pCir);
	}
	else
	{
		if (pArc)
		{
			AcGePoint3d ptC = pArc->center();
			dDist = ptC.distanceTo(pt);
			if (dDist < data.dThick)
			{
				acutPrintf(_T("\n选取点不合适！"));
				DELETE_PTR(pCurve);
				pWall->close();
				return;
			}
			pArc->setRadius(dDist);

			es = pWall->SetBaseCurve(pArc);
			if (es != Acad::eOk)
			{
				DELETE_PTR(pCurve);
				pWall->close();
				return;
			}

			DELETE_PTR(pL);
			DELETE_PTR(pCir);
		}
		else if (pCir)
		{
			AcGePoint3d ptC = pCir->center();
			dDist = ptC.distanceTo(pt);
			if (dDist < data.dThick)
			{
				acutPrintf(_T("\n选取点不合适！"));
				DELETE_PTR(pCurve);
				pWall->close();
				return;
			}
			pCir->setRadius(dDist);

			es = pWall->SetBaseCurve(pCir);
			if (es != Acad::eOk)
			{
				DELETE_PTR(pCurve);
				pWall->close();
				return;
			}

			DELETE_PTR(pL);
			DELETE_PTR(pArc);
		}

		DELETE_PTR(pCurve);
	}	

	pWall->close();
}

// 边线对齐
void PL_BXDQCmdFnc()
{
	ads_name ent;
	ads_point adsPt, adsPtSelect;
	struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择墙体边线:"), ent, pRb, adsPt);
	acutRelRb(pRb);
	if (nRes != RTNORM)
	{
		return;
	}

	nRes = acedGetPoint(NULL, _T("\n请选择墙边边线应通过的点:"), adsPtSelect);
	if (nRes != RTNORM)
	{
		return;
	}

	AcDbObjectId idWall;
	acdbGetObjectId(idWall, ent);

	AcGePoint3d pt(asPnt3d(adsPtSelect));
	CoreTools::UCS2WCS(pt, pt);

	AcDbEntity* pEnt(NULL);
	if (Acad::eOk != acdbOpenAcDbEntity(pEnt, idWall, AcDb::kForWrite))
	{
		return;
	}

	AecDbXWall* pWall = AecDbXWall::cast(pEnt);
	if (!pWall)
	{
		pEnt->close();
		return;
	}
	WallData data;
	pWall->GetWallData(data);

	AcDbCurve* pCurve = pWall->GetBaseCurve();
	if (!pCurve)
	{
		pWall->close();
		return;
	}

	AcDbLine* pL(NULL);
	AcDbArc* pArc(NULL);
	AcDbCircle* pCir(NULL);
	pL = AcDbLine::cast(pCurve);
	pArc = AcDbArc::cast(pCurve);
	pCir = AcDbCircle::cast(pCurve);
	if (!pL && !pArc && !pCir)
	{
		acutPrintf(_T("\n存在除直线、弧线、圆形之外的曲线类型！"));
		DELETE_PTR(pCurve);
		pWall->close();
		return;
	}

	AcGePoint3d ptCurve;
	Acad::ErrorStatus es = pCurve->getClosestPointTo(pt, ptCurve);
	if (es != Acad::eOk)
	{
		DELETE_PTR(pCurve);
		pWall->close();
		return;
	}
	double dDist = ptCurve.distanceTo(pt);
	AcGeVector3d vt = (ptCurve - pt).normalize();

	// 判断点在左墙边线、右墙边线
	AcDbCurve* pCurveL = pWall->GetLeftCurve();
	if (!pCurveL)
	{
		DELETE_PTR(pCurve);
		pWall->close();
		return;
	}
	AcDbCurve* pCurveR = pWall->GetRightCurve();
	if (!pCurveR)
	{
		DELETE_PTR(pCurve);
		DELETE_PTR(pCurveL);
		pWall->close();
		return;
	}
	AcGePoint3d ptWall(asPnt3d(adsPt));
	CoreTools::UCS2WCS(ptWall, ptWall);
	double dDistWall = ptWall.distanceTo(pt);
	AcGePoint3d ptCurveL, ptCurveR;
	double dDistL(.0), dDistR(.0);
	es = pCurveL->getClosestPointTo(ptWall, ptCurveL);
	if (es != Acad::eOk)
	{
		DELETE_PTR(pCurve);
		DELETE_PTR(pCurveL);
		DELETE_PTR(pCurveR);
		pWall->close();
		return;
	}
	es = pCurveR->getClosestPointTo(ptWall, ptCurveR);
	if (es != Acad::eOk)
	{
		DELETE_PTR(pCurve);
		DELETE_PTR(pCurveL);
		DELETE_PTR(pCurveR);
		pWall->close();
		return;
	}
	dDistL = ptWall.distanceTo(ptCurveL);
	dDistR = ptWall.distanceTo(ptCurveR);

	if (pL)
	{
		// 判断点在基点上方、下方
		AcGePoint3d ptCurveLNew, ptCurveRNew;
		double dDistLNew(.0), dDistRNew(.0);
		es = pCurveL->getClosestPointTo(pt, ptCurveLNew);
		if (es != Acad::eOk)
		{
			DELETE_PTR(pCurve);
			DELETE_PTR(pCurveL);
			DELETE_PTR(pCurveR);
			pWall->close();
			return;
		}
		es = pCurveR->getClosestPointTo(pt, ptCurveRNew);
		if (es != Acad::eOk)
		{
			DELETE_PTR(pCurve);
			DELETE_PTR(pCurveL);
			DELETE_PTR(pCurveR);
			pWall->close();
			return;
		}
		dDistLNew = pt.distanceTo(ptCurveLNew);
		dDistRNew = pt.distanceTo(ptCurveRNew);

		double dDistNew(.0);
		if (dDistL < dDistR)
		{
			// 左墙边线
			if (dDistLNew < dDistRNew)
			{
				// 点在基点下方
				dDistNew = dDist + data.dThick * -.5;
			}
			else
			{
				// 点在基点上方
				dDistNew = dDist + data.dThick * .5;
			}
		}
		else
		{
			// 右墙边线
			if (dDistLNew < dDistRNew)
			{
				// 点在基点下方
				dDistNew = dDist + data.dThick * .5;
			}
			else
			{
				// 点在基点上方
				dDistNew = dDist + data.dThick * -.5;
			}
		}

		if (dDistNew < data.dThick)
		{
			acutPrintf(_T("\n选取点距离墙体太近！"));
			DELETE_PTR(pCurve);
			DELETE_PTR(pCurveL);
			DELETE_PTR(pCurveR);
			pWall->close();
			return;
		}
		AcGeMatrix3d mat;
		mat.setTranslation(dDistNew * -vt);
		pCurve->transformBy(mat);

		es = pWall->SetBaseCurve(pCurve);
		if (es != Acad::eOk)
		{
			DELETE_PTR(pCurve);
			DELETE_PTR(pCurveL);
			DELETE_PTR(pCurveR);
			pWall->close();
			return;
		}

		DELETE_PTR(pL);
		DELETE_PTR(pArc);
		DELETE_PTR(pCir);
	}
	else
	{
		if (pArc)
		{
			AcGePoint3d ptC = pArc->center();
			dDist = ptC.distanceTo(pt);

			double dRNew(.0);
			if (dDistL < dDistR)
			{
				// 内侧
				dRNew = dDist + data.dThick * .5;
			}
			else
			{
				// 外侧
				dRNew = dDist + data.dThick * -.5;
			}
			if (dRNew < data.dThick)
			{
				acutPrintf(_T("\n选取点距离圆弧曲线圆心太近！"));
				DELETE_PTR(pCurve);
				DELETE_PTR(pCurveL);
				DELETE_PTR(pCurveR);
				pWall->close();
				return;
			}
			pArc->setRadius(dRNew);

			es = pWall->SetBaseCurve(pArc);
			if (es != Acad::eOk)
			{
				DELETE_PTR(pCurve);
				DELETE_PTR(pCurveL);
				DELETE_PTR(pCurveR);
				pWall->close();
				return;
			}

			DELETE_PTR(pL);
			DELETE_PTR(pCir);
		}
		else if (pCir)
		{
			AcGePoint3d ptC = pCir->center();
			dDist = ptC.distanceTo(pt);

			double dRNew(.0);
			if (dDistL < dDistR)
			{
				// 内侧
				dRNew = dDist + data.dThick * .5;
			}
			else
			{
				// 外侧
				dRNew = dDist + data.dThick * -.5;
			}
			if (dRNew < data.dThick)
			{
				acutPrintf(_T("\n选取点距离圆弧曲线圆心太近！"));
				DELETE_PTR(pCurve);
				DELETE_PTR(pCurveL);
				DELETE_PTR(pCurveR);
				pWall->close();
				return;
			}
			pCir->setRadius(dRNew);

			es = pWall->SetBaseCurve(pCir);
			if (es != Acad::eOk)
			{
				DELETE_PTR(pCurve);
				DELETE_PTR(pCurveL);
				DELETE_PTR(pCurveR);
				pWall->close();
				return;
			}

			DELETE_PTR(pL);
			DELETE_PTR(pArc);
		}

		DELETE_PTR(pCurve);
	}

	DELETE_PTR(pCurveL);
	DELETE_PTR(pCurveR);

	pWall->close();
}

void DBL_AEC_DBLNSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBLNSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbLineSegStair, pStair)
		if (pStair)
		{
			LineStair data;
			::memset(&data, 0, sizeof(LineStair));
			pStair->GetLineStairData(data);
			CAcModuleResourceOverride myResources;
			CZXLTDlg dlg;
			dlg.SetLineStairData(data);
			if (IDOK == dlg.DoModal())
			{
				::memset(&data, 0, sizeof(LineStair));
				dlg.GetLineStairData(data);
				pStair->SetLineStairData(data);
			}
		}
		OPENOBJ_END()
	}
}

void DBL_AEC_SCISSORSSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_SCISSORSSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbScissorsStair, pStair)
		if (pStair)
		{
			SFSPStair data;
			::memset(&data, 0, sizeof(SFSPStair));
			pStair->GetSFPXStair(data);
			CAcModuleResourceOverride myResources;
			CJCLTDlg dlg;
			dlg.SetSFPXStair(data);
			if (IDOK == dlg.DoModal())
			{
				::memset(&data, 0, sizeof(SFSPStair));
				dlg.GetSFPXStair(data);
				pStair->SetSFPXStair(data);
			}
		}
		OPENOBJ_END()
	}
}

void DBL_AEC_DOUBLEMULSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DOUBLEMULSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbDoubleMulStair, pStair)
		if (pStair)
		{
			SFSPStair data;
			::memset(&data, 0, sizeof(SFSPStair));
			pStair->GetSFPXStair(data);
			CAcModuleResourceOverride myResources;
			CSFSPLTDlg dlg;
			dlg.SetSFSPStair(data);
			if (IDOK == dlg.DoModal())
			{
				::memset(&data, 0, sizeof(SFSPStair));
				dlg.GetSFSPStair(data);
				pStair->SetSFPXStair(data);
			}
		}
		OPENOBJ_END()
	}
}

void DBL_AEC_RECTCORNERSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_RECTCORNERSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbRectCornerStair, pStair)
		if (pStair)
		{
			SFPXStair data;
			::memset(&data, 0, sizeof(SFPXStair));
			pStair->GetSFPXStair(data);
			CAcModuleResourceOverride myResources;
			CJXZJDlg dlg;
			dlg.SetSFPXStair(data);
			if (IDOK == dlg.DoModal())
			{
				::memset(&data, 0, sizeof(SFPXStair));
				dlg.GetSFPXStair(data);
				pStair->SetSFPXStair(data);
			}
		}
		OPENOBJ_END()
	}
}

void DBL_AEC_DBASSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBASSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbArcSegStair, pStair)
		if (pStair)
		{
			SFPXStair data;
			::memset(&data, 0, sizeof(SFPXStair));
			pStair->GetSFPXStair(data);
			CAcModuleResourceOverride myResources;
			CYHLTDlg dlg;
			dlg.SetSFPXStair(data);
			if (IDOK == dlg.DoModal())
			{
				::memset(&data, 0, sizeof(SFPXStair));
				dlg.GetSFPXStair(data);
				pStair->SetSFPXStair(data);
			}
		}
		OPENOBJ_END()
	}
}

void DBL_AEC_PARALLELSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_PARALLELSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbParaLlelStair, pStair)
			if (pStair)
			{
				SFPXStair data;
				::memset(&data, 0, sizeof(SFPXStair));
				pStair->GetSFPXStair(data);
			
				CAcModuleResourceOverride myResources;
				CSFPXLTDlg dlg;
				dlg.SetSFPXStair(data);
				if (IDOK == dlg.DoModal())
				{
					::memset(&data, 0, sizeof(SFPXStair));
					dlg.GetSFPXStair(data);
					pStair->SetSFPXStair(data);
				}
			}
		OPENOBJ_END()
	}

}

void DBL_AEC_DBCNRSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBCNRSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbCornerStair, pStair)
			if (pStair)
			{
				SFPXStair data;
				::memset(&data, 0, sizeof(SFPXStair));
				pStair->GetSFPXStair(data);

				CAcModuleResourceOverride myResources;
				CSFZJLTDlg dlg;
				dlg.SetSFPXStair(data);
				if (IDOK == dlg.DoModal())
				{
					::memset(&data, 0, sizeof(SFPXStair));
					dlg.GetSFPXStair(data);
					pStair->SetSFPXStair(data);
				}
			}
		OPENOBJ_END()
	}
}

void DBL_AEC_CROSSSTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_CROSSSTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbCrossStair, pStair)
			if (pStair)
			{
				SFPXStair data;
				::memset(&data, 0, sizeof(SFPXStair));
				pStair->GetSFPXStair(data);

				CAcModuleResourceOverride myResources;
				CJDLTDlg dlg;
				dlg.SetSFPXStair(data);
				if (IDOK == dlg.DoModal())
				{
					::memset(&data, 0, sizeof(SFPXStair));
					dlg.GetSFPXStair(data);
					pStair->SetSFPXStair(data);
				}
			}
		OPENOBJ_END()
	}

}

void DBL_AEC_TRIANGLESTAIR()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_TRIANGLESTAIR"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbTriangleStair, pStair)
			if (pStair)
			{
				SFPXStair data;
				::memset(&data, 0, sizeof(SFPXStair));
				pStair->GetSFPXStair(data);

				CAcModuleResourceOverride myResources;
				CSJLTDlg dlg;
				dlg.SetSFPXStair(data);
				if (IDOK == dlg.DoModal())
				{
					::memset(&data, 0, sizeof(SFPXStair));
					dlg.GetSFPXStair(data);
					pStair->SetSFPXStair(data);
				}
			}
		OPENOBJ_END()
	}
}

void DBL_AEC_DBBALCONY()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBBALCONY"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbBalcony, pBalcony)
			if (pBalcony)
			{
				BalconyData data;
				::memset(&data, 0, sizeof(BalconyData));
				pBalcony->GetBalconyData(data);

				CAcModuleResourceOverride myResources;
				CFZYTDlg dlg;
				dlg.SetBalconyData(data);
				if (IDOK == dlg.DoModal())
				{
					::memset(&data, 0, sizeof(BalconyData));
					dlg.GetBalconyData(data);
					pBalcony->SetBalconyData(data);
				}
			}
		OPENOBJ_END()
	}
}

void DBL_AEC_DBZXOPENING()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBZXOPENING"), id);
	if (bIsOk && id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbZLineXOpening, pZXOpening)
		if (pZXOpening)
		{
			OpeningData data;
			::memset(&data, 0, sizeof(OpeningData));
			AcDbObjectIdArray arIds;
			pZXOpening->GetOpeningData(data);
			CAcModuleResourceOverride myResources;
			CDXCHDlg dlg;
			dlg.SetOpeningData(data);
			if (IDOK == dlg.DoModal())
			{
				::memset(&data, 0, sizeof(OpeningData));
				dlg.GetOpeningData(data);
				pZXOpening->SetOpeningData(data, arIds);
			}
		}
		OPENOBJ_END()
	}
}

void DBL_AEC_DBCOLMN_CRJZ()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBCOLMN"), id);
	if (!bIsOk || !id.isValid()) return;

	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbColumn, pCol)
	if (pCol)
	{
		AcDbRegion* pReg = pCol->GetSection();
		if (!pReg) return;

		ColumnParam data;
		memset(&data, 0, sizeof(ColumnParam));
		pCol->GetColumnData(data);

		CAcModuleResourceOverride myResources;
		CCRJZDlg dlg;
		dlg.SetColumnParam(data);
		dlg.setColumnReg(pReg);
		
		if (dlg.DoModal() != IDOK) return;

		pCol->GetSpecialtyData()->SetAt(KEY_MATERIAL, dlg.m_sMaterial);
		//pCol->GetSpecialtyData()->SetAt(KEY_BLOCKNAME, ColParam.m_sBlockName);
		pCol->GetSpecialtyData()->SetAt(KEY_SIZE1, dlg.m_dA);
		pCol->GetSpecialtyData()->SetAt(KEY_SIZE2, dlg.m_dB);
		pCol->GetSpecialtyData()->SetAt(KEY_SIZE3, dlg.m_dAW);
		pCol->GetSpecialtyData()->SetAt(KEY_SIZE4, dlg.m_dBW);
		pCol->GetSpecialtyData()->SetAt(KEY_SECTION_HATCH, dlg.m_sHatch);

		AcDbCurve* pCur = pCol->GetBaseCurve();
		if (!pCur) return;
		AcDbLine* pLn = AcDbLine::cast(pCur);
		if (!pLn)
		{
			DELETE_PTR(pCur);
			return;
		}

		AcGePoint3d ptSta = pLn->startPoint();
		AcGePoint3d ptEnd = pLn->endPoint();
		ptSta.z = dlg.m_dBomEl;
		ptEnd.z = ptSta.z + dlg.m_dH;
		pLn->setStartPoint(ptSta);
		pLn->setEndPoint(ptEnd);
		pCol->SetBaseCurve(ptSta, ptEnd);
		DELETE_PTR(pCur);

		AcGePoint3d ptGe[3];
		AcGePoint3d ptA, ptB, ptInner;
		pCol->GetSpecialtyData(AcDb::kForWrite)->GetAt(CCRJZDlg::_JZ_PT_INNER, ptInner);
		pCol->GetSpecialtyData(AcDb::kForWrite)->GetAt(CCRJZDlg::_JZ_PT_A, ptA);
		pCol->GetSpecialtyData(AcDb::kForWrite)->GetAt(CCRJZDlg::_JZ_PT_B, ptB);

		AcGeVector3d vt(ptA - ptInner);
		vt.normalize();
		vt *= dlg.m_dA;
		ptA = ptInner + vt;

		vt = ptB - ptInner;
		vt.normalize();
		vt *= dlg.m_dB;
		ptB = ptInner + vt;

		AcDbRegion *pRegNew = CCRJZDlg::makeRegion(ptInner, ptA, ptB, dlg.m_dAW, dlg.m_dBW);
		if (!pRegNew) return;

		pCol->GetSpecialtyData(AcDb::kForWrite)->SetAt(CCRJZDlg::_JZ_PT_INNER, ptInner);
		pCol->GetSpecialtyData(AcDb::kForWrite)->SetAt(CCRJZDlg::_JZ_PT_A, ptA);
		pCol->GetSpecialtyData(AcDb::kForWrite)->SetAt(CCRJZDlg::_JZ_PT_B, ptB);

		pCol->SetSection(pRegNew, AcGePoint3d::kOrigin);
	}
	OPENOBJ_END()
}