#include "stdafx.h"
#include "StdArx.h"
#include "XMLCDlg.h"
#include "CNameDlg.h"
#include "CProSetDlg.h"
#include "FloorViewNameDlg.h"
#include "EarThwormDef.h"
#include "CoreTools.h"
#include "KTCadUtility.h"
#include "CCopyAxFrFloorDlg.h"
#include "KTSetting.h"
#include "entityfilter.h"

#define IMG_ROOT 0
#define IMG_VIEW 1
#define IMG_VIEW_ON 2
#define IMG_FLOOR 5
#define IMG_FLOOR_ON 3
#define IMG_ENT_TYPE 7
#define IMG_ENT_NAME_CHECK 9
#define IMG_ENT_NAME_UNCHECK 8

#define FLOOR_XY _T("楼层平面")
#define FLOOR_3D _T("三维视图")

//static const LPCTSTR g_pszViews[] = { _T("楼层平面"),_T("楼层立面"),_T("楼层剖面"),_T("系统图"), _T("原理图"),_T("配筋图"),_T("大样图"),_T("详图"),_T("三维视图"),NULL};
static const LPCTSTR g_pszViews[] = { _T("楼层平面"),NULL};
extern CString IDCreate();

bool HasIntersectOnZ(double dZmin, double dZmax, double dFrEl, double dToEl);
namespace
{
	// 获得本层实体
	void getEntitiesOfFloor(FloorViewData *pViewData
		, const double &dBomEl
		, AcDbObjectIdArray &idsIn	// 层内实体
		, AcDbObjectIdArray &idsOut)	// 层外实体
	{
		idsIn.removeAll();
		idsOut.removeAll();

		double dFrEl = dBomEl, dToEl = dBomEl;
		if (pViewData != NULL)
		{
			dToEl += pViewData->m_bFloorIndxTo
				? ((pViewData->m_nFloorIndxTo - pViewData->m_nFloorIndxFr + 1) * pViewData->m_nFloorH)
				: pViewData->m_nFloorH;
		}

		ads_name ss, ent;
		resbuf *pFilter = acutBuildList(0, _T("AEC_*,INSERT"), 0);
		int nRet = acedSSGet(_T("A"), NULL, NULL, pFilter, ss);
		acutRelRb(pFilter);

		Adesk::Int32 nLen = 0;
		acedSSLength(ss, &nLen);

		Acad::ErrorStatus es;
		AcDbObjectId idAxisLn = KTSetting::InitLayer(_T("LAY_AXIS"));
		AcDbObjectId idAxisLb = KTSetting::InitLayer(_T("LAY_DIMAX"));

		AcDbExtents ext;
		AcDbObjectId id;
		for (int i = 0; i < nLen; ++i)
		{
			acedSSName(ss, i, ent);
			acdbGetObjectId(id, ent);
			if (!id.isValid()) continue;
			AcDbEntityPointer ent(id, AcDb::kForRead);
			if (ent.openStatus() != Acad::eOk) continue;

			AecDbCurveBase *pCrvB = AecDbCurveBase::cast(ent);
			if (pCrvB != NULL)
				es = pCrvB->subGet3dGeomExtents(ext);

			AecDbEntityBase *pEntB = AecDbEntityBase::cast(ent);
			if (pEntB != NULL)
				es = pEntB->subGet3dGeomExtents(ext);

			if (pEntB == NULL && pCrvB == NULL)
			{
				AcDbBlockReference *pBK = AcDbBlockReference::cast(ent);
				if (pBK != NULL)
				{
					if (pBK->layerId() == idAxisLb)
						continue;

					es = pBK->geomExtentsBestFit(ext);

				}
				else
				{
					if (ent->layerId() == idAxisLb ||
						ent->layerId() == idAxisLn)
						continue;

					es = ent->getGeomExtents(ext);
				}
			}

			if (es != Acad::eOk) continue;

			if (fabs(dToEl - dFrEl) < 1.e-3)
			{
				idsIn.append(id);
			}
			else
			{
				//标高有交集,即可
				if (HasIntersectOnZ(ext.minPoint().z, ext.maxPoint().z, dFrEl, dToEl))
					idsIn.append(id);
				else
					idsOut.append(id);
			}
		}
		acedSSFree(ss);

		//轴网
		pFilter = acutBuildList(0, _T("DIMENSION,LINE,INSERT"), 0);
		nRet = acedSSGet(_T("A"), NULL, NULL, pFilter, ss);
		acutRelRb(pFilter);


		nLen = 0;
		acedSSLength(ss, &nLen);

		for (int i = 0; i < nLen; ++i)
		{
			acedSSName(ss, i, ent);
			acdbGetObjectId(id, ent);
			if (!id.isValid()) continue;
			AcDbEntityPointer ent(id, AcDb::kForRead);
			if (ent.openStatus() != Acad::eOk) continue;

			if (idAxisLn == ent->layerId() || idAxisLb == ent->layerId())
			{

				AcDbBlockReference *pBK = AcDbBlockReference::cast(ent);
				if (pBK != NULL)
				{
					ext.addPoint(pBK->position());
				}
				else
				{
					AcDbDimension *pDim = AcDbDimension::cast(ent);
					if (pDim != NULL)
					{
						ext.addPoint(pDim->textPosition());
					}
					else
					{
						es = ent->getGeomExtents(ext);
					}
				}

				if (es != Acad::eOk) continue;

				if (fabs(dToEl - dFrEl) < 1.e-3)
				{
					if (idsIn.find(id) == -1)
						idsIn.append(id);
				}
				else
				{
					//标高有交集,即可 轴网取max
					if (HasIntersectOnZ(ext.maxPoint().z, ext.maxPoint().z, dFrEl, dToEl))
					{
						//acutPrintf( _T("\nDXF=%s"), ent->isA()->dxfName());

						if (idsIn.find(id) == -1)
							idsIn.append(id);
					}
					else
					{
						if (idsOut.find(id) == -1)
							idsOut.append(id);
					}
				}
			}
		}
		acedSSFree(ss);
	}

	// 分析实体类型
	void analyzeTypesOfEntities(const AcDbObjectIdArray &ids
		, std::map<AcDbObjectId, std::vector<CString>> &alltypes)
	{
		std::vector<CString> ss;
		for (int i(0); i < ids.length(); ++i)
		{
			const AcDbObjectId &id(ids[i]);
			ss.clear();
			CEntityProperty::getTypeTreeOfEntity(id, ss);
			if (!ss.empty())
				alltypes.insert(std::make_pair(id, ss));
		}
	}

	// 展开所有节点
	void expandAll(CTreeListCtrl &tree, HTREEITEM hItem, UINT nCode = TVE_EXPAND)
	{
		if (hItem == NULL)
			return;

		// 展开当前节点
		tree.Expand(hItem, nCode);

		// 递归展开所有子节点
		HTREEITEM hChild = tree.GetChildItem(hItem);
		while (hChild)
		{
			expandAll(tree, hChild, nCode);
			hChild = tree.GetNextSiblingItem(hChild);
		}
	}
	
	// 展开指定层数的子节点
	void expandItem(CTreeCtrl &tree, HTREEITEM hItem, int nLevel)
	{
		if (hItem == NULL || nLevel <= 0)
			return;

		// 展开当前节点
		tree.Expand(hItem, TVE_EXPAND);

		// 如果只需要展开到当前层，停止递归
		if (nLevel == 1)
			return;

		// 遍历当前节点的所有子节点
		HTREEITEM hChild = tree.GetChildItem(hItem);
		while (hChild != NULL)
		{
			expandItem(tree, hChild, nLevel - 1);
			hChild = tree.GetNextSiblingItem(hChild);
		}
	}

	// 删除hParent下所有子节点
	void deleteAllChildItems(CTreeCtrl &tree, HTREEITEM hParent)
	{
		if (hParent == NULL)
			return;

		HTREEITEM hChild = tree.GetChildItem(hParent);
		while (hChild)
		{
			HTREEITEM hNext = tree.GetNextSiblingItem(hChild);
			tree.DeleteItem(hChild);
			hChild = hNext;
		}
	}

	// 查找hParent下的名称为psz的子项
	HTREEITEM findChildItem(CTreeCtrl &wndlist, HTREEITEM hParent, LPCTSTR psz)
	{
		if (!hParent || !psz) return NULL;

		HTREEITEM hChild = wndlist.GetChildItem(hParent);
		CString sName(_T(""));
		while (hChild)
		{
			HTREEITEM hNext = wndlist.GetNextSiblingItem(hChild);

			sName = wndlist.GetItemText(hChild);
			if (sName == psz)
				return hChild;

			hChild = hNext;
		}

		return NULL;
	}

	// 是否点击图标区域
	bool isClickedOnICON(CTreeListCtrl &wndlist)
	{
		DWORD dwPos = GetMessagePos();     // 获取当前鼠标位置（屏幕坐标）
		CPoint pt(GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos));
		wndlist.ScreenToClient(&pt);        // 转换为客户区坐标

		// 如果是图标区域，离开
		UINT uFlags = 0;
		HTREEITEM hItem = wndlist.HitTest(pt, &uFlags);
		if (hItem && (uFlags & TVHT_ONITEMICON)) return true;
		return false;
	}

	// 是否点击 +/- 区域
	bool isClickedExpandIcon(CTreeListCtrl &wndlist)
	{
		DWORD dwPos = GetMessagePos();     // 获取当前鼠标位置（屏幕坐标）
		CPoint pt(GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos));
		wndlist.ScreenToClient(&pt);        // 转换为客户区坐标
		// 如果是图标区域，离开
		UINT uFlags = 0;
		HTREEITEM hItem = wndlist.HitTest(pt, &uFlags);
		if (hItem && (uFlags & TVHT_ONITEMBUTTON)) return true;
		return false;
	}

	// 实体加入选择集
	void addToPickFirst(AcDbObjectIdArray &ids)
	{
		CEntityProperty::addToPickFirst(ids, true);
	}

	// item 的图标是否是给定的？
	bool isItemImgIdx(CTreeListCtrl &wndList, HTREEITEM hItem, int imageIndex)
	{
		if (!hItem) return false;
		int img1 = -1, img2 = -1;
		wndList.GetItemImage(hItem, img1, img2);
		return img1 == imageIndex;
	}

	// 设置item 的图标
	void setItemImgIdx(CTreeListCtrl &wndList, HTREEITEM hItem, int imageIndex)
	{
		if (!hItem) return;
		wndList.SetItemImage(hItem, imageIndex, imageIndex);
	}
	
	// 设置check状态
	void setCheckState(CTreeListCtrl &wndlist, HTREEITEM hItem, bool bCheck)
	{
		if (!hItem) return;
		setItemImgIdx(wndlist, hItem, bCheck ? IMG_ENT_NAME_CHECK : IMG_ENT_NAME_UNCHECK);
	}

	// 获得check状态
	bool getCheckState(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return false;
		return isItemImgIdx(wndlist, hItem, IMG_ENT_NAME_CHECK);
	}

	// 是否是层项
	bool isFloorItem(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return false;
		if (isItemImgIdx(wndlist, hItem, IMG_FLOOR)
			|| isItemImgIdx(wndlist, hItem, IMG_FLOOR_ON))
			return true;
		return false;
	}

	// 是否是checkbox项
	bool isCheckboxItem(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return false;
		if (isItemImgIdx(wndlist, hItem, IMG_ENT_NAME_CHECK)
			|| isItemImgIdx(wndlist, hItem, IMG_ENT_NAME_UNCHECK))
			return true;
		return false;
	}

	// 是否是实体类型项
	bool isTypeItem(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return false;
		// 有子节点的checkbox项，就是类型项
		return (isCheckboxItem(wndlist, hItem)
			&& wndlist.GetChildItem(hItem) != NULL);
	}

	// 是否是实体项
	bool isLeafItem(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return false;
		// 没有子节点的checkbox项，就是实体项
		return (isCheckboxItem(wndlist, hItem)
			&& wndlist.GetChildItem(hItem) == NULL);
	}

	// 给定一个 层项、类型项、实体项 得到层项
	HTREEITEM getFloorItem(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return NULL;

		HTREEITEM hParent = hItem;
		while (hParent)
		{
			if (isFloorItem(wndlist, hParent))
				return hParent;

			hParent = wndlist.GetParentItem(hParent);
		}

		return NULL; // 没找到满足条件的父节点
	}

	// 鼠标点击图标位置，改变图标
	void changeImg(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return;

		// 不是 checkbox 项 离开
		if (!isCheckboxItem(wndlist, hItem)) return;

		// 没有点击到图标，离开
		if (!isClickedOnICON(wndlist)) return;

		bool bNewState(!getCheckState(wndlist, hItem));
		setCheckState(wndlist, hItem, bNewState);

		// 不是类型节点就可以走了，是的话， 处理子节点
		if (!isTypeItem(wndlist, hItem)) return;

		HTREEITEM hNxt, hChd(wndlist.GetChildItem(hItem));
		while (hChd != NULL)
		{
			hNxt = wndlist.GetNextItem(hChd, TVGN_NEXT);

			// hChd的状态应与修改前父节点状态一致
			setCheckState(wndlist, hChd, !bNewState);
			changeImg(wndlist, hChd);

			hChd = hNxt;
		}
	}

	// 删除 hItem 下面所有 checkbox 项
	void deleteCheckboxItems(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return;

		HTREEITEM hChild = wndlist.GetChildItem(hItem);
		while (hChild != NULL)
		{
			HTREEITEM hNext = wndlist.GetNextSiblingItem(hChild);
			deleteCheckboxItems(wndlist, hChild);
			hChild = hNext;
		}

		if (isCheckboxItem(wndlist, hItem))
			wndlist.DeleteItem(hItem);
	}
	
	// 获得鼠标选中的项或这一项的所有子项
	void collectLeavesByPickedItem(CTreeListCtrl &wndlist
		, HTREEITEM hItem
		, std::vector<HTREEITEM> &items)
	{
		if (!hItem) return;

		// 楼层项、非实体的checkbox项
		if (isFloorItem(wndlist, hItem) || 
			(isCheckboxItem(wndlist, hItem)
				&& !isLeafItem(wndlist, hItem)) )
		{
			HTREEITEM hNxt, hChd(wndlist.GetChildItem(hItem));
			while (hChd != NULL)
			{
				hNxt = wndlist.GetNextItem(hChd, TVGN_NEXT);
				collectLeavesByPickedItem(wndlist, hChd, items);
				hChd = hNxt;
			}
		}

		if (isLeafItem(wndlist, hItem))
		{
			AcDbObjectId id(AcDbObjectId::kNull);
			id.setFromOldId((Adesk::IntDbId)wndlist.GetItemData(hItem));
			if (id.isValid())
				items.push_back(hItem);
		}
	}
	
	// 获得鼠标选中的项或这一项的所有实体
	void collectLeavesByPickedItem(CTreeListCtrl &wndlist
		, HTREEITEM hItem
		, AcDbObjectIdArray &ids)
	{
		std::vector<HTREEITEM> items;
		collectLeavesByPickedItem(wndlist, hItem, items);

		AcDbObjectId id(AcDbObjectId::kNull);
		for (size_t i(0); i < items.size(); ++i)
		{
			id.setFromOldId((Adesk::IntDbId)wndlist.GetItemData(items[i]));
			if (id.isValid())
				ids.append(id);
		}
	}

	// inner use
	void _getCheckedLeaves( CTreeListCtrl &wndlist
		, HTREEITEM hItem
		, std::vector<HTREEITEM> &items )
	{
		if (!hItem) return;

		// 楼层项、非实体的checkbox项
		if (isFloorItem(wndlist, hItem) || 
			(isCheckboxItem(wndlist, hItem)
				&& !isLeafItem(wndlist, hItem)) )
		{
			HTREEITEM hNxt, hChd(wndlist.GetChildItem(hItem));
			while (hChd != NULL)
			{
				hNxt = wndlist.GetNextItem(hChd, TVGN_NEXT);
				_getCheckedLeaves(wndlist, hChd, items);
				hChd = hNxt;
			}
		}

		if (isLeafItem(wndlist, hItem) && getCheckState(wndlist, hItem))
		{
			AcDbObjectId id(AcDbObjectId::kNull);
			id.setFromOldId((Adesk::IntDbId)wndlist.GetItemData(hItem));
			if (id.isValid())
				items.push_back(hItem);
		}
	}

	// 获得checkbox为选择状态的实体
	void collectCheckedLeavesFromFloor(CTreeListCtrl &wndlist
		, HTREEITEM hItem
		, std::vector<HTREEITEM> &items )
	{
		if (!hItem) return;

		HTREEITEM hFloorItem = getFloorItem(wndlist, hItem);
		if (!hFloorItem) return;

		_getCheckedLeaves(wndlist, hFloorItem, items);
	}

	// 获得checkbox为选择状态的项
	void collectCheckedLeavesFromFloor(CTreeListCtrl &wndlist
		, HTREEITEM hItem
		, AcDbObjectIdArray &ids )
	{
		if (!hItem) return;

		std::vector<HTREEITEM> items;
		collectCheckedLeavesFromFloor(wndlist, hItem, items);

		AcDbObjectId id(AcDbObjectId::kNull);
		for (size_t i(0); i < items.size(); ++i)
		{
			id.setFromOldId((Adesk::IntDbId)wndlist.GetItemData(items[i]));
			if (id.isValid())
				ids.append(id);
		}
	}

	// 更新hItem所在层项下面实体的状态
	void updateInfo(CTreeListCtrl &tree , HTREEITEM hItem)
	{
		if (isLeafItem(tree, hItem)) return;
		if (isFloorItem(tree, hItem))
		{
			
			HTREEITEM hNxt, hChd(tree.GetChildItem(hItem));
			while (hChd != NULL)
			{
				hNxt = tree.GetNextItem(hChd, TVGN_NEXT);
				updateInfo(tree, hChd);
				hChd = hNxt;
			}
			return;
		}

		int countOfHide(0), countOfLock(0), countOfNone(0);

		std::vector<HTREEITEM> items;
		// 收集所有子节点的叶子数量
		collectLeavesByPickedItem(tree, hItem, items);
		if (items.empty()) return;

		CString s(_T(""));
		//s.Format(_T("%s(%d)"), tree.GetItemText(hItem), (int)items.size());
		//tree.SetItemText(hItem, s);

		CEntityProperty::EEntityState st(CEntityProperty::eNoneState);
		AcDbObjectId id(AcDbObjectId::kNull);
		for (size_t i(0); i < items.size(); ++i)
		{
			id.setFromOldId((Adesk::IntDbId)tree.GetItemData(items[i]));
			if (!id.isValid()) continue;
			st = CEntityProperty::entityState(id);

			if (st == CEntityProperty::eHide)
			{
				countOfHide++;
				tree.SetItemText(items[i], _T("隐藏"), 1);
			}
			else if (st == CEntityProperty::eLocked)
			{
				countOfLock++;
				tree.SetItemText(items[i], _T("锁定"), 1);
			}
			else
			{
				countOfNone++;
				tree.SetItemText(items[i], _T(""), 1);
			}
		}

		if (countOfHide == items.size())
			tree.SetItemText(hItem, _T("全部隐藏"), 1);
		else if (countOfLock == items.size())
			tree.SetItemText(hItem, _T("全部锁定"), 1);
		else if (countOfNone == items.size())
			tree.SetItemText(hItem, _T(""), 1);
		else
		{
			s.Format(_T("隐藏(%d) 锁定(%d)"), countOfHide, countOfLock);
			tree.SetItemText(hItem, s, 1);
		}

		// 处理子节点中，不是叶子的节点
		if (isTypeItem(tree, hItem))
		{
			HTREEITEM hNxt, hChd(tree.GetChildItem(hItem));
			while (hChd != NULL)
			{
				hNxt = tree.GetNextItem(hChd, TVGN_NEXT);
				updateInfo(tree, hChd);
				hChd = hNxt;
			}
		}
	}

	// 统计叶子节点数量，并更新非叶子节点名称
	int updateCountOfLeaf(CTreeListCtrl &tree, HTREEITEM hItem)
	{
		if (!hItem)
			return 0;

		HTREEITEM hChild = tree.GetChildItem(hItem);

		// 如果没有子节点，本身是叶子
		if (hChild == NULL)
			return 1;

		// 递归统计子节点的叶子数量
		int leafCount = 0;
		while (hChild)
		{
			leafCount += updateCountOfLeaf(tree, hChild);
			hChild = tree.GetNextSiblingItem(hChild);
		}

		// 更新非叶子节点的文本
		CString oldText = tree.GetItemText(hItem);
		CString newText;
		newText.Format(_T("%s (%d)"), oldText, leafCount);
		if (!isFloorItem(tree, hItem))
			tree.SetItemText(hItem, newText);

		return leafCount;
	}

	void makeTypeTreeOfEntity(const std::map<AcDbObjectId, std::vector<CString>> &allTypes
		, CTreeListCtrl &wndlist
		, HTREEITEM hRoot)
	{
		int imgIdx(IMG_ENT_NAME_UNCHECK);
		std::map<AcDbObjectId, std::vector<CString>>::const_iterator it(allTypes.begin());
		// 遍历每一条类型路径
		for (; it != allTypes.end(); ++it)
		{
			const AcDbObjectId &id(it->first);
			const std::vector<CString> &types = it->second;
			if (types.empty())
				continue;

			HTREEITEM hParent = hRoot;

			// 逐级插入节点，最后一个单独处理
			for (size_t j = 0; j < types.size() - 1; ++j)
			{
				const CString &name = types[j];

				HTREEITEM hChild = wndlist.GetChildItem(hParent);
				HTREEITEM hFound = NULL;

				// 查找是否已有同名子节点
				while (hChild)
				{
					CString text = wndlist.GetItemText(hChild);
					if (text.CompareNoCase(name) == 0)
					{
						hFound = hChild;
						break;
					}
					hChild = wndlist.GetNextSiblingItem(hChild);
				}

				// 没找到则插入新节点
				if (hFound == NULL)
				{
					hFound = wndlist.InsertItem(name, imgIdx, imgIdx, hParent);
				}

				// 进入下一层
				hParent = hFound;
			}

			// 处理路径中最后一个项目
			{
				HTREEITEM hItem(NULL);
				const CString &lastname(*types.rbegin());

				// 如果存在，判断是否有子节点
				// 如果存在子节点，则作为子节点插入hSubItem
				// 如果不存在子节点，则在hSubItem下面插入两个
				HTREEITEM hSubItem = findChildItem(wndlist, hParent, lastname);
				if (hSubItem)
				{
					if (wndlist.GetChildItem(hSubItem))
					{
						/* 操作前
							|hParent
							|  |-lastname(hSubItem)
							|  |  |-lastname
							...
						*/

						hItem = wndlist.InsertItem(lastname, imgIdx, imgIdx, hSubItem);

						/* 操作后
							|hParent
							|  |-lastname(hSubItem)
							|  |  |-lastname
							|  |  |-lastname (new item)
							...
						*/
					}
					else
					{
						//在hSubItem下面插入一个新的item，并且把dw设置进去
						//这个操作相当与把原hSubItem，下调一级

						// 得到原有的hSubItem的数据，然后清空
						DWORD_PTR dw = wndlist.GetItemData(hSubItem);
						wndlist.SetItemData(hSubItem, NULL);

						/* 操作前
							|hParent
							|  |-lastname(hSubItem 无子节点) (有数据)
							
						*/
					
						// 在原hSubItem下插入一个新的lastname，作为原hSubItem的替代
						hItem = wndlist.InsertItem(lastname, imgIdx, imgIdx, hSubItem);
						if (hItem)
							wndlist.SetItemData(hItem, dw);

						// 再在原hSubItem下插入一个，这个相当与本次要插入的项
						hItem = wndlist.InsertItem(lastname, imgIdx, imgIdx, hSubItem);

						/* 操作后
							|hParent
							|  |-lastname(hSubItem 有子节点) (无数据)
							|  |  |-lastname (替代hSubItem,使用hSubItem数据)
							|  |  |-lastname (new item)
						*/
					}
				}
				else						// 直接插入
				{
					/* 操作前
						|hParent
					*/

					hItem = wndlist.InsertItem(lastname, imgIdx, imgIdx, hParent);

					/* 操作后
						|hParent
						|  |-lastname
					*/
				}
				if (hItem)
					wndlist.SetItemData(hItem, id.asOldId());
			}
		}

		// 展开根节点（可选）
		expandItem(wndlist, hRoot, 1);

		updateCountOfLeaf(wndlist, hRoot);
	}

	// 添加实体项(实体类型和实体名称)
	void makeEntityTreeForFloor(const AcDbObjectIdArray &ids, CTreeListCtrl &wndlist, HTREEITEM hTreeItem)
	{
		if (!hTreeItem) return;
		if (!isFloorItem(wndlist, hTreeItem)) return;

		std::map<AcDbObjectId, std::vector<CString>> alltypes;
		analyzeTypesOfEntities(ids, alltypes);

		makeTypeTreeOfEntity(alltypes, wndlist, hTreeItem);

		// 现在更新实体状态(插入item后立刻更新无效)
		updateInfo(wndlist, hTreeItem);
	}

	// 将 hItem 下面的实体加入选择集
	void selectEntities(CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return;
		if (isClickedOnICON(wndlist)) return;

		CString s = wndlist.CTreeCtrl::GetItemText(hItem);

		AcDbObjectIdArray ids;
		collectLeavesByPickedItem(wndlist, hItem, ids);
		
		addToPickFirst(ids);
		actrTransactionManager->flushGraphics();
		acedUpdateDisplay();
	}

	// 处理右键菜单
	void processPopmenu(const DWORD &mid, CTreeListCtrl &wndlist, HTREEITEM hItem)
	{
		if (!hItem) return;

		AcAxDocLock lock;

		/*
			处理逻辑：
			先按照checked的状态选一次，如果选到了，则说明用户只想操作选中的这几个item
			如果没有选中状态的item，会有一下三种情况
			1.选中的是实体项(单独处理这一个)
			2.选中的类型项(处理整个类型)
			3.选中的是楼层项(处理整个楼层)
		*/
		AcDbObjectIdArray ids;
		collectCheckedLeavesFromFloor(wndlist, hItem, ids);
		if (ids.isEmpty())
			collectLeavesByPickedItem(wndlist, hItem, ids);

		if (ids.isEmpty())
			return;

		switch (mid)
		{
		case IDM_ENTITY_LOCK:
			CEntityProperty::setLockedLayerForEntities(ids);
			break;
		case IDM_ENTITY_HIDE:
			CEntityProperty::setHideLayerForEntities(ids);
			break;
		case IDM_ENTITY_SHOW:
			CEntityProperty::resetLayerForEntities(ids);
			break;
		default:
			break;
		}

		updateInfo(wndlist, getFloorItem(wndlist, hItem));
	}
}

IMPLEMENT_DYNAMIC(CXMLCDlg, CDialog)

CXMLCDlg::CXMLCDlg(CWnd* pParent /*=NULL*/)
	: CDialog(IDD_XMLC_DLG, pParent)
	, m_bAutoSelEnt(false)
{
}

CXMLCDlg::~CXMLCDlg()
{
}

void CXMLCDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_BUTTON1, m_wndBt1);
	DDX_Control(pDX, IDC_BUTTON2, m_wndBt2);
	DDX_Control(pDX, IDC_BUTTON3, m_wndBt3);
	DDX_Control(pDX, IDC_BUTTON4, m_wndBt4);
	DDX_Control(pDX, IDC_BUTTON5, m_wndBt5);
	DDX_Control(pDX, IDC_BUTTON6, m_wndBt6);
	DDX_Control(pDX, IDC_BUTTON8, m_wndBt8);
	DDX_Control(pDX, IDC_BUTTON9, m_wndBt9);

}

BEGIN_MESSAGE_MAP(CXMLCDlg, CDialog)
	ON_BN_CLICKED(IDC_BUTTON1, &CXMLCDlg::OnBnClickedButton1)
	ON_BN_CLICKED(IDC_BUTTON2, &CXMLCDlg::OnBnClickedButton2)
	ON_BN_CLICKED(IDC_BUTTON3, &CXMLCDlg::OnBnClickedButton3)
	ON_BN_CLICKED(IDC_BUTTON4, &CXMLCDlg::OnBnClickedButton4)
	ON_BN_CLICKED(IDC_BUTTON5, &CXMLCDlg::OnBnClickedButton5)
	ON_BN_CLICKED(IDC_BUTTON6, &CXMLCDlg::OnBnClickedButton6)
	ON_BN_CLICKED(IDC_BUTTON8, &CXMLCDlg::OnBnClickedButton8)
	ON_BN_CLICKED(IDC_BUTTON9, &CXMLCDlg::OnBnClickedButton9)
	ON_MESSAGE(WM_ACAD_KEEPFOCUS, &CXMLCDlg::onAcadKeepFocus)
	ON_WM_SIZE()
	ON_NOTIFY(TVN_SELCHANGED, IDC_TREE1, &CXMLCDlg::OnSelChanged)
	ON_NOTIFY(NM_RCLICK, IDC_TREE1, &CXMLCDlg::OnNMClickTree1)
	ON_NOTIFY(NM_CLICK, IDC_TREE1, &CXMLCDlg::OnNMClickTree)
	ON_BN_CLICKED(IDC_XMLC_CHK_AUTOSEL, &CXMLCDlg::OnBnClickedChkAutoseL)
END_MESSAGE_MAP()

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

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

	m_wndChkAutoSel.Create(_T("自动选择实体")
	, WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX
	, CRect(10, 10, 150, 30)
	, this
	, IDC_XMLC_CHK_AUTOSEL);
	m_wndChkAutoSel.SetFont(GetFont());

	m_wndChkAutoSel.SetCheck(m_bAutoSelEnt ? BST_CHECKED : BST_UNCHECKED);

	CRect rc;
	GetDlgItem(IDC_STATIC_TREE)->GetWindowRect(rc);
	ScreenToClient(&rc);
	GetDlgItem(IDC_STATIC_TREE)->ShowWindow(SW_HIDE);

	unsigned uStyle = TVS_HASBUTTONS | TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT | TVS_FULLROWSELECT;
	unsigned uExStyle = TVS_EX_ITEMLINES | TVS_EX_ITEMLINES | TVS_EX_ALTERNATECOLOR | TVS_EX_SUBSELECT | TVS_EX_FULLROWMARK;

	m_wndFloorView.Create(uStyle | WS_CHILD | WS_VISIBLE | WS_BORDER, rc, this, IDC_TREE1);
	m_wndFloorView.SetExtendedStyle(uExStyle);
	m_wndFloorView.ShowWindow(SW_SHOW);

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

	BITMAP bmpObj;
	bmp.GetBitmap(&bmpObj);

	UINT nFlags = ILC_COLOR24 | ILC_MASK;
	m_Imagelist.Create(16, bmpObj.bmHeight, nFlags, 0, 0);
	m_Imagelist.Add(&bmp, RGB(255, 0, 0));
	m_wndFloorView.SetImageList(&m_Imagelist, TVSIL_NORMAL);
	
	CBitmap bmp24;
	if (!bmp24.LoadBitmap(IDB_BITMAP_XMLC))
	{
		AfxMessageBox(_T("Can't load bitmap: IDB_BITMAP32"));
		ASSERT(FALSE);
		return FALSE;
	}

	BITMAP bmpObj24;
	bmp24.GetBitmap(&bmpObj24);
	m_Imagelist24.Create(24, bmpObj24.bmHeight, nFlags, 0, 0);
	m_Imagelist24.Add(&bmp24, RGB(255, 0, 0));

	m_wndBt1.SetIcon(m_Imagelist24.ExtractIcon(0));
	m_wndBt2.SetIcon(m_Imagelist24.ExtractIcon(1));
	m_wndBt3.SetIcon(m_Imagelist24.ExtractIcon(2));
	m_wndBt4.SetIcon(m_Imagelist24.ExtractIcon(3));
	m_wndBt5.SetIcon(m_Imagelist24.ExtractIcon(4));
	m_wndBt6.SetIcon(m_Imagelist24.ExtractIcon(5));
	m_wndBt8.SetIcon(m_Imagelist24.ExtractIcon(6));
	m_wndBt9.SetIcon(m_Imagelist24.ExtractIcon(7));

	m_wndBt5.ShowWindow(SW_HIDE);
	m_wndBt6.ShowWindow(SW_HIDE);
	m_wndBt8.ShowWindow(SW_HIDE);

	InitObjListColumn();

	Refrush();

	GetWindowRect(&m_rcMain);
	m_wndBt1.GetWindowRect(&m_rcBt);

	return TRUE;
}

BOOL CXMLCDlg::PreTranslateMessage(MSG* pMsg)
{
	if (pMsg != NULL && pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_ESCAPE)
	{
		return TRUE;
	}
	return CDialog::PreTranslateMessage(pMsg);
}

void CXMLCDlg::OnCancel()
{
}

void CXMLCDlg::InitObjListColumn()
{
	LPCTSTR lpszCols[] = { _T("名称"),_T("始层"),_T("底标高"),_T("终层"),_T("层高"),_T("状态"),_T("ID"),_T("DWG"),NULL};
	int lnColumns[] = { 200,200,50,50,50,50,10,10,0 };

	LV_COLUMN  lvColumn;
	lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvColumn.fmt = LVCFMT_LEFT;
	lvColumn.cx = 120;

	for (int i = 0; lpszCols[i] != NULL; i++)
	{
		lvColumn.cx = lnColumns[i];
		lvColumn.pszText = const_cast<LPTSTR>(lpszCols[i]);
		m_wndFloorView.InsertColumn(i, &lvColumn);
	}
}

void CXMLCDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialog::OnSize(nType, cx, cy);

	if (::IsWindow(m_wndFloorView.m_hWnd))
	{
		CRect rc;
		GetClientRect(&rc);

		rc.DeflateRect(7, 7, 7, m_rcBt.Height() + 7);
		m_wndFloorView.MoveWindow(rc);
	}

	if (::IsWindow(m_wndBt1.m_hWnd) &&
		::IsWindow(m_wndBt2.m_hWnd) &&
		::IsWindow(m_wndBt3.m_hWnd) &&
		::IsWindow(m_wndBt4.m_hWnd) &&
		::IsWindow(m_wndBt5.m_hWnd) &&
		::IsWindow(m_wndBt6.m_hWnd) &&
		::IsWindow(m_wndBt8.m_hWnd) &&
		::IsWindow(m_wndBt9.m_hWnd) &&
		::IsWindow(m_wndChkAutoSel.m_hWnd) )
	{
		CRect rc, rcItem;
		GetClientRect(&rc);

		rcItem = rc;
		rcItem.left += 7;
		rcItem.top = rcItem.bottom - 7 - m_rcBt.Height();
		rcItem.right = rcItem.left + m_rcBt.Width();
		m_wndBt1.MoveWindow(rcItem);

		int w(m_rcBt.Width() + 5);

		rcItem.left += w;
		rcItem.right += w;
		m_wndBt2.MoveWindow(rcItem);

		rcItem.left += w;
		rcItem.right += w;
		m_wndBt3.MoveWindow(rcItem);

		rcItem.left += w;
		rcItem.right += w;
		m_wndBt4.MoveWindow(rcItem);

		rcItem.left += w;
		rcItem.right += w;
		//m_wndBt5.MoveWindow(rcItem);
		m_wndBt9.MoveWindow(rcItem);

		double dScale(CoreTools::GetDPIScale());
		int i140((int)(140 * dScale + .5))
			, i15((int)(15 * dScale + .5))
			, i5((int)(5 * dScale + .5))
			, i3((int)(3 * dScale + .5));
		
		CSize szChk(i140, i15);
		CRect rcChk(CPoint(rcItem.right + i5, rcItem.bottom - szChk.cy - i3), szChk);
		m_wndChkAutoSel.MoveWindow(rcChk);

		rcItem.left += m_rcBt.Width();
		rcItem.right += m_rcBt.Width();
		//m_wndBt6.MoveWindow(rcItem);

		rcItem.left += m_rcBt.Width();
		rcItem.right += m_rcBt.Width();
		//m_wndBt8.MoveWindow(rcItem);

		rcItem.left += m_rcBt.Width();
		rcItem.right += m_rcBt.Width();
		//m_wndBt9.MoveWindow(rcItem);
	}
}
	
static void DisableFloorRec()
{
	AcAxDocLock lock;
	AcDbDatabase *pDb = acdbCurDwg();
	if (pDb == NULL) return;
	AcDbObjectId idSpace = pDb->currentSpaceId();
	AcDbObject *pObj = NULL;
	if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForRead))
	{
		AcDbObjectId idDic = pObj->extensionDictionary();

		AcDbDictionary *pDic = NULL;
		Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
		if (es == Acad::eOk)
		{
			//AcDbXFloorFrame handle
			//PRO_NAME- FloorEx Handle- FloorEx Handle- FloorEx Handle- FloorEx Handle...
			AcDbObject *pSubObj = NULL;
			if (Acad::eOk == (es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite)))
			{
				AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
				if (pRec != NULL)
				{
					pRec->SetFocusOn(false);
				}
				pSubObj->close();
			}
			pDic->close();
		}
		pObj->close();
	}
}

void CXMLCDlg::OnSelChanged(NMHDR *pNmHdr, LRESULT *pResult)
{
	NM_TREEVIEW *pNmTreeView = (NM_TREEVIEW *)pNmHdr;
	FloorViewData viewData;
	if (pNmTreeView && pNmTreeView->itemNew.hItem)
	{
		//增加选择
		HTREEITEM hItem = pNmTreeView->itemNew.hItem;
		CString sText = m_wndFloorView.GetItemText(hItem);

		if (!GetItemViewData(hItem, viewData))
		{
			//当前节点置灰
			DisableFloorRec();
			return;
		}

		//1.显示当前选择的楼层
		AcAxDocLock lock;
		SetActive(hItem, viewData);
	}
}

UINT CXMLCDlg::EnableMenuItem(HTREEITEM hItem, UINT nID)
{
	int nImg = -1, nImg2 = -1,i = 0;
	m_wndFloorView.GetItemImage(hItem, nImg, nImg2);
	CString sName = m_wndFloorView.GetItemText(hItem);

	UINT nFlag = MF_ENABLED;
	switch (nID)
	{
		case ID_NEWPRO:
		{
			break;
		}
		case ID_NEWFLR:
		{
			if (sName.CompareNoCase(FLOOR_XY) != 0)
			{
				nFlag = MF_DISABLED;
			}
			break;
		}
		case ID_DELFLR:
		case ID_MODFLR:
		case ID_3DAXLN:
		case ID_SHOWFR:
		case ID_HIDEFR:
		{
			if (nImg != IMG_FLOOR)
			{
				nFlag = MF_DISABLED;
			}
			break;
		}
		case ID_3D:
		{
			if (sName.CompareNoCase(FLOOR_3D) != 0)
			{
				nFlag = MF_DISABLED;
			}
			break;
		}
		case ID_REFRSH:
		{
			break;
		}
		case ID_CROSSSEL:
		case ID_SELDWG:
		{
			//{ _T("楼层平面"),_T("楼层立面"),_T("楼层剖面"),_T("系统图"), _T("原理图"),_T("配筋图"),_T("三维视图"),NULL }
			for (i = 0;i < sizeof(g_pszViews) / sizeof(g_pszViews[0]); i++)
			{
				if (g_pszViews[i] == NULL)
					break;

				if (sName.CompareNoCase(g_pszViews[i]) == 0)
				{
					if (i > 0 && i < 8)
					{
						nFlag = MF_ENABLED;
					}
					else
					{
						nFlag = MF_DISABLED;
					}
					break;
				}
			}
			break;
		}
		case ID_OPENDWG:
		{
			if (nImg != IMG_FLOOR)
			{
				nFlag = MF_DISABLED;
			}
			else
			{
				FloorViewData data;
				memset(&data, 0, sizeof(FloorViewData));
				if (!GetItemViewData(hItem, data))
				{
					nFlag = MF_DISABLED;
				}
				else
				{
					if (_tcslen(data.m_szFilePath) > 0)
					{
						CFileFind fd;
						if (!fd.FindFile(data.m_szFilePath))
						{
							nFlag = MF_DISABLED;
						}
					}
				}
			}
			break;
		}
	default:
		break;
	}
	return nFlag;
}

void CXMLCDlg::OnNMClickTree(NMHDR * pNMHDR, LRESULT * pResult)
{
	NM_TREEVIEW *pNmTreeView = (NM_TREEVIEW *)pNMHDR;

	HTREEITEM hItem(pNmTreeView->itemNew.hItem);

	// 没有子节点才重新刷新，防止反复单击同一项
	if (isFloorItem(m_wndFloorView, hItem) && !m_wndFloorView.GetChildItem(hItem))
	{
		deleteCheckboxItems(m_wndFloorView, m_wndFloorView.GetRootItem());
		FloorViewData viewData;
		if (!GetItemViewData(hItem, viewData)) return;
		double dBomEl = GetBomElTo(hItem, viewData);
		//getEntitiesOfFloor(&viewData, dBomEl, m_idIns, m_idOuts);
		makeEntityTreeForFloor(m_idIns, m_wndFloorView, hItem);
	}

	// 如果点中了checkbox，修改图标(只处理有checkbox图标的项)
	changeImg(m_wndFloorView, pNmTreeView->itemNew.hItem);

	// 如果点中了非图标区域，选择实体(只处理楼层项和有checkbox的项)
	if (m_bAutoSelEnt)
		selectEntities(m_wndFloorView, pNmTreeView->itemNew.hItem);

	*pResult = 0;
}

void CXMLCDlg::OnBnClickedChkAutoseL()
{
	m_bAutoSelEnt = !m_bAutoSelEnt;
	m_wndChkAutoSel.SetCheck(m_bAutoSelEnt ? BST_CHECKED : BST_UNCHECKED);
}

void CXMLCDlg::OnNMClickTree1(NMHDR *pNMHDR, LRESULT *pResult)
{
	*pResult = 0;

	CPoint point, ptcursor;
	::GetCursorPos(&point);
	ptcursor = point;

	CAcModuleResourceOverride myResources;
	CMenu menu;
	menu.CreatePopupMenu();

	HTREEITEM hItem = m_wndFloorView.GetSelectedItem();

	DWORD dwDefState(MF_BYCOMMAND | MF_STRING | MF_ENABLED);

	if (hItem != NULL)
	{
		if (!isCheckboxItem(m_wndFloorView, hItem))
		{
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_NEWPRO), ID_NEWPRO, _T("建项目(&P)"));
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_PROMODI), ID_PROMODI, _T("修改项目(&M)"));
			menu.AppendMenu(MF_SEPARATOR);
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_NEWFLR), ID_NEWFLR, _T("建楼层(&N)"));
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_DELFLR), ID_DELFLR, _T("删楼层(&D)"));
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_MODFLR), ID_MODFLR, _T("修改楼层(&F)"));

			menu.AppendMenu(MF_SEPARATOR);
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_3DAXLN), ID_3DAXLN, _T("3D轴网(&A)"));
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_3DAXCPY), ID_3DAXCPY, _T("复制轴网到本层(&C)"));

			menu.AppendMenu(MF_SEPARATOR);
			//menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_SHOWFR), ID_SHOWFR, _T("显楼层(&S)"));
			//menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_HIDEFR), ID_HIDEFR, _T("隐楼层(&Y)"));
			//menu.AppendMenu(MF_SEPARATOR);
			//menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_3D), ID_3D, _T("显示三维(&W)"));
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_REFRSH), ID_REFRSH, _T("刷新(&R)"));

			//menu.AppendMenu(MF_SEPARATOR);
			//menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_CROSSSEL), ID_CROSSSEL, _T("图面框选(&K)"));

			//2024-11-27 暂时关闭
			//menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_SELDWG), ID_SELDWG, _T("关联外部文件(&F)"));
			//menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_OPENDWG), ID_OPENDWG, _T("打开关联文件(&O)"));

			if (isFloorItem(m_wndFloorView, hItem) && m_wndFloorView.GetChildItem(hItem))
			{
				menu.AppendMenu(MF_SEPARATOR);
				menu.AppendMenu(dwDefState , IDM_ENTITY_LOCK , _T("锁定(&L)"));
				menu.AppendMenu(dwDefState , IDM_ENTITY_HIDE , _T("隐藏(&H)"));
				menu.AppendMenu(dwDefState , IDM_ENTITY_SHOW , _T("恢复(&X)"));
			}
		}
		else
		{
			menu.AppendMenu(dwDefState , IDM_ENTITY_LOCK , _T("锁定(&L)"));
			menu.AppendMenu(dwDefState , IDM_ENTITY_HIDE , _T("隐藏(&H)"));
			menu.AppendMenu(dwDefState , IDM_ENTITY_SHOW , _T("恢复(&X)"));
		}


		int nID = menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, ptcursor.x, ptcursor.y, &m_wndFloorView);
		switch (nID)
		{
			
		case IDM_ENTITY_LOCK:
		case IDM_ENTITY_HIDE:
		case IDM_ENTITY_SHOW:
		{
			processPopmenu(nID, m_wndFloorView, hItem);
			break;
		}
		case ID_NEWPRO:
		{
			OnBnClickedButton1();
			break;
		}
		case ID_PROMODI:
		{
			OnModifyPro();
			break;
		}
		case ID_NEWFLR:
		{
			OnBnClickedButton2();
			break;
		}
		case ID_DELFLR:
		{
			OnBnClickedButton3();
			break;
		}
		case ID_MODFLR:
		{
			OnModifyFloor();
			break;
		}
		case ID_3DAXLN:
		{
			OnBnClickedButton4();
			break;
		}
		case ID_3DAXCPY:
		{
			On3DAxisLineCopy();
		}
		case ID_SHOWFR:
		{
			OnBnClickedButton5();
			break;
		}
		case ID_HIDEFR:
		{
			OnBnClickedButton6();
			break;
		}
		case ID_3D:
		{
			OnBnClickedButton8();
			break;
		}
		case ID_REFRSH:
		{
			OnBnClickedButton9();
			break;
		}
		case ID_CROSSSEL:
		{
			OnCrossSelFloorView(hItem);
			break;
		}
		case ID_SELDWG:
		{
			OnSeldwgFloorView(hItem);
			break;
		}
		case ID_OPENDWG:
		{
			OnOpenFloorViewdwgFile(hItem);
		}
		default:
			break;
		}
	}
	else
	{
		if (m_wndFloorView.GetCount() == 0)
		{
			menu.AppendMenu(MF_BYCOMMAND | MF_STRING | EnableMenuItem(hItem, ID_REFRSH), ID_REFRSH, _T("刷新(&R)"));

			int nID = menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, ptcursor.x, ptcursor.y, &m_wndFloorView);
			switch (nID)
			{
				case ID_REFRSH:
				{
					OnBnClickedButton9();
					break;
				}
				default:
					break;
			}
		}
	}

}

//刷新
void CXMLCDlg::Refrush()
{
	//+--项目名称
	// +---视图名称
	//	+----楼层名称
	m_wndFloorView.DeleteAllItems();

	//先建好平面,立面 节点
	//g_pszViews

	AcAxDocLock lock;

	//模型空间的字典中放置
	AcDbDatabase *pDb = acdbCurDwg();
	if (pDb == NULL) return;

	AcDbObjectId idSpace = pDb->currentSpaceId();
	AcDbObject *pObj = NULL;
	if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForRead))
	{
		AcDbObjectId idDic = pObj->extensionDictionary();

		AcDbDictionary *pDic = NULL;
		Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
		if (es == Acad::eOk)
		{
			//AcDbXFloorFrame handle
			//PRO_NAME - FloorEx Handle - FloorEx Handle- FloorEx Handle- FloorEx Handle...
			AcDbObject *pSubObj = NULL;
			es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForRead);
			if (es == Acad::eOk)
			{
				AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
				if (pRec != NULL)
				{
					CString sProjName;
					pRec->GetProjectName(sProjName);

					double dBomEl = 0.0;
					dBomEl = pRec->GetBomEl();

					CString sBom, sRem, sBasePt;
					HTREEITEM hProject = NULL;

					pRec->GetRem(sRem);

					AcGePoint3d ptBase;
					pRec->GetBasePoint(ptBase);
					sBasePt.Format(_T("%g,%g,%g"),ptBase.x,ptBase.y,ptBase.z);
				
					//项目名称
					hProject = m_wndFloorView.InsertItem(sProjName, IMG_ROOT, IMG_ROOT);
						
					m_wndFloorView.SelectItem(m_wndFloorView.GetRootItem());
					m_wndFloorView.Expand(m_wndFloorView.GetRootItem(), TVE_EXPAND);

					sBom.Format(_T("%.1f"), dBomEl);
					int nItem = m_wndFloorView.GetRowOfItem(hProject);
					m_wndFloorView.ListSetItem(nItem, 1, _T(""));
					m_wndFloorView.ListSetItem(nItem, 2, sBom);
					m_wndFloorView.ListSetItem(nItem, 3, _T(""));
					m_wndFloorView.ListSetItem(nItem, 4, _T(""));
					m_wndFloorView.ListSetItem(nItem, 5, _T(""));
					m_wndFloorView.ListSetItem(nItem, 6, sBasePt);
					m_wndFloorView.ListSetItem(nItem, 7, sRem);

					//建立视图节点
					CMapStringToPtr mapView2Item;
					HTREEITEM hItem = NULL,hView = NULL, hFloor = NULL;
					for (int i = 0; i < sizeof(g_pszViews) / sizeof(g_pszViews[0]); i++)
					{
						if (g_pszViews[i] != NULL)
						{
							hItem = m_wndFloorView.InsertItem(g_pszViews[i], IMG_VIEW, IMG_VIEW_ON, hProject);
							mapView2Item.SetAt(g_pszViews[i], hItem);

							m_wndFloorView.SelectItem(hProject);
							m_wndFloorView.Expand(hProject, TVE_EXPAND);

							nItem = m_wndFloorView.GetRowOfItem(hItem);
							m_wndFloorView.ListSetItem(nItem, 1, _T(""));
							m_wndFloorView.ListSetItem(nItem, 2, _T(""));
							m_wndFloorView.ListSetItem(nItem, 3, _T(""));
							m_wndFloorView.ListSetItem(nItem, 4, _T(""));
							m_wndFloorView.ListSetItem(nItem, 5, _T(""));
							m_wndFloorView.ListSetItem(nItem, 6, _T(""));
							m_wndFloorView.ListSetItem(nItem, 7, _T(""));
						}
					}

					//楼层名称
					FloorViewData viewData;
					memset(&viewData, 0, sizeof(FloorViewData));
					CString sFr, sTo,sH, sTmp;

					for(int ii = 0;ii < pRec->GetCount();ii++)
					{
						pRec->GetFloorViewRecord(ii, viewData);

						if (mapView2Item.Lookup(viewData.m_szFloorView, (void*&)hView))
						{
							//楼层名称
							hFloor = m_wndFloorView.InsertItem(viewData.m_szName, IMG_FLOOR, IMG_FLOOR_ON, hView);

							m_wndFloorView.SelectItem(hView);
							m_wndFloorView.Expand(hView, TVE_EXPAND);

							//temp point
							FloorViewData *pViewData = &viewData;

							nItem = m_wndFloorView.GetRowOfItem(hFloor);
							sFr.Format(_T("%d"), pViewData->m_nFloorIndxFr);
							m_wndFloorView.ListSetItem(nItem, 1, sFr);
							
							//底标高
							sFr.Format(_T("%.3f"), GetBomElTo(pRec,viewData));
							m_wndFloorView.ListSetItem(nItem, 2, sFr);

							if (pViewData->m_bFloorIndxTo)
							{
								sTo.Format(_T("%d"), pViewData->m_nFloorIndxTo);
								m_wndFloorView.ListSetItem(nItem, 3, sTo);
							}

							sH.Format(_T("%d"), pViewData->m_nFloorH);
							m_wndFloorView.ListSetItem(nItem, 4, sH);

							sTmp = pViewData->m_nActive ? _T("活动") : _T("非活动");
							m_wndFloorView.ListSetItem(nItem, 5, sTmp);

							m_wndFloorView.ListSetItem(nItem, 6, pViewData->m_szID);

							m_wndFloorView.ListSetItem(nItem, 7, pViewData->m_szFilePath);
						}
					}
				}
				pSubObj->close();
			}
			pDic->close();
		}
		pObj->close();
	}
}

//刷新
void CXMLCDlg::OnBnClickedButton9()
{
	Refrush();
}

//新建项目
void CXMLCDlg::NewProjectFloorView(CString& sName,double dBomEl,CString& sBasePt,CString& sRem)
{
	AcGePoint3d ptBase;
	std::vector<CString> arXYZ;
	CoreTools::SplitString(sBasePt, _T(","), arXYZ);
	if (arXYZ.size() == 3)
	{
		ptBase.x = _ttof(arXYZ.at(0));
		ptBase.y = _ttof(arXYZ.at(1));
		ptBase.z = _ttof(arXYZ.at(2));
	}

	HTREEITEM hRoot = m_wndFloorView.GetRootItem();

	AcAxDocLock lock;

	//模型空间的字典中放置
	AcDbDatabase *pDb = acdbCurDwg();
	if (pDb == NULL) return;

	AcDbObjectId idSpace = pDb->currentSpaceId();
	AcDbObject *pObj = NULL;
	if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForWrite))
	{
		pObj->createExtensionDictionary();
		AcDbObjectId idDic = pObj->extensionDictionary();

		AcDbDictionary *pDic = NULL;
		Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForWrite);
		if (es == Acad::eOk)
		{
			//AcDbXFloorFrame handle
			//PRO_NAME - FloorEx Handle - FloorEx Handle- FloorEx Handle- FloorEx Handle...
			AcDbObject *pSubObj = NULL;
			es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite);

			if (es == Acad::eKeyNotFound)
			{
				AecFloorViewDataRecord *pFvRec = new AecFloorViewDataRecord;
				pFvRec->SetProjectName(sName);
				pFvRec->SetBomEl(dBomEl);
				pFvRec->SetBasePoint(ptBase);
				pFvRec->SetRem(sRem);

				AcDbObjectId idRec;
				pDic->setAt(KEY_NAME, pFvRec, idRec);
				pFvRec->close();
			}
			else if (es == Acad::eOk)
			{
				AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
				if (pRec != NULL)
				{
					pRec->SetProjectName(sName);
					pRec->SetBomEl(dBomEl);
					pRec->SetBasePoint(ptBase);
					pRec->SetRem(sRem);
				}
				pSubObj->close();
			}
			pDic->close();
		}
		pObj->close();
	}

	//g_pszViews
	if (hRoot == NULL)
	{
		HTREEITEM hRoot = m_wndFloorView.InsertItem(sName, IMG_ROOT, IMG_ROOT);

		CString sBom;
		sBom.Format(_T("%.1f"), dBomEl);

		int nItem = m_wndFloorView.GetRowOfItem(hRoot);
		m_wndFloorView.ListSetItem(nItem, 1, _T(""));
		m_wndFloorView.ListSetItem(nItem, 2, sBom);
		m_wndFloorView.ListSetItem(nItem, 3, _T(""));
		m_wndFloorView.ListSetItem(nItem, 4, _T(""));
		m_wndFloorView.ListSetItem(nItem, 5, _T(""));
		m_wndFloorView.ListSetItem(nItem, 6, sBasePt);
		m_wndFloorView.ListSetItem(nItem, 7, sRem);

		HTREEITEM hItem = NULL;
		for (int i = 0; i < sizeof(g_pszViews) / sizeof(g_pszViews[0]); i++)
		{
			if (g_pszViews[i] != NULL)
			{
				hItem = m_wndFloorView.InsertItem(g_pszViews[i], IMG_VIEW, IMG_VIEW_ON, hRoot);

				nItem = m_wndFloorView.GetRowOfItem(hItem);
				m_wndFloorView.ListSetItem(nItem, 1, _T(""));
				m_wndFloorView.ListSetItem(nItem, 2, _T(""));
				m_wndFloorView.ListSetItem(nItem, 3, _T(""));
				m_wndFloorView.ListSetItem(nItem, 4, _T(""));
				m_wndFloorView.ListSetItem(nItem, 5, _T(""));
				m_wndFloorView.ListSetItem(nItem, 6, _T(""));
				m_wndFloorView.ListSetItem(nItem, 7, _T(""));
			}
		}
		m_wndFloorView.SelectItem(hRoot);
		m_wndFloorView.Expand(hRoot, TVE_EXPAND);
	}
	else
	{
		CString sBom;
		sBom.Format(_T("%.1f"), dBomEl);

		int nItem = m_wndFloorView.GetRowOfItem(hRoot);
		m_wndFloorView.ListSetItem(nItem, 2, sBom);

		m_wndFloorView.SetItemText(hRoot, sName);

		HTREEITEM hProject = m_wndFloorView.GetChildItem(hRoot);
		if (hProject != NULL)
		{
			nItem = m_wndFloorView.GetRowOfItem(hProject);
			m_wndFloorView.ListSetItem(nItem, 1, _T(""));
			m_wndFloorView.ListSetItem(nItem, 2, _T(""));
			m_wndFloorView.ListSetItem(nItem, 3, _T(""));
			m_wndFloorView.ListSetItem(nItem, 4, _T(""));
			m_wndFloorView.ListSetItem(nItem, 5, _T(""));
			m_wndFloorView.ListSetItem(nItem, 6, sBasePt);
			m_wndFloorView.ListSetItem(nItem, 7, sRem);
		}
	}
}

//新建项目
void CXMLCDlg::OnBnClickedButton1()
{
	//+--项目名称--对齐点 标高
	// +---视图名称
	//	+----楼层名称

	CAcModuleResourceOverride myResources;

	CProSetDlg dlg;
	HTREEITEM hRoot = m_wndFloorView.GetRootItem();
	if (hRoot != NULL)
	{
		dlg.m_sName = m_wndFloorView.GetItemText(hRoot);
	}
	if (IDOK == dlg.DoModal())
	{
		NewProjectFloorView(dlg.m_sName,dlg.m_dBomEl,dlg.m_sBasePt,dlg.m_sRem);
	}
}

void CXMLCDlg::OnModifyPro()
{
	AcAxDocLock lock;

	//模型空间的字典中放置
	AcDbDatabase *pDb = acdbCurDwg();
	if (pDb == NULL) return;

	CString sProjName, sRem, sBasePt;
	double dBomEl = 0.0;
	AcGePoint3d ptBase;
	bool bHsPro = false;

	AcDbObjectId idSpace = pDb->currentSpaceId();
	AcDbObject *pObj = NULL;
	if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForRead))
	{
		AcDbObjectId idDic = pObj->extensionDictionary();

		AcDbDictionary *pDic = NULL;
		Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
		if (es == Acad::eOk)
		{
			//AcDbXFloorFrame handle
			//PRO_NAME - FloorEx Handle - FloorEx Handle- FloorEx Handle- FloorEx Handle...
			AcDbObject *pSubObj = NULL;
			es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForRead);
			if (es == Acad::eOk)
			{
				AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
				if (pRec != NULL)
				{
					pRec->GetProjectName(sProjName);

					dBomEl = pRec->GetBomEl();

					pRec->GetRem(sRem);

					pRec->GetBasePoint(ptBase);
					sBasePt.Format(_T("%g,%g,%g"), ptBase.x, ptBase.y, ptBase.z);

					bHsPro = true;
				}
				pSubObj->close();
			}
			pDic->close();
		}
		pObj->close();
	}

	if (bHsPro)
	{
		CAcModuleResourceOverride myResources;
		CProSetDlg dlg;

		dlg.m_sName = sProjName;
		dlg.m_dBomEl = dBomEl;
		dlg.m_sBasePt = sBasePt;
		dlg.m_sRem = sRem;

		if (IDOK == dlg.DoModal())
		{
			NewProjectFloorView(dlg.m_sName, dlg.m_dBomEl, dlg.m_sBasePt, dlg.m_sRem);
		}
	}
}

//项目标高
double CXMLCDlg::GetProBomEl()
{
	CString sTmp = _T("0.0");
	HTREEITEM hRoot = m_wndFloorView.GetRootItem();
	if (hRoot != NULL)
	{
		int nItem = m_wndFloorView.GetRowOfItem(hRoot);
		if (nItem != -1)
		{
			sTmp = m_wndFloorView.ListGetItemText(nItem, 2);
		}
	}

	CString sReal = sTmp;
	int nPos = sTmp.Find(_T(':'));
	if (nPos != -1)
	{
		sReal = sTmp.Mid(nPos + 1);
	}
	return _ttof(sReal);
}

BOOL CXMLCDlg::GetItemViewData(HTREEITEM hItem, FloorViewData &data)
{
	memset(&data, 0, sizeof(FloorViewData));

	int nImage = -1,nImge2 = -1;
	m_wndFloorView.GetItemImage(hItem, nImage, nImge2);

	if (nImage != IMG_FLOOR)//不是楼层
	{
		return FALSE;
	}

	CString sTmp;
	int nItem = m_wndFloorView.GetRowOfItem(hItem);
	if (nItem != -1)
	{
		//FloorIndxFr不能为空
		sTmp = m_wndFloorView.ListGetItemText(nItem, 1);
		
		data.m_nFloorIndxFr = _ttoi(sTmp);

		//底标高
		//ListGetItemText(nItem,2)

		//终止层
		sTmp = m_wndFloorView.ListGetItemText(nItem, 3);
		data.m_nFloorIndxTo = _ttoi(sTmp);

		if (data.m_nFloorIndxTo > data.m_nFloorIndxFr)
			data.m_bFloorIndxTo = TRUE;

		sTmp = m_wndFloorView.ListGetItemText(nItem, 4);
		data.m_nFloorH = _ttoi(sTmp);

		//状态
		sTmp = m_wndFloorView.ListGetItemText(nItem, 5);
		data.m_nActive = _ttoi(sTmp);

		sTmp = m_wndFloorView.ListGetItemText(nItem, 6);
		_tcscpy(data.m_szID, (LPCTSTR)sTmp);

		sTmp = m_wndFloorView.ListGetItemText(nItem, 7);
		_tcscpy(data.m_szFilePath, (LPCTSTR)sTmp);

		sTmp = m_wndFloorView.ListGetItemText(nItem, 0);
		_tcscpy(data.m_szName, (LPCTSTR)sTmp);

		HTREEITEM hParent = m_wndFloorView.GetParentItem(hItem);
		if (hParent == NULL)
		{
			return FALSE;
		}
		sTmp = m_wndFloorView.GetItemText(hParent);
		_tcscpy(data.m_szFloorView, (LPCTSTR)sTmp);

		return TRUE;
	}
	return FALSE;
}

//新建楼层
void CXMLCDlg::OnBnClickedButton2()
{
	if (m_wndFloorView.GetCount() == 0)
	{
		AfxMessageBox(_T("请新建项目!"));
		return;
	}

	CAcModuleResourceOverride myResources;
	CFloorViewNameDlg dlg;
	dlg.m_bNewFloor = TRUE;
	if (IDOK == dlg.DoModal())
	{
		//...
		HTREEITEM hViewFind = NULL;
		HTREEITEM hRoot = m_wndFloorView.GetRootItem();
		if (hRoot != NULL)//项目
		{
			//判断是否已经存在
			HTREEITEM hFloor = NULL;
			CString sText,sViewName;
			HTREEITEM hView = m_wndFloorView.GetChildItem(hRoot);
			while (hView != NULL)
			{
				hFloor = m_wndFloorView.GetChildItem(hView);
				while (hFloor != NULL)
				{
					sText = m_wndFloorView.GetItemText(hFloor);
					if (sText.CompareNoCase(dlg.m_sName) == 0)
					{
						AfxMessageBox(_T("楼层名称同名,已经存在!"));
						return;
					}

					hFloor = m_wndFloorView.GetNextSiblingItem(hFloor);
				}

				sViewName = m_wndFloorView.GetItemText(hView);
				if (sViewName.CompareNoCase(dlg.m_sFloorView) == 0)
				{
					hViewFind = hView;
					break;
				}
				if (hViewFind != NULL)
					break;
				hView = m_wndFloorView.GetNextSiblingItem(hView);
			}

			//找到楼层视图名
			if (hViewFind == NULL)
			{
				CString sTip;
				sTip.Format(_T("没有找到楼层视图节点%s"), dlg.m_sFloorView);
				AfxMessageBox(sTip);
				return;
			}

			//创建楼层
			hFloor = m_wndFloorView.InsertItem(dlg.m_sName, IMG_FLOOR, IMG_FLOOR_ON, hViewFind);
			m_wndFloorView.SelectItem(hViewFind);
			m_wndFloorView.Expand(hViewFind, TVE_EXPAND);

			int nItem = m_wndFloorView.GetRowOfItem(hFloor);

			CString sFr, sTo, sH;
			sFr.Format(_T("%d"), dlg.m_nFloorIndxFr);
			m_wndFloorView.ListSetItem(nItem, 1, sFr);

			if (dlg.m_bFloorIndxTo)
			{
				sTo.Format(_T("%d"), dlg.m_nFloorIndxTo);
				m_wndFloorView.ListSetItem(nItem, 3, sTo);
			}
			sH.Format(_T("%d"), dlg.m_nFloorH);
			m_wndFloorView.ListSetItem(nItem, 4, sH);
			m_wndFloorView.ListSetItem(nItem, 5, _T("非活动"));

			FloorViewData viewData;
			memset(&viewData, 0, sizeof(FloorViewData));

			viewData.m_nFloorIndxFr = dlg.m_nFloorIndxFr;
			viewData.m_bFloorIndxTo = dlg.m_bFloorIndxTo;
			viewData.m_nFloorIndxTo = dlg.m_nFloorIndxTo;
			viewData.m_nFloorH = dlg.m_nFloorH;
			viewData.m_nActive = 0;

			_tcscpy(viewData.m_szID, IDCreate());
			m_wndFloorView.ListSetItem(nItem, 6, viewData.m_szID);

			_tcscpy(viewData.m_szFloorView, (LPCTSTR)dlg.m_sFloorView);
			_tcscpy(viewData.m_szName, (LPCTSTR)dlg.m_sName);
			
			//底标高
			sFr.Format(_T("%.3f"), GetBomElTo(hFloor, viewData));
			m_wndFloorView.ListSetItem(nItem, 2, sFr);

			AcAxDocLock lock;

			//模型空间的字典中放置
			AcDbDatabase *pDb = acdbCurDwg();
			if (pDb == NULL) return;

			AcDbObjectId idSpace = pDb->currentSpaceId();
			AcDbObject *pObj = NULL;
			if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForWrite))
			{
				AcDbObjectId idDic = pObj->extensionDictionary();

				AcDbDictionary *pDic = NULL;
				Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
				if (es == Acad::eOk)
				{
					//AcDbXFloorFrame handle
					//PRO_NAME- FloorEx Handle- FloorEx Handle- FloorEx Handle- FloorEx Handle...
					AcDbObject *pSubObj = NULL;
					if (Acad::eOk == (es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite)))
					{
						AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
						if (pRec != NULL)
						{
							pRec->AddFloorViewRecord(viewData);
						}
						pSubObj->close();
					}
					pDic->close();
				}
				pObj->close();
			}
		}
	}
}

double CXMLCDlg::GetBomElTo(AecFloorViewDataRecord *pRec, FloorViewData &vtTo)
{
	double dBomEl = pRec->GetBomEl();

	FloorViewData vtDL;
	for (int i = 0;i < pRec->GetCount();i++)
	{
		pRec->GetFloorViewRecord(i, vtDL);

		if (vtDL.m_nFloorIndxFr < vtTo.m_nFloorIndxFr)
		{
			if (vtDL.m_bFloorIndxTo)
			{
				dBomEl += (vtDL.m_nFloorIndxTo - vtDL.m_nFloorIndxFr + 1) * vtDL.m_nFloorH;
			}
			else
			{
				dBomEl += vtDL.m_nFloorH;
			}
		}
	}
	return dBomEl;
}

double CXMLCDlg::GetBomElTo(HTREEITEM hCurFloor,FloorViewData& vtTo)
{
	double dBomEl = GetProBomEl();
	HTREEITEM hFloorView = m_wndFloorView.GetParentItem(hCurFloor);//项目
	if (hFloorView != NULL)
	{
		FloorViewData vtDL;
		HTREEITEM hChild = m_wndFloorView.GetChildItem(hFloorView);//楼层视图
		while (hChild != NULL)
		{
			if (GetItemViewData(hChild, vtDL))
			{
				if (vtDL.m_nFloorIndxFr < vtTo.m_nFloorIndxFr)
				{
					if (vtDL.m_bFloorIndxTo)
					{
						dBomEl += (vtDL.m_nFloorIndxTo - vtDL.m_nFloorIndxFr + 1) * vtDL.m_nFloorH;
					}
					else
					{
						dBomEl += vtDL.m_nFloorH;
					}
				}
			}
			hChild = m_wndFloorView.GetNextSiblingItem(hChild);
		}
	}
	return dBomEl;
}

//三维轴网
void CXMLCDlg::OnBnClickedButton4()
{
	HTREEITEM hSelect = m_wndFloorView.GetSelectedItem();
	if (hSelect != NULL)
	{
		int nImage = -1,nImage2 = -1;
		m_wndFloorView.GetItemImage(hSelect, nImage, nImage2);

		if (nImage == IMG_FLOOR)//是楼层
		{
			FloorViewData viewData;
			if (!GetItemViewData(hSelect, viewData))
			{
				AfxMessageBox(_T("没有获取到楼层数据设置!"));
				return;
			}

			//或取到此层的底标高
			double dBomEl = GetBomElTo(hSelect,viewData);

			//获取底标高+之前的层高
			struct resbuf rb;
			acedGetVar(_T("elevation"), &rb);
			rb.resval.rreal = dBomEl;
			acedSetVar(_T("elevation"), &rb);

			struct resbuf rb3;
			acedGetVar(_T("userr3"), &rb3);
			rb3.resval.rreal = viewData.m_bFloorIndxTo ? ((viewData.m_nFloorIndxTo - viewData.m_nFloorIndxFr + 1) * viewData.m_nFloorH) : viewData.m_nFloorH;
			acedSetVar(_T("userr3"), &rb3);

			//布置轴网
			acedPostCommand(_T("PL_BZZW "));
		}
		else
		{
			AfxMessageBox(_T("请选择楼层节点创建轴网!"));
		}
	}
	else
	{
		AfxMessageBox(_T("请选择楼层节点创建轴网!"));
	}
}

//复制轴网
void CXMLCDlg::On3DAxisLineCopy()
{
	HTREEITEM hSelect = m_wndFloorView.GetSelectedItem();
	if (hSelect != NULL)
	{
		int nImage = -1, nImage2 = -1;
		m_wndFloorView.GetItemImage(hSelect, nImage, nImage2);

		if (nImage != IMG_FLOOR)//是楼层
		{
			AfxMessageBox(_T("选择节点不是楼层，请选择目标楼层复制轴网到该层!"));
			return;
		}
	}

	CMapStringToPtr mapNameToItem;
	//弹出界面,选择某层轴网
	HTREEITEM hRoot = m_wndFloorView.GetRootItem();
	if (hRoot != NULL)
	{
		HTREEITEM hFloorXY = m_wndFloorView.GetChildItem(hRoot);
		CString sName = m_wndFloorView.GetItemText(hFloorXY);
		if (sName.CompareNoCase(FLOOR_XY) == 0)
		{
			HTREEITEM hParent = m_wndFloorView.GetParentItem(hSelect);
			if (hParent != hFloorXY)
			{
				AfxMessageBox(_T("选择节点不是标准楼层，请选择目标标准楼层复制轴网到该层!"));
				return;
			}

			HTREEITEM hChild = m_wndFloorView.GetChildItem(hFloorXY);

			while (hChild != NULL)
			{
				int nImage = -1, nImage2 = -1;
				m_wndFloorView.GetItemImage(hChild, nImage, nImage2);

				if (nImage == IMG_FLOOR)//是楼层
				{
					if (hChild != hSelect)
					{
						sName = m_wndFloorView.GetItemText(hChild);
						mapNameToItem.SetAt(sName, hChild);
					}
				}
				hChild = m_wndFloorView.GetNextSiblingItem(hChild);
			}

			CAcModuleResourceOverride myResources;
			CCopyAxFrFloorDlg dlg;
			dlg.SetFloorMap(&mapNameToItem);
			if (IDOK == dlg.DoModal())
			{
				HTREEITEM hFromFloor;
				CString sFromFloor;
				dlg.GetSelectFloor(sFromFloor);
				mapNameToItem.Lookup(sFromFloor, (void *&)hFromFloor);

				FloorViewData viewData;
				if (!GetItemViewData(hFromFloor, viewData))
				{
					AfxMessageBox(_T("没有获取到楼层数据设置!"));
					return;
				}

				AcDbObjectIdArray arIds;
				GetFloorAxisLines(viewData.m_szID, arIds);

				double dStaBomEl = GetProBomEl();


				FloorViewData viewDataTo;
				if (!GetItemViewData(hSelect, viewDataTo))
				{
					AfxMessageBox(_T("没有获取到当前楼层数据!"));
					return;
				}

				//或取到此层的底标高
				double dBomEl = GetBomElTo(hSelect, viewDataTo);

				AcAxDocLock lock;

				SetActive(hSelect, viewDataTo);

				AcGePoint3d ptS, ptE, ptC;
				AcDbEntity *pEnt = NULL;
				Acad::ErrorStatus es;
				AcDbObjectId idT;

				for (int i = 0;i < arIds.length();i++)
				{
					if (Acad::eOk == (es = acdbOpenAcDbEntity(pEnt, arIds.at(i), AcDb::kForRead)))
					{
						AcDbEntity *pEntCln = (AcDbEntity *)pEnt->clone();
						if (pEntCln != NULL)
						{
							AcDbLine *pLn = AcDbLine::cast(pEntCln);
							if (pLn != NULL)
							{
								ptS = pLn->startPoint();
								ptS.z = dBomEl;

								ptE = pLn->endPoint();
								ptE.z = dBomEl;

								pLn->setStartPoint(ptS);
								pLn->setEndPoint(ptE);
							}

							AcDbArc *pArc = AcDbArc::cast(pEntCln);
							if (pArc != NULL)
							{
								ptC = pArc->center();
								ptC.z = dBomEl;
								pArc->setCenter(ptC);
							}

							CKTCadUtility::AddToBlockTableRecord(pEntCln);
							pEntCln->close();
						}
						pEnt->close();
					}
				}
			}
		}
	}
}

//删除楼层
void CXMLCDlg::OnBnClickedButton3()
{
	//删除节点
	//删除链点
	//删除框
	HTREEITEM hSelect = m_wndFloorView.GetSelectedItem();
	if (hSelect != NULL)
	{
		int nImage = -1, nImage2 = -1;
		m_wndFloorView.GetItemImage(hSelect, nImage, nImage2);

		if (nImage == IMG_FLOOR)
		{
			FloorViewData vData;
			memset(&vData, 0, sizeof(FloorViewData));

			//删除节点
			CString sFloor = m_wndFloorView.GetItemText(hSelect);
			m_wndFloorView.DeleteItem(hSelect);
			
			//删除链点
			AcAxDocLock lock;
			AcDbDatabase *pDb = acdbCurDwg();
			if (pDb == NULL) return;

			AcDbObjectId idSpace = pDb->currentSpaceId();
			AcDbObject *pObj = NULL;
			if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForRead))
			{
				AcDbObjectId idDic = pObj->extensionDictionary();

				AcDbDictionary *pDic = NULL;
				Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
				if (es == Acad::eOk)
				{
					//AcDbXFloorFrame handle
					//PRO_NAME- FloorEx Handle- FloorEx Handle- FloorEx Handle- FloorEx Handle...
					AcDbObject *pSubObj = NULL;
					if (Acad::eOk == (es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite)))
					{
						AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
						if (pRec != NULL)
						{
							pRec->GetFloorViewRecord(sFloor, vData);
							pRec->RemoveFloorViewRecord(sFloor);
						}
						pSubObj->close();
					}
					pDic->close();
				}
				pObj->close();
			}

			if (_tcscmp(vData.m_szFloorView, FLOOR_XY) == 0)
				RemoveFloorEntities(vData.m_szID);
			else
				RemoveFloorFrame(vData.m_szName);
		}
		else
		{
			AfxMessageBox(_T("请选择楼层节点删除!"));
		}
	}
}

void CXMLCDlg::OnModifyFloor()
{
	HTREEITEM hSelect = m_wndFloorView.GetSelectedItem();
	if (hSelect != NULL)
	{
		int nImage = -1, nImage2 = -1;
		m_wndFloorView.GetItemImage(hSelect, nImage, nImage2);

		if (nImage == IMG_FLOOR)
		{
			FloorViewData vData;
			memset(&vData, 0, sizeof(FloorViewData));

			//节点
			CString sFloor = m_wndFloorView.GetItemText(hSelect);

			//链点
			AcAxDocLock lock;
			AcDbDatabase *pDb = acdbCurDwg();
			if (pDb == NULL) return;

			AcDbObjectId idSpace = pDb->currentSpaceId();
			AcDbObject *pObj = NULL;
			if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForRead))
			{
				AcDbObjectId idDic = pObj->extensionDictionary();

				AcDbDictionary *pDic = NULL;
				Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
				if (es == Acad::eOk)
				{
					//AcDbXFloorFrame handle
					//PRO_NAME- FloorEx Handle- FloorEx Handle- FloorEx Handle- FloorEx Handle...
					AcDbObject *pSubObj = NULL;
					if (Acad::eOk == (es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite)))
					{
						AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
						if (pRec != NULL)
						{
							pRec->GetFloorViewRecord(sFloor, vData);

							CAcModuleResourceOverride myResources;
							CFloorViewNameDlg dlg;
							
							dlg.m_nFloorIndxFr = vData.m_nFloorIndxFr;
							dlg.m_bFloorIndxTo = vData.m_bFloorIndxTo;
							dlg.m_nFloorIndxTo = vData.m_nFloorIndxTo;
							dlg.m_nFloorH = vData.m_nFloorH;
							dlg.m_sFloorView = vData.m_szFloorView;
							dlg.m_sName = vData.m_szName;
							dlg.m_dFloorElFr = GetBomElTo(pRec, vData);

							if (IDOK == dlg.DoModal())
							{
								vData.m_nFloorIndxFr = dlg.m_nFloorIndxFr;
								vData.m_bFloorIndxTo = dlg.m_bFloorIndxTo;
								vData.m_nFloorIndxTo = dlg.m_nFloorIndxTo;
								vData.m_nFloorH = dlg.m_nFloorH;

								_tcscpy(vData.m_szFloorView, (LPCTSTR)dlg.m_sFloorView);
								_tcscpy(vData.m_szName, (LPCTSTR)dlg.m_sName);

								int nItem = m_wndFloorView.GetRowOfItem(hSelect);

								m_wndFloorView.ListSetItem(nItem, 0, dlg.m_sName);

								CString sFr, sTo, sH,sEl;
								sFr.Format(_T("%d"), dlg.m_nFloorIndxFr);
								m_wndFloorView.ListSetItem(nItem, 1, sFr);

								sEl.Format(_T("%.3f"), GetBomElTo(pRec, vData));
								m_wndFloorView.ListSetItem(nItem, 2, sEl);

								if (dlg.m_bFloorIndxTo)
								{
									sTo.Format(_T("%d"), dlg.m_nFloorIndxTo);
									m_wndFloorView.ListSetItem(nItem, 3, sTo);
								}
								sH.Format(_T("%d"), dlg.m_nFloorH);
								m_wndFloorView.ListSetItem(nItem, 4, sH);
								m_wndFloorView.ListSetItem(nItem, 5, vData.m_nActive ? _T("活动") : _T("非活动"));

								//先删除,后加
								pRec->RemoveFloorViewRecord(sFloor);
								pRec->AddFloorViewRecord(vData);
							}
						}
						pSubObj->close();
					}
					pDic->close();
				}
				pObj->close();
			}
		}
	}
}

//显示楼层
void CXMLCDlg::OnBnClickedButton5()
{
	//框内实体设置显示
	HTREEITEM hSelect = m_wndFloorView.GetSelectedItem();
	if (hSelect != NULL)
	{
		int nImage = -1, nImage2 = -1;
		m_wndFloorView.GetItemImage(hSelect, nImage, nImage2);

		if (nImage == IMG_FLOOR)
		{
			CString sFloor = m_wndFloorView.GetItemText(hSelect);
			FloorViewData viewData;
			if (!GetItemViewData(hSelect, viewData))
			{
				AfxMessageBox(_T("没有获取到楼层数据设置!"));
				return;
			}
			
			if (_tcslen(viewData.m_szFilePath) > 0)
			{
				CString sFile = viewData.m_szFilePath; sFile.MakeLower();
				if (sFile.Find(_T(".dwg")) != -1)
				{
					AfxMessageBox(_T("本楼层为外部Dwg文件楼层,请代开外部dwg文件操作!"));
					return;
				}
			}

			AcAxDocLock lock;
			if (_tcscmp(viewData.m_szFloorView, FLOOR_XY) == 0)
			{
				double dBomEl = GetBomElTo(hSelect, viewData);

				ShowFloorEntities(&viewData, dBomEl, 1);
			}
			else
			{
				ShowFloorFrame(viewData.m_szName, 1);
			}
		}
		else
		{
			AfxMessageBox(_T("请选择楼层节点显示!"));
		}
	}
}

//隐藏楼层
void CXMLCDlg::OnBnClickedButton6()
{
	//框内实体隐藏
	//框内实体设置显示
	HTREEITEM hSelect = m_wndFloorView.GetSelectedItem();
	if (hSelect != NULL)
	{
		int nImage = -1,nImage2 = -1;
		m_wndFloorView.GetItemImage(hSelect, nImage, nImage2);

		if (nImage == IMG_FLOOR)
		{
			CString sFloor = m_wndFloorView.GetItemText(hSelect);
			FloorViewData ViewData;
			if (!GetItemViewData(hSelect, ViewData))
			{
				return;
			}

			if (_tcslen(ViewData.m_szFilePath) > 0)
			{
				CString sFile = ViewData.m_szFilePath; sFile.MakeLower();
				if (sFile.Find(_T(".dwg")) != -1)
				{
					AfxMessageBox(_T("本楼层为外部Dwg文件楼层,请代开外部dwg文件操作!"));
					return;
				}
			}
			
			double dBomEl = GetBomElTo(hSelect, ViewData);

			AcAxDocLock lock;
			if (_tcscmp(ViewData.m_szFloorView, FLOOR_XY) == 0)
				ShowFloorEntities(&ViewData, dBomEl, 0);
			else
				ShowFloorFrame(ViewData.m_szName, 0);
		}
		else
		{
			AfxMessageBox(_T("请选择楼层节点隐藏!"));
		}
	}
}

//组装三维
void CXMLCDlg::OnBnClickedButton8()
{
	//1.层实体做块记录
	//2.wbclone到db
	
	//首选选择三维视图节点
	CString sFloor;
	HTREEITEM hSelect = m_wndFloorView.GetSelectedItem();
	if (hSelect != NULL)
	{
		sFloor = m_wndFloorView.GetItemText(hSelect);
	}

	if (sFloor.CompareNoCase(FLOOR_3D) != 0)
	{
		AfxMessageBox(_T("请先选择三维视图节点,显示三维!"));
		return;
	}

	//1.获取当前图所有的楼层框
	AcAxDocLock lock;
	ShowFloorEntities(NULL,0.0,1);

	// 转到西南轴侧
	SHacedCommand(RTSTR, _T("_view"), RTSTR, _T("_swiso"), NULL);
#ifdef ZWCAD
	SHacedCommand(RTSTR, _T("_SHADEMODE"), RTSTR, _T("_G"), RTNONE);
#else
	SHacedCommand(RTSTR, _T("_vscurrent"), RTSTR, _T("c"), RTNONE);
#endif
}

//框选**图
void CXMLCDlg::OnCrossSelFloorView(HTREEITEM hView)
{
	//框选,加入楼层框
	ads_point pt1, pt2;
	int nRes = acedGetPoint(NULL, _T("\n请框选范围左下角点:"), pt1);
	if (nRes == RTNORM)
	{
		nRes = acedGetCorner(pt1, _T("\n请框选范围左下角点:"), pt2);
		if (nRes == RTNORM)
		{
			CAcModuleResourceOverride myResources;
			CNameDlg dlg;
			if (IDOK == dlg.DoModal())
			{
				CString sText;
				HTREEITEM hFloor = m_wndFloorView.GetChildItem(hView);
				while (hFloor != NULL)
				{
					sText = m_wndFloorView.GetItemText(hFloor);
					if (sText.CompareNoCase(dlg.m_sName) == 0)
					{
						AfxMessageBox(_T("楼层名称同名,已经存在!"));
						return;
					}
					hFloor = m_wndFloorView.GetNextSiblingItem(hFloor);
				}

				FloorViewData vData;
				memset(&vData, 0, sizeof(FloorViewData));

				CString sFloor = m_wndFloorView.GetItemText(hView);
				_tcscpy(vData.m_szFloorView, sFloor);
				_tcscpy(vData.m_szID, IDCreate());
				_tcscpy(vData.m_szName, dlg.m_sName);
				vData.m_nActive = 1;

				//创建楼层
				hFloor = m_wndFloorView.InsertItem(dlg.m_sName, IMG_FLOOR, IMG_FLOOR_ON, hView);
				m_wndFloorView.SelectItem(hView);
				m_wndFloorView.Expand(hView, TVE_EXPAND);

				int nItem = m_wndFloorView.GetRowOfItem(hFloor);

				CString sFr = _T(""), sTo = _T(""), sH = _T("");
				m_wndFloorView.ListSetItem(nItem, 1, sFr);
				m_wndFloorView.ListSetItem(nItem, 3, _T(""));
				m_wndFloorView.ListSetItem(nItem, 3, sTo);
				m_wndFloorView.ListSetItem(nItem, 4, sH);
				m_wndFloorView.ListSetItem(nItem, 5, _T("活动"));

				AcAxDocLock lock;
				//模型空间的字典中放置
				AcDbDatabase *pDb = acdbCurDwg();
				if (pDb == NULL) return;

				AcDbObjectId idSpace = pDb->currentSpaceId();
				AcDbObject *pObj = NULL;
				if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForWrite))
				{
					AcDbObjectId idDic = pObj->extensionDictionary();

					AcDbDictionary *pDic = NULL;
					Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
					if (es == Acad::eOk)
					{
						//AcDbXFloorFrame handle
						//PRO_NAME- FloorEx Handle- FloorEx Handle- FloorEx Handle- FloorEx Handle...
						AcDbObject *pSubObj = NULL;
						if (Acad::eOk == (es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite)))
						{
							AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
							if (pRec != NULL)
							{
								pRec->AddFloorViewRecord(vData);
							}
							pSubObj->close();
						}
						pDic->close();
					}
					pObj->close();
				}

				//加入楼层框
				ads_point pt11, pt22;
				acdbUcs2Wcs(pt1, pt11, false);
				acdbUcs2Wcs(pt2, pt22, false);

				AcDbXFloorFrame *pFloorFr = new AcDbXFloorFrame;
				pFloorFr->SetFloorFrame(sFloor, asPnt3d(pt11), asPnt3d(pt22), asPnt3d(pt11));
				pFloorFr->SetFloorName(dlg.m_sName);
				pFloorFr->GetFloorViewName(sFloor);
				CoreTools::AddToModelSpace(pFloorFr);
			}
		}
	}
}

//选择dwg文件 **图
void CXMLCDlg::OnSeldwgFloorView(HTREEITEM hView)
{
	const TCHAR *pszFilter = _T("dwg文件 (*.dwg;)|*.dwg|");
	CFileDialog dlg(TRUE, _T("dwg"), NULL, OFN_HIDEREADONLY, pszFilter, NULL);

	TCHAR strFileName[MAX_PATH] = _T("");
	TCHAR strFileTitle[] = _T("选择视图对应的DWG文件");
	int maxChar = MAX_PATH;

	dlg.m_ofn.lpstrFile = strFileName;
	dlg.m_ofn.nMaxFile = maxChar;
	dlg.m_ofn.lpstrTitle = strFileTitle;

	if (dlg.DoModal() != IDOK)
	{
		return;
	}

	CString sFilePath = dlg.GetPathName();
	CString sFileName = dlg.GetFileName();

	CString sText;
	HTREEITEM hFloor = m_wndFloorView.GetChildItem(hView);
	while (hFloor != NULL)
	{
		sText = m_wndFloorView.GetItemText(hFloor);
		if (sText.CompareNoCase(sFileName) == 0)
		{
			AfxMessageBox(_T("楼层名称同名,已经存在!"));
			return;
		}
		hFloor = m_wndFloorView.GetNextSiblingItem(hFloor);
	}

	FloorViewData vData;
	memset(&vData, 0, sizeof(FloorViewData));

	CString sFloor = m_wndFloorView.GetItemText(hView);
	_tcscpy(vData.m_szFloorView, sFloor);
	_tcscpy(vData.m_szID, IDCreate());
	_tcscpy(vData.m_szName, sFileName);
	_tcscpy(vData.m_szFilePath, sFilePath);
	vData.m_nActive = 0;

	//创建楼层
	hFloor = m_wndFloorView.InsertItem(sFileName, IMG_FLOOR, IMG_FLOOR_ON, hView);
	m_wndFloorView.SelectItem(hView);
	m_wndFloorView.Expand(hView, TVE_EXPAND);

	int nItem = m_wndFloorView.GetRowOfItem(hFloor);

	CString sFr = _T(""), sTo = _T(""), sH = _T("");
	m_wndFloorView.ListSetItem(nItem, 1, sFr);
	m_wndFloorView.ListSetItem(nItem, 2, _T(""));
	m_wndFloorView.ListSetItem(nItem, 3, sTo);
	m_wndFloorView.ListSetItem(nItem, 4, sH);
	m_wndFloorView.ListSetItem(nItem, 5, _T("非活动"));
	m_wndFloorView.ListSetItem(nItem, 6, vData.m_szID);
	m_wndFloorView.ListSetItem(nItem, 7, sFilePath);
	
	AcAxDocLock lock;
	//模型空间的字典中放置
	AcDbDatabase *pDb = acdbCurDwg();
	if (pDb == NULL) return;

	AcDbObjectId idSpace = pDb->currentSpaceId();
	AcDbObject *pObj = NULL;
	if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForWrite))
	{
		AcDbObjectId idDic = pObj->extensionDictionary();

		AcDbDictionary *pDic = NULL;
		Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
		if (es == Acad::eOk)
		{
			//AcDbXFloorFrame handle
			//PRO_NAME- FloorEx Handle- FloorEx Handle- FloorEx Handle- FloorEx Handle...
			AcDbObject *pSubObj = NULL;
			if (Acad::eOk == (es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite)))
			{
				AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
				if (pRec != NULL)
				{
					pRec->AddFloorViewRecord(vData);
				}
				pSubObj->close();
			}
			pDic->close();
		}
		pObj->close();
	}
}

typedef struct OpenFileParam
{
	TCHAR szDwgFile[MAX_PATH];
	CWnd *pParent;
}OPENFILEPARAM;

static void OpenDwgFile(void *pData)
{
	OpenFileParam *pParam = (OpenFileParam *)pData;
	AcApDocument *pDoc = acDocManager->curDocument();
	if (acDocManager->isApplicationContext())
	{
	#if ARX < 21
		acDocManager->pushResourceHandle(acedGetAcadResourceInstance());
	#endif
		acDocManager->appContextOpenDocument(pParam->szDwgFile);
		acDocManager->popResourceHandle();
	}
}

//打开dwg文件 **图
void CXMLCDlg::OnOpenFloorViewdwgFile(HTREEITEM hItem)
{
	FloorViewData data;
	memset(&data, 0, sizeof(FloorViewData));
	if (!GetItemViewData(hItem, data))
	{
		return;
	}
	else
	{
		if (_tcslen(data.m_szFilePath) > 0)
		{
			CFileFind fd;
			if (fd.FindFile(data.m_szFilePath))
			{
				static OpenFileParam param;
				memset(&param, 0, sizeof(OpenFileParam));

				_tcscpy(param.szDwgFile, data.m_szFilePath);
				param.pParent = &m_wndFloorView;
				acDocManager->executeInApplicationContext(OpenDwgFile, (void *)&param);
			}
		}
	}
}

void CXMLCDlg::SetActive(HTREEITEM hHit, FloorViewData& viewData)
{
	HTREEITEM hRoot = m_wndFloorView.GetParentItem(hHit);
	if (hRoot != NULL)//是楼层视图
	{
		//判断是否已经存在
		int nItem = -1;
		HTREEITEM hView = m_wndFloorView.GetChildItem(hRoot);
		while (hView != NULL)
		{
			nItem = m_wndFloorView.GetRowOfItem(hView);
			if (hHit == hView)
			{
				m_wndFloorView.ListSetItem(nItem, 5, _T("活动"));
			}
			else
			{
				m_wndFloorView.ListSetItem(nItem, 5, _T("非活动"));
			}
			hView = m_wndFloorView.GetNextSiblingItem(hView);
		}
	}

	double dBomEl = 0.0;
	//模型空间的字典中放置
	bool bZoomTo = false;
	AcDbDatabase *pDb = acdbCurDwg();
	if (pDb == NULL) return;

	AcDbObjectId idSpace = pDb->currentSpaceId();
	AcDbObject *pObj = NULL;
	if (Acad::eOk == acdbOpenObject(pObj, idSpace, AcDb::kForRead))
	{
		AcDbObjectId idDic = pObj->extensionDictionary();

		AcDbDictionary *pDic = NULL;
		Acad::ErrorStatus es = acdbOpenObject(pDic, idDic, AcDb::kForRead);
		if (es == Acad::eOk)
		{
			//AcDbXFloorFrame handle
			//PRO_NAME- FloorEx Handle- FloorEx Handle- FloorEx Handle- FloorEx Handle...
			AcDbObject *pSubObj = NULL;
			if (Acad::eOk == (es = pDic->getAt(KEY_NAME, pSubObj, AcDb::kForWrite)))
			{
				AecFloorViewDataRecord *pRec = AecFloorViewDataRecord::cast(pSubObj);
				if (pRec != NULL)
				{
					if (_tcscmp(viewData.m_szFloorView, FLOOR_XY) == 0)
					{
						pRec->SetActive(viewData.m_szName, 1);

						dBomEl = GetBomElTo(pRec, viewData);

						//同时显示本层实体
						ShowFloorEntities(&viewData, dBomEl, 1);
					}
					else
					{
						bZoomTo = true;
					}
				}
				pSubObj->close();
			}
			pDic->close();
		}
		pObj->close();
	}

	if (bZoomTo)
	{
		CString sFloorName;
		//找到名称是 viewData.m_szName 的楼层框
		CString sFile = viewData.m_szFilePath;
		sFile.MakeLower();
		if ( sFile.Find(_T(".dwg")) == -1)//不是外部参照
		{
			ads_name ss, ent;
			AcDbObjectId id;
			struct resbuf *pRb = acutBuildList(RTDXF0, _T("AEC_XFLOORFR"), 0);//AcDbXFloorFrame

			int nRes = acedSSGet(_T("A"), NULL, NULL, pRb, ss);
			acutRelRb(pRb);

			Adesk::Int32 nLen = 0;
			acedSSLength(ss, &nLen);

			CString sFloorNo;
			AcGePoint3d pt1, pt2, pt3;
			bool bZoom = false;
			AcDbEntity *pEnt = NULL;
			for (int i = 0;i < nLen;i++)
			{
				acedSSName(ss, i, ent);
				acdbGetObjectId(id, ent);

				if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
				{
					AcDbXFloorFrame *pFloorFr = AcDbXFloorFrame::cast(pEnt);
					pFloorFr->GetFloorName(sFloorName);

					pFloorFr->GetFloorFrame(sFloorNo, pt1, pt2,pt3);

					if (sFloorName.CompareNoCase(viewData.m_szName) == 0)
					{
						bZoom = true;
						pEnt->close();
						break;
					}
					pEnt->close();
				}
			}
			acedSSFree(ss);

			if (bZoom)
			{
				CKTCadUtility::Zoom(pt1, pt2);
			}
		}
	}
	else
	{
		//actrTransactionManager->flushGraphics();
		acedUpdateDisplay();
	}
}

void CXMLCDlg::GetFloorAxisLines(LPCTSTR pszID,AcDbObjectIdArray& arIds)
{
	AcAxDocLock lock;
	ads_name ss, ent;
	int nRet = acedSSGet(_T("A"), NULL, NULL, NULL, ss);

	Adesk::Int32 nLen = 0;
	acedSSLength(ss, &nLen);

	AcDbObjectId id, idAxis;
	idAxis = KTSetting::InitLayer(_T("LAY_AXIS"));;

	Acad::ErrorStatus es;
	AcDbEntity *pEnt = NULL;
	for (int i = 0; i < nLen; i++)
	{
		acedSSName(ss, i, ent);
		acdbGetObjectId(id, ent);

		if (Acad::eOk == (es = acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead)))
		{
			struct resbuf *pRb = pEnt->xData(KEY_FLOOR);
			if (pRb != NULL)
			{
				struct resbuf *pTmp = pRb->rbnext;
				//while (pTmp != NULL)
				{
					if (pTmp->restype == AcDb::kDxfXdAsciiString)
					{
						if (_tcscmp(pTmp->resval.rstring, pszID) == 0)
						{
							if (pEnt->layerId() == idAxis)
							{
								arIds.append(id);
							}
						}
					}
					pTmp = pTmp->rbnext;
				}
				acutRelRb(pRb);
			}
			pEnt->close();
		}
	}
	acedSSFree(ss);
}

static bool HasIntersectOnZ(double dZmin, double dZmax, double dFrEl, double dToEl)
{
	//判断无交集
	if (fabs(dZmin - dZmax) < 1.e-6)//等高 是轴网，二维线 
	{
		double dZ = dZmin;
		if ( (dZ - dFrEl) < -1.e-6)//相等可以
			return false;

		if (fabs(dZ - dToEl) < 1.e-6)//排除落在顶层位置
			return false;

		if (fabs(dZ - dFrEl) < 1.e-6)
			return true;
	}

	if ( (dZmax - dFrEl) < 1.e-6)//排除相等
		return false;

	if ( (dZmin - dToEl) > -1.e-6)//排除相等
		return false;

	return true;
}

void CXMLCDlg::ShowFloorEntities(FloorViewData *pViewData, double dBomEl, Adesk::Int16 nActive)
{
	getEntitiesOfFloor(pViewData, dBomEl, m_idIns, m_idOuts);
	for (int i(0); i < m_idIns.length(); ++i)
	{
		AcDbEntityPointer ent(m_idIns[i], AcDb::kForWrite);
		if (ent.openStatus() != Acad::eOk) continue;
		ent->setVisibility(nActive ? AcDb::kVisible : AcDb::kInvisible);

	}

	for (int i(0); i < m_idOuts.length(); ++i)
	{
		AcDbEntityPointer ent(m_idOuts[i], AcDb::kForWrite);
		if (ent.openStatus() != Acad::eOk) continue;
		ent->setVisibility(nActive ? AcDb::kInvisible : AcDb::kVisible);
	}

}

void CXMLCDlg::RemoveFloorEntities(LPCTSTR pszID)
{
	/*
	ads_name ss, ent;
	int nRet = acedSSGet(_T("A"), NULL, NULL, NULL, ss);

	Adesk::Int32 nLen = 0;
	acedSSLength(ss, &nLen);

	AcDbObjectId id;
	AcDbEntity *pEnt = NULL;

	for (int i = 0; i < nLen; i++)
	{
		acedSSName(ss, i, ent);
		acdbGetObjectId(id, ent);

		if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
		{
			struct resbuf *pRb = pEnt->xData(KEY_FLOOR);
			if (pRb != NULL)
			{
				struct resbuf *pTmp = pRb;
				while (pTmp != NULL)
				{
					if (pTmp->restype == AcDb::kDxfXdAsciiString)
					{
						if (_tcscmp(pTmp->resval.rstring, pszID) == 0)
						{
							if (pEnt->visibility() == AcDb::kInvisible)
							{
								pEnt->setVisibility(AcDb::kVisible);
							}
							
							// 存在清空
							struct resbuf *pTmp2 = acutNewRb(AcDb::kDxfRegAppName);
							acutNewString(KEY_FLOOR, pTmp2->resval.rstring);

							pEnt->setXData(pTmp2);
							acutRelRb(pTmp2);

							break;
						}
					}
					pTmp = pTmp->rbnext;
				}
				acutRelRb(pRb);
			}
			pEnt->close();
		}
	}*/
}

void CXMLCDlg::RemoveFloorFrame(LPCTSTR pszName)
{
	ads_name ss, ent;
	AcDbObjectId id;
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("AEC_XFLOORFR"), 0);

	int nRes = acedSSGet(_T("A"), NULL, NULL, pRb, ss);
	acutRelRb(pRb);

	Adesk::Int32 nLen = 0;
	acedSSLength(ss, &nLen);

	CString sFloorName;
	Acad::ErrorStatus es;
	AcDbEntity *pEnt = NULL;
	for (int i = 0; i < nLen; i++)
	{
		acedSSName(ss, i, ent);
		acdbGetObjectId(id, ent);

		if (Acad::eOk == (es = acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite)))
		{
			AcDbXFloorFrame *pFloorFr = AcDbXFloorFrame::cast(pEnt);
			pFloorFr->GetFloorName(sFloorName);
			if (sFloorName.CompareNoCase(pszName) == 0)
			{
				pEnt->erase();
				pEnt->close();
				break;
			}
			pEnt->close();
		}
	}
	acedSSFree(ss);
}

void CXMLCDlg::ShowFloorFrame(LPCTSTR pszName,Adesk::Int16 nActive)
{
	ads_name ss, ent;
	AcDbObjectId id;
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("AEC_XFLOORFR"), 0);

	int nRes = acedSSGet(_T("A"), NULL, NULL, pRb, ss);
	acutRelRb(pRb);

	Adesk::Int32 nLen = 0;
	acedSSLength(ss, &nLen);

	CString sFloorName,sFloorNo;
	AcGePoint3d pt1, pt2, pt3;
	bool bFind = false;
	AcDbEntity *pEnt = NULL;
	for (int i = 0; i < nLen; i++)
	{
		acedSSName(ss, i, ent);
		acdbGetObjectId(id, ent);

		if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
		{
			AcDbXFloorFrame *pFloorFr = AcDbXFloorFrame::cast(pEnt);
			pFloorFr->GetFloorName(sFloorName);
			pFloorFr->GetFloorFrame(sFloorNo, pt1, pt2, pt3);
			if (sFloorName.CompareNoCase(pszName) == 0)
			{
				bFind = true;
				break;
			}
			pEnt->close();
		}
	}
	acedSSFree(ss);

	if (bFind)
	{
		ads_point pt11, pt22;
		acdbWcs2Ucs(asDblArray(pt1), pt11, false);
		acdbWcs2Ucs(asDblArray(pt2), pt22, false);

		nRes = acedSSGet(_T("C"), pt11, pt22, NULL, ss);

		nLen = 0;
		acedSSLength(ss, &nLen);

		for (int i = 0; i < nLen; i++)
		{
			acedSSName(ss, i, ent);
			acdbGetObjectId(id, ent);

			if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
			{
				pEnt->setVisibility(nActive ? AcDb::kVisible : AcDb::kInvisible);
				pEnt->close();
			}
		}
		acedSSFree(ss);
	}
}