#include "stdafx.h"
#include "KTCADUtilityEx.h"
#include "KTCadUtility.h"
#include "EquipmentMakeDlg.h"
#include "AecDbEwEquipment.h"
#include "KTSetting.h"
#include "PipelineTools.h"
#include "BoxDlg.h"
#include "CylinderDlg.h"
#include "ConeDLg.h"
#include "PyrmDlg.h"
#include "SpereDlg.h"
#include "DishDlg.h"
#include "CirtorDlg.h"
#include "RecttorDlg.h"
#include "TydfDlg.h"
#include "NozzDlg.h"
#include "coretools.h"
#include "UserDataDlg.h"
#include "EquipSelDlg.h"
#include "EquToDbDlg.h"
#include "EquBand2D.h"
#include "parseFamilyForRevit.h"
#include "equipmentlibrarydlg.h"
#include "BrepOper.h"
#include "EQU_MODIFY.h"

#pragma region define

#define IMPEQUP_TYPE 1000

#define SUB_BTN_BOX 0
#define SUB_BTN_CLN 1
#define SUB_BTN_CON 2
#define SUB_BTN_PRM 3
#define SUB_BTN_SPE 4
#define SUB_BTN_DIS 5
#define SUB_BTN_LOFT	6
#define SUB_BTN_SWEEP 7
#define SUB_BTN_EXTRU 8
#define SUB_BTN_REVOL 9
#define SUB_BTN_CIT 10
#define SUB_BTN_RCT 11
#define SUB_BTN_TYDF 12
#define SUB_BTN_RVT 13
#define SUB_BTN_EQU 14


#define SUB_TREE_BOX 0
#define SUB_TREE_CLN 1
#define SUB_TREE_CON 2
#define SUB_TREE_PRM 3
#define SUB_TREE_CIT 4
#define SUB_TREE_RCT 5
#define SUB_TREE_DIS 6
#define SUB_TREE_SPE 7
#define SUB_TREE_EXTRU 8
#define SUB_TREE_REVOL 9
#define SUB_TREE_TYDF 10
#define SUB_TREE_NOZZ 11
#define SUB_TREE_LOFT 12
#define SUB_TREE_SWEEP 13
#define SUB_TREE_RVT_COMBIN 14
#define SUB_TREE_EQU_COMBIN 15

#define EQP_TREE_ROOT 16
#define SUB_TREE_X 17
#define SUB_TREE_Y 18
#define SUB_TREE_Z 19


#define SUB_SUBDMESH 0

#define SUB_NAMEBOX			CString(_T("长方体"))
#define SUB_NAMECLN			CString(_T("圆柱"))
#define SUB_NAMECON			CString(_T("圆台"))
#define SUB_NAMEPRM			CString(_T("四方台"))
#define SUB_NAMECIT			CString(_T("圆截面环"))
#define SUB_NAMERCT			CString(_T("矩形截面环"))
#define SUB_NAMEDIS			CString(_T("椭圆封头"))
#define SUB_NAMESPE			CString(_T("球"))
#define SUB_NAMEEXT			CString(_T("拉伸体"))
#define SUB_NAMEREV			CString(_T("旋转体"))
#define SUB_NAMETYDF		CString(_T("天圆地方"))
#define SUB_NAMENOZZ		CString(_T("管觜"))
#define SUB_NAMESUBDMESH	CString(_T("revit对象"))
#define SUB_NAME_NEWEXT		CString(_T("拉伸体"))
#define SUB_NAME_NEWREV		CString(_T("旋转体"))
#define SUB_NAME_NEWSWEEP	CString(_T("扫掠体"))
#define SUB_NAME_SWEEP_R	CString(_T("扫掠体R"))
#define SUB_NAME_COMBIN_R	CString(_T("组合体R"))
#define SUB_NAME_NEWLOFT	CString(_T("放样体"))
#define SUB_NAME_EQU		CString(_T("组合设备"))
#define EQU_COMPANY		"Beijing shanghua equipment design file"

#pragma endregion define

namespace
{
	Adesk::Int32 getItemID(std::set<int> &idBuffer)
	{
		long id = _time32(NULL);

		std::pair<std::set<int>::iterator, bool> pr = idBuffer.insert(id);
		if (!pr.second)	// 存在重复
		{
			id = *idBuffer.rbegin() + 1;
			idBuffer.insert(id);
		}

		return id;
	}

	void CheckChildItem(CTreeCtrl &tree, HTREEITEM hParent, BOOL bCheck)
	{
		HTREEITEM hChild = tree.GetChildItem(hParent);
		while (hChild != NULL)
		{
			tree.SetCheck(hChild, bCheck);

			CheckChildItem(tree, hChild, bCheck);
			hChild = tree.GetNextSiblingItem(hChild);
		}
	}

	void getSelectItems(CTreeCtrl &tree, HTREEITEM hParent, std::vector<HTREEITEM> &items)
	{
		BOOL bCheck(false);
		HTREEITEM hChild = tree.GetChildItem(hParent);
		while (hChild != NULL)
		{
			if (tree.GetCheck(hChild)) items.push_back(hChild);
			getSelectItems(tree, hChild, items);
			hChild = tree.GetNextSiblingItem(hChild);
		}
	}

	CString getTreeItemSuffix(bool bSub)
	{
		CString sSuffix(_T("(+)"));
		if (bSub)
			sSuffix = _T("(-)");
		return sSuffix;
	}

	HTREEITEM refreshTree(AecDbEwEquipment *pEqu, CTreeCtrl &ctrl)
	{
		if (!pEqu) return NULL;

		ctrl.DeleteAllItems();

		CString sName(_T("设备"));
		AecDbObjXDataMap *pXDataMap = pEqu->GetSpecialtyData();
		if (pXDataMap)
			pXDataMap->GetAt(KEY_NAME, sName);
		HTREEITEM hRoot = ctrl.InsertItem(sName, EQP_TREE_ROOT, EQP_TREE_ROOT);

		AcDbObjectId id = pEqu->objectId();
		ctrl.SetItemData(hRoot, (DWORD_PTR)id.asOldId());

		AecEqui::Primitive ePrim;
		AecEqui::XPrimData* p3dsolid = NULL;
		HTREEITEM hItem = NULL;

		std::set<int> ss;
		std::pair<std::set<int>::iterator, bool> pr;
		CString sSuffix(_T(""));
		for (int i = 0; i < pEqu->GetSubPrimObjCount(); i++)
		{
			p3dsolid = pEqu->GetSubPrimObj(i);
			if (!p3dsolid) continue;

			sSuffix = getTreeItemSuffix(p3dsolid->m_bBoolSubtract);

			ePrim = (AecEqui::Primitive)p3dsolid->m_eType;

			switch (ePrim)
			{
			case AecEqui::kBox:
				hItem = ctrl.InsertItem(SUB_NAMEBOX + sSuffix
					, SUB_TREE_BOX
					, SUB_TREE_BOX
					, hRoot);
				break;
			case AecEqui::kCylinder:
				hItem = ctrl.InsertItem(SUB_NAMECLN + sSuffix
					, SUB_TREE_CLN
					, SUB_TREE_CLN
					, hRoot);
				break;
			case AecEqui::kCone:
				hItem = ctrl.InsertItem(SUB_NAMECON + sSuffix
					, SUB_TREE_CON
					, SUB_TREE_CON
					, hRoot);
				break;
			case AecEqui::kPyramid:
				hItem = ctrl.InsertItem(SUB_NAMEPRM + sSuffix
					, SUB_TREE_PRM
					, SUB_TREE_PRM
					, hRoot);
				break;
			case AecEqui::kCirTorus:
				hItem = ctrl.InsertItem(SUB_NAMECIT + sSuffix
					, SUB_TREE_CIT
					, SUB_TREE_CIT
					, hRoot);
				break;
			case AecEqui::kRectTorus:
				hItem = ctrl.InsertItem(SUB_NAMERCT + sSuffix
					, SUB_TREE_RCT
					, SUB_TREE_RCT
					, hRoot);
				break;
			case AecEqui::kDish:
				hItem = ctrl.InsertItem(SUB_NAMEDIS + sSuffix
					, SUB_TREE_DIS
					, SUB_TREE_DIS
					, hRoot);
				break;
			case AecEqui::kSphere:
				hItem = ctrl.InsertItem(SUB_NAMESPE + sSuffix
					, SUB_TREE_SPE
					, SUB_TREE_SPE
					, hRoot);
				break;
			case AecEqui::kExtrude:
				hItem = ctrl.InsertItem(SUB_NAMEEXT + sSuffix
					, SUB_TREE_EXTRU
					, SUB_TREE_EXTRU
					, hRoot);
				break;
			case AecEqui::kRevolve:
				hItem = ctrl.InsertItem(SUB_NAMEREV + sSuffix
					, SUB_TREE_REVOL
					, SUB_TREE_REVOL
					, hRoot);
				break;
			case AecEqui::kTydf:
				hItem = ctrl.InsertItem(SUB_NAMETYDF + sSuffix
					, SUB_TREE_TYDF
					, SUB_TREE_TYDF
					, hRoot);
				break;
			case AecEqui::kNozz:
				hItem = ctrl.InsertItem(SUB_NAMENOZZ + sSuffix
					, SUB_TREE_NOZZ
					, SUB_TREE_NOZZ
					, hRoot);
				break;
			case AecEqui::kNewExtrude:
				hItem = ctrl.InsertItem(SUB_NAME_NEWEXT + sSuffix
					, SUB_TREE_EXTRU
					, SUB_TREE_EXTRU
					, hRoot);
				break;
			case AecEqui::kNewRevolve:
				hItem = ctrl.InsertItem(SUB_NAME_NEWREV + sSuffix
					, SUB_TREE_REVOL
					, SUB_TREE_REVOL
					, hRoot);
				break;
			case AecEqui::kRevitSweep:
				hItem = ctrl.InsertItem(SUB_NAME_SWEEP_R + sSuffix
					, SUB_TREE_SWEEP
					, SUB_TREE_SWEEP
					, hRoot);
				break;
			case AecEqui::kNewSweep:
				hItem = ctrl.InsertItem(SUB_NAME_NEWSWEEP + sSuffix
					, SUB_TREE_SWEEP
					, SUB_TREE_SWEEP
					, hRoot);
				break;
			case AecEqui::kNewLoft:
				hItem = ctrl.InsertItem(SUB_NAME_NEWLOFT + sSuffix
					, SUB_TREE_LOFT
					, SUB_TREE_LOFT
					, hRoot);
				break;
			case AecEqui::kRevitCombination:
				hItem = ctrl.InsertItem(SUB_NAME_COMBIN_R + sSuffix
					, SUB_TREE_RVT_COMBIN
					, SUB_TREE_RVT_COMBIN
					, hRoot);
				break;
			case AecEqui::kCombination:
				hItem = ctrl.InsertItem(SUB_NAME_EQU + sSuffix
					, SUB_TREE_EQU_COMBIN
					, SUB_TREE_EQU_COMBIN
					, hRoot);
				break;
			default:
				break;
			}

			if (!p3dsolid->m_sName.IsEmpty())
				ctrl.SetItemText(hItem, p3dsolid->m_sName + sSuffix);

			ctrl.SetItemData(hItem, (DWORD_PTR)p3dsolid->m_nID);
			pr = ss.insert(p3dsolid->m_nID);
			if (!pr.second)
				acutPrintf(_T("\n%d"), p3dsolid->m_nID);
		}
		return hRoot;
	}

	template <typename T>
	void setData(AecEqui::XPrimData *pXPData, void *pData, std::set<int> &idBuffer)
	{
		pXPData->m_nID = getItemID(idBuffer);
		switch (pXPData->m_eType)
		{
		case AecEqui::kExtrude:
		case AecEqui::kRevolve:
			pXPData->m_nSize = ((AecEqui::XBuffer*)pData)->nSize;
			if (pXPData->m_nSize > 0)
			{
				pXPData->m_pData = new byte[pXPData->m_nSize];
				::memcpy(pXPData->m_pData, ((AecEqui::XBuffer*)pData)->pData, pXPData->m_nSize);
			}
			break;
		default:
			pXPData->m_pData = new T;
			::memcpy(pXPData->m_pData, pData, sizeof(T));
			pXPData->m_nSize = sizeof(T);
			break;
		}
	}

	void deleteEntity(AcDbObjectId id, bool bUnRecord = false)
	{
		AcAxDocLock lock;
		if (!id.isValid()) return;
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt)
		{
			if (pEnt)
			{
				if (bUnRecord)
				{
					AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
					pDb->disableUndoRecording(true);
					pEnt->erase();
					pEnt->close();
					pDb->disableUndoRecording(false);
				}
				else
				{
					pEnt->erase();
					pEnt->close();
				}
			}
		}
		OPENOBJ_END()
	}

	bool setFaceClr(AcDbObjectId solidID
		, std::map<AcDbSubentId, int, CEquipmentMakeDlg::compare_subent> &subIds
		, const int &idx
		, int clr)
	{
		AcCmColor cm;
		cm.setColorIndex(256);

		OPENOBJ_BEGIN(solidID, AcDb::kForWrite, AcDb3dSolid, pSolid)
			if (!pSolid) return false;
		std::map<AcDbSubentId, int, CEquipmentMakeDlg::compare_subent>::iterator it(subIds.begin());
		for (; it != subIds.end(); ++it)
		{
			const AcDbSubentId &subId(it->first);
			if (clr == it->second)
			{
				pSolid->setSubentColor(BrepOper::Acad2Zcad(subId), cm);
				it->second = 256;
				break;
			}
		}
		it = subIds.begin();
		std::advance(it, idx);
		cm.setColorIndex(clr);
		pSolid->setSubentColor(BrepOper::Acad2Zcad(it->first), cm);
		it->second = clr;
		OPENOBJ_END()

			acedPostCommand(_T("regen "));

		return true;
	}

	int getColorByUser(int idx)
	{
		AcCmColor clr;
	#if ARX < 24
		clr.setColorMethod(AcCmEntityColor::kByACI);
	#endif
		clr.setColorIndex(idx);
		acedSetColorDialogTrueColor(clr
			, Adesk::kTrue
			, clr
			, AcCm::kACITab);
		return clr.colorIndex();
	}

	void selectPolyline(AcGePoint3d &pickPnt, AcArray<AcDbRegion*> &regs)
	{
#ifdef ZWCAD
		acedPostCommand(_T("_SHADEMODE _2D "));
#else
		acedPostCommand(_T("_vscurrent 2 "));
#endif

		ads_name ent, ss;
		struct resbuf *pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE,CIRCLE"), 0);
		int nRes = CKTCadUtility::SelectEntities(_T("\n请选择多条闭合多段线或面域："), ss, pRb);
		acutRelRb(pRb);

		if (nRes == RTNORM)
		{
			AcDbObjectId id;

			Adesk::Int32 nLen = 0;
			acedSSLength(ss, &nLen);
			for (long i = 0; i < nLen; i++)
			{
				acedSSName(ss, i, ent);
				acdbGetObjectId(id, ent);
				OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
					if (pEnt)
					{
						AcDbRegion *pReg = AcDbRegion::cast(pEnt);
						AcDbPolyline *pPoly = AcDbPolyline::cast(pEnt);
						AcDbCircle *pCir = AcDbCircle::cast(pEnt);
						if (pReg)
						{
							regs.append((AcDbRegion*)pReg->clone());
							continue;
						}
						if (pPoly)
						{
							AcDbPolyline *p = (AcDbPolyline*)pPoly->clone();
							if (p->isClosed())
								p->setClosed(true);
							AcDbRegion *pR = CoreTools::createRegion(p);
							DELETE_PTR(p);
							if (pR)
								regs.append(pR);
						}
						if (pCir)
						{
							AcDbCircle *p = (AcDbCircle*)pCir->clone();
							AcDbRegion *pR = CoreTools::createRegion(p);
							DELETE_PTR(p);
							if (pR)
								regs.append(pR);
						}
					}
				OPENOBJ_END()
			}

			pickPnt = acdbCurDwg()->ucsorg();
			CoreTools::UCS2WCS(pickPnt, pickPnt);

		}
		acedSSFree(ss);
	}

	bool isSubtract()
	{
		bool bSub = false;
		TCHAR szKey[131] = {};
		acedInitGet(RSG_OTHER, _T("Y N"));
		acedGetKword(_T("\n是否是挖掘操作[是(Y)/否(N)]<否(N)>:"), szKey);
		if (CString(szKey).CompareNoCase(_T("Y")) == 0)
			bSub = true;
		return bSub;
	}

	AcDbPolyline* curve2Polyline(AcDbCurve *pCurve)
	{
		AcDbPolyline *pPoly(AcDbPolyline::cast(pCurve));
		if (pPoly) return (AcDbPolyline*)pPoly->clone();

		return CoreTools::MakePolyline(pCurve);
	}

	AcDbPolyline* selectPath(AcGePoint3d &pickPnt)
	{
		AcDbPolyline *pPoly(NULL);
		ads_name ent;
		struct resbuf *pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE,LINE,ARC,CIRCLE"), 0);
		int nRes = CKTCadUtility::SelectEntity(_T("\n选择一条曲线(直线，弧线，圆，多段线)做为路径："), ent, pRb);
		acutRelRb(pRb);
		if (nRes != RTNORM) return NULL;
		AcDbObjectId id;
		if (acdbGetObjectId(id, ent) != Acad::eOk) return NULL;

		OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbCurve, p)
			if (p) pPoly = curve2Polyline(p);
		OPENOBJ_END()
			return pPoly;
	}

	AcDbRegion* selectPolyline(AcGePoint3d &pickPnt, LPCTSTR pszMsg, bool bVscurrent)
	{
		if (bVscurrent)
#ifdef ZWCAD
			acedPostCommand(_T("_SHADEMODE _2D "));
#else
			acedPostCommand(_T("_vscurrent 2 "));
#endif
		ads_name ent;
		ads_point adsPt;
		struct resbuf *pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE,CIRCLE"), 0);
		int nRes = CKTCadUtility::SelectEntity(pszMsg, ent, pRb, adsPt);
		acutRelRb(pRb);
		if (nRes != RTNORM) return NULL;

		pickPnt = asPnt3d(adsPt);
		CoreTools::UCS2WCS(pickPnt, pickPnt);

		AcDbObjectId id;
		acdbGetObjectId(id, ent);
		OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
			if (pEnt)
			{
				AcDbRegion *pReg = AcDbRegion::cast(pEnt);
				AcDbPolyline *pPoly = AcDbPolyline::cast(pEnt);
				AcDbCircle *pCir = AcDbCircle::cast(pEnt);
				if (pReg)
				{
					return (AcDbRegion*)pReg->clone();
				}
				if (pPoly)
				{
					AcDbPolyline *p = (AcDbPolyline*)pPoly->clone();
					if (p->isClosed())
						p->setClosed(true);
					AcDbRegion *pR = CoreTools::createRegion(p);
					DELETE_PTR(p);
					return pR;
				}
				if (pCir)
				{
					AcDbCircle *p = (AcDbCircle*)pCir->clone();
					AcDbRegion *pR = CoreTools::createRegion(p);
					DELETE_PTR(p);
					return pR;
				}
			}
		OPENOBJ_END()
			return NULL;
	}

	AcDbEntity* selectEntity(LPCTSTR filter, LPCTSTR pszMsg, const AcGePoint3d &ptOrg, const bool &bMove = true)
	{
		if (!filter || !pszMsg) return NULL;

		ads_name ent;
		struct resbuf *pRb = acutBuildList(RTDXF0, filter, 0);
		int nRes = CKTCadUtility::SelectEntity2(pszMsg, ent, pRb);
		acutRelRb(pRb);
		if (nRes != RTNORM) return NULL;

		AcDbObjectId id;
		acdbGetObjectId(id, ent);
		if (!id.isValid()) return NULL;

		AcDbEntity *pResult(NULL);

		OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
		{
			if (!pEnt) return NULL;
			pResult = (AcDbEntity*)pEnt->clone();
		}
		OPENOBJ_END()

			if (!bMove) return pResult;

		// 移动到ptOrg
		AcDbExtents ext;
		pResult->getGeomExtents(ext);
		AcGePoint3d ptCen(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
		AcGeVector3d vt(ptOrg - ptCen);
		AcGeMatrix3d mat;
		mat.setToTranslation(vt);
		pResult->transformBy(mat);

		return pResult;
	}

	bool getInsertPt(CWnd *pWnd, AcGePoint3d &pt)
	{
		if (pWnd->IsWindowVisible())
			pWnd->ShowWindow(SW_HIDE);

		ads_point adsPt = {.0,.0,.0};
		int nRes = acedGetPoint(NULL, _T("\n请选择放置点<0,0,0>："), adsPt);
		if (nRes == RTCAN)
		{
			if (!pWnd->IsWindowVisible())
				pWnd->ShowWindow(SW_SHOW);
			return false;
		}

		if (nRes == RTNONE)
		{
			adsPt[0] = adsPt[1] = adsPt[2] = .0;
		}

		pt = asPnt3d(adsPt);
		CoreTools::UCS2WCS(pt, pt);

		if (!pWnd->IsWindowVisible())
			pWnd->ShowWindow(SW_SHOW);
		return true;
	}

	void CreateExtrude(std::vector<AecEqui::XPrimData> &solids, std::set<int> &idBuffer)
	{
		AcArray<AcDbRegion*> regs(0);
		AcGePoint3d pickPnt(AcGePoint3d::kOrigin);
		selectPolyline(pickPnt, regs);
		if (regs.isEmpty()) return;

		AcGeVector3d vtNormal;
		regs[0]->getNormal(vtNormal);
		vtNormal.normalize();

		double dH(.0);
		if (acedGetReal(_T("\n输入拉伸高度:"), &dH) != RTNORM) return;

		bool bSub = isSubtract();
		int clr = getColorByUser(256);
		AcGePoint3d pt;
		long tid = getItemID(idBuffer);
		for (int i = 0; i < regs.length(); ++i)
		{
			NewExtrude ne(!bSub, regs[i], dH);
			AecEqui::XPrimData data;
			data.m_nID = tid++;
			data.m_eType = AecEqui::kNewExtrude;
			data.m_bBoolSubtract = bSub;
			data.m_iClr = clr;
			ne.toData(data.m_pData, data.m_nSize);
			solids.push_back(data);
		}

		deleteContainerOfArx<AcDbRegion>(regs);
	}

	void CreateSweep(std::vector<AecEqui::XPrimData> &solids, std::set<int> &idBuffer)
	{
		AcArray<AcDbRegion*> regs(0);
		AcDbPolyline *pPoly(NULL);
		do
		{
			AcGePoint3d pickPnt(AcGePoint3d::kOrigin);
			selectPolyline(pickPnt, regs);
			if (regs.isEmpty()) break;

			pPoly = selectPath(pickPnt);
			if (!pPoly) break;

			bool bSub = isSubtract();
			int clr = getColorByUser(256);

			long tid = getItemID(idBuffer);
			for (int i = 0; i < regs.length(); ++i)
			{
				NewSweep ns(!bSub, regs[i], pPoly);
				AecEqui::XPrimData data;
				data.m_nID = tid++;
				data.m_eType = AecEqui::kNewSweep;
				data.m_bBoolSubtract = bSub;
				data.m_iClr = clr;
				ns.toData(data.m_pData, data.m_nSize);
				solids.push_back(data);
			}

		} while (false);

		deleteContainerOfArx<AcDbRegion>(regs);
		DELETE_PTR(pPoly);
	}

	void CreateLoft(AecEqui::XPrimData &solid, std::set<int> &idBuffer)
	{
		AcGePoint3d ptOrg = acdbCurDwg()->ucsorg();
		int idx(0);
		CString sMsg(_T(""));
		AcGePoint3d pickPnt(AcGePoint3d::kOrigin);
		AcArray<AcDbRegion*> regs;
		AcDbRegion *pBot(NULL);
		AcGeVector3d vtNormal, vt;
		AcGeMatrix3d mat;
		AcGePlane botPlan, plan;
		double dH(.0), dAll(.0);
		int iSign = 1;
		while (true)
		{
			if (!idx)
				sMsg = _T("\n请选择第一级底面(闭合多段线或面域)：");
			else
				sMsg.Format(_T("\n请选择第%d级顶面"), idx);
			AcDbRegion *pReg = selectPolyline(pickPnt, sMsg, !idx);
			if (!pReg) break;

			if (!idx)
			{
				pReg->getNormal(vtNormal);
				vtNormal.normalize();
				pReg->getPlane(botPlan);
				regs.append(pReg);
			}
			else
			{
				pReg->getPlane(plan);
				if (!botPlan.isCoplanarTo(plan))
				{
					acutPrintf(_T("\n此面不与底层共面，请重新选择："));
					continue;
				}

				if (acedGetReal(_T("\n请输入层高(毫米):"), &dH) != RTNORM) break;

				if (idx == 1)
					iSign = dH > 0 ? 1 : -1;
				else
					dH = abs(dH) * iSign;

				dAll += dH;

				mat.setToIdentity();
				mat.setToTranslation(vtNormal * dAll);
				pReg->transformBy(mat);
				regs.append(pReg);
			}
			++idx;
		}

		if (regs.length() < 2)
		{
			deleteContainerOfArx<AcDbRegion>(regs);
			return;
		}

		bool bSub = isSubtract();
		int clr = getColorByUser(256);

		NewLoft nl(!bSub, regs, NULL);
		solid.m_nID = getItemID(idBuffer);
		solid.m_eType = AecEqui::kNewLoft;
		solid.m_bBoolSubtract = bSub;
		solid.m_iClr = clr;
		nl.toData(solid.m_pData, solid.m_nSize);

		deleteContainerOfArx<AcDbRegion>(regs);
	}

	void CreateRevolve(std::vector<AecEqui::XPrimData> &solids, std::set<int> &idBuffer)
	{
		AcArray<AcDbRegion*> regs(0);
		AcGePoint3d pickPnt(AcGePoint3d::kOrigin);
		selectPolyline(pickPnt, regs);
		if (regs.isEmpty()) return;

		AcDbLine *pLine = (AcDbLine*)selectEntity(_T("LINE")
			, _T("\n请选择一条直段做为旋转轴：")
			, AcGePoint3d::kOrigin
			, false);

		if (!pLine)
		{
			acutPrintf(_T("请选择一条直线做为旋转轴！"));
			return;
		}

		bool bSub = isSubtract();
		int clr = getColorByUser(256);

		long tid = getItemID(idBuffer);
		for (int i = 0; i < regs.length(); ++i)
		{
			NewRevolve nr(!bSub, regs[i]
				, pLine->startPoint()
				, pLine->endPoint() - pLine->startPoint()
				, 2 * PI
				, 0.);
			AecEqui::XPrimData data;
			data.m_nID = tid++;
			data.m_eType = AecEqui::kNewRevolve;
			data.m_bBoolSubtract = bSub;
			data.m_iClr = clr;
			nr.toData(data.m_pData, data.m_nSize);
			solids.push_back(data);
		}
		DELETE_PTR(pLine);
		deleteContainerOfArx<AcDbRegion>(regs);
	}
}

IMPLEMENT_DYNAMIC(CEquipmentMakeDlg, CDialog)

CEquipmentMakeDlg::CEquipmentMakeDlg(AcDbObjectId id, CWnd* pParent /*=NULL*/)
	: CDialog(CEquipmentMakeDlg::IDD, pParent)
	, m_dXMove(0)
	, m_dYMove(0)
	, m_dZMove(0)
	, m_dXRot(0)
	, m_dYRot(0)
	, m_dZRot(0)
	, m_dIMove(0)
	, m_dIRot(0)
	, m_MainID(id)
	, m_sName(_T(""))
	, m_dwIDSel(0)
	, m_dwIDAgn(0)
{
	Create(IDD_EQUIPMAKEDLG, pParent);
	m_pDb = NULL;
}

CEquipmentMakeDlg::~CEquipmentMakeDlg()
{
	AcAxDocLock lock;
	deleteEntity(m_HligthtID, true);
}

void CEquipmentMakeDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_TREEEQUIP, m_wndEquipPrmTree);
	DDX_Text(pDX, IDC_EDITXMOVE, m_dXMove);
	DDX_Text(pDX, IDC_EDITYMOVE, m_dYMove);
	DDX_Text(pDX, IDC_EDITZMOVE, m_dZMove);
	DDX_Text(pDX, IDC_EDITXROT,  m_dXRot);
	DDX_Text(pDX, IDC_EDITYROT,  m_dYRot);
	DDX_Text(pDX, IDC_EDITZROT,  m_dZRot);
	DDX_Text(pDX, IDC_EDITIMOVE, m_dIMove);
	DDX_Text(pDX, IDC_EDITIROT, m_dIRot);
	DDX_Control(pDX, IDC_BUTTONBOX, m_wndBtBox);
	DDX_Control(pDX, IDC_BUTTONCLN, m_wndBtCln);
	DDX_Control(pDX, IDC_BUTTONCONE, m_wndBtCone);
	DDX_Control(pDX, IDC_BUTTONPYRM, m_wndBtPyrm);
	DDX_Control(pDX, IDC_BUTTONSPERE, m_wndBtSpere);
	DDX_Control(pDX, IDC_BUTTONDISH, m_wndBtDish);
	DDX_Control(pDX, IDC_BUTTONCIRTOR, m_wndBtCirtor);
	DDX_Control(pDX, IDC_BUTTONRECTOR, m_wndBtRector);
	DDX_Control(pDX, IDC_BUTTONTYDF, m_wndBtTydf);
	DDX_Control(pDX, IDC_BUTTONEXTRU, m_wndBtExtru);
	DDX_Control(pDX, IDC_BUTTONREVO, m_wndBtRevo);
	DDX_Control(pDX, IDC_BUTTONSWEEP, m_wndBtSweep);
	DDX_Control(pDX, IDC_BUTTONLOFT, m_wndBtLoft);
	DDX_Control(pDX, IDC_BUTTONRVT, m_wndBtRvt);
	DDX_Control(pDX, IDC_BUTTONEQU, m_wndBtEqu);
	DDX_Control(pDX, IDC_BTSHOWX, m_wndBtShowX);
	DDX_Control(pDX, IDC_BTSHOWY, m_wndBtShowY);
	DDX_Control(pDX, IDC_BTSHOWZ, m_wndBtShowZ);
	DDX_Control(pDX, IDC_BTSHOWX2, m_wndBtShowX2);
	DDX_Control(pDX, IDC_BTSHOWY2, m_wndBtShowY2);
	DDX_Control(pDX, IDC_BTSHOWZ2, m_wndBtShowZ2);
}

BEGIN_MESSAGE_MAP(CEquipmentMakeDlg, CDialog)
	ON_BN_CLICKED(IDOK, &CEquipmentMakeDlg::OnBnClickedOk)
	ON_BN_CLICKED(IDCANCEL, &CEquipmentMakeDlg::OnBnClickedCancle)
	ON_BN_CLICKED(IDC_BTNEWEQP, &CEquipmentMakeDlg::OnBnClickedBtneweqp)
	ON_BN_CLICKED(IDC_BUTTONBOX, &CEquipmentMakeDlg::OnBnClickedButtonbox)
	ON_BN_CLICKED(IDC_BUTTONCLN, &CEquipmentMakeDlg::OnBnClickedButtoncln)
	ON_BN_CLICKED(IDC_BUTTONCONE, &CEquipmentMakeDlg::OnBnClickedButtoncone)
	ON_BN_CLICKED(IDC_BUTTONPYRM, &CEquipmentMakeDlg::OnBnClickedButtonpyrm)
	ON_BN_CLICKED(IDC_BUTTONSPERE, &CEquipmentMakeDlg::OnBnClickedButtonspere)
	ON_BN_CLICKED(IDC_BUTTONDISH, &CEquipmentMakeDlg::OnBnClickedButtondish)
	ON_BN_CLICKED(IDC_BUTTONCIRTOR, &CEquipmentMakeDlg::OnBnClickedButtoncirtor)
	ON_BN_CLICKED(IDC_BUTTONRECTOR, &CEquipmentMakeDlg::OnBnClickedButtonrector)
	ON_MESSAGE( WM_ACAD_KEEPFOCUS, &CEquipmentMakeDlg::onAcadKeepFocus )
	ON_BN_CLICKED(IDC_BTACTIVEINF, &CEquipmentMakeDlg::OnBnClickedBtactiveinf)
	ON_BN_CLICKED(IDC_BTLOCATE, &CEquipmentMakeDlg::OnBnClickedBtlocate)
	ON_BN_CLICKED(IDC_BTRESET, &CEquipmentMakeDlg::OnBnClickedBtreset)
	ON_BN_CLICKED(IDC_BTAPPLY, &CEquipmentMakeDlg::OnBnClickedBtapply)
	ON_BN_CLICKED(IDC_BTMODIPRM, &CEquipmentMakeDlg::OnBnClickedBtmodiprm)
	ON_BN_CLICKED(IDC_BTDELPRM, &CEquipmentMakeDlg::OnBnClickedBtdelprm)
	ON_BN_CLICKED(IDC_BTAPPLY2, &CEquipmentMakeDlg::OnBnClickedBtapply2)
	ON_BN_CLICKED(IDC_BTRESET2, &CEquipmentMakeDlg::OnBnClickedBtreset2)
	ON_WM_DESTROY()
	ON_NOTIFY(TVN_SELCHANGED, IDC_TREEEQUIP, &CEquipmentMakeDlg::OnTvnSelchangedTreeequip)
	ON_BN_CLICKED(IDC_BUTTONEXTRU, &CEquipmentMakeDlg::OnBnClickedButtonextru)
	ON_BN_CLICKED(IDC_BUTTONREVO, &CEquipmentMakeDlg::OnBnClickedButtonrevo)
	ON_BN_CLICKED(IDC_BTUNDOLOCATE, &CEquipmentMakeDlg::OnBnClickedBtundolocate)
	ON_BN_CLICKED(IDC_BUTTONRELOAD, &CEquipmentMakeDlg::OnBnClickedButtonreload)
	ON_BN_CLICKED(IDC_BTSELASMOVE, &CEquipmentMakeDlg::OnBnClickedBtselasmove)
	ON_BN_CLICKED(IDC_BTSELASALIGN, &CEquipmentMakeDlg::OnBnClickedBtselasalign)
	ON_STN_CLICKED(IDC_STATICSEL, &CEquipmentMakeDlg::OnStnClickedStaticsel)
	ON_STN_CLICKED(IDC_STATICAGN, &CEquipmentMakeDlg::OnStnClickedStaticagn)
	ON_BN_CLICKED(IDC_BUTTONTYDF, &CEquipmentMakeDlg::OnBnClickedButtontydf)
	ON_BN_CLICKED(IDC_BUTTONHIDEARO, &CEquipmentMakeDlg::OnBnClickedButtonhidearo)
	ON_BN_CLICKED(IDC_BUTTONADDNOZ, &CEquipmentMakeDlg::OnBnClickedButtonaddnoz)
	ON_WM_MOUSEACTIVATE()
	ON_WM_HSCROLL()
	ON_WM_VSCROLL()
	ON_WM_MOUSEWHEEL()
	ON_WM_SIZE()
	ON_BN_CLICKED(IDC_BUTTONMOVEX, &CEquipmentMakeDlg::OnBnClickedButtonmovex)
	ON_BN_CLICKED(IDC_BUTTONMOVEY, &CEquipmentMakeDlg::OnBnClickedButtonmovey)
	ON_BN_CLICKED(IDC_BUTTONMOVEZ, &CEquipmentMakeDlg::OnBnClickedButtonmovez)
	ON_BN_CLICKED(IDC_BUTTONMOVEA, &CEquipmentMakeDlg::OnBnClickedButtonmovea)
	ON_BN_CLICKED(IDC_BUTTONROTX, &CEquipmentMakeDlg::OnBnClickedButtonrotx)
	ON_BN_CLICKED(IDC_BUTTONROTY, &CEquipmentMakeDlg::OnBnClickedButtonroty)
	ON_BN_CLICKED(IDC_BUTTONROTZ, &CEquipmentMakeDlg::OnBnClickedButtonrotz)
	ON_BN_CLICKED(IDC_BUTTONROTA, &CEquipmentMakeDlg::OnBnClickedButtonrota)
	ON_BN_CLICKED(IDC_BUTTONSAVEFILE, &CEquipmentMakeDlg::OnBnClickedButtonsavefile)
	ON_BN_CLICKED(IDC_BUTTONUSERDATA, &CEquipmentMakeDlg::OnBnClickedButtonuserdata)
	ON_BN_CLICKED(IDC_BUTTONOPEN, &CEquipmentMakeDlg::OnBnClickedButtonopen)
	ON_BN_CLICKED(IDC_BUTTONPUBLIC, &CEquipmentMakeDlg::OnBnClickedButtonpublic)
	ON_NOTIFY(NM_RCLICK, IDC_TREEEQUIP, &CEquipmentMakeDlg::OnNMRclickTreeequip)
	ON_BN_CLICKED(IDC_BTSHOWX, &CEquipmentMakeDlg::OnBnClickedBtshowx)
	ON_BN_CLICKED(IDC_BTSHOWY, &CEquipmentMakeDlg::OnBnClickedBtshowy)
	ON_BN_CLICKED(IDC_BTSHOWZ, &CEquipmentMakeDlg::OnBnClickedBtshowz)
	ON_NOTIFY(NM_DBLCLK, IDC_TREEEQUIP, &CEquipmentMakeDlg::OnNMDblclkTreeequip)
	ON_BN_CLICKED(IDC_SAVETODB, &CEquipmentMakeDlg::OnBnClickedSavetodb)
	ON_BN_CLICKED(IDC_BTSHOWX2, &CEquipmentMakeDlg::OnBnClickedBtshowx2)
	ON_BN_CLICKED(IDC_BTSHOWY2, &CEquipmentMakeDlg::OnBnClickedBtshowy2)
	ON_BN_CLICKED(IDC_BTSHOWZ2, &CEquipmentMakeDlg::OnBnClickedBtshowz2)
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_BUTTONMOVEPOINT, &CEquipmentMakeDlg::OnBnClickedButtonMovePoint)
	ON_BN_CLICKED(IDC_BUTTONRVT, &CEquipmentMakeDlg::OnBnClickedButtonRvt)
	ON_BN_CLICKED(IDC_BUTTONSWEEP, &CEquipmentMakeDlg::OnBnClickedButtonSweep)
	ON_BN_CLICKED(IDC_BUTTONLOFT, &CEquipmentMakeDlg::OnBnClickedButtonLoft)
	ON_WM_SHOWWINDOW()
	ON_BN_CLICKED(IDC_BUTTON_START, &CEquipmentMakeDlg::OnBnClickedButtonStart)
	ON_BN_CLICKED(IDC_BUTTON_NEXT, &CEquipmentMakeDlg::OnBnClickedButtonNext)
	ON_BN_CLICKED(IDC_BUTTON_PREV, &CEquipmentMakeDlg::OnBnClickedButtonPrev)
	ON_BN_CLICKED(IDC_BUTTON_END, &CEquipmentMakeDlg::OnBnClickedButtonEnd)
	ON_BN_CLICKED(IDC_BUTTONSAVE, &CEquipmentMakeDlg::OnBnClickedButtonsave)
	ON_MESSAGE(WM_REFRESH_HLIGHT_ENTITY_MESSAGE, &CEquipmentMakeDlg::OnRefreshHlightEntityMsg)
	ON_NOTIFY(NM_CLICK, IDC_TREEEQUIP, &CEquipmentMakeDlg::OnNMClickTreeequip)
	ON_BN_CLICKED(IDC_BUTTONCOPY, &CEquipmentMakeDlg::OnBnClickedButtoncopy)
	ON_BN_CLICKED(IDC_BUTTONMIRR, &CEquipmentMakeDlg::OnBnClickedButtonmirr)
	ON_BN_CLICKED(IDC_BUTTONEQU, &CEquipmentMakeDlg::OnBnClickedButtonins)
	ON_BN_CLICKED(IDC_BUTTONNAME, &CEquipmentMakeDlg::OnBnClickedButtonname)
	ON_BN_CLICKED(IDC_BUTTONCLOSE, &CEquipmentMakeDlg::OnBnClickedButtonClose)
	ON_BN_CLICKED(IDC_BUTTONLOADDWG, &CEquipmentMakeDlg::OnBnClickedButtonLoadDWG)
END_MESSAGE_MAP()

LONG_PTR CEquipmentMakeDlg::onAcadKeepFocus( UINT_PTR, LONG_PTR)
{
	POINT pt;
	::GetCursorPos(&pt);
	CRect rect;
	GetWindowRect(&rect);
	if(!(rect.PtInRect(pt)))
	{
		return FALSE;
	}

	//如果当前有命令在执行中，提示
	struct resbuf rb;
	acedGetVar(_T("CMDNAMES"),&rb);

	if (rb.restype == RTSTR && rb.resval.rstring != NULL)
	{
		if (_tcslen(rb.resval.rstring) > 0)
		{
#if ARX > 19
			CoreTools::sendKeyToCADView(VK_ESCAPE);
#else
			acedPostCommand(_T("\x03"));
#endif
		}
	}

	return TRUE;
}

void CEquipmentMakeDlg::SetAdoDb(CUIISQLiteServer *pDb)
{
	m_pDb = pDb;
}

BOOL CEquipmentMakeDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	CBitmap bmpBtn, bmpTree;
	if (!bmpBtn.LoadBitmap (IDB_EQU_MAKE))
	{
		AfxMessageBox(_T ("Can't load bitmap: %x\n"), IDB_EQU_MAKE);
		ASSERT (FALSE);
		return FALSE;
	}
	if (!bmpTree.LoadBitmap (IDB_BITMAPPRIV	))
	{
		AfxMessageBox(_T ("Can't load bitmap: %x\n"), IDB_BITMAPPRIV);
		ASSERT (FALSE);
		return FALSE;
	}

	BITMAP bmpObjBtn, bmpObjTree;
	bmpBtn.GetBitmap (&bmpObjBtn);
	bmpTree.GetBitmap (&bmpObjTree);

	UINT nFlags =  ILC_COLOR24 | ILC_MASK;

	m_ImageTreelist.Create (16, bmpObjTree.bmHeight, nFlags, 0, 0);
	m_ImageTreelist.Add (&bmpTree, RGB (255, 0, 0));
	m_wndEquipPrmTree.SetImageList(&m_ImageTreelist,TVSIL_NORMAL);

	m_ImageBtnlist.Create(32, bmpObjBtn.bmHeight, nFlags, 0, 0);
	m_ImageBtnlist.Add (&bmpBtn, RGB (255, 0, 0));

	m_wndBtBox.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_BOX));
	m_wndBtCln.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_CLN));
	m_wndBtCone.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_CON));
	m_wndBtPyrm.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_PRM));
	m_wndBtSpere.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_SPE));
	m_wndBtDish.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_DIS));
	m_wndBtCirtor.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_CIT));
	m_wndBtRector.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_RCT));
	m_wndBtTydf.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_TYDF));
	m_wndBtExtru.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_EXTRU));
	m_wndBtRevo.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_REVOL));
	m_wndBtSweep.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_SWEEP));
	m_wndBtLoft.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_LOFT));
	m_wndBtRvt.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_RVT));
	m_wndBtEqu.SetIcon(m_ImageBtnlist.ExtractIcon(SUB_BTN_EQU));

	m_wndBtShowX.SetIcon(m_ImageTreelist.ExtractIcon(SUB_TREE_X));
	m_wndBtShowY.SetIcon(m_ImageTreelist.ExtractIcon(SUB_TREE_Y));
	m_wndBtShowZ.SetIcon(m_ImageTreelist.ExtractIcon(SUB_TREE_Z));

	m_wndBtShowX2.SetIcon(m_ImageTreelist.ExtractIcon(SUB_TREE_X));
	m_wndBtShowY2.SetIcon(m_ImageTreelist.ExtractIcon(SUB_TREE_Y));
	m_wndBtShowZ2.SetIcon(m_ImageTreelist.ExtractIcon(SUB_TREE_Z));

	std::set<int> exp;
	exp.insert(IDC_BUTTON_NEXT);
	exp.insert(IDC_BUTTON_PREV);
	exp.insert(IDC_BUTTON_END);
	enableWindows(true, exp);

	//搜AecDbEwEquipmentImp
	ShowWEquipmentOnTree();

	return TRUE;
}

int CEquipmentMakeDlg::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
{
	int status = CDialog::OnMouseActivate(pDesktopWnd, nHitTest, message);
	SetFocus();
	return status;
}

void CEquipmentMakeDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	//m_scrollHelper->OnHScroll(nSBCode, nPos, pScrollBar);
}

void CEquipmentMakeDlg::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	//m_scrollHelper->OnVScroll(nSBCode, nPos, pScrollBar);
}

BOOL CEquipmentMakeDlg::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
	//BOOL wasScrolled = m_scrollHelper->OnMouseWheel(nFlags, zDelta, pt);
	//return wasScrolled;
	return TRUE;
}

void CEquipmentMakeDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialog::OnSize(nType, cx, cy);
	//m_scrollHelper->OnSize(nType, cx, cy);
}

void CEquipmentMakeDlg::OnBnClickedOk()
{
	AcAxDocLock lock;
	deleteEntity(m_HligthtID, true);
}

void CEquipmentMakeDlg::OnBnClickedCancle()
{
	AcAxDocLock lock;
	deleteEntity(m_HligthtID, true);
	CDialog::OnCancel();
}

void CEquipmentMakeDlg::ShowWEquipmentOnTree()
{
	AcDbDatabase* pDb = acdbCurDwg();
	if (!pDb)
	{
		AfxMessageBox(_T("当前文档无效。"));
		return;
	}
	AcAxDocLock lock;
	m_wndEquipPrmTree.DeleteAllItems();

	m_idBuffer.clear();

	HTREEITEM hRoot = NULL;
	OPENOBJ_BEGIN(m_MainID, AcDb::kForWrite, AecDbEwEquipment, pWEquip)
	if (pWEquip)
	{
		// 在这里缓存一下设备里面几何体的ID
		std::vector<AecEqui::XPrimData*> arRepeats;
		for (int i(0); i < pWEquip->GetSubPrimObjCount(); ++i)
		{
			AecEqui::XPrimData *p = pWEquip->GetSubPrimObj(i);
			if (p)
			{
				std::pair<std::set<int>::iterator, bool> pr = m_idBuffer.insert(p->m_nID);
				if (!pr.second) // 说明存在重复的
				{	// 把重复的指针记录下来，一起修改
					arRepeats.push_back(p);
				}
			}
		}

		// 修改重复id的几何体,让他们的id唯一
		if (!arRepeats.empty())
		{
			for (size_t i(0); i < arRepeats.size(); ++i)
			{
				AecEqui::XPrimData *p(arRepeats[i]);
				p->m_nID = *m_idBuffer.rbegin() + 1;
				m_idBuffer.insert(p->m_nID);
			}
		}

		hRoot = refreshTree(pWEquip, m_wndEquipPrmTree);
	}
	OPENOBJ_END()
	if (hRoot != NULL) m_wndEquipPrmTree.Expand(hRoot, TVE_EXPAND);
}

void CEquipmentMakeDlg::OnBnClickedBtneweqp()
{
	AcDbDatabase* pDb = acdbCurDwg();
	if (!pDb)
	{
		AfxMessageBox(_T("当前文档无效。"));
		return;
	}

	AcAxDocLock lock;

	CString sName(_T("设备元件1"));

	AcDbObjectId id(GetEquIDByTree());
	if (!id.isValid())
	{
		m_wndEquipPrmTree.DeleteAllItems();
	}
	else
	{
		int nRes = 0;
		int nCount = m_wndEquipPrmTree.GetCount();
		if (nCount > 0)
		{
			nRes = AfxMessageBox(_T("当前发现设备元件!是否在当前设备元件上重新设计?"), MB_YESNO);
			if (nRes == IDNO)
			{
				return;
			}
			else
			{
				sName = m_sName;
				m_wndEquipPrmTree.DeleteAllItems();
				AcDbEntity *pEnt(NULL);
				if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
				{
					pEnt->erase();
					pEnt->close();
				}
			}
		}
	}
	
	//弹出名称
	if (!CoreTools::getNameByDialog(_T("请输入名称"), _T("名称："), sName)) return;
	m_sName = sName;

	if (!CoreTools::checkFileName(m_sName))
	{
		AfxMessageBox(_T("请检查设备名称，不能出现“ \\/:*?\"<>| ”。"));
		return;
	}


	AecDbEwEquipment* pWEquip = new AecDbEwEquipment;

	AecDbObjXDataMap* pXDataMap = pWEquip->GetSpecialtyData();
	pXDataMap->SetAt(KEY_NAME, m_sName);
	pXDataMap->SetAt(KEY_FITSRV, KEY_FITWPIPE);
	pXDataMap->SetAt(KEY_RUNTIME, eEquipment);
	//pWEquip->ReCreateByXDataMap();

	//设置图层
	CString sSys;
	pXDataMap->GetAt(PIPE_SYS,sSys);
	AcDbObjectId idLayer = CoreTools::AecInitLayerEx(LAY_PIPE_OUTSIDE,sSys,7,_T("Continuous"),NULL);

	pWEquip->setLayer(idLayer);
	pWEquip->SetDashLayer(KTSetting::InitLayer(LAY_FITN_DASH));
	pWEquip->SetCenterLayer(KTSetting::InitLayer(LAY_FITN_CENTER));

	//pWEquip->setColorIndex();
	id = CoreTools::AddToModelSpace(pWEquip);
	HTREEITEM hRoot = m_wndEquipPrmTree.InsertItem(m_sName, EQP_TREE_ROOT, EQP_TREE_ROOT);
	m_wndEquipPrmTree.SetItemData(hRoot, (DWORD_PTR)id.asOldId());
	m_MainID = id;
}

void CEquipmentMakeDlg::Test()
{

}

//添加3d图元体 
void CEquipmentMakeDlg::OnBnClickedButtonbox()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	CAcModuleResourceOverride myResources;
	CBoxDlg boxDlg;
	int nRes = boxDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;
		AecEqui::XBox box;
		box.dL = boxDlg.m_dX;
		box.dW = boxDlg.m_dY;
		box.dH = boxDlg.m_dZ;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kBox,&box);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kBox;
		data.m_iClr = boxDlg.m_clr;
		data.m_bBoolSubtract = boxDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XBOX>(&data, &box, m_idBuffer);
		
		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id = GetEquIDByTree();

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMEBOX + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_BOX
					,SUB_TREE_BOX
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtoncln()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	CAcModuleResourceOverride myResources;
	CCylinderDlg clnDlg;
	int nRes = clnDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XCylinder cln;
		cln.dr = clnDlg.m_dR;
		cln.dH = clnDlg.m_dH;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kCylinder,&cln);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kCylinder;
		data.m_iClr = clnDlg.m_clr;
		data.m_bBoolSubtract = clnDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XCYLINDER>(&data, &cln, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id = GetEquIDByTree();

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMECLN + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_CLN
					,SUB_TREE_CLN
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtoncone()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}
	CAcModuleResourceOverride myResources;
	CConeDLg coneDlg;
	int nRes = coneDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XCone cone;
		memset(&cone,0,sizeof(AecEqui::XCone));
		cone.dr = coneDlg.m_dr;
		cone.dR = coneDlg.m_dR;
		cone.dH = coneDlg.m_dH;
		cone.dXOffset = coneDlg.m_dXOffset;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kCone,&cone);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kCone;
		data.m_iClr = coneDlg.m_clr;
		data.m_bBoolSubtract = coneDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XCone>(&data, &cone, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMECON + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_CON
					,SUB_TREE_CON
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonpyrm()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
		return;

	CAcModuleResourceOverride myResources;
	CPyrmDlg coneDlg;
	int nRes = coneDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XPyramid cone;
		memset(&cone,0,sizeof(AecEqui::XPyramid));
		cone.dTX = coneDlg.m_dTx;
		cone.dTY = coneDlg.m_dTy;
		cone.dBX = coneDlg.m_dBx;
		cone.dBY = coneDlg.m_dBy;
		cone.dH = coneDlg.m_dTH;
		cone.dXOffset = coneDlg.m_dXOffset;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kPyramid,&cone);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kPyramid;
		data.m_iClr = coneDlg.m_clr;
		data.m_bBoolSubtract = coneDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XPyramid>(&data, &cone, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMEPRM + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_PRM
					,SUB_TREE_PRM
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonspere()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}
	CAcModuleResourceOverride myResources;
	CSpereDlg spereDlg;
	int nRes = spereDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XSphere sp;
		memset(&sp,0,sizeof(AecEqui::XSphere));
		sp.dr = spereDlg.m_dR;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kSphere,&sp);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kSphere;
		data.m_iClr = spereDlg.m_clr;
		data.m_bBoolSubtract = spereDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XSphere>(&data, &sp, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMESPE + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_SPE
					,SUB_TREE_SPE
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}	
}

void CEquipmentMakeDlg::OnBnClickedButtondish()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}
	CAcModuleResourceOverride myResources;
	CDishDlg dishDlg;
	int nRes = dishDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XDish dish;
		memset(&dish,0,sizeof(AecEqui::XDish));
		dish.dD = dishDlg.m_dD;
		dish.dH = dishDlg.m_dH;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kDish,&dish);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kDish;
		data.m_iClr = dishDlg.m_clr;
		data.m_bBoolSubtract = dishDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XDish>(&data, &dish, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMEDIS + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_DIS
					,SUB_TREE_DIS
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}		
}

void CEquipmentMakeDlg::OnBnClickedButtoncirtor()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}
	CAcModuleResourceOverride myResources;
	CCirtorDlg cirtorDlg;
	int nRes = cirtorDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XCirtorus cirtor;
		memset(&cirtor,0,sizeof(AecEqui::XCirtorus));
		cirtor.dInr = cirtorDlg.m_dR1;
		cirtor.dOutR = cirtorDlg.m_dR2;
		cirtor.dStaAngle = cirtorDlg.m_dSAngle * PI / 180.0;
		cirtor.dEndAngle = cirtorDlg.m_dEAngle * PI / 180.0;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kCirTorus,&cirtor);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kCirTorus;
		data.m_iClr = cirtorDlg.m_clr;
		data.m_bBoolSubtract = cirtorDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XCIRTORUS>(&data, &cirtor, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMECIT + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_CIT
					,SUB_TREE_CIT
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}		
}

void CEquipmentMakeDlg::OnBnClickedButtonrector()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}
	CAcModuleResourceOverride myResources;
	CRecttorDlg rctorDlg;
	int nRes = rctorDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XRecttorus rctor;
		memset(&rctor,0,sizeof(AecEqui::XRecttorus));
		rctor.dInr = rctorDlg.m_dR1;
		rctor.dOutR = rctorDlg.m_dR2;
		rctor.dStaAngle = rctorDlg.m_dSAngle * PI / 180.0;
		rctor.dEndAngle = rctorDlg.m_dEAngle * PI / 180.0;
		rctor.dH = rctorDlg.m_dH;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kRectTorus,&rctor);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kRectTorus;
		data.m_iClr = rctorDlg.m_clr;
		data.m_bBoolSubtract = rctorDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XRecttorus>(&data, &rctor, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMERCT + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_RCT
					,SUB_TREE_RCT
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}	
}

//接口面
void CEquipmentMakeDlg::OnBnClickedBtactiveinf()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);

	if (items.empty())
	{
		HTREEITEM h = m_wndEquipPrmTree.GetSelectedItem();
		if (h)
			items.push_back(h);
		else
			return;
	}

	if (items.size() != 1) return;

	HTREEITEM hItem = items[0];
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

			AcDbObjectId id(GetEquIDByTree());

			AcAxDocLock lock;
			AcDbEntity* pEnt = NULL;
			AecDbEwEquipment* pWEqt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				pWEqt = AecDbEwEquipment::cast(pEnt);
				if (pWEqt != NULL)
				{
					AecEqui::XPrimData data;
					data.m_nActiveInf = 1;
					pWEqt->ModifyPrimData(dwSubID,data,1,FALSE);
				}
				pEnt->close();
			}
			acedUpdateDisplay();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedBtlocate()
{
	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();

	HTREEITEM hCheck = NULL;
	HTREEITEM hSel = NULL;

	HTREEITEM hChild = m_wndEquipPrmTree.GetChildItem(hRoot);
	while(hChild != NULL)
	{
		DWORD dwSel = m_wndEquipPrmTree.GetItemData(hChild);
		if (dwSel == m_dwIDAgn)
		{
			hCheck = hChild;
		}
		if (dwSel == m_dwIDSel)
		{
			hSel = hChild;
		}
		hChild = m_wndEquipPrmTree.GetNextSiblingItem(hChild);
	}

	if (hSel == NULL || hCheck == NULL)
	{
		AfxMessageBox(_T("没有找到要移动的元素和对齐元素!请确认选择正确!"));
		return;
	}
	if (hSel == hCheck )
	{
		AfxMessageBox(_T("要移动的元素和对齐元素为同一元素!请重新选择!"));
		return;
	}

	if (hSel == hRoot || hCheck == hRoot)
	{
		AfxMessageBox(_T("没有找到要移动的元素和对齐元素!请确认选择正确!"));
		return;
	}

	DWORD_PTR dwSelSubID = m_wndEquipPrmTree.GetItemData(hSel);
	DWORD_PTR dwChkSubID = m_wndEquipPrmTree.GetItemData(hCheck);

	AcDbObjectId id(GetEquIDByTree());

	AcAxDocLock lock;

	AcDbEntity* pEnt = NULL;
	AecDbEwEquipment* pWEqt = NULL;
	if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
	{
		pWEqt = AecDbEwEquipment::cast(pEnt);
		if (pWEqt != NULL)
		{
			AecEqui::XPrimData* pData = NULL;
			pData = pWEqt->GetSUbPrimObjByID(dwChkSubID);

			pWEqt->ModifyPrimData(dwSelSubID,*pData,5,TRUE);
		}
		pEnt->close();
	}
	
	acedUpdateDisplay();
}

//数据更新
void CEquipmentMakeDlg::OnBnClickedBtreset()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
				AecEqui::XPrimData data;
				data.m_vtMove.set(0.0, 0.0, 0.0);
				pWEqt->ModifyPrimData(dwSubID, data, 2, TRUE);
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedBtapply()
{
	UpdateData();

	HTREEITEM hItem = m_wndEquipPrmTree.GetSelectedItem();
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

			AcDbObjectId id(GetEquIDByTree());

			AcAxDocLock lock;

			AcDbEntity* pEnt = NULL;
			AecDbEwEquipment* pWEqt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				pWEqt = AecDbEwEquipment::cast(pEnt);
				if (pWEqt != NULL)
				{
					AecEqui::XPrimData data;
					data.m_vtMove.set(m_dXMove,m_dYMove,m_dZMove);
					pWEqt->ModifyPrimData(dwSubID,data,2);

					if ( fabs(m_dIMove) > 1.e-3)
					{
						data.m_vtMove.set(m_dIMove,0,0);
						pWEqt->ModifyPrimData(dwSubID,data,6);
					}
				}
				pEnt->close();
			}
			acedUpdateDisplay();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonmovex()
{
	UpdateData();
	Impmove(m_dXMove,X,m_dIMove);
}

void CEquipmentMakeDlg::Impmove(double dMove,int nPos,double dIMove)
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);
			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

				AecEqui::XPrimData data;
				data.m_vtMove.set(0.0, 0.0, 0.0);
				data.m_vtMove[nPos] = dMove;

				pWEqt->ModifyPrimData(dwSubID, data, 2);

				if (fabs(dIMove) > 1.e-3)
				{
					data.m_vtMove.set(dIMove, 0, 0);
					pWEqt->ModifyPrimData(dwSubID, data, 6);
				}
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

AcDbObjectId CEquipmentMakeDlg::GetEquIDByTree()
{
	AcDbObjectId id(AcDbObjectId::kNull);
	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	if (!hRoot) return id;

	DWORD_PTR dwXData = m_wndEquipPrmTree.GetItemData(hRoot);
	id.setFromOldId((LONG_PTR)dwXData);
	if (!id.isValid())
	{
		return AcDbObjectId::kNull;
	}
	return id;
}

void CEquipmentMakeDlg::OnBnClickedButtonmovey()
{
	UpdateData();

	Impmove(m_dYMove,Y,m_dIMove);
}

void CEquipmentMakeDlg::OnBnClickedButtonmovez()
{
	UpdateData();

	Impmove(m_dZMove,Z,m_dIMove);
}

void CEquipmentMakeDlg::OnBnClickedButtonmovea()
{
	UpdateData();

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
				AecEqui::XPrimData data;
				if (fabs(m_dIMove) > 1.e-3)
				{
					data.m_vtMove.set(m_dIMove, 0, 0);
					pWEqt->ModifyPrimData(dwSubID, data, 6);
				}
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedBtapply2()
{
	UpdateData();

	HTREEITEM hItem = m_wndEquipPrmTree.GetSelectedItem();
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

			AcDbObjectId id(GetEquIDByTree());

			AcAxDocLock lock;

			AcDbEntity* pEnt = NULL;
			AecDbEwEquipment* pWEqt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				pWEqt = AecDbEwEquipment::cast(pEnt);
				if (pWEqt != NULL)
				{
					m_dXRot *= PI / 180.0;
					m_dYRot *= PI / 180.0;
					m_dZRot *= PI / 180.0;
					m_dIRot *= PI / 180.0;

					AecEqui::XPrimData data;
					data.m_ptRotation.set(m_dXRot,m_dYRot,m_dZRot);
					pWEqt->ModifyPrimData(dwSubID,data,3);

					if ( fabs(m_dIRot) > 1.e-3)
					{
						data.m_ptRotation.set(m_dIRot,0.0,0.0);
						pWEqt->ModifyPrimData(dwSubID,data,7);
					}
				}
				pEnt->close();
			}

			acedUpdateDisplay();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonrotx()
{
	UpdateData();

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		m_dXRot *= PI / 180.0;
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
				AecEqui::XPrimData data;
				data.m_ptRotation.set(m_dXRot, 0.0, 0.0);
				pWEqt->ModifyPrimData(dwSubID, data, 3);
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedBtshowx()
{
	AcAxDocLock lock;
	HTREEITEM hItem = m_wndEquipPrmTree.GetSelectedItem();
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

			AcDbObjectId id(GetEquIDByTree());

			AcDbEntity* pEnt = NULL;
			AecDbEwEquipment* pWEqt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				pWEqt = AecDbEwEquipment::cast(pEnt);
				if (pWEqt != NULL)
				{
					AecEqui::XPrimData data;
					pWEqt->ModifyPrimData(dwSubID,data,10);
				}
				pEnt->close();
			}

			acedUpdateDisplay();
		}
	}	
}

void CEquipmentMakeDlg::OnBnClickedButtonroty()
{
	UpdateData();

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		m_dYRot *= PI / 180.0;
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
				AecEqui::XPrimData data;
				data.m_ptRotation.set(0.0, m_dYRot, 0.0);
				pWEqt->ModifyPrimData(dwSubID, data, 3);
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedBtshowy()
{
	AcAxDocLock lock;
	HTREEITEM hItem = m_wndEquipPrmTree.GetSelectedItem();
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

			AcDbObjectId id(GetEquIDByTree());

			AcDbEntity* pEnt = NULL;
			AecDbEwEquipment* pWEqt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				pWEqt = AecDbEwEquipment::cast(pEnt);
				if (pWEqt != NULL)
				{
					AecEqui::XPrimData data;
					pWEqt->ModifyPrimData(dwSubID,data,11);
				}
				pEnt->close();
			}
			acedUpdateDisplay();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonrotz()
{
	UpdateData();

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		m_dZRot *= PI / 180.0;
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

				AecEqui::XPrimData data;
				data.m_ptRotation.set(0.0, 0.0, m_dZRot);
				pWEqt->ModifyPrimData(dwSubID, data, 3);
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedBtshowz()
{
	AcAxDocLock lock;
	HTREEITEM hItem = m_wndEquipPrmTree.GetSelectedItem();
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

			AcDbObjectId id(GetEquIDByTree());

			AcDbEntity* pEnt = NULL;
			AecDbEwEquipment* pWEqt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				pWEqt = AecDbEwEquipment::cast(pEnt);
				if (pWEqt != NULL)
				{
					AecEqui::XPrimData data;
					pWEqt->ModifyPrimData(dwSubID,data,12);
				}
				pEnt->close();
			}
			acedUpdateDisplay();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonrota()
{
	UpdateData();

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

				m_dIRot *= PI / 180.0;
				AecEqui::XPrimData data;
				if (fabs(m_dIRot) > 1.e-3)
				{
					data.m_ptRotation.set(m_dIRot, 0.0, 0.0);
					pWEqt->ModifyPrimData(dwSubID, data, 7);
				}
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedBtreset2()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

				AecEqui::XPrimData data;
				data.m_ptRotation.set(0.0, 0.0, 0.0);
				pWEqt->ModifyPrimData(dwSubID, data, 3, TRUE);
			}
		}
	}
	OPENOBJ_END()
	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedBtmodiprm()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);

	if (items.empty())
	{
		HTREEITEM h(m_wndEquipPrmTree.GetSelectedItem());
		if (h)
			items.push_back(h);
		else
			return;
	}

	if (items.size() != 1) return;


	HTREEITEM hItem = items[0];
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);
		CString sItem = m_wndEquipPrmTree.GetItemText(hItem);

		DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		AecEqui::XPrimData* pPrimData = NULL;
		AcDbEntity* pEnt = NULL;
		AecDbEwEquipment* pWEqt = NULL;

		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
		{
			if (!pWEqt) return;
			AecDbObjXDataMap* pXDataMap = pWEqt->GetSpecialtyData();
			pPrimData = pWEqt->GetSUbPrimObjByID(dwSubID);

			AcGePoint3d ptIns(AcGePoint3d::kOrigin);
			AcGeVector3d vtDir(AcGeVector3d::kIdentity);
			bool bVert(false);

			pWEqt->GetInsert(ptIns, vtDir);
			bVert = pWEqt->IsVert();

			CAcModuleResourceOverride myResources;
			switch (nImage)
			{
			case SUB_TREE_BOX:
			{
				CBoxDlg boxDlg;
				boxDlg.m_clr = pPrimData->m_iClr;
				boxDlg.m_pData = pPrimData->m_pData;
				if (boxDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = boxDlg.m_clr;
					pPrimData->m_bBoolSubtract = boxDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_CIT:
			{
				CCirtorDlg cirtorDlg;
				cirtorDlg.m_clr = pPrimData->m_iClr;
				cirtorDlg.m_pData = pPrimData->m_pData;
				if (cirtorDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = cirtorDlg.m_clr;
					pPrimData->m_bBoolSubtract = cirtorDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_RCT:
			{
				CRecttorDlg rctorDlg;
				rctorDlg.m_clr = pPrimData->m_iClr;
				rctorDlg.m_pData = pPrimData->m_pData;
				if (rctorDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = rctorDlg.m_clr;
					pPrimData->m_bBoolSubtract = rctorDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_DIS:
			{
				CDishDlg dishDlg;
				dishDlg.m_clr = pPrimData->m_iClr;
				dishDlg.m_pData = pPrimData->m_pData;
				if (dishDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = dishDlg.m_clr;
					pPrimData->m_bBoolSubtract = dishDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_SPE:
			{
				CSpereDlg spereDlg;
				spereDlg.m_clr = pPrimData->m_iClr;
				spereDlg.m_pData = pPrimData->m_pData;
				if (spereDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = spereDlg.m_clr;
					pPrimData->m_bBoolSubtract = spereDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_NOZZ:
			{
				CNozzDlg nozDlg;
				nozDlg.m_clr = pPrimData->m_iClr;
				nozDlg.m_pData = pPrimData->m_pData;
				if (nozDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = nozDlg.m_clr;
					pPrimData->m_bBoolSubtract = false;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_TYDF:
			{
				CTydfDlg tydfDlg;
				tydfDlg.m_clr = pPrimData->m_iClr;
				tydfDlg.m_pData = pPrimData->m_pData;
				if (tydfDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = tydfDlg.m_clr;
					pPrimData->m_bBoolSubtract = tydfDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_CLN:
			{
				CCylinderDlg clnDlg;
				clnDlg.m_clr = pPrimData->m_iClr;
				clnDlg.m_pData = pPrimData->m_pData;
				if (clnDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = clnDlg.m_clr;
					pPrimData->m_bBoolSubtract = clnDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_CON:
			{
				CConeDLg coneDlg;
				coneDlg.m_clr = pPrimData->m_iClr;
				coneDlg.m_pData = pPrimData->m_pData;
				if (coneDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = coneDlg.m_clr;
					pPrimData->m_bBoolSubtract = coneDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_PRM:
			{
				CPyrmDlg coneDlg;
				coneDlg.m_clr = pPrimData->m_iClr;
				coneDlg.m_pData = pPrimData->m_pData;
				if (coneDlg.DoModal() == IDOK)
				{
					pPrimData->m_iClr = coneDlg.m_clr;
					pPrimData->m_bBoolSubtract = coneDlg.m_bSub == FALSE ? false : true;
					pWEqt->clearGeoBuffer();
				}
				break;
			}
			case SUB_TREE_EXTRU:
			{
				if (!::IsWindow(g_equXGExtrud::instance().GetSafeHwnd()))
					g_equXGExtrud::instance().Create(IDD_DTYG_MODIFY_EXTRUD, this);
				if (!g_equXGExtrud::instance().init(pPrimData
					, pWEqt->objectId()
					, m_HligthtID
					, ptIns
					, vtDir
					, bVert ))
				{
					g_equXGExtrud::instance().ShowWindow(SW_HIDE);
					return;
				}
				g_equXGExtrud::instance().CenterWindow();
				g_equXGExtrud::instance().ShowWindow(SW_SHOW);
				break;
			}
			case SUB_TREE_REVOL:
			{
				if (!::IsWindow(g_equXGRevolve::instance().GetSafeHwnd()))
					g_equXGRevolve::instance().Create(IDD_DTYG_MODIFY_DEF, this);
				if (!g_equXGRevolve::instance().init(pPrimData
					, pWEqt->objectId()
					, m_HligthtID
					, ptIns
					, vtDir
					, bVert ))
				{
					g_equXGRevolve::instance().ShowWindow(SW_HIDE);
					return;
				}
				g_equXGRevolve::instance().CenterWindow();
				g_equXGRevolve::instance().ShowWindow(SW_SHOW);
				break;
			}
			case SUB_TREE_SWEEP:
			{
				if (sItem.Find(SUB_NAME_SWEEP_R) != -1)
				{
					AfxMessageBox(_T("从revit导入的扫掠体不能修改！"));
					break;
				}
				if (!::IsWindow(g_equXGSweep::instance().GetSafeHwnd()))
					g_equXGSweep::instance().Create(IDD_DTYG_MODIFY_DEF, this);
				if (!g_equXGSweep::instance().init(pPrimData
					, pWEqt->objectId()
					, m_HligthtID
					, ptIns
					, vtDir
					, bVert ))
				{
					g_equXGSweep::instance().ShowWindow(SW_HIDE);
					return;
				}
				g_equXGSweep::instance().CenterWindow();
				g_equXGSweep::instance().ShowWindow(SW_SHOW);
				break;
			}
			case SUB_TREE_LOFT:
			{
				if (!::IsWindow(g_equXGLoft::instance().GetSafeHwnd()))
					g_equXGLoft::instance().Create(IDD_DTYG_MODIFY_LOFT, this);
				if (!g_equXGLoft::instance().init(pPrimData
					, pWEqt->objectId()
					, m_HligthtID
					, ptIns
					, vtDir
					, bVert ))
				{
					g_equXGLoft::instance().ShowWindow(SW_HIDE);
					return;
				}
				g_equXGLoft::instance().CenterWindow();
				g_equXGLoft::instance().ShowWindow(SW_SHOW);
				break;
			}
			case EQP_TREE_ROOT:
			{
				CString sName = m_wndEquipPrmTree.GetItemText(hRoot);
				if (CoreTools::getNameByDialog(_T("请输入名称"), _T("名称："), sName))
				{
					pXDataMap->SetAt(KEY_NAME, sName);
					m_wndEquipPrmTree.SetItemText(hRoot, sName);
				}
				break;
			}
			case SUB_TREE_RVT_COMBIN:
			{
				AfxMessageBox(_T("从revit导入的组合体不能修改！"));
				break;
			}
			default:
				break;
			}
		}
		OPENOBJ_END()
		acedUpdateDisplay();
	}
}

void CEquipmentMakeDlg::OnBnClickedBtdelprm()
{
	if (!m_MainID.isValid())	// 文档已无效
	{
		AfxMessageBox(_T("当前设备无效！请新建或载入一个新设备。"));
		m_wndEquipPrmTree.DeleteAllItems();
	}

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty())
	{
		HTREEITEM h = m_wndEquipPrmTree.GetSelectedItem();
		if (h)
			items.push_back(h);
		else
			return;
	}

	if (AfxMessageBox(_T("此操作不可恢复，确定删除？"), MB_YESNO) != IDYES)
	{
		return;
	}

	AcAxDocLock lock;
	deleteEntity(m_HligthtID, true);
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);
			if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
			{
				DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
				pWEqt->RemoveSubPrimObjByID(dwSubID);
				m_wndEquipPrmTree.DeleteItem(hItem);
			}
		}
	}
	OPENOBJ_END()
	acedUpdateDisplay();
}

void CEquipmentMakeDlg::OnDestroy()
{
	AcAxDocLock lock;
	deleteEntity(m_HligthtID, true);
	CDialog::OnDestroy();
}

void CEquipmentMakeDlg::OnTvnSelchangedTreeequip(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
	enableMoveRotateUI();
	refreshHlightEntity();
	acedUpdateDisplay();
	*pResult = 0;
}

void CEquipmentMakeDlg::OnBnClickedButtonextru()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	AcAxDocLock lock;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id(GetEquIDByTree());

	if (!id.isValid()) return;

	std::vector<AecEqui::XPrimData> datas;

	CreateExtrude(datas, m_idBuffer);

	if (datas.empty()) return;

	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEw)
	if (pEw)
	{
		for (size_t i(0); i < datas.size(); ++i)
		{
			AecEqui::XPrimData &data(datas[i]);
			pEw->AddSubPrimObj(&data);
			data.releaseData();
			HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMEEXT + getTreeItemSuffix(data.m_bBoolSubtract)
				, SUB_TREE_EXTRU
				, SUB_TREE_EXTRU
				, hRoot);
			m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)data.m_nID);
		}
	}
	OPENOBJ_END()
	m_wndEquipPrmTree.Expand(hRoot, TVE_EXPAND);
	m_wndEquipPrmTree.SelectItem(hRoot);

}

void CEquipmentMakeDlg::OnBnClickedButtonrevo()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	AcAxDocLock lock;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id(GetEquIDByTree());

	if (!id.isValid()) return;

	std::vector<AecEqui::XPrimData> datas;

	CreateRevolve(datas, m_idBuffer);

	if (datas.empty()) return;

	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEw)
	if (pEw)
	{
		for (size_t i(0); i < datas.size(); ++i)
		{
			AecEqui::XPrimData &data(datas[i]);
			pEw->AddSubPrimObj(&data);
			data.releaseData();
			HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMEREV + getTreeItemSuffix(data.m_bBoolSubtract)
				, SUB_TREE_REVOL
				, SUB_TREE_REVOL
				, hRoot);
			m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)data.m_nID);
		}
	}
	OPENOBJ_END()
	m_wndEquipPrmTree.Expand(hRoot, TVE_EXPAND);
	m_wndEquipPrmTree.SelectItem(hRoot);
}

void CEquipmentMakeDlg::OnBnClickedBtundolocate()
{
	AcAxDocLock lock;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	if (hRoot != NULL)
	{
		AcDbObjectId id(GetEquIDByTree());

		Acad::ErrorStatus es;
		AcDbEntity* pEntT = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEntT,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEntT);
			if (pWEqu != NULL)
			{
				AecEqui::XPrimData data;
				HTREEITEM hChild = m_wndEquipPrmTree.GetSelectedItem();
				if (hChild != NULL)
				{
					int nImage = 0,nSelImg = 0;
					m_wndEquipPrmTree.GetItemImage(hChild,nImage,nSelImg);

					if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
					{
						DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hChild);
						pWEqu->ModifyPrimData(dwSubID,data,9,FALSE);
					}
				}
			}
			pEntT->close();
		}
	}
	acedUpdateDisplay();
}

void CEquipmentMakeDlg::OnBnClickedButtonreload()
{
	AcDbDatabase* pDb = acdbCurDwg();
	if (!pDb)
	{
		AfxMessageBox(_T("当前文档无效。"));
		return;
	}

	CAcModuleResourceOverride myResources;
	CEquipmentLibraryDlg dlg(CEquipmentLibraryDlg::eMana);
	if (dlg.DoModal() != IDOK) return;

	AcAxDocLock lock;

	if (m_MainID.isValid())
		deleteEntity(m_MainID);

	if (m_HligthtID.isValid())
		deleteEntity(m_HligthtID);

	m_wndEquipPrmTree.DeleteAllItems();

	if (dlg.m_iSelectFileID == -1)
	{
		AfxMessageBox(_T("未选中任何设备！"));
		return;
	}

	AecDbEwEquipment *pEqu = dlg.getEquipment(dlg.m_iSelectFileID);
	if (!pEqu)
	{
		AfxMessageBox(_T("生成设备失败！"));
		return;
	}
	pEqu->SetInsert(AcGePoint3d::kOrigin, AcGeVector3d::kXAxis);

	m_MainID = CoreTools::AddToModelSpace(pEqu);

	ShowWEquipmentOnTree();
}

void CEquipmentMakeDlg::OnBnClickedBtselasmove()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty())
	{
		HTREEITEM h = m_wndEquipPrmTree.GetSelectedItem();
		if (h)
			items.push_back(h);
		else
			return;
	}
	if (items.size() != 1) return;

	HTREEITEM hItem = items[0];
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			m_dwIDSel = m_wndEquipPrmTree.GetItemData(hItem);
			CString sText;
			sText = m_wndEquipPrmTree.GetItemText(hItem);
			GetDlgItem(IDC_STATICSEL)->SetWindowText(sText);
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedBtselasalign()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty())
	{
		HTREEITEM h = m_wndEquipPrmTree.GetSelectedItem();
		if (h)
			items.push_back(h);
		else
			return;
	}
	if (items.empty()) return;
	HTREEITEM hItem = items[0];
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			m_dwIDAgn = m_wndEquipPrmTree.GetItemData(hItem);	
			CString sText;
			sText = m_wndEquipPrmTree.GetItemText(hItem);
			GetDlgItem(IDC_STATICAGN)->SetWindowText(sText);
		}
	}
}

void CEquipmentMakeDlg::OnStnClickedStaticsel()
{
	if (m_dwIDSel != NULL)
	{
		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		
		HTREEITEM hChild = m_wndEquipPrmTree.GetChildItem(hRoot);
		while(hChild != NULL)
		{
			DWORD dwSel = m_wndEquipPrmTree.GetItemData(hChild);
			if (dwSel == m_dwIDSel)
			{
				m_wndEquipPrmTree.SelectItem(hChild);
				break;
			}
			hChild = m_wndEquipPrmTree.GetNextSiblingItem(hChild);
		}
	}
}

void CEquipmentMakeDlg::OnStnClickedStaticagn()
{
	if (m_dwIDAgn != NULL)
	{
		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();

		HTREEITEM hChild = m_wndEquipPrmTree.GetChildItem(hRoot);
		while(hChild != NULL)
		{
			DWORD dwSel = m_wndEquipPrmTree.GetItemData(hChild);
			if (dwSel == m_dwIDAgn)
			{
				m_wndEquipPrmTree.SelectItem(hChild);
				break;
			}
			hChild = m_wndEquipPrmTree.GetNextSiblingItem(hChild);
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtontydf()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}
	CAcModuleResourceOverride myResources;
	CTydfDlg tydfDlg;
	int nRes = tydfDlg.DoModal();
	if (nRes == IDOK)
	{
		AcGePoint3d ptIns(AcGePoint3d::kOrigin);
		if (!getInsertPt(this, ptIns)) return;

		AecEqui::XTydf tydef;
		tydef.dTR = tydfDlg.m_dR;
		tydef.dTL = tydfDlg.m_dL;
		tydef.dH = tydfDlg.m_dH;
		tydef.dTW = tydfDlg.m_dW;
		tydef.dXOffset = tydfDlg.m_dXOffset;

// 		AecDb3dSolid* pSolid = new AecDb3dSolid;
// 		pSolid->SetData(AecEqui::kTydf,&tydef);
		AecEqui::XPrimData data;
		data.m_eType = AecEqui::kTydf;
		data.m_iClr = tydfDlg.m_clr;
		data.m_bBoolSubtract = tydfDlg.m_bSub == FALSE ? false : true;
		data.m_vtMove = ptIns.asVector();
		setData<AecEqui::XTydf>(&data, &tydef, m_idBuffer);

		HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		Acad::ErrorStatus es;
		AcDbEntity* pEnt = NULL;
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				pWEqu->AddSubPrimObj(&data);
				data.releaseData();

				HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMETYDF + getTreeItemSuffix(data.m_bBoolSubtract)
					,SUB_TREE_TYDF
					,SUB_TREE_TYDF
					,hRoot);
				m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
				m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
				m_wndEquipPrmTree.SelectItem(hItem);
			}
			pEnt->close();
		}
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonhidearo()
{
	AcDbObjectId id(GetEquIDByTree());

	AcAxDocLock lock;

	Acad::ErrorStatus es;
	AcDbEntity* pEnt = NULL;
	if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
	{
		AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
		if (pWEqu != NULL)
		{
			AecEqui::XPrimData data;
			pWEqu->ModifyPrimData(0,data,10);
		}
		pEnt->recordGraphicsModified();
		pEnt->close();
	}
	acedUpdateDisplay();
}

bool CEquipmentMakeDlg::PickHitPoint(DWORD dwSubiD,AcGeVector3d& vtMove,AcGeVector3d& vtDir)
{
	bool bGet = false;
	ads_point pt,pt2,pt3;
	int nRes = acedGetPoint(NULL, _T("\n请在设备需要加管嘴的地方选一点:"), pt);
	if (nRes == RTNORM)
	{
		acdbUcs2Wcs(pt, pt2, false);

		vtMove = asVec3d(pt2);
		bGet = true;

		acedInitGet(RSG_OTHER, _T("X Y Z A B C"));
		nRes = acedGetPoint(pt, _T("\n请选择管嘴方向(X/Y/Z/-X:A/-Y:B/-Z:C):"), pt3);
		switch (nRes)
		{
			case RTNORM:
			{
				vtDir = asPnt3d(pt3) - asPnt3d(pt);
				vtDir.normalize();
				break;
			}
			case RTKWORD:
			{
				TCHAR szKey[6];
				szKey[0] = '0';
				acedGetInput(szKey);

				switch (szKey[0])
				{
					case _T('X'):
					{
						vtDir.set(1, 0, 0);
						break;
					}
					case _T('Y'):
					{
						vtDir.set(0, 1, 0);
						break;
					}
					case _T('Z'):
					{
						vtDir.set(0, 0, 1);
						break;
					}
					case _T('A'):
					{
						vtDir.set(-1, 0, 0);
						break;
					}
					case _T('B'):
					{
						vtDir.set(0, -1, 0);
						break;
					}
					case _T('C'):
					{
						vtDir.set(0, 0, -1);
						break;
					}
					default:
						break;
				}
			}
			default:
				break;
		}
		//精确的做法 每个单元创建为body,然后使用body::closestPointOnBody 定位
	}
	return bGet;
}

void CEquipmentMakeDlg::OnBnClickedButtonaddnoz()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.size() != 1) return;

	HTREEITEM hItem = items[0];
	if (hItem != NULL)
	{
		int nImage = 0,nSelImg = 0;
		m_wndEquipPrmTree.GetItemImage(hItem,nImage,nSelImg);
		DWORD dwSubiD = m_wndEquipPrmTree.GetItemData(hItem);

		if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
		{
			AcGeVector3d vtDir(0,0,0);
			AcGePoint3d ptGe(0,0,0);

			AcDbObjectId id(GetEquIDByTree());

			AcAxDocLock lock;

			Acad::ErrorStatus es;
			AcDbEntity* pEnt = NULL;
			if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead) ) )
			{
				AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
				if (pWEqu != NULL)
				{
					AecEqui::XPrimData* pPrimData = pWEqu->GetSUbPrimObjByID(dwSubiD);
					if (pPrimData->m_nActiveInf == -1)
					{
						pEnt->close();
						//AfxMessageBox(_T("选择的元素的接口面方向没有激活!请拾取点加gui'z!"));
					}
					//得到当前的接口位置和方向
					pWEqu->GetInfFaceInf(pPrimData,vtDir,ptGe);
				}
				pEnt->close();
			}

			AcGeVector3d vtMove;
			if (vtDir.isZeroLength())
			{
				if (!PickHitPoint(dwSubiD,vtMove,vtDir))
				{
					return;
				}
				vtDir.negate();
				ptGe.set(vtMove.x, vtMove.y, vtMove.z);
			}

			//方口,圆口
			CAcModuleResourceOverride myResources;
			CNozzDlg dlg;
			int nRes = dlg.DoModal();
			if (nRes == IDOK)
			{
				AecEqui::XNozz* pNozzData = dlg.GetNozzData();
				AddNozz(dwSubiD, vtDir,ptGe,pNozzData, dlg.m_clr);
			}
		}
	}
}

void CEquipmentMakeDlg::AddNozz(DWORD dwSubiD, AcGeVector3d& vtDir, AcGePoint3d& ptGe, AecEqui::XNozz* pNozzData, const int &clr)
{
	AecEqui::XPrimData data;
	data.m_eType = AecEqui::kNozz;
	data.m_iClr = clr;
	setData<AecEqui::XNozz>(&data, pNozzData, m_idBuffer);
	data.m_nActiveInf = 0;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id(GetEquIDByTree());

	AcAxDocLock lock;

	Acad::ErrorStatus es;
	AcDbEntity* pEnt = NULL;
	if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
	{
		AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
		if (pWEqu != NULL)
		{
			CoreTools::addNozzForEqu(pWEqu, vtDir, ptGe, data);

			HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAMENOZZ + getTreeItemSuffix(data.m_bBoolSubtract)
				,SUB_TREE_NOZZ
				,SUB_TREE_NOZZ
				,hRoot);
			m_wndEquipPrmTree.SetItemData(hItem,(DWORD_PTR)data.m_nID);
			m_wndEquipPrmTree.Expand(hRoot,TVE_EXPAND);
			m_wndEquipPrmTree.SelectItem(hItem);
		}
		pEnt->close();
	}
}

void CEquipmentMakeDlg::OnBnClickedButtonsavefile()
{
	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	if (hRoot == NULL)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据保存!"));
		return;
	}

	//先关闭箭头
	OnBnClickedButtonhidearo();

	if (!acDocManager->curDocument()) return;

	AcAxDocLock lock;

	const TCHAR *pszDwgFile = acDocManager->curDocument()->fileName();
	CString sEquFile = pszDwgFile;
	CString sFaceDwg = pszDwgFile;
	sEquFile.MakeLower();
	sEquFile.Replace(_T(".dwg"), _T(".equ"));

	CFileDialog dlg(FALSE, NULL, (LPCTSTR)sEquFile, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
		_T("通用设备元件设计文件(*.equ)|*.equ|All Files (*.*)|*.*||"));

	int nRes = dlg.DoModal();
	if (nRes == IDOK)
	{
		sEquFile = dlg.GetPathName();

		//保存
		SaveEquipFile(sEquFile);

		AfxMessageBox(_T("成功保存设备元件定义数据到本地文件!"));
	}
}

BOOL CEquipmentMakeDlg::SaveEquipFile(LPCTSTR pszFile)
{
	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	if (hRoot == NULL)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据保存!"));
		return FALSE;
	}

	AcDbObjectId id(GetEquIDByTree());
	DWORD_PTR dwXData = m_wndEquipPrmTree.GetItemData(hRoot);
	if (dwXData == 0)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据保存!"));
		return FALSE;
	}

	CString sText = m_wndEquipPrmTree.GetItemText(hRoot);

	return CoreTools::equipment2File(id, pszFile, sText) ? TRUE : FALSE;
}

void CEquipmentMakeDlg::OnBnClickedButtonopen()
{
	AcDbDatabase* pDb = acdbCurDwg();
	if (!pDb)
	{
		AfxMessageBox(_T("当前文档无效。"));
		return;
	}
	
	CFileDialog dlg( TRUE, NULL,NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
					_T("通用设备元件设计文件(*.equ)|*.equ|All Files (*.*)|*.*||"));
	if (dlg.DoModal() != IDOK) return;

	AcAxDocLock lock;

	if (m_MainID.isValid())
		deleteEntity(m_MainID);

	if (m_HligthtID.isValid())
		deleteEntity(m_HligthtID);

	m_wndEquipPrmTree.DeleteAllItems();


	AecDbEwEquipment *pEw = new AecDbEwEquipment();
	if (!CoreTools::file2Equipment(pEw, dlg.GetPathName(), &m_sName)) return;

	m_MainID = CoreTools::AddToModelSpace(pEw);
	
	ShowWEquipmentOnTree();
}

void CEquipmentMakeDlg::OnBnClickedButtonLoadDWG()
{
	ShowWindow(SW_HIDE);
	//选择
	struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWEQUIPMENT"), 0);
	ads_name ssSet,adsEnt;
	int nRes = acedSSGet(_T(":S"),NULL,NULL,pRb, ssSet);
	acutRelRb(pRb);
	if (nRes == RTNORM)
	{
		Adesk::Int32 lLen = 0;
		acedSSLength(ssSet, &lLen);
		if (lLen == 0)
		{
			acedAlert(_T("没有选择到设备!"));
			ShowWindow(SW_SHOW);
			return;
		}

		acedSSName(ssSet, 0, adsEnt);
		acedSSFree(ssSet);
		
		AcDbObjectId id;
		acdbGetObjectId(id,adsEnt);

		if (m_MainID.isValid())
			deleteEntity(m_MainID);

		if (m_HligthtID.isValid())
			deleteEntity(m_HligthtID);

		m_wndEquipPrmTree.DeleteAllItems();

		m_HligthtID.setNull();
		m_MainID = id;
		ShowWEquipmentOnTree();
	}
	ShowWindow(SW_SHOW);
}

void CEquipmentMakeDlg::OnBnClickedButtonuserdata()
{
	CAcModuleResourceOverride myResources;

	CMapStringToString mapData;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	if (hRoot == NULL)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据!"));
		return;
	}
	AcDbObjectId id(GetEquIDByTree());
	DWORD_PTR dwXData = m_wndEquipPrmTree.GetItemData(hRoot);
	if (dwXData == 0)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据!"));
		return;
	}

	AcAxDocLock lock;

	SH_BIM_BLOCK bims;
	Acad::ErrorStatus es;
	AcDbEntity* pEnt = NULL;
	if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead) ) )
	{
		AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
		if (pWEqu != NULL)
		{
			CoreTools::getBimDatas(pWEqu, bims);
		}
		pEnt->close();
	}

	CUserDataDlg userDlg(1);
	userDlg.SetUserData(bims);
	int nRes = userDlg.DoModal();
	if (nRes == IDOK)
	{
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite) ) )
		{
			AecDbEwEquipment* pWEqu = AecDbEwEquipment::cast(pEnt);
			if (pWEqu != NULL)
			{
				userDlg.GetUserData(bims);
				CoreTools::setBimDatas(pWEqu, bims);
			}
			pEnt->close();
		}
	}
}

void CEquipmentMakeDlg::OnNMRclickTreeequip(NMHDR *pNMHDR, LRESULT *pResult)
{
	CPoint point,ptcursor;
	::GetCursorPos(&point);
	ptcursor = point;
	m_wndEquipPrmTree.ScreenToClient(&point);

	UINT uFlags;
	HTREEITEM hItem = m_wndEquipPrmTree.HitTest(point,&uFlags);
	if(hItem != NULL)
	{
		m_wndEquipPrmTree.SelectItem(hItem);
		DoPopularMenu(hItem,ptcursor);
	}
	*pResult = 0;
}

void CEquipmentMakeDlg::DoPopularMenu(HTREEITEM hItem,CPoint point)
{
	CAcModuleResourceOverride myResources;
	CMenu menu;
	menu.CreatePopupMenu();

	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_MODIFY,	_T("修改(&M)"));

	int nImage = 0, nSelImg = 0;
	m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED, ID_COLOR, _T("颜色(&C)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_DELETE,	_T("删除(&D)"));
	menu.AppendMenu(MF_SEPARATOR);

	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_SELINFFACE,_T("选择当前接口面(&I)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_SHOWHIDEAR,_T("关闭接口面箭头(&H)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_ADDNOZZ,	_T("添加管觜(&N)"));
	menu.AppendMenu(MF_SEPARATOR);

	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_SELASMOVE,	_T("选为移动元素(&S)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_SELASALGN,	_T("选为对齐元素(&A)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_ELPOSTOINF,_T("元素定位到接口面(&T)"));
	menu.AppendMenu(MF_SEPARATOR);

	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_SAVELOCAL,	_T("保存本地(&L)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_SAVETODB,	_T("入库(&Q)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED,ID_MODIFY_NAME,	_T("改名(&E)"));

	int nID = menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, point.x, point.y,this);
	switch (nID)
	{
	case ID_COLOR:
	{
		modifyColor();
		break;
	}
	case ID_MODIFY:
	{
		OnBnClickedBtmodiprm();
		break;
	}
	case ID_DELETE:
	{
		OnBnClickedBtdelprm();
		break;
	}
	case ID_SELINFFACE:
	{
		OnBnClickedBtactiveinf();
		break;
	}
	case ID_SHOWHIDEAR:
	{
		OnBnClickedButtonhidearo();
		break;
	}
	case ID_ADDNOZZ:
	{
		OnBnClickedButtonaddnoz();
		break;
	}
	case ID_SELASMOVE:
	{
		OnBnClickedBtselasmove();
		break;
	}
	case ID_SELASALGN:
	{
		OnBnClickedBtselasalign();
		break;
	}
	case ID_ELPOSTOINF:
	{
		OnBnClickedBtlocate();
		break;
	}
	case ID_SAVELOCAL:
	{
		OnBnClickedButtonsavefile();
		break;
	}
	case ID_SAVETODB:
	{
		OnBnClickedOk();
		break;
	}
	case ID_MODIFY_NAME:
	{
		OnBnClickedButtonname();
		break;
	}
	default:
		break;
	}
}

BOOL CEquipmentMakeDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{

#if ARX > 19
	struct resbuf rb;
	acedGetVar(_T("CMDNAMES"), &rb);
	if (rb.restype == RTSTR && rb.resval.rstring != NULL)
	{
		if (_tcslen(rb.resval.rstring) > 0)
		{
			CString sCmd(rb.resval.rstring);
			sCmd.MakeLower();
			if (sCmd.Find(_T("3dforbit")) != -1)
			{
				CoreTools::sendKeyToCADView(VK_ESCAPE);
				return TRUE;
			}
		}
	}
#endif

	switch (LOWORD(wParam))
	{
	case IDOK:
		return TRUE;
	default:
		break;
	}
	return CDialog::OnCommand(wParam, lParam);
}

void CEquipmentMakeDlg::OnNMDblclkTreeequip(NMHDR *pNMHDR, LRESULT *pResult)
{
	OnBnClickedBtmodiprm();
	*pResult = 0;
}

//发布
void CEquipmentMakeDlg::OnBnClickedButtonpublic()
{
	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	if (hRoot == NULL)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据保存!"));
		return;
	}
}

void CEquipmentMakeDlg::OnBnClickedSavetodb()
{
	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	if (hRoot == NULL)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据保存!"));
		return;
	}

	DWORD_PTR dwXData = m_wndEquipPrmTree.GetItemData(hRoot);
	if (dwXData == 0)
	{
		AfxMessageBox(_T("当前没有设备元件设计数据保存!"));
		return;
	}

	int nRes = AfxMessageBox(_T("确认设备安装对称点是原点吗?"),MB_YESNO);
	if (nRes == IDNO)
	{
		return;
	}

	CString sEquName = m_wndEquipPrmTree.GetItemText(hRoot);
	if (CEquipmentLibraryDlg::saveEquToDb(GetEquIDByTree(), sEquName))
		AfxMessageBox(_T("设备入库成功！"));
	else
		AfxMessageBox(_T("设备入库失败！"));
}

void CEquipmentMakeDlg::OnBnClickedButtonRvt()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id(GetEquIDByTree());

	AcAxDocLock lock;

	CAcModuleResourceOverride myResources;
	CFileDialog dlg(TRUE
		, _T("r2p")
		, NULL
		, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT
		, _T("r2p (*.r2p)|*.r2p||"));
	if (dlg.DoModal() != IDOK) return;

	std::wstring json;
	ParseRevitFamily::parseFile2String(dlg.GetPathName(), json);
	if (json.empty()) return;


	SH_BIM_BLOCK bims;
	ParseRevitFamily::parseBimDatas(json, bims);

	CPtrArray ar;
	ParseRevitFamily::parseJson(json, ar);

	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEw)
	if (pEw)
	{
		CString sKeyName(_T("未知"));
		for (int i(0); i < ar.GetCount(); ++i)
		{
			AecEqui::XPrimData *pX((AecEqui::XPrimData*)ar[i]);
			pEw->AddSubPrimObj(pX);
			pX->releaseData();

			int ico(0);
			switch (pX->m_eType)
			{
			case AecEqui::kNewExtrude:
			{
				sKeyName = _T("拉伸体");
				ico = SUB_TREE_EXTRU;
				break;
			}
			case AecEqui::kNewRevolve:
			{
				sKeyName = _T("旋转体");
				ico = SUB_TREE_REVOL;
				break;
			}
			case AecEqui::kRevitSweep:
			{
				sKeyName = _T("扫掠体R");
				ico = SUB_TREE_SWEEP;
				break;
			}
			case AecEqui::kNewLoft:
			{
				sKeyName = _T("放样体");
				ico = SUB_TREE_LOFT;
				break;
			}
			case AecEqui::kRevitCombination:
			{
				sKeyName = _T("组合体R");
				ico = SUB_TREE_RVT_COMBIN;
				break;
			}
			case AecEqui::kNozz:
			{
				sKeyName = _T("管嘴");
				ico = SUB_TREE_NOZZ;
				break;
			}
			default:
				sKeyName = _T("未知实体");
				break;
			}
			if (pX->m_bBoolSubtract)
				sKeyName += _T("(-)");
			else
				sKeyName += _T("(+)");
			HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(sKeyName, ico, ico, hRoot);
			if (hItem)
				m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)pX->m_nID);
			DELETE_PTR(pX);
		}
		ar.RemoveAll();
		CoreTools::setBimDatas(pEw, bims);
		m_wndEquipPrmTree.Expand(hRoot, TVE_EXPAND);
	}
	OPENOBJ_END()
}

void CEquipmentMakeDlg::OnBnClickedButtonSweep()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	AcAxDocLock lock;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id(GetEquIDByTree());

	if (!id.isValid()) return;

	std::vector<AecEqui::XPrimData> datas;

	CreateSweep(datas, m_idBuffer);

	if (datas.empty()) return;

	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEw)
	if (pEw)
	{
		for (size_t i(0); i < datas.size(); ++i)
		{
			AecEqui::XPrimData &data(datas[i]);
			pEw->AddSubPrimObj(&data);
			data.releaseData();
			HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAME_NEWSWEEP + getTreeItemSuffix(data.m_bBoolSubtract)
				, SUB_TREE_SWEEP
				, SUB_TREE_SWEEP
				, hRoot);
			m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)data.m_nID);
		}
	}
	OPENOBJ_END()
		m_wndEquipPrmTree.Expand(hRoot, TVE_EXPAND);
	m_wndEquipPrmTree.SelectItem(hRoot);
}

void CEquipmentMakeDlg::OnBnClickedButtonLoft()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	AcAxDocLock lock;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id(GetEquIDByTree());

	if (!id.isValid()) return;

	AecEqui::XPrimData data;

	data.m_eType = AecEqui::kUnknownPrim;
	CreateLoft(data, m_idBuffer);

	if (data.m_eType == AecEqui::kUnknownPrim)
		return;


	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEw)
	if (pEw)
	{
		pEw->AddSubPrimObj(&data);
		data.releaseData();
		HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(SUB_NAME_NEWLOFT + getTreeItemSuffix(data.m_bBoolSubtract)
			, SUB_TREE_LOFT
			, SUB_TREE_LOFT
			, hRoot);
		m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)data.m_nID);
	}
	OPENOBJ_END()
	m_wndEquipPrmTree.Expand(hRoot, TVE_EXPAND);
	m_wndEquipPrmTree.SelectItem(hRoot);
}

void CEquipmentMakeDlg::OnBnClickedBtshowx2()
{
	OnBnClickedBtshowx();
}

void CEquipmentMakeDlg::OnBnClickedBtshowy2()
{
	OnBnClickedBtshowy();
}

void CEquipmentMakeDlg::OnBnClickedBtshowz2()
{
	OnBnClickedBtshowz();
}

void CEquipmentMakeDlg::OnClose()
{
	// 如果 m_idSolidTemp 有效，则说明在 选择平面状态
	if (m_idSolidTemp.isValid()) return;
	AcAxDocLock lock;
	deleteEntity(m_HligthtID, true);
	m_MainID = AcDbObjectId::kNull;
	m_wndEquipPrmTree.DeleteAllItems();
	this->ShowWindow(SW_HIDE);
}

void CEquipmentMakeDlg::OnBnClickedButtonMovePoint()
{
	ads_point pt1,pt2;
	int nRes = acedGetPoint(NULL,_T("\n请选择基点:"),pt1);
	if (nRes == RTNORM)
	{
		acutPrintf(_T("\n基点(%.3f, %.3f, %.3f)"), pt1[0], pt1[1], pt1[2]);
		nRes = acedGetPoint(pt1,_T("\n请选择目标点:"),pt2);
		if (nRes == RTNORM)
		{
			acutPrintf(_T("\n目标点(%.3f, %.3f, %.3f)"), pt2[0], pt2[1], pt2[2]);
			//注造族没有用户坐标系
			AcGeVector3d vtMove = asPnt3d(pt2) - asPnt3d(pt1);

			Impmove(vtMove.x,X,0.0);
			Impmove(vtMove.y,Y,0.0);
			Impmove(vtMove.z,Z,0.0);
		}
	}
}

void CEquipmentMakeDlg::enableWindows(bool bEnble, const std::set<int> &exceptions)
{
	CWnd *pWnd(this);

	int nCtrlID(-1);
	CWnd *pChildWnd = pWnd->GetWindow(GW_CHILD);
	while (pChildWnd != NULL)
	{
		nCtrlID = pChildWnd->GetDlgCtrlID();
		if (exceptions.find(nCtrlID) == exceptions.end())
		{
			pChildWnd->EnableWindow(bEnble);
		}
		else
		{
			pChildWnd->EnableWindow(!bEnble);
		}
		pChildWnd = pChildWnd->GetWindow(GW_HWNDNEXT);
	}

	enableMoveRotateUI();
}

void CEquipmentMakeDlg::enableMoveRotateUI()
{
	return;
	HTREEITEM hItem = m_wndEquipPrmTree.GetSelectedItem();
	int nImage = 0, nSelImg = 0;
	m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

	bool bEnable(true);
	if (nImage == SUB_TREE_EXTRU
		|| nImage == SUB_TREE_REVOL
		|| nImage == SUB_TREE_SWEEP
		|| nImage == SUB_TREE_LOFT)
		bEnable = false;

	CWnd *pWnd(NULL);
	pWnd = GetDlgItem(IDC_EDITXMOVE);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_EDITYMOVE);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_EDITZMOVE);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_EDITIMOVE);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONMOVEX);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONMOVEY);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONMOVEZ);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONMOVEA);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONMOVEPOINT);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTSHOWX2);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTSHOWY2);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTSHOWZ2);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTRESET);
	if (pWnd) pWnd->EnableWindow(bEnable);

	pWnd = GetDlgItem(IDC_EDITXROT);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_EDITYROT);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_EDITZROT);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_EDITIROT);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONROTX);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONROTY);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONROTZ);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BUTTONROTA);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTSHOWX);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTSHOWY);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTSHOWZ);
	if (pWnd) pWnd->EnableWindow(bEnable);
	pWnd = GetDlgItem(IDC_BTRESET2);
	if (pWnd) pWnd->EnableWindow(bEnable);
}

void CEquipmentMakeDlg::showEntity(bool bShow)
{
	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id(GetEquIDByTree());

	if (!id.isValid()) return;

	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEw)
		if (pEw) pEw->setVisibility(bShow ? AcDb::kVisible : AcDb::kInvisible);
	OPENOBJ_END()
}

void CEquipmentMakeDlg::refreshHlightEntity()
{
	HTREEITEM hItem = m_wndEquipPrmTree.GetSelectedItem();
	if (!hItem) return;

	if (m_HligthtID.isValid())
	{
		deleteEntity(m_HligthtID, true);
	}

	int nImage = 0, nSelImg = 0;
	m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);

	if (nImage >= SUB_TREE_BOX && nImage < EQP_TREE_ROOT)
	{
		DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);

		AcDbObjectId id(GetEquIDByTree());

		AcAxDocLock lock;

		AcDbEntity* pEnt = NULL;
		AecDbEwEquipment* pWEqt = NULL;
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
		if (pWEqt != NULL)
		{
			AecEqui::XPrimData *pData = pWEqt->GetSUbPrimObjByID(dwSubID);
			AcGePoint3d ptIns;
			AcGeVector3d vtDir;
			pWEqt->GetInsert(ptIns, vtDir);
			if (pData)
			{
				AcDb3dSolid *pSolid = pWEqt->Draw3dSolid(pData, ptIns, vtDir);
				if (pSolid)
				{
					double v;
					AcGePoint3d ptC(AcGePoint3d::kOrigin);
					double ds[3];
					AcGeVector3d vts[3];
					AcDbExtents ext;
					pSolid->getMassProp(v, ptC, ds, ds, ds, vts, ds, ext);
					AcGeMatrix3d mat;
					mat.setToScaling(1.01, ptC);
					pSolid->transformBy(mat);

					pSolid->setColorIndex(6);
					CoreTools::AddToModelSpace(pSolid, NULL, true, &m_HligthtID);
					acedUpdateDisplay();
				}
			}
		}
		OPENOBJ_END()
	}
}

bool CEquipmentMakeDlg::getSelectItems(std::vector<HTREEITEM>& items)
{
	::getSelectItems(m_wndEquipPrmTree, m_wndEquipPrmTree.GetRootItem(), items);
	return !items.empty();
}

void CEquipmentMakeDlg::OnBnClickedButtonStart()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();

	CheckChildItem(m_wndEquipPrmTree, hRoot, false);

	AcDbObjectId id(GetEquIDByTree());

	if (!id.isValid()) return;

	AcAxDocLock lock;
	std::set<int> exp;
	exp.insert(IDC_BUTTON_NEXT);
	exp.insert(IDC_BUTTON_PREV);
	exp.insert(IDC_BUTTON_END);
	enableWindows(false, exp);

#ifdef ZWCAD
	acedPostCommand(_T("_SHADEMODE _2D "));
#else
	acedPostCommand(_T("_vscurrent 2 "));
#endif

	do
	{
		AcDb3dSolid *pSolid = BrepOper::get3DSolidBySH(id);
		if (!pSolid) break;
		pSolid->setTransparency(.7);
		CoreTools::AddToModelSpace(pSolid, NULL, true, &m_idSolidTemp);
		if (!m_idSolidTemp.isValid())
		{
			DELETE_PTR(pSolid);
			break;
		}

		m_SolidSubentIds.clear();
		m_SolidGeFaces.removeAll();

		AcArray<AcDbSubentId> subids;
		BrepOper::getSubPathBySolid(m_idSolidTemp, subids, m_SolidGeFaces);
		for (int i(0); i < subids.length(); ++i)
		{
			m_SolidSubentIds.insert(std::make_pair(subids[i], 256));
		}

		if (m_SolidSubentIds.empty() || m_SolidGeFaces.isEmpty()) break;

		m_iFaceIdx = 0;

		showEntity(false);

		if (!setFaceClr(m_idSolidTemp, m_SolidSubentIds, m_iFaceIdx, 1)) break;

		return;
	} while (true);

	OPENOBJ_BEGIN(m_idSolidTemp, AcDb::kForWrite, AcDb3dSolid, pSolid)
	if (pSolid)
		pSolid->erase();
	OPENOBJ_END()

	showEntity(true);

	m_idSolidTemp = AcDbObjectId::kNull;
	m_iFaceIdx = 0;
	m_SolidSubentIds.clear();
	m_SolidGeFaces.removeAll();

	AfxMessageBox(_T("提取3dSolid失败！"));
	exp.clear();
	exp.insert(IDC_BUTTON_NEXT);
	exp.insert(IDC_BUTTON_PREV);
	exp.insert(IDC_BUTTON_END);
	enableWindows(true, exp);
}

void CEquipmentMakeDlg::OnBnClickedButtonNext()
{
	// TODO: Add your control notification handler code here
	AcAxDocLock lock;
	if (++m_iFaceIdx >= m_SolidSubentIds.size()) m_iFaceIdx = 0;
	setFaceClr(m_idSolidTemp, m_SolidSubentIds, m_iFaceIdx, 1);
}

void CEquipmentMakeDlg::OnBnClickedButtonPrev()
{
	// TODO: Add your control notification handler code here
	AcAxDocLock lock;
	if (--m_iFaceIdx < 0) m_iFaceIdx = m_SolidSubentIds.size() - 1;
	setFaceClr(m_idSolidTemp, m_SolidSubentIds, m_iFaceIdx, 1);
}

void CEquipmentMakeDlg::OnBnClickedButtonEnd()
{
	AcAxDocLock lock;

	std::set<int> exp;
	exp.insert(IDC_BUTTON_NEXT);
	exp.insert(IDC_BUTTON_PREV);
	exp.insert(IDC_BUTTON_END);
	enableWindows(true, exp);

	OPENOBJ_BEGIN(m_idSolidTemp, AcDb::kForWrite, AcDb3dSolid, pSolid)
		if (pSolid) pSolid->erase();
	OPENOBJ_END()

		showEntity(true);

	if (m_iFaceIdx < m_SolidGeFaces.length())
	{
		BrepOper::setUCS(m_SolidGeFaces[m_iFaceIdx], false);
		//acedPostCommand(_T("plan c "));
	}

	m_idSolidTemp = AcDbObjectId::kNull;
	m_SolidSubentIds.clear();
	m_SolidGeFaces.removeAll();
	m_iFaceIdx = 0;
}

void CEquipmentMakeDlg::OnBnClickedButtonsave()
{
	// TODO: Add your control notification handler code here
}

LRESULT CEquipmentMakeDlg::OnRefreshHlightEntityMsg(WPARAM, LPARAM)
{
	refreshHlightEntity();
	return 0;
}

void CEquipmentMakeDlg::OnNMClickTreeequip(NMHDR *pNMHDR, LRESULT *pResult)
{
	CPoint point;
	::GetCursorPos(&point);
	m_wndEquipPrmTree.ScreenToClient(&point);

	UINT uFlags;

	HTREEITEM hItem = m_wndEquipPrmTree.HitTest(point, &uFlags), hP(NULL);
	if (hItem == NULL) return;
	// 判断 uFlags
	if (uFlags == TVHT_ONITEMSTATEICON)	// check框
	{
		CheckChildItem(m_wndEquipPrmTree, hItem, !m_wndEquipPrmTree.GetCheck(hItem));
	}
	m_wndEquipPrmTree.SelectItem(hItem);
	*pResult = 0;
}

#define ENABLE_BUTTON(id, empty) pWnd = GetDlgItem(id);\
	if (pWnd) pWnd->EnableWindow(empty ? FALSE : TRUE)
LRESULT CEquipmentMakeDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	if (message == WM_IDLEUPDATECMDUI)
	{
		std::vector<HTREEITEM> items;
		::getSelectItems(m_wndEquipPrmTree, m_wndEquipPrmTree.GetRootItem(), items);
		bool empty(items.empty());
		CWnd *pWnd(NULL);

		if (items.size() == 1)
		{
			ENABLE_BUTTON(IDC_BTMODIPRM, false);
			ENABLE_BUTTON(IDC_BTSELASMOVE, false);
			ENABLE_BUTTON(IDC_BTSELASALIGN, false);
			ENABLE_BUTTON(IDC_BTACTIVEINF, false);
			ENABLE_BUTTON(IDC_BUTTONADDNOZ, false);
			ENABLE_BUTTON(IDC_BTSHOWX2, false);
			ENABLE_BUTTON(IDC_BTSHOWY2, false);
			ENABLE_BUTTON(IDC_BTSHOWZ2, false);
			ENABLE_BUTTON(IDC_BTSHOWX, false);
			ENABLE_BUTTON(IDC_BTSHOWY, false);
			ENABLE_BUTTON(IDC_BTSHOWZ, false);
		}
		else
		{
			ENABLE_BUTTON(IDC_BTMODIPRM, true);
			ENABLE_BUTTON(IDC_BTSELASMOVE, true);
			ENABLE_BUTTON(IDC_BTSELASALIGN, true);
			ENABLE_BUTTON(IDC_BTACTIVEINF, true);
			ENABLE_BUTTON(IDC_BUTTONADDNOZ, true);
			ENABLE_BUTTON(IDC_BTSHOWX2, true);
			ENABLE_BUTTON(IDC_BTSHOWY2, true);
			ENABLE_BUTTON(IDC_BTSHOWZ2, true);
			ENABLE_BUTTON(IDC_BTSHOWX, true);
			ENABLE_BUTTON(IDC_BTSHOWY, true);
			ENABLE_BUTTON(IDC_BTSHOWZ, true);
		}

		ENABLE_BUTTON(IDC_BUTTONMIRR, empty);
		ENABLE_BUTTON(IDC_BUTTONCOPY, empty);

		ENABLE_BUTTON(IDC_BTDELPRM, empty);
		ENABLE_BUTTON(IDC_EDITXMOVE, empty);
		ENABLE_BUTTON(IDC_EDITYMOVE, empty);
		ENABLE_BUTTON(IDC_EDITZMOVE, empty);
		ENABLE_BUTTON(IDC_EDITIMOVE, empty);
		ENABLE_BUTTON(IDC_BUTTONMOVEX, empty);
		ENABLE_BUTTON(IDC_BUTTONMOVEY, empty);
		ENABLE_BUTTON(IDC_BUTTONMOVEZ, empty);
		ENABLE_BUTTON(IDC_BUTTONMOVEA, empty);
		ENABLE_BUTTON(IDC_BUTTONMOVEPOINT, empty);
		ENABLE_BUTTON(IDC_BTRESET, empty);

		ENABLE_BUTTON(IDC_EDITXROT, empty);
		ENABLE_BUTTON(IDC_EDITYROT, empty);
		ENABLE_BUTTON(IDC_EDITZROT, empty);
		ENABLE_BUTTON(IDC_EDITIROT, empty);
		ENABLE_BUTTON(IDC_BUTTONROTX, empty);
		ENABLE_BUTTON(IDC_BUTTONROTY, empty);
		ENABLE_BUTTON(IDC_BUTTONROTZ, empty);
		ENABLE_BUTTON(IDC_BUTTONROTA, empty);
		ENABLE_BUTTON(IDC_BTRESET2, empty);
		ENABLE_BUTTON(IDC_BUTTONNAME, empty);
	}
	return CDialog::WindowProc(message, wParam, lParam);
}

void CEquipmentMakeDlg::OnBnClickedButtoncopy()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	AcGePoint3d ptIns(AcGePoint3d::kOrigin);
	if (!getInsertPt(this, ptIns)) return;

	AcAxDocLock lock;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	Adesk::Int32 _id = getItemID(m_idBuffer);
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEnt)
	if (pEnt != NULL)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);
			CString sText = m_wndEquipPrmTree.GetItemText(hItem);
			if (nImage < SUB_TREE_BOX || nImage >= EQP_TREE_ROOT) continue;

			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
			AecEqui::XPrimData *pData = pEnt->GetSUbPrimObjByID(dwSubID);
			if (!pData) continue;

			AecEqui::XPrimData *pNewData = AecDbEwEquipment::copyFromXPrimData(pData);
			if (pNewData)
			{
				pNewData->m_nID = _id++;
				pNewData->m_vtMove.normalize();
				pNewData->m_vtMove.x += ptIns.asVector().x;
				pNewData->m_vtMove.y += ptIns.asVector().y;
				pNewData->m_vtMove.z += ptIns.asVector().z;
			
				pEnt->AddSubPrimObj(pNewData);
				pNewData->releaseData();
				hItem = m_wndEquipPrmTree.InsertItem(sText, nImage, nImage, hRoot);
				m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)pNewData->m_nID);
				DELETE_PTR(pNewData);
			}
		}

	}
	OPENOBJ_END()

	refreshHlightEntity();
}


void CEquipmentMakeDlg::OnBnClickedButtonmirr()
{
	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty()) return;

	if (this->IsWindowVisible()) this->ShowWindow(SW_HIDE);

	ads_name ent;
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("LINE"), 0);
	int nRes = CKTCadUtility::SelectEntity2(_T("\n请选择一段直线做为对称轴："), ent, pRb);
	acutRelRb(pRb);
	if (nRes != RTNORM)
	{
		if (!this->IsWindowVisible()) this->ShowWindow(SW_SHOW);
		return;
	}

	AcDbObjectId id;
	acdbGetObjectId(id, ent);
	if (!id.isValid())
	{
		if (!this->IsWindowVisible()) this->ShowWindow(SW_SHOW);
		return;
	}
	
	AcGePoint3d pts, pte;
	OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbLine, pLine)
	{
		if (!pLine)
		{
			if (!this->IsWindowVisible()) this->ShowWindow(SW_SHOW);
			return;
		}
		pts = pLine->startPoint();
		pte = pLine->endPoint();
	}
	OPENOBJ_END()
	
	if (!this->IsWindowVisible())
		this->ShowWindow(SW_SHOW);

	AcGeVector3d vt(pte - pts);
	vt.rotateBy(.5 * PI, AcGeVector3d::kZAxis);
	AcGeMatrix3d mat;
	mat.setToMirroring(AcGePlane(pts, vt));

	AcAxDocLock lock;

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	Adesk::Int32 _id = getItemID(m_idBuffer);
	OPENOBJ_BEGIN(GetEquIDByTree(), AcDb::kForWrite, AecDbEwEquipment, pEnt)
	if (pEnt != NULL)
	{
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			int nImage = 0, nSelImg = 0;
			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);
			CString sText = m_wndEquipPrmTree.GetItemText(hItem);
			if (nImage < SUB_TREE_BOX || nImage >= EQP_TREE_ROOT) continue;

			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
			AecEqui::XPrimData *pData = pEnt->GetSUbPrimObjByID(dwSubID);
			if (!pData) continue;

			AecEqui::XPrimData *pNewData = AecDbEwEquipment::copyFromXPrimData(pData);
			if (pNewData)
			{
				pNewData->m_nID = _id++;
				pNewData->m_arMatrix.append(mat);
				pEnt->AddSubPrimObj(pNewData);
				pNewData->releaseData();
				hItem = m_wndEquipPrmTree.InsertItem(sText, nImage, nImage, hRoot);
				m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)pNewData->m_nID);
				DELETE_PTR(pNewData);
			}
		}

	}
	OPENOBJ_END()

	refreshHlightEntity();
}

void CEquipmentMakeDlg::OnBnClickedButtonins()
{
	int nCount = m_wndEquipPrmTree.GetCount();
	if (nCount == 0)
	{
		AfxMessageBox(_T("请新建设备元件放置元素!"));
		return;
	}

	HTREEITEM hRoot = m_wndEquipPrmTree.GetRootItem();
	AcDbObjectId id = GetEquIDByTree();

	bool bTemp(false);
	AecDbEwEquipment *pNewEqu = CEquipmentLibraryDlg::selectSingleEqu((LPCTSTR)NULL, (LPCTSTR)NULL, false, false, bTemp, bTemp);
	if (!pNewEqu) return;

	CString sName(_T(""));
	pNewEqu->GetSpecialtyData()->GetAt(KEY_NAME, sName);

	AcGePoint3d ptIns(AcGePoint3d::kOrigin);
	if (!getInsertPt(this, ptIns))
	{
		DELETE_PTR(pNewEqu);
		return;
	}

	AcAxDocLock lock;

	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pEqu)
	if (pEqu)
	{
		AecEqui::XPrimData *pNewData = new AecEqui::XPrimData();
		for (int i(0); i < pNewEqu->GetSubPrimObjCount(); ++i)
		{
			AecEqui::XPrimData *p = pNewEqu->GetSubPrimObj(i);
			if (p)
				pNewData->m_Combins.push_back(p);
		}

		pNewData->m_nID = ::getItemID(m_idBuffer);
		pNewData->m_eType = AecEqui::kCombination;
		pNewData->m_bBoolSubtract = false;
		pNewData->m_vtMove = ptIns.asVector();
		pNewData->m_sName = sName;

		pEqu->AddSubPrimObj(pNewData);
		pNewData->releaseData();

		HTREEITEM hItem = m_wndEquipPrmTree.InsertItem(sName.IsEmpty() ? SUB_NAME_EQU : sName + getTreeItemSuffix(false)
			, SUB_TREE_EQU_COMBIN
			, SUB_TREE_EQU_COMBIN
			, hRoot);
		m_wndEquipPrmTree.SetItemData(hItem, (DWORD_PTR)pNewData->m_nID);
		m_wndEquipPrmTree.Expand(hRoot, TVE_EXPAND);
		m_wndEquipPrmTree.SelectItem(hItem);
	}
	OPENOBJ_END()


	DELETE_PTR(pNewEqu);
}

void CEquipmentMakeDlg::modifyColor()
{
	if (!m_MainID.isValid())	// 文档已无效
	{
		AfxMessageBox(_T("当前设备无效！请新建或载入一个新设备。"));
		m_wndEquipPrmTree.DeleteAllItems();
	}

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty())
	{
		HTREEITEM h(m_wndEquipPrmTree.GetSelectedItem());
		if (h)
			items.push_back(h);
		else
			return;
	}

	Adesk::UInt16 iClr = getColorByUser(256);

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		int nImage = 0, nSelImg = 0;
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);
			if (nImage < SUB_TREE_BOX || nImage >= EQP_TREE_ROOT) continue;

			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
			AecEqui::XPrimData *p = pWEqt->GetSUbPrimObjByID(dwSubID);
			if (!p) continue;
			p->m_iClr = iClr;
		}
		pWEqt->clearGeoBuffer();
	}
	OPENOBJ_END()
}

void CEquipmentMakeDlg::OnBnClickedButtonname()
{
	if (!m_MainID.isValid())	// 文档已无效
	{
		AfxMessageBox(_T("当前设备无效！请新建或载入一个新设备。"));
		m_wndEquipPrmTree.DeleteAllItems();
	}

	std::vector<HTREEITEM> items;
	getSelectItems(items);
	if (items.empty())
	{
		HTREEITEM h(m_wndEquipPrmTree.GetSelectedItem());
		if (h)
			items.push_back(h);
		else
			return;
	}

	CString sName(_T(""));
	if (!CoreTools::getNameByDialog(_T("重命名"), _T("名称:"), sName))
		return;

	if (sName.IsEmpty()) return;

	AcAxDocLock lock;
	AcDbObjectId id(GetEquIDByTree());
	OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbEwEquipment, pWEqt)
	if (pWEqt != NULL)
	{
		int nImage = 0, nSelImg = 0;
		for (size_t i(0); i < items.size(); ++i)
		{
			HTREEITEM hItem = items[i];
			if (!hItem) continue;

			m_wndEquipPrmTree.GetItemImage(hItem, nImage, nSelImg);
			if (nImage < SUB_TREE_BOX || nImage >= EQP_TREE_ROOT) continue;

			DWORD_PTR dwSubID = m_wndEquipPrmTree.GetItemData(hItem);
			AecEqui::XPrimData *p = pWEqt->GetSUbPrimObjByID(dwSubID);
			if (!p) continue;

			p->m_sName = sName;

			m_wndEquipPrmTree.SetItemText(hItem, sName);

		}
	}
	OPENOBJ_END()
}

void CEquipmentMakeDlg::OnBnClickedButtonClose()
{
	OnClose();
}