#include "stdafx.h"
#include "filepath.h"
#include <algorithm>
#include "KTCadUtility.h"
#include "modelLibDlgbase.h"
#include "CoreTools.h"
#include "aecdbewequipment.h"
#include "dbobjptr.h"
#include "EquInsDirJig.h"
#include "KTSetting.h"
#include "CFZSBAddDlg.h"
#include "ModelLibCopyTreeDlg.h"
#include "aecdbopening.h"
#include "aecdbx3dpartentity.h"
#include "aecdbwall.h"
#include "aecdbcolumn.h"

#define SHOWWINDOW(id, sh) if (GetDlgItem(id)) GetDlgItem(id)->ShowWindow(sh);

#define EQU_DIR _T("\\equipment")

namespace
{
	static std::map<int, CString> g_result;

	void refreshSearchResult(CUIISQLiteServer &db
		, bool bRefresh
		, LPCTSTR pszTablePrefix)
	{
		if (!bRefresh) return;
		if (!pszTablePrefix) return;

		g_result.clear();

		std::vector<std::vector<CString>> rr;
		CString sTbl(pszTablePrefix)
			, sql(_T(""));
		sql.Format(_T("SELECT distinct %s_package.[id], %s_folder.[folder], %s_class.[class], %s_package.[name]")
			_T("\nFROM %s_package")
			_T("\nINNER JOIN %s_folder, %s_class")
			_T("\nON(%s_package.[idclass] = %s_class.[id]")
			_T("\nAND %s_class.[idfolder] = %s_folder.[id])"), sTbl, sTbl, sTbl, sTbl, sTbl
			, sTbl, sTbl, sTbl, sTbl, sTbl, sTbl);
		db.GetSelDataEx(sql, rr);
		for (size_t i(0); i < rr.size(); ++i)
		{
			std::vector<CString> &ss(rr[i]);
			if (ss.size() < 3) continue;

			g_result.insert(
				std::make_pair(TypeConvert::convert<int, LPCTSTR>(ss[0])
					, (ss[1] + _T("\\") + ss[2] + _T("\\") + ss[3]).MakeUpper()));
		}
	}

	void search(CUIISQLiteServer &db
		, const std::vector<CString> &conditions
		, std::map<int, CString> &result
		, LPCTSTR pszTablePrefix)
	{
		if (g_result.empty())
		{
			refreshSearchResult(db, true, pszTablePrefix);
		}

		bool bFind(true);
		std::map<int, CString>::const_iterator it(g_result.begin());
		for (it; it != g_result.end(); ++it)
		{
			const CString &s(it->second);
			bFind = true;
			for (size_t i(0); i < conditions.size(); ++i)
			{
				if (s.Find(conditions[i]) == -1)
				{
					bFind = false;
					break;
				}
			}

			if (bFind)
			{
				result.insert(*it);
			}
		}
	}

	HTREEITEM FindTreeItem(CTreeCtrl *pTreeCtrl, HTREEITEM hItem, const CString &strText)
	{
		// 如果当前节点的文本匹配，返回该节点
		if (pTreeCtrl->GetItemText(hItem) == strText)
			return hItem;

		// 获取第一个子节点
		HTREEITEM hChildItem = pTreeCtrl->GetChildItem(hItem);
		while (hChildItem != NULL)
		{
			// 递归查找子节点
			HTREEITEM hFoundItem = FindTreeItem(pTreeCtrl, hChildItem, strText);
			if (hFoundItem != NULL)
				return hFoundItem;

			// 获取下一个兄弟节点
			hChildItem = pTreeCtrl->GetNextSiblingItem(hChildItem);
		}

		// 如果没有找到，返回 nullptr
		return NULL;
	}

	HTREEITEM FindItemInTreeCtrl(CTreeCtrl *pTreeCtrl, const CString &strText)
	{
		// 从根节点开始查找
		HTREEITEM hRootItem = pTreeCtrl->GetRootItem();
		while (hRootItem != NULL)
		{
			HTREEITEM hFoundItem = FindTreeItem(pTreeCtrl, hRootItem, strText);
			if (hFoundItem != NULL)
				return hFoundItem;

			// 查找下一个兄弟节点
			hRootItem = pTreeCtrl->GetNextSiblingItem(hRootItem);
		}

		return NULL; // 未找到返回 nullptr
	}

	// windows文件命不能含有“/\:*?"<>|”,统一替换为"'"
	CString checkFileName(LPCTSTR sfile)
	{
		if (!sfile) return _T("");
		CString s(sfile);
		s.Replace(_T('/'), _T('\''));
		s.Replace(_T('\\'), _T('\''));
		s.Replace(_T(':'), _T('\''));
		s.Replace(_T('*'), _T('\''));
		s.Replace(_T('?'), _T('\''));
		s.Replace(_T('\"'), _T('\''));
		s.Replace(_T('<'), _T('\''));
		s.Replace(_T('>'), _T('\''));
		s.Replace(_T('|'), _T('\''));
		return s;
	}

	CString getLastErrorMsg()
	{
		LPVOID lpMsgBuf;
		::FormatMessage(
			FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_FROM_SYSTEM |
			FORMAT_MESSAGE_IGNORE_INSERTS,
			NULL,
			GetLastError(),
			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
			(LPTSTR)&lpMsgBuf,
			0,
			NULL
		);
		CString sErr = (LPCTSTR)lpMsgBuf;
		LocalFree(lpMsgBuf);
		return sErr;
	}

	AecDbEwEquipment *makeEqu(LPCTSTR pszEqu, SH_BIM_BLOCK &bims)
	{
		if (!pszEqu) return NULL;
		if (_taccess(pszEqu, 0x0) != 0x0) return NULL;

		AecDbEwEquipment *pEqu = new AecDbEwEquipment();
		if (!pEqu->ReadFromFile(pszEqu))
		{
			DELETE_PTR(pEqu);
			return NULL;
		}

		bims.clear();
		CoreTools::getBimDatas(pEqu, bims);
		return pEqu;
	}

	void insertEqu(AecDbEwEquipment *pEqu)
	{
		if (!pEqu) return;

		AecMInterfaces *pMInf = (AecMInterfaces *)pEqu;

		CFZSBAddDlg dlg;
		dlg.SetEqu(pEqu, pMInf);
		if (IDOK == dlg.DoModal())
		{
			pEqu->SetAt(KEY_POSNO, dlg.m_sPosNo);
		}

		//设置osnap
		AcDbObjectId idPipe;
		double dEl = 0.0;
		bool bdEl = false;
		//选择插入点
		ads_point ptRes;
		while (TRUE)
		{
			acedInitGet(RSG_OTHER, _T("E R"));
			int nRes = acedGetPoint(NULL, _T("\n选择插入位置点或[指定标高(E)/参考点(R)]:"), ptRes);
			switch (nRes)
			{
			case RTNORM:
			{
				{
				EQU_INSERT_POS:
					acdbUcs2Wcs(ptRes, ptRes, false);
					if (bdEl) ptRes[Z] = dEl;

					AcGeVector3d vtMove = asPnt3d(ptRes).asVector();
					AcGeMatrix3d mat;
					mat.setToTranslation(vtMove);
					pEqu->transformBy(mat);

					struct resbuf rb;
					acedGetVar(_T("INSUNITS"), &rb);
					if (rb.resval.rint == AcDb::kUnitsMeters) //当前图是米制
					{
						AcGeMatrix3d scale;
						scale.setToScaling(.001);
						pEqu->AddTransform(scale);
					}

					//选择方向,插入
					CEquInsDirJig jig;
					jig.SetEqu(pEqu, asPnt3d(ptRes));
					if (jig.DoIt())
					{
						AcGeVector3d vtDir = AcGeVector3d::kXAxis;
						vtDir.rotateBy(jig.m_dAngle, AcGeVector3d::kZAxis);
						AcGePoint3d ptIns = asPnt3d(ptRes);
						pEqu->SetInsert(ptIns, vtDir);

						if (dlg.m_nIndex1 != -1 && dlg.m_bByInf)
						{
							//移动接口到ins 位置
							AecInterface infT;
							pEqu->GetInterface(dlg.m_nIndex1, infT);

							AcGeVector3d vtInfPos = ptIns - infT.ptPos;
							mat.setToTranslation(vtInfPos);
							pEqu->transformBy(mat);
						}

						AcDbObjectId idLayE, idLayC, idLayD;
						idLayE = KTSetting::InitLayer(LAY_EQU);
						idLayC = KTSetting::InitLayer(LAY_EQU_CENTER);
						idLayD = KTSetting::InitLayer(LAY_EQU_DASH);

						pEqu->setLayer(idLayE);
						pEqu->SetCenterLayer(idLayC);
						pEqu->SetDashLayer(idLayD);

						//设备内部已经处理了单位
						if (rb.resval.rint == AcDb::kUnitsMeters) //当前图是米制
						{
							pEqu->RemoveLastTransform();
						}

						CoreTools::AddToModelSpace(pEqu);
						return;
					}
					else
					{
						DELETE_PTR(pEqu);
						return;
					}
				}
				break;
			}
			case RTKWORD:
			{
				TCHAR szKey[3];
				acedGetInput(szKey);
				if (_tcsicmp(_T("E"), szKey) == 0)
				{
					CString sTip;
					sTip.Format(_T("\n请输入标高<%.1f>:"), dEl);

					nRes = acedGetReal(sTip, &dEl);

					if (nRes == RTNORM || nRes == RTNONE)
					{
						bdEl = true;
						continue;
					}
					else
					{
						return;
					}
				}
				else if (_tcsicmp(_T("R"), szKey) == 0)
				{
					//参考点<退出>:
					ads_point ptBase, pt22;
					int nRelt = acedGetPoint(NULL, _T("\n参考点<退出>:"), ptBase);
					if (nRelt == RTNORM)
					{
						//起点<退出>:
						nRelt = acedGetPoint(ptBase, _T("\n指定相对位置为插入点<退出>:"), pt22);
						if (nRelt == RTNORM)
						{
							ads_point_set(pt22, ptRes);

							goto EQU_INSERT_POS;
						}
					}
				}
				break;
			}
			default:
				return;
			}
		}
	}

	bool checkFileName(LPCTSTR pszName, LPCTSTR pszCondition)
	{
		if (!pszName || !pszCondition) return false;
		CString sName(pszName), sCondition(pszCondition);
		sName.MakeLower();
		sCondition.MakeLower();

		int idx = sName.Find(sCondition);
		if (idx == -1) return false;

		// 主要解决 在文件名中查找DN100 会得到 DN1000... 等结果
		// 只判断 子串 后面第一个字符是否是数字即可
		idx = idx + sCondition.GetLength();
		if (idx >= sName.GetLength()) return true;
		if (sName[idx] <= _T('9') && sName[idx] >= _T('0'))
			return false;
		return true;
	}

	HTREEITEM findSubDir(CTreeCtrl &tree, HTREEITEM hRoot, LPCTSTR pszSubDir)
	{
		if (!tree.ItemHasChildren(hRoot) || !pszSubDir) return NULL;

		CString str(_T(""));
		HTREEITEM hChildItem = tree.GetChildItem(hRoot);
		while (hChildItem != NULL)
		{
			str = tree.GetItemText(hChildItem);
			if (str == pszSubDir)
				return hChildItem;
			hChildItem = tree.GetNextItem(hChildItem, TVGN_NEXT);
		}
		return NULL;
	}

	void getAllChildrenItem(CTreeCtrl &tree, HTREEITEM hRoot, std::vector<HTREEITEM> &items)
	{
		if (!tree.ItemHasChildren(hRoot)) return;

		HTREEITEM hChildItem = tree.GetChildItem(hRoot);
		while (hChildItem != NULL)
		{
			items.push_back(hChildItem);
			getAllChildrenItem(tree, hChildItem, items);
			hChildItem = tree.GetNextItem(hChildItem, TVGN_NEXT);
		}
	}

	bool isFolderItem(CTreeCtrl &tree, HTREEITEM hItem)
	{
		return tree.GetRootItem() == tree.GetParentItem(hItem);
	}

	bool isRootItem(CTreeCtrl &tree, HTREEITEM hItem)
	{
		return hItem == tree.GetRootItem();
	}

	bool isClassItem(CTreeCtrl &tree, HTREEITEM hItem)
	{
		return (!isRootItem(tree, hItem) && !isFolderItem(tree, hItem));
	}

	HTREEITEM getParentFolder(CTreeCtrl &tree, const HTREEITEM &hItem)
	{
		if (hItem == tree.GetRootItem()) return NULL;
		if (isFolderItem(tree, hItem)) return hItem;

		HTREEITEM h = tree.GetParentItem(hItem);
		while (isClassItem(tree, h))
		{
			h = tree.GetParentItem(h);;
		}

		return h;
	}

	CString getClassName(CTreeCtrl &tree, const HTREEITEM &hItem)
	{
		if (!isClassItem(tree, hItem)) return _T("");
		CString sItem = tree.GetItemText(hItem);
		std::vector<CString> v;
		HTREEITEM hParent(hItem);
		while (isClassItem(tree, hParent))
		{
			v.push_back(tree.GetItemText(hParent));
			hParent = tree.GetParentItem(hParent);
		}
		CString sClass(_T(""));
		for (std::vector<CString>::reverse_iterator it = v.rbegin(); it != v.rend(); ++it)
		{
			sClass += *it;
			sClass += _T("\\");
		}
		sClass = sClass.Left(sClass.ReverseFind(_T('\\')));
		return sClass;
	}

	AecDbEwEquipment *makeEqu(CUIISQLiteServer &db, const int &fid)
	{
		CString sSQL(_T(""));
		std::vector<CString> ss;
		std::vector<std::vector<CString>> bims;
		ss.clear();
		sSQL.Format(_T("select id,name,idclass,rem from aec_package where ID='%d'"), fid);
		if (!db.GetSelData(sSQL, ss)) return NULL;
		if (ss.size() < 4) return NULL;

		CString tmpFile(FilePath::getSystemTemporaryFolder() + _T("\\temp_$_$_.equ"));
		sSQL.Format(_T("select package from aec_package where ID='%d'"), fid);
		if (!db.GetSelBlob(sSQL, tmpFile)) return NULL;

		AecDbEwEquipment *pEqu = new AecDbEwEquipment;

		if (!pEqu->ReadFromFile(tmpFile))
		{
			DELETE_PTR(pEqu);
			::DeleteFile(tmpFile);
			return NULL;
		}
		::DeleteFile(tmpFile);

		pEqu->GetSpecialtyData()->SetAt(KEY_ID, ss[0]);
		pEqu->GetSpecialtyData()->SetAt(KEY_NAME, ss[1]);
		pEqu->GetSpecialtyData()->SetAt(KEY_CLASSID, ss[2]);
		pEqu->GetSpecialtyData()->SetAt(_T("_KEY_REM_"), ss[3]);

		pEqu->setLayer(KTSetting::InitLayer(LAY_PIPE_OUTSIDE));
		pEqu->SetDashLayer(KTSetting::InitLayer(LAY_FITN_DASH));
		pEqu->SetCenterLayer(KTSetting::InitLayer(LAY_FITN_CENTER));

		//关闭箭头,通常入库的设备元件箭头是关闭的
		AecEqui::XPrimData xdata;
		pEqu->ModifyPrimData(0, xdata, 10);

		// BIM数据
		sSQL.Format(_T("select name,value from aec_bims where equid='%d'"), fid);
		if (db.GetSelDataEx(sSQL, bims))
		{
			SH_BIM_BLOCK datas;
			for (size_t b = 0; b < bims.size(); ++b)
			{
				std::vector<CString> &s(bims[b]);
				if (s.size() >= 2)
					datas.push_back(std::make_pair(s[0], s[1]));
			}
			CoreTools::setBimDatas(pEqu, datas);
		}

		return pEqu;
	}

	bool selectPath(LPCTSTR pszTitle, CString &strPath)
	{
		TCHAR           szFolderPath[MAX_PATH] = { 0 };
		CString         strFolderPath = TEXT("");
		BROWSEINFO      sInfo;
		::ZeroMemory(&sInfo, sizeof(BROWSEINFO));
		sInfo.pidlRoot = 0;
		sInfo.lpszTitle = pszTitle;
		sInfo.ulFlags = BIF_RETURNONLYFSDIRS | BIF_EDITBOX | BIF_DONTGOBELOWDOMAIN;
		sInfo.lpfn = NULL;
		LPITEMIDLIST lpidlBrowse = ::SHBrowseForFolder(&sInfo);
		if (lpidlBrowse != NULL)
		{
			if (::SHGetPathFromIDList(lpidlBrowse, szFolderPath))
			{
				strFolderPath = szFolderPath;
			}
		}
		if (lpidlBrowse != NULL)
		{
			::CoTaskMemFree(lpidlBrowse);
		}
		if (!lpidlBrowse)
			return false;

		if (_taccess(strFolderPath, 0x0) != 0x0)
		{
			AfxMessageBox(_T("请选择一个有效路径！"));
			return false;
		}

		strPath = strFolderPath + _T("\\");

		return true;
	}

	bool makeDir(CTreeCtrl &tree, HTREEITEM hItem, LPCTSTR pszRootDir)
	{
		if (!pszRootDir) return false;

		// 根目录不存在
		if (_taccess(pszRootDir, 0x0) != 0x0)
			return false;

		// hItem 所指目录已经存在, 继续新建子目录，如果不存在，新建
		CString sDir = pszRootDir + tree.GetItemText(hItem) + _T("\\");
		if (!(_taccess(sDir, 0x0) == 0x0))
		{
			if (!CreateDirectory(sDir, NULL))
			{
#ifndef NDEBUG
				AfxMessageBox(getLastErrorMsg());
#endif
				return false;
			}
		}

		if (!tree.ItemHasChildren(hItem)) return true;

		HTREEITEM hChildItem = tree.GetChildItem(hItem);
		while (hChildItem != NULL)
		{
			makeDir(tree, hChildItem, sDir);
			hChildItem = tree.GetNextItem(hChildItem, TVGN_NEXT);
		}
		return true;
	}

	int getLastInserId(CUIISQLiteServer &db, LPCTSTR pszTable)
	{
		CString sId;
		if (db.GetSelData(CString(_T("select last_insert_rowid() from")) + pszTable, sId))
			return TypeConvert::convert<int, LPCTSTR>(sId);
		return -1;
	}

	bool putEQUFileToDb(CUIISQLiteServer &db
		, LPCTSTR pszFile
		, int idClass)
	{
		if (!pszFile) return false;
		if (_taccess(pszFile, 0x0) != 0x0) return false;

		CString sName = CoreTools::getEquipmentName(pszFile);
		if (sName.IsEmpty()) return false;

		CString sql(_T(""));
		sql.Format(_T("insert into aec_package ([name],[rem],[idclass],[package]) values ('%s', '', '%d', ?)")
			, sName
			, idClass);
		if (db.InsertBlob(sql, pszFile) != 0)
		{
			db.BeginTrans();
			int fid = getLastInserId(db, _T("aec_package"));
			SH_BIM_BLOCK bims;
			SH_BIM_BLOCK::const_iterator it;
			AecDbEwEquipment *pEqu = makeEqu(pszFile, bims);
			DELETE_PTR(pEqu);
			for (it = bims.begin(); it != bims.end(); ++it)
			{
				sql.Format(_T("insert into aec_bims (name, value, equid) values ('%s', '%s', '%d')")
					, it->first
					, it->second
					, fid);
				db.ExecuteSQL(sql);
			}
			db.CommitTrans();
			return true;
		}

		return false;
	}

	bool putR2PFileToDb(CUIISQLiteServer &db
		, LPCTSTR pszFile
		, int idClass)
	{
		if (!pszFile) return false;
		if (_taccess(pszFile, 0x0) != 0x0) return false;

		CString sPath(pszFile);
		AecDbEwEquipment *pEqu = new AecDbEwEquipment();
		if (pEqu->ReadFromFile(sPath))
		{
			sPath = FilePath::getSystemTemporaryFolder() + _T("\\xxx__xx_dd.equ");
			pEqu->WriteToFile(sPath);
			DELETE_PTR(pEqu);
			return putEQUFileToDb(db, sPath, idClass);
		}

		return false;
	}

	bool putZHSBFileToDb(CUIISQLiteServer &db
		, LPCTSTR pszFile
		, int idClass
		, LPCTSTR pszBlkName
		, LPCTSTR pszPrefix)
	{
		if (!pszFile || !pszBlkName || !pszPrefix) return false;
		if (_taccess(pszFile, 0x0) != 0x0) return false;

		CString sFile(FilePath::getSystemTemporaryFolder() + _T("\\temp&&$$.dwg"));
		if (_taccess(sFile, 0x0) == 0x0)
			::DeleteFile(sFile);


		if (!::CopyFile(pszFile, sFile, false)) return false;

		std::shared_ptr<AcDbDatabase> pDb(new AcDbDatabase(false));
		if (pDb->readDwgFile(sFile, AcDbDatabase::kForReadAndAllShare) != Acad::eOk)
			return false;
		AcDbBlockTableRecordPointer pRcd(pszBlkName, pDb.get(), AcDb::kForRead);
		if (pRcd.openStatus() != Acad::eOk)
		{
			CString sErr(_T(""));
			sErr.Format(_T("文件%s，不是上华组合设备格式！"), pszFile);
			AfxMessageBox(sErr);
			return false;
		}

		CString sql(_T(""));
		sql.Format(_T("insert into %s_package ([name],[rem],[idclass],[package]) values ('%s', '', '%d', ?)")
			, pszPrefix
			, FilePath(pszFile)._file_name_without_ext
			, idClass);
		return db.InsertBlob(sql, sFile) == 0 ? false : true;
	}

	bool putEquFileToDb(CUIISQLiteServer &db, LPCTSTR pszFile, int idClass)
	{
		if (!pszFile) return false;
		if (_taccess(pszFile, 0x0) != 0x0) return false;

		CString sSuffix = FilePath(pszFile)._ext;

		if (sSuffix == _T(".equ"))
		{
			return putEQUFileToDb(db, pszFile, idClass);
		}
		else if (sSuffix == _T(".r2p"))
		{
			return putR2PFileToDb(db, pszFile, idClass);
		}
		else if (sSuffix == _T(".zhequ"))
		{
			return putZHSBFileToDb(db, pszFile, idClass, _T("ZH_SB_BLK_NAME"), _T("DWG"));
		}
		else if (sSuffix == _T(".shmod"))
		{
			return putZHSBFileToDb(db, pszFile, idClass, _T("MODEL_3D_BLK_NAME"), _T("MODEL"));
		}

		return false;
	}

	bool hasEquFilesInFolder(LPCTSTR pszDir)
	{
		std::vector<CString> vs;
		CoreTools::getFilesInFolder(pszDir, _T("*.equ"), vs, false, true);
		CoreTools::getFilesInFolder(pszDir, _T("*.r2p"), vs, false, true);
		CoreTools::getFilesInFolder(pszDir, _T("*.zhequ"), vs, false, true);
		return !vs.empty();
	}

	void importTo(LPCTSTR pszDir
		, CTreeCtrl &tree
		, CUIISQLiteServer &db
		, HTREEITEM hItem
		, LPCTSTR pszTablePrefix
		, const std::vector<CString> &fileTypes )
	{
		if (!pszDir || !pszTablePrefix) return;
		if (fileTypes.empty()) return;
		if (!hasEquFilesInFolder(pszDir)) return;

		CString sql(_T("")), sTbl(pszTablePrefix);

		std::vector<CString> v;
		std::vector<CString>::const_reverse_iterator rit;
		CoreTools::SplitString(pszDir, _T('\\'), v);
		if (v.empty()) return;
		CString sFolder(*v.rbegin()), sClassPath(_T(""));
		if (sFolder.IsEmpty())
		{
			for (rit = v.rbegin(); rit != v.rend(); ++rit)
			{
				if (!rit->IsEmpty())
				{
					sFolder = *rit;
					break;
				}
			}
		}
		int idFolder(-1);
		std::vector<CString> files;
		std::vector<CString> dirs;
		if (isRootItem(tree, hItem))
		{	// 如果选择的是根节点，则需要把第一个目录名当做Folder插入到数据库中
			HTREEITEM h = findSubDir(tree, hItem, sFolder);
			if (h)
			{
				idFolder = tree.GetItemData(h);
			}
			else
			{
				sql.Format(_T("insert into %s_folder (folder) values ('%s')"), sTbl, sFolder);
				if (!db.ExecuteSQL(sql))
				{
					AfxMessageBox(_T("新建Folder失败！"));
					return;
				}
				idFolder = getLastInserId(db, CString(pszTablePrefix) + _T("_folder"));
				h = tree.InsertItem(sFolder, 0, 2, hItem);
				tree.SetItemData(h, idFolder);
			}
			// Folder 目录下面没有文件操作
			dirs.clear();
			CoreTools::getSubFolderByPath(pszDir, dirs, false);
			for (size_t i = 0; i < dirs.size(); ++i)
			{
				importTo(dirs[i], tree, db, h, pszTablePrefix, fileTypes);
			}
		}
		else
		{	// 如果不是根目录，则只需要在hItem下面新建节点，并在 class 库内新建记录
			HTREEITEM h = findSubDir(tree, hItem, sFolder);
			if (!h)
			{
				h = tree.InsertItem(sFolder, 0, 2, hItem);
				HTREEITEM hFolder = getParentFolder(tree, h);
				idFolder = tree.GetItemData(hFolder);
				sClassPath = getClassName(tree, h);
				sql.Format(_T("insert into %s_class (class, idfolder) values('%s', '%d')")
					, sTbl, sClassPath, idFolder);
				if (!db.ExecuteSQL(sql))
				{
					tree.DeleteItem(h);
					AfxMessageBox(_T("向aec_class插入数据失败！"));
					return;
				}
				tree.SetItemData(h, getLastInserId(db, sTbl + _T("_class")));
			}

			sFolder = tree.GetItemText(getParentFolder(tree, h));
			sClassPath = getClassName(tree, h);
			
			int idClass = tree.GetItemData(h);
			files.clear();

			for (size_t i(0); i < fileTypes.size(); ++i)
			{
				CoreTools::getFilesInFolder(pszDir, fileTypes[i], files, false, false);
			}

			for (size_t f = 0; f < files.size(); ++f)
			{
				CString &sPath(files[f]);
				if (!putEquFileToDb(db, sPath, idClass)) continue;
			}

			dirs.clear();
			CoreTools::getSubFolderByPath(pszDir, dirs, false);
			for (size_t i = 0; i < dirs.size(); ++i)
			{
				importTo(dirs[i], tree, db, h, pszTablePrefix, fileTypes);
			}
		}
	}


	bool hasSameFileName(CListBox &list, LPCTSTR name)
	{
		CString s;
		for (int i = 0; i < list.GetCount(); ++i)
		{
			list.GetText(i, s);
			if (s == name)
				return true;
		}
		return false;
	}

	extern "C" bool WblockToDgnFile(AcDbVoidPtrArray &, LPCTSTR , const AcGePoint3d &);
	/*void saveToBentley(AecDbEwEquipment *pEqu, CString &sPath)
	{
		FilePath fp(sPath);
		CString sFile = fp._directory + fp._file_name_without_ext + _T(".dwg");
		pEqu->SetInsert(AcGePoint3d::kOrigin, AcGeVector3d::kXAxis);

		AcGiViewDraw dc(NULL, NULL);
		pEqu->Draw3d(dc);

		AcDbVoidPtrArray ar;
		pEqu->GetDraw3dables(ar, true);
		WblockToDgnFile(ar, sFile, AcGePoint3d::kOrigin);
	}*/
}

#pragma region CModelLibDlgBase
#define _VALVE_ _T("阀")
IMPLEMENT_DYNAMIC(CModelLibDlgBase, CDialog)

BEGIN_MESSAGE_MAP(CModelLibDlgBase, CDialog)
	ON_MESSAGE( WM_ACAD_KEEPFOCUS, &CModelLibDlgBase::onAcadKeepFocus)
	ON_BN_CLICKED(IDC_DIR_ADD, &CModelLibDlgBase::OnBnClickedDirAdd)
	ON_BN_CLICKED(IDC_DIR_MODI, &CModelLibDlgBase::OnBnClickedDirRename)
	ON_BN_CLICKED(IDC_DIR_DEL, &CModelLibDlgBase::OnBnClickedDirDel)
	ON_BN_CLICKED(IDC_DIR_OUT, &CModelLibDlgBase::OnBnClickedDirOut)
	ON_BN_CLICKED(IDC_DIR_IN, &CModelLibDlgBase::OnBnClickedDirIn)
	ON_BN_CLICKED(IDC_FILE_NEW, &CModelLibDlgBase::OnBnClickedFileNew)
	ON_BN_CLICKED(IDC_FILE_IN, &CModelLibDlgBase::OnBnClickedFileIn)
	ON_BN_CLICKED(IDC_FILE_COPY, &CModelLibDlgBase::OnBnClickedFileCopy)
	ON_BN_CLICKED(IDC_FILE_RENAME, &CModelLibDlgBase::OnBnClickedFileRename)
	ON_BN_CLICKED(IDC_FILE_DEL, &CModelLibDlgBase::OnBnClickedFileDel)
	ON_BN_CLICKED(IDC_FILE_OUT, &CModelLibDlgBase::OnBnClickedFileOut)
	ON_BN_CLICKED(IDC_BIM_ADD, &CModelLibDlgBase::OnBnClickedBimAdd)
	ON_BN_CLICKED(IDC_BIM_MODI, &CModelLibDlgBase::OnBnClickedBimModi)
	ON_BN_CLICKED(IDC_BIM_DEL, &CModelLibDlgBase::OnBnClickedBimDel)
	ON_BN_CLICKED(IDOK, &CModelLibDlgBase::OnBnClickedOk)
	ON_BN_CLICKED(IDC_INSERT, &CModelLibDlgBase::OnBnClickedInsert)
	ON_NOTIFY(TVN_SELCHANGED, IDC_DIR_TREE, &CModelLibDlgBase::OnTvnSelchangedLocalDirTree)
	ON_LBN_SELCHANGE(IDC_FILE_LIST, &CModelLibDlgBase::OnLbnSelchangeFileList)
	ON_WM_CONTEXTMENU()
	ON_BN_CLICKED(IDC_CHECK_SEARCH, &CModelLibDlgBase::OnCheckSearch)
	ON_EN_CHANGE(IDC_EDIT_SEARCH, &CModelLibDlgBase::OnEnChangeSearch)
	ON_LBN_DBLCLK(IDC_FILE_LIST, &CModelLibDlgBase::OnLbnDblClkFileList)
	ON_BN_CLICKED(IDC_BTN_EXPAND_SERVER, &CModelLibDlgBase::OnBnClickedBtnExpandServerDirTree)
END_MESSAGE_MAP()

CModelLibDlgBase::CModelLibDlgBase(LPCTSTR pszTitle, LPCTSTR pszDir, LPCTSTR pszFile, CWnd* pParent)
	: CDialog(CModelLibDlgBase::IDD, pParent)
	, m_hBitmap(NULL)
	, m_bSearch(FALSE)
	, m_strDirAnchor(_T(""))
	, m_strFileAnchor(_T(""))
	, m_iSelectFileID(-1)
	, m_sTitle(pszTitle)
	, m_nDlgExpandedWidth(0)
	, m_nDlgCollapsedWidth(0)
{
	if (pszDir)
		m_strDirAnchor = pszDir;
	if (pszFile)
		m_strFileAnchor = pszFile;
}

CModelLibDlgBase::~CModelLibDlgBase()
{
	if (m_hBitmap) ::DeleteObject(m_hBitmap);
}

void CModelLibDlgBase::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_DIR_TREE, m_ctrlLocalDirTree);
	DDX_Control(pDX, IDC_FILE_LIST, m_ctrlLocalFileList);
	DDX_Control(pDX, IDC_BIM_LIST, m_ctrlBimPropertyList);
	DDX_Control(pDX, IDC_EDIT_SEARCH, m_ctrlSearchEdit);

	DDX_Control(pDX, IDC_STATIC_SEP_MID, m_ctrlStaticSepMid);
	DDX_Control(pDX, IDC_STATIC_DIR, m_ctrlStaticDir);
	DDX_Control(pDX, IDC_STATIC_FILE, m_ctrlStaticFile);

	DDX_Check(pDX, IDC_CHECK_SEARCH, m_bSearch);
	DDX_Text(pDX, IDC_EDIT_SEARCH, m_sSearch);

	DDX_Control(pDX, IDC_STATIC_SEP_LEFT, m_ctrlStaticSepLeft);
	DDX_Control(pDX, IDC_SERVER_TREE, m_ctrlServerDirTree);
	DDX_Control(pDX, IDC_BTN_EXPAND_SERVER, m_btnExpandServerDirTree);
}

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

	// 初始化数据库
	initSqliteDB();


	// 此时还没有隐藏“共享文件”部分，先得到对话框宽度
	CRect rt1, rt2;
	GetWindowRect(&rt1);
	m_nDlgExpandedWidth = rt1.Width();
	m_ctrlStaticSepLeft.GetWindowRect(rt2);
	m_nDlgCollapsedWidth = m_nDlgExpandedWidth - (rt2.left - rt1.left);


	// 初始化image list
	initImageListForLocalDirTree();
	initImageListForServerDirTree();

	// 初始化目录树
	initLocalDirTree();

	// 初始化Server目录树
	initServerDirTree();

	// 初始化 BIM 属性列表
	initBimPropertyList();

	// 初始化预览控件
	initPreviewCtrl();

	m_ctrlLocalFileList.ResetContent();

	m_ctrlSearchEdit.EnableWindow(m_bSearch);

	UpdateData(FALSE);

	// 初始状态，为收起 “共享文件”部分
	ExpandServerDirTree(false);

	SetWindowText(m_sTitle);

	if (m_bSearch && !m_sSearch.IsEmpty())
	{	// 开始就进入搜索模式
		OnCheckSearch();
		OnEnChangeSearch();
	}
	return TRUE;
}

BOOL CModelLibDlgBase::DestroyWindow()
{
	g_result.clear();
	return CDialog::DestroyWindow();
}

void CModelLibDlgBase::getBimDatasByList(std::map<CString, CString> &bims)
{
	for (int i = 0; i < m_ctrlBimPropertyList.GetItemCount(); ++i)
	{
		bims.insert(std::make_pair(m_ctrlBimPropertyList.GetItemText(i, 0), m_ctrlBimPropertyList.GetItemText(i, 1)));
	}
}

void CModelLibDlgBase::getSelectedFiles(std::vector<int>& files)
{
	for (int i = 0; i < m_ctrlLocalFileList.GetCount(); ++i)
	{
		if (m_ctrlLocalFileList.GetSel(i) > 0)
		{
			files.push_back(i);
		}
	}
}

void CModelLibDlgBase::anchorDir()
{
	if (m_strDirAnchor.IsEmpty()) return;

	m_strDirAnchor.TrimLeft(_T('\\'));
	std::vector<CString> dirs;
	CoreTools::SplitString(m_strDirAnchor, _T('\\'), dirs);
	HTREEITEM hRoot = m_ctrlLocalDirTree.GetRootItem();
	for (size_t i = 0; i < dirs.size(); ++i)
	{
		HTREEITEM h = findSubDir(m_ctrlLocalDirTree, hRoot, dirs[i]);
		if (!h) break;
		hRoot = h;
		m_ctrlLocalDirTree.SelectItem(h);
		m_ctrlLocalDirTree.Expand(h, TVE_EXPAND);
	}
}

void CModelLibDlgBase::moveCtrlX(int ctrlID, int offset)
{
	CWnd *pWnd = GetDlgItem(ctrlID);
	if (!pWnd) return;

	CRect rect;
	::GetWindowRect(pWnd->m_hWnd, rect);


	rect.right += offset;
	rect.left += offset;
	
	ScreenToClient(rect);

	pWnd->MoveWindow(&rect);
}

void CModelLibDlgBase::moveCtrlX(int nDelta)
{
	moveCtrlX(IDC_STATIC_DIR, nDelta);
	moveCtrlX(IDC_STATIC_FILE, nDelta);
	moveCtrlX(IDC_CHECK_SEARCH, nDelta);
	moveCtrlX(IDC_EDIT_SEARCH, nDelta);

	moveCtrlX(IDC_DIR_TREE, nDelta);
	moveCtrlX(IDC_FILE_LIST, nDelta);
	moveCtrlX(IDC_STATIC_SEP_SEARCH, nDelta);
	moveCtrlX(IDC_STATIC_PREVIEW, nDelta);
	moveCtrlX(IDC_PREVIEW_PIC, nDelta);
	moveCtrlX(IDC_STATIC_SEP_BIM, nDelta);

	moveCtrlX(IDC_STATIC_BIM, nDelta);
	moveCtrlX(IDC_BIM_LIST, nDelta);
	moveCtrlX(IDC_STATIC_SEP_BOTTOM, nDelta);
	moveCtrlX(IDC_DIR_ADD, nDelta);
	moveCtrlX(IDC_DIR_MODI, nDelta);
	moveCtrlX(IDC_DIR_DEL, nDelta);
	moveCtrlX(IDC_DIR_IN, nDelta);
	moveCtrlX(IDC_DIR_OUT, nDelta);

	moveCtrlX(IDC_FILE_IN, nDelta);
	moveCtrlX(IDC_FILE_OUT, nDelta);
	moveCtrlX(IDC_FILE_COPY, nDelta);
	moveCtrlX(IDC_FILE_RENAME, nDelta);
	moveCtrlX(IDC_FILE_DEL, nDelta);
	moveCtrlX(IDC_FILE_NEW, nDelta);

	moveCtrlX(IDC_BIM_ADD, nDelta);
	moveCtrlX(IDC_BIM_MODI, nDelta);
	moveCtrlX(IDC_BIM_DEL, nDelta);

	moveCtrlX(IDC_BTN_EXPAND_SERVER, nDelta);
	moveCtrlX(IDOK, nDelta);
	moveCtrlX(IDC_INSERT, nDelta);

	moveCtrlX(IDC_STATIC_SEP_MID, nDelta);
	moveCtrlX(IDC_STATIC_SEP_RIGHT, nDelta);
}

void CModelLibDlgBase::ShowHideWindow(int ctrlID, bool bShow)
{
	CWnd *pWnd = GetDlgItem(ctrlID);
	if (!pWnd) return;

	pWnd->ShowWindow(bShow ? SW_SHOW : SW_HIDE);
}

bool CModelLibDlgBase::isFolderItem(HTREEITEM hItem)
{
	return ::isFolderItem(m_ctrlLocalDirTree, hItem);
}

bool CModelLibDlgBase::isRootItem(HTREEITEM hItem)
{
	return ::isRootItem(m_ctrlLocalDirTree, hItem);
}

bool CModelLibDlgBase::isClassItem(HTREEITEM hItem)
{
	return ::isClassItem(m_ctrlLocalDirTree, hItem);
}

HTREEITEM CModelLibDlgBase::getParentFolder(const HTREEITEM &hItem)
{
	return ::getParentFolder(m_ctrlLocalDirTree, hItem);
}

CString CModelLibDlgBase::getClassName(const HTREEITEM & hItem)
{
	return ::getClassName(m_ctrlLocalDirTree, hItem);
}

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

void CModelLibDlgBase::ExpandServerDirTree(bool bExpand)
{
	CRect rect;
	GetWindowRect(rect);
	int nDelta(m_nDlgExpandedWidth - m_nDlgCollapsedWidth);

	if (bExpand)
	{// 展开
		m_ctrlServerDirTree.ShowWindow(SW_SHOW);
		m_ctrlStaticSepLeft.ShowWindow(SW_SHOW);
		ShowHideWindow(IDC_DIR_ADD_TO_LOCAL, true);
		ShowHideWindow(IDC_STATIC_SERVER, true);
		rect.left = rect.right - m_nDlgExpandedWidth;
		MoveWindow(rect);
		moveCtrlX(nDelta);
		m_btnExpandServerDirTree.SetWindowText(_T("-->"));
	}
	else
	{// 收起
		m_ctrlServerDirTree.ShowWindow(SW_HIDE);
		m_ctrlStaticSepLeft.ShowWindow(SW_HIDE);
		ShowHideWindow(IDC_DIR_ADD_TO_LOCAL, false);
		ShowHideWindow(IDC_STATIC_SERVER, false);
		rect.left = rect.right - m_nDlgCollapsedWidth;
		MoveWindow(rect);
		moveCtrlX(-nDelta);
		m_btnExpandServerDirTree.SetWindowText(_T("<--"));
	}
	Invalidate(TRUE);
}

void CModelLibDlgBase::OnBnClickedDirAdd()
{
	BnClickedDirAdd();
}

void CModelLibDlgBase::OnBnClickedDirRename()
{
	BnClickedDirRename();
}

void CModelLibDlgBase::OnBnClickedDirDel()
{
	BnClickedDirDel();
}

void CModelLibDlgBase::OnBnClickedDirOut()
{
	BnClickedDirOut();
	
}

void CModelLibDlgBase::OnBnClickedDirIn()
{
	BnClickedDirIn();
}

void CModelLibDlgBase::OnBnClickedFileIn()
{
	BnClickedFileIn();
}

void CModelLibDlgBase::OnBnClickedFileCopy()
{
	BnClickedFileCopy();
}

void CModelLibDlgBase::helper_CurrentSelectFilePosition()
{
	std::vector<int> files;
	getSelectedFiles(files);
	if (files.size() != 1) return;
	
	CString path;
	m_ctrlLocalFileList.GetText(files[0], path);

	std::vector<CString> items;
	CoreTools::SplitString(path, _T("\\"), items);

	if (items.size() < 1) return;

	HTREEITEM hParent(m_ctrlLocalDirTree.GetRootItem());
	for (size_t i(0); i < items.size() - 1; ++i)
	{
		hParent = FindTreeItem(&m_ctrlLocalDirTree, hParent, items[i]);
	}

	if (!hParent) return;

	m_bSearch = FALSE;
	UpdateData(FALSE);
	
	OnCheckSearch();

	m_ctrlLocalDirTree.Select(hParent, TVGN_CARET);
	
	int idx = m_ctrlLocalFileList.FindString(0, *items.rbegin());
	if (idx != -1)
		m_ctrlLocalFileList.SetSel(idx);
}

void CModelLibDlgBase::OnBnClickedFileRename()
{
	BnClickedFileRename();
}

void CModelLibDlgBase::OnBnClickedFileDel()
{
	BnClickedFileDel();
}

void CModelLibDlgBase::OnBnClickedFileOut()
{
	BnClickedFileOut();
}

void CModelLibDlgBase::OnBnClickedBimAdd()
{
	BnClickedBimAdd();
}

void CModelLibDlgBase::OnBnClickedBimModi()
{
	BnClickedBimModi();
}

void CModelLibDlgBase::OnBnClickedBimDel()
{
	BnClickedBimDel();
}

void CModelLibDlgBase::OnBnClickedOk()
{
	BnClickedOk();
}

void CModelLibDlgBase::OnBnClickedInsert()
{
	BnClickedInsert();
}

AecDbEwEquipment* CModelLibDlgBase::getEquipment(int fid)
{
	return makeEqu(m_sqlDB, fid);
}

void CModelLibDlgBase::OnTvnSelchangedLocalDirTree(NMHDR *pNMHDR, LRESULT *pResult)
{
	TvnSelchangedLocalDirTree(pNMHDR, pResult);
}

void CModelLibDlgBase::OnLbnSelchangeFileList()
{
	LbnSelchangeFileList();
}

void CModelLibDlgBase::OnContextMenu(CWnd *pWnd, CPoint pt)
{
	UpdateData(TRUE);
	UINT uFlags;
	CPoint ptScreen = pt;

	::ScreenToClient(pWnd->GetSafeHwnd(), &ptScreen);
	if (pWnd->IsKindOf(RUNTIME_CLASS(CTreeCtrl)))
	{
		CTreeCtrl *pTreeCtrl = (CTreeCtrl*)CTreeCtrl::FromHandle(pWnd->GetSafeHwnd());
		HTREEITEM hItem = pTreeCtrl->HitTest(ptScreen, &uFlags);
		if ((hItem != NULL) && (TVHT_ONITEM & uFlags))
			pTreeCtrl->SelectItem(hItem);
	}
	else if (pWnd->IsKindOf(RUNTIME_CLASS(CListBox)))
	{
		CListBox *pListBox = (CListBox*)CListBox::FromHandle(pWnd->GetSafeHwnd());
		BOOL bOutSide;
		int nIndex = pListBox->ItemFromPoint(ptScreen, bOutSide);
		if (nIndex >= 0 && nIndex < pListBox->GetCount())
		{
			CRect rc;
			pListBox->GetItemRect(nIndex, &rc);
			if (rc.PtInRect(ptScreen))
				pListBox->SetCurSel(nIndex);
			
		}
	}

	if (pWnd->GetSafeHwnd() == m_ctrlLocalFileList.GetSafeHwnd())
	{
		PopMenuForLocalFileList(pt);
	}
	if (pWnd->GetSafeHwnd() == m_ctrlLocalDirTree.GetSafeHwnd())
	{
		PopMenuForLocalDirTree(pt);
	}
	if (pWnd->GetSafeHwnd() == m_ctrlServerDirTree.GetSafeHwnd())
	{
		PopMenuForServerDirTree(pt);
	}

	g_result.clear();
	return;
}

void CModelLibDlgBase::OnBnClickedFileNew()
{
	BnClickedFileNew();
}

void CModelLibDlgBase::OnCheckSearch()
{
	CheckSearch();
}

void CModelLibDlgBase::OnEnChangeSearch()
{
	EnChangeSearch();
}

void CModelLibDlgBase::OnLbnDblClkFileList()
{
	LbnDblClkFileList();
}

void CModelLibDlgBase::OnBnClickedBtnExpandServerDirTree()
{
	// 通过 m_ctrlServerDirTree的显示状态来决定是展开还是收起
	bool bExpand = !m_ctrlServerDirTree.IsWindowVisible();
	ExpandServerDirTree(bExpand);
}

#pragma endregion

#pragma region override method

void CModelLibDlgBase::CheckSearch()
{
	UpdateData(TRUE);
	CRect reSep, reTree, reList;
	m_ctrlStaticSepMid.GetWindowRect(reSep);
	m_ctrlLocalDirTree.GetWindowRect(reTree);

	if (m_bSearch)
	{
		m_ctrlLocalFileList.GetWindowRect(reList);
		int delta = reList.left - reSep.left;
		reList.left = reTree.left;
		ScreenToClient(reList);
		m_ctrlLocalFileList.MoveWindow(reList);
		SetWindowText(_T("输入要搜索的文件的特征，多个特征用“空格”分开。"));
	}
	else
	{
		m_ctrlLocalFileList.GetWindowRect(reList);
		reList.left = reSep.left + 6;
		ScreenToClient(reList);
		m_ctrlLocalFileList.MoveWindow(reList);
		SetWindowText(m_sTitle);
	}

	m_ctrlStaticDir.SetWindowText(m_bSearch ? _T("搜索结果") : _T("文件目录"));
	m_ctrlSearchEdit.EnableWindow(m_bSearch);
	::ShowWindow(m_ctrlStaticSepMid, m_bSearch ? SW_HIDE : SW_SHOW);
	::ShowWindow(m_ctrlLocalDirTree, m_bSearch ? SW_HIDE : SW_SHOW);
	::ShowWindow(m_ctrlStaticFile, m_bSearch ? SW_HIDE : SW_SHOW);

	m_ctrlLocalDirTree.SelectItem(m_ctrlLocalDirTree.GetRootItem());


	m_ctrlSearchEdit.IsWindowVisible();

	SHOWWINDOW(IDC_DIR_ADD, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_DIR_MODI, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_DIR_DEL, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_DIR_OUT, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_DIR_IN, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_FILE_NEW, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_FILE_IN, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_FILE_OUT, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_FILE_DEL, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_FILE_RENAME, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_FILE_IN, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_FILE_COPY, m_bSearch ? SW_HIDE : SW_SHOW);
	SHOWWINDOW(IDC_BTN_EXPAND_SERVER, m_bSearch ? SW_HIDE : SW_SHOW);

	m_ctrlLocalFileList.ResetContent();
}
#pragma endregion

#pragma region helper method

void CModelLibDlgBase::helper_initServerDirTree(LPCTSTR pszRoot)
{
	m_ctrlServerDirTree.SetImageList(&m_imageListServerDir, TVSIL_NORMAL);

	CString sTitle(pszRoot);

	HTREEITEM hRoot = m_ctrlServerDirTree.InsertItem(sTitle, 0, 2, TVI_ROOT);
	m_ctrlServerDirTree.SetItemData(hRoot, -1);
}

void CModelLibDlgBase::helper_initLocalDirTree(LPCTSTR pszRoot, LPCTSTR pszTablePrefix)
{
	helper_initLocalDirTree(m_ctrlLocalDirTree
		, m_imageListLocalDir
		, m_sqlDB
		, pszRoot
		, pszTablePrefix);
	anchorDir();
}

void CModelLibDlgBase::helper_initImageList(CImageList &imglist,UINT imgListID)
{
	CBitmap bmp;
	if (!bmp.LoadBitmap(imgListID))
	{
		AfxMessageBox(_T("Can't load bitmap: %x\n"), imgListID);
		ASSERT(FALSE);
		return;
	}
	BITMAP bmpObj;
	bmp.GetBitmap(&bmpObj);
	UINT nFlags = ILC_COLOR24 | ILC_MASK;
	imglist.Create(16, bmpObj.bmHeight, nFlags, 0, 0);
	imglist.Add(&bmp, RGB(255, 0, 0));
}

void CModelLibDlgBase::helper_initBIMList()
{
	m_ctrlBimPropertyList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_SINGLEROW);
	m_ctrlBimPropertyList.InsertColumn(0, _T("名称"), LVCFMT_LEFT, 150);
	m_ctrlBimPropertyList.InsertColumn(1, _T("属性"), LVCFMT_LEFT, 150);
}

void CModelLibDlgBase::helper_ClickedLocalDirAdd(LPCTSTR pszTablePrefix)
{
	if (!pszTablePrefix) return;

	HTREEITEM hRoot(m_ctrlLocalDirTree.GetRootItem());
	HTREEITEM hItem = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hItem)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}

	CString sName(_T("")), sTmp(_T(""));
	if (!CoreTools::getNameByDialog(_T("输入目录名称"), _T("目录名称"), sTmp)) return;
	if (sTmp.Find(_T('\\')) != -1)
	{
		AfxMessageBox(_T("目录名称中不能存在字符“\\”！"));
		return;
	}

	HTREEITEM h = findSubDir(m_ctrlLocalDirTree, hItem, sTmp);
	if (h)
	{
		AfxMessageBox(_T("目录已经存在！"));
		return;
	}


	CString sTbl(pszTablePrefix), sql(_T("")), sId(_T(""));

	HTREEITEM hNew(NULL);
	if (isRootItem(hItem))	// 添加 folder
	{

		sql.Format(_T("insert into %s_folder (folder) values ('%s')"), sTbl, sTmp);
		if (m_sqlDB.ExecuteSQL(sql))
		{
			hNew = m_ctrlLocalDirTree.InsertItem(sTmp, 0, 2, hItem);
			m_ctrlLocalDirTree.SetItemData(hNew, getLastInserId(m_sqlDB, sTbl + _T("_folder")));
			m_ctrlLocalDirTree.Expand(hItem, TVE_EXPAND);
		}
		return;
	}
	else
	{
		CString sClass = getClassName(hItem);
		if (!sClass.IsEmpty())
			sClass += _T("\\");
		sClass += sTmp;

		HTREEITEM hParent = getParentFolder(hItem);
		int idFolder = m_ctrlLocalDirTree.GetItemData(hParent);

		sql.Format(_T("insert into %s_class(class, idfolder) values ('%s', '%d')"), sTbl, sClass, idFolder);
		if (m_sqlDB.ExecuteSQL(sql))
		{
			hNew = m_ctrlLocalDirTree.InsertItem(sTmp, 0, 2, hItem);
			m_ctrlLocalDirTree.SetItemData(hNew, getLastInserId(m_sqlDB, sTbl + _T("_class")));
			m_ctrlLocalDirTree.Expand(hItem, TVE_EXPAND);
		}
		return;
	}
}

void CModelLibDlgBase::helper_ClickedLocalDirRename(LPCTSTR pszTablePrefix)
{
	if (pszTablePrefix == NULL) return;

	HTREEITEM hItem = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hItem)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}

	if (isRootItem(hItem))
	{
		AfxMessageBox(_T("不能修改根目录名称！"));
		return;
	}

	if (isFolderItem(hItem))
	{
		CString sItem = m_ctrlLocalDirTree.GetItemText(hItem);
		if (sItem == _VALVE_)
		{
			AfxMessageBox(_T("不能修改“阀”目录名称！"));
			return;
		}
	}

	CString sTmp(m_ctrlLocalDirTree.GetItemText(hItem));
	if (!CoreTools::getNameByDialog(_T("输入目录新名称"), _T("目录新名称"), sTmp)) return;


	if (sTmp.Find(_T('\\')) != -1)
	{
		AfxMessageBox(_T("目录名称中不能存在字符“\\”！"));
		return;
	}

	HTREEITEM hParent = m_ctrlLocalDirTree.GetParentItem(hItem);
	HTREEITEM h = findSubDir(m_ctrlLocalDirTree, hParent, sTmp);
	if (h)
	{
		AfxMessageBox(_T("目录已经存在！"));
		return;
	}

	int idFolder = m_ctrlLocalDirTree.GetItemData(hItem);
	CString sql(_T("")), str(_T("")), sItemName(m_ctrlLocalDirTree.GetItemText(hItem)), sTbl(pszTablePrefix);

	if (isFolderItem(hItem))
	{
		sql.Format(_T("update %s_folder set folder='%s' where id='%d'"), sTbl, sTmp, idFolder);
		if (m_sqlDB.ExecuteSQL(sql))
		{
			m_ctrlLocalDirTree.SetItemText(hItem, sTmp);
			m_ctrlLocalDirTree.Invalidate();
			return;
		}
		return;
	}
	else
	{
		// 首先把自己的一行记录修改
		// 先判断一下自己的目录名称在目录串是第几个位置
		sql.Format(_T("select class from %s_class where id='%d'"), sTbl, idFolder);
		if (!m_sqlDB.GetSelData(sql, str)) return;

		std::vector<CString> v;
		CoreTools::SplitString(str, _T('\\'), v);
		if (v.empty()) return;

		std::vector<CString>::iterator it = std::find(v.begin(), v.end(), sItemName);
		if (it == v.end()) return;
		int dist = std::distance(v.begin(), it);

		std::vector<HTREEITEM> items;
		items.push_back(hItem);
		getAllChildrenItem(m_ctrlLocalDirTree, hItem, items);

		std::vector<CString> vv;
		int idSub(-1);
		BOOL bSuccess(false);
		for (size_t i = 0; i < items.size(); ++i)
		{
			vv.clear();
			idSub = m_ctrlLocalDirTree.GetItemData(items[i]);
			sql.Format(_T("select class from %s_class where id='%d'"), sTbl, idSub);
			if (!m_sqlDB.GetSelData(sql, str)) continue;
			CoreTools::SplitString(str, _T('\\'), vv);
			if (vv.size() <= dist) continue;
			str.Empty();
			vv[dist] = sTmp;
			for (size_t j = 0; j < vv.size(); ++j)
			{
				str += vv[j];
				str += _T("\\");
			}
			str = str.Left(str.GetLength() - 1);
			sql.Format(_T("update %s_class set class = '%s' where id='%d'"), sTbl, str, idSub);
			bSuccess = m_sqlDB.ExecuteSQL(sql);
		}
		if (bSuccess)
		{
			m_ctrlLocalDirTree.SetItemText(hItem, sTmp);
			m_ctrlLocalDirTree.Invalidate();
		}

		return;
	}

}

void CModelLibDlgBase::helper_ClickedLocalDirDel(LPCTSTR pszTablePrefix)
{
	if (pszTablePrefix == NULL) return;

	HTREEITEM hItem = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hItem)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}
	if (isRootItem(hItem))
	{
		AfxMessageBox(_T("不能删除根目录！"));
		return;
	}

	if (m_ctrlLocalDirTree.ItemHasChildren(hItem))
	{
		AfxMessageBox(_T("此目录下还有子目录，请先删除子目录！"));
		return;
	}

	if (isFolderItem(hItem))
	{
		CString sItem = m_ctrlLocalDirTree.GetItemText(hItem);
		if (sItem == _VALVE_)
		{
			AfxMessageBox(_T("不能删除“阀”目录！"));
			return;
		}
	}

	CString sTbl(pszTablePrefix), sql(_T(""));

	int idFolder = m_ctrlLocalDirTree.GetItemData(hItem);
	if (isClassItem(hItem))
	{

		CString sTmp(_T(""));
		sql.Format(_T("select count(id) from %s_package where idclass='%d'"), sTbl, idFolder);
		if (m_sqlDB.GetSelData(sql, sTmp))
		{
			if (TypeConvert::convert<int, LPCTSTR>(sTmp) > 0)
			{
				AfxMessageBox(_T("此目录下还有文件，请先删除子目录下的文件！"));
				return;
			}
		}
		else
			return;

		if (AfxMessageBox(_T("是否删除？此操作不可逆！"), MB_YESNO) != IDYES)
			return;

		sql.Format(_T("delete from %s_class where id='%d'"), sTbl, idFolder);
		if (m_sqlDB.ExecuteSQL(sql))
		{
			m_ctrlLocalDirTree.DeleteItem(hItem);
			m_ctrlLocalDirTree.Invalidate();
		}
	}

	if (isFolderItem(hItem))
	{
		// 先删除数据库中内容
		if (AfxMessageBox(_T("是否删除？此操作不可逆！"), MB_YESNO) != IDYES)
			return;
		sql.Format(_T("delete from %s_folder where id='%d'"), sTbl, idFolder);
		if (m_sqlDB.ExecuteSQL(sql))
		{
			m_ctrlLocalDirTree.DeleteItem(hItem);
			m_ctrlLocalDirTree.Invalidate();
		}

		return;
	}
}

void CModelLibDlgBase::helper_ClickedLocalDirOut(LPCTSTR pszTablePrefix, LPCTSTR pszFileSuffix)
{
	if (pszTablePrefix == NULL || pszFileSuffix == NULL) return;

	HTREEITEM hRoot = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hRoot)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}
	bool bRootItem(isRootItem(hRoot));

	CString sPath(_T(""));
	if (!selectPath(_T("请选择文件要保存的目录"), sPath))
		return;
	
	// 先建好目录
	makeDir(m_ctrlLocalDirTree, hRoot, sPath);
	sPath += m_ctrlLocalDirTree.GetItemText(hRoot);

	std::vector<HTREEITEM> items;
	items.push_back(hRoot);
	getAllChildrenItem(m_ctrlLocalDirTree, hRoot, items);

	CString sRoot(_T(""));
	if (isClassItem(hRoot))
		sRoot = getClassName(hRoot);

	CString sFullPath(_T(""))
		, sql(_T(""))
		, sTmp(_T(""))
		, sClassPath(_T(""))
		, sFolderName(_T(""))
		, sFileSuffix(pszFileSuffix)
		, sTbl(pszTablePrefix);

	int classId(-1);
	static int _idx(0);
	std::map<CString, CString> mm;
	std::map<CString, CString>::const_iterator it;
	for (size_t i = 0; i < items.size(); ++i)
	{
		HTREEITEM h(items[i]);
		if (!isClassItem(h)) continue;

		sClassPath = getClassName(h);
		sClassPath.Replace(sRoot, _T(""));

		if (bRootItem)
		{
			sFolderName = m_ctrlLocalDirTree.GetItemText(getParentFolder(h));
			sFullPath.Format(_T("%s\\%s\\%s\\"), sPath, sFolderName, sClassPath);
		}
		else
		{
			sFullPath.Format(_T("%s\\%s\\"), sPath, sClassPath);
		}

		mm.clear();
		classId = m_ctrlLocalDirTree.GetItemData(h);
		sql.Format(_T("select id, name from %s_package where idclass='%d'"), sTbl, classId);
		m_sqlDB.GetSelData(sql, mm);
		if (mm.empty()) continue;

		CString sName(_T(""));
		for (it = mm.begin(); it != mm.end(); ++it)
		{
			_idx = 0;
			AecDbEwEquipment *pEqu = makeEqu(m_sqlDB, TypeConvert::convert<int, LPCTSTR>(it->first));
			if (pEqu)
			{
				sName = checkFileName(it->second);
				sTmp = sFullPath + sName + sFileSuffix;
				while (_taccess(sTmp, 0x0) == 0x0)
				{
					sTmp.Format(_T("%s%s%d%s"), sFullPath, it->second, ++_idx, sFileSuffix);
				}
				CoreTools::equipment2File(pEqu, sTmp, it->second);
				//saveToBentley(pEqu, sTmp);
				DELETE_PTR(pEqu);
			}
		}
	}
	AfxMessageBox(_T("导出完毕。"));
}

void CModelLibDlgBase::helper_ClickedLocalDirIn(LPCTSTR pszTablePrefix, const std::vector<CString> &filetypes)
{
	HTREEITEM hItem = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hItem)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}

	CString sPath(_T(""));
	if (!selectPath(_T("请选择一个要导入的目录"), sPath))
		return;

	importTo(sPath + _T("\\")
		, m_ctrlLocalDirTree
		, m_sqlDB
		, hItem
		, pszTablePrefix
		, filetypes);

	AfxMessageBox(_T("导入完毕。"));
}

void CModelLibDlgBase::helper_ClickedFileIn(LPCTSTR pszFileTypeFilter)
{
	if (!pszFileTypeFilter) return;

	HTREEITEM hItem = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hItem)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}

	if (!isClassItem(hItem))
	{
		AfxMessageBox(_T("不能在根目录或一级目录下保存文件，请选择一个二级目录！"));
		return;
	}

	CFileDialog fileDlg(TRUE
		, NULL
		, NULL
		, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_ALLOWMULTISELECT
		, pszFileTypeFilter);

	fileDlg.m_ofn.nMaxFile = 4096;
	fileDlg.m_ofn.lpstrFile = new TCHAR[fileDlg.m_ofn.nMaxFile];
	::memset(fileDlg.m_ofn.lpstrFile, 0, sizeof(TCHAR) * fileDlg.m_ofn.nMaxFile);

	if (fileDlg.DoModal() != IDOK) return;

	HTREEITEM hFolder = getParentFolder(hItem);
	if (!hFolder || !isFolderItem(hFolder)) return;

	CString sPath(_T(""));
	int idxClass = m_ctrlLocalDirTree.GetItemData(hItem);

	POSITION pos = fileDlg.GetStartPosition();
	while (pos != NULL)
	{
		sPath = fileDlg.GetNextPathName(pos);
		putEquFileToDb(m_sqlDB, sPath, idxClass);
	}

	delete[] fileDlg.m_ofn.lpstrFile;

	refreshLocalFileList(hItem);

	AfxMessageBox(_T("导入完毕。"));
}

void CModelLibDlgBase::helper_ClickedFileCopy(LPCTSTR pszRoot, LPCTSTR pszTablePrefix)
{
	if (!pszTablePrefix || !pszRoot) return;

	HTREEITEM hItem = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hItem)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}

	std::vector<int> files;
	getSelectedFiles(files);
	if (files.empty())
	{
		AfxMessageBox(_T("请至少选择一个文件!"));
		return;
	}

	CModelLibCopyTreeDlg dlg(m_imageListLocalDir
		, m_sqlDB
		, pszRoot
		, pszTablePrefix
		, this);
	if (dlg.DoModal() != IDOK) return;

	int newID;
	int classId = dlg.getClassId();
	CString sql(_T("")), str(_T("")), sTbl(pszTablePrefix);
	std::vector<std::vector<CString>> mm;
	m_sqlDB.BeginTrans();
	for (size_t i = 0; i < files.size(); ++i)
	{
		int fileId = m_ctrlLocalFileList.GetItemData(files[i]);

		sql.Format(_T("insert into %s_package (name, idclass, rem, package) ")
			_T("select name, idclass, rem, package from %s_package where id = '%d'"), sTbl, sTbl, fileId);
		if (!m_sqlDB.ExecuteSQL(sql)) continue;

		newID = getLastInserId(m_sqlDB, sTbl + _T("_package"));
		sql.Format(_T("update %s_package set idclass = '%d' where id = '%d'")
			, sTbl
			, classId
			, newID);
		if (!m_sqlDB.ExecuteSQL(sql)) continue;

		// 如果是组合设备，下面代码不会执行，因为没有 dwg_bims 表
		mm.clear();
		sql.Format(_T("select Name, Value from %s_Bims where EquID='%d'"), pszTablePrefix, fileId);
		m_sqlDB.GetSelDataEx(sql, mm);
		for (int i(0); i != mm.size(); ++i)
		{
			if (mm[i].size() < 2) continue;
			sql.Format(_T("insert into %s_Bims (Name, Value, EquID, ReadOnly) values ('%s','%s','%d','0')")
				, pszTablePrefix
				, mm[i][0]
				, mm[i][1]
				, newID);
			m_sqlDB.ExecuteSQL(sql);
		}
	}
	m_sqlDB.CommitTrans();
	refreshLocalFileList(hItem);
}

void CModelLibDlgBase::helper_ClickedFileRename(LPCTSTR pszTablePrefix)
{
	if (!pszTablePrefix) return;

	HTREEITEM hRoot = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hRoot)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}

	std::vector<int> files;
	getSelectedFiles(files);
	if (files.size() != 1)
	{
		AfxMessageBox(_T("请选择单个文件!"));
		return;
	}

	int idx = files[0];

	CString sTmp(_T("")), sql(_T("")), sTbl(pszTablePrefix);
	m_ctrlLocalFileList.GetText(idx, sTmp);
	int fileId = m_ctrlLocalFileList.GetItemData(idx);
	if (!CoreTools::getNameByDialog(_T("输入文件新名称"), _T("文件新名称"), sTmp)) return;

	if (hasSameFileName(m_ctrlLocalFileList, sTmp))
	{
		AfxMessageBox(_T("存在相同的文件名称！"));
		return;
	}

	sql.Format(_T("update %s_package set name='%s' where id='%d'"), sTbl, sTmp, fileId);

	if (m_sqlDB.ExecuteSQL(sql))
		refreshLocalFileList(hRoot);
}

void CModelLibDlgBase::helper_ClickedFileAnchor()
{ }

void CModelLibDlgBase::helper_ClickedFileDel(LPCTSTR pszTablePrefix)
{
	if (AfxMessageBox(_T("是否删除？此操作不可逆！"), MB_YESNO) != IDYES)
		return;

	HTREEITEM hRoot = m_ctrlLocalDirTree.GetSelectedItem();
	if (!hRoot)
	{
		AfxMessageBox(_T("请选中一个目录！"));
		return;
	}

	std::vector<int> files;
	getSelectedFiles(files);
	if (files.empty())
	{
		AfxMessageBox(_T("请至少选择一个文件!"));
		return;
	}

	int idx(-1);
	CString sql(_T("")), sTbl(pszTablePrefix);
	m_sqlDB.BeginTrans();
	for (size_t i = 0; i < files.size(); ++i)
	{
		idx = m_ctrlLocalFileList.GetItemData(files[i]);

		// 如果是组合设备，下面代码不会执行，因为没有 dwg_bims 表
		{
			sql.Format(_T("delete from aec_bims where equid='%d'"), idx);
			m_sqlDB.ExecuteSQL(sql);
		}

		sql.Format(_T("delete from %s_package where id='%d'"), sTbl, idx);
		m_sqlDB.ExecuteSQL(sql);
	}
	m_sqlDB.CommitTrans();

	refreshLocalFileList(hRoot);
}

bool CModelLibDlgBase::helper_hasSameFileName(LPCTSTR name)
{
	return hasSameFileName(m_ctrlLocalFileList, name);
}

void CModelLibDlgBase::helper_refreshLocalFileList(HTREEITEM hItem, LPCTSTR pszTablePrefix)
{
	m_ctrlLocalFileList.ResetContent();
	if (!hItem) return;

	// 判断点中的是不Class目录
	if (isRootItem(hItem)) return;
	if (isFolderItem(hItem)) return;

	CString sql(_T(""));
	std::vector<std::vector<CString>> files;


	int idFolder = m_ctrlLocalDirTree.GetItemData(hItem);
	
	CString sTable(pszTablePrefix);
	
	sql.Format(_T("select id, name from %s_package where idclass='%d'"), sTable, idFolder);

	m_sqlDB.GetSelDataEx(sql, files);
	int idx(-1);
	bool bAnchorFile(!m_strFileAnchor.IsEmpty());
	for (size_t i = 0; i < files.size(); ++i)
	{
		std::vector<CString> &v(files[i]);
		if (v.size() < 2) continue;

		if (bAnchorFile)
		{
			if (!checkFileName(v[1], m_strFileAnchor))
				continue;
		}

		idx = m_ctrlLocalFileList.AddString(v[1]);
		if (idx != -1)
			m_ctrlLocalFileList.SetItemData(idx, TypeConvert::convert<int, LPCTSTR>(v[0]));

	}
}

void CModelLibDlgBase::helper_EnChangeSearch(LPCTSTR pszTablePrefix)
{
	UpdateData(TRUE);
	CString str;
	m_ctrlSearchEdit.GetWindowText(str);

	if (str.IsEmpty()) return;

	str.MakeUpper();

	std::vector<CString> conditions;
	CoreTools::SplitString(str, _T(' '), conditions);
	if (conditions.empty()) return;

	m_ctrlLocalFileList.ResetContent();

	int idx;
	std::map<int, CString> result;
	search(m_sqlDB, conditions, result, pszTablePrefix);
	std::map<int, CString>::const_iterator it(result.begin());
	for (; it != result.end(); ++it)
	{
		idx = m_ctrlLocalFileList.AddString(it->second);
		m_ctrlLocalFileList.SetItemData(idx, it->first);
	}
	if (m_ctrlLocalFileList.GetCount() > 0)
	{
		m_ctrlLocalFileList.SetSel(0);
		m_iSelectFileID = m_ctrlLocalFileList.GetItemData(0);
	}
}

void CModelLibDlgBase::helper_PopMenuForLocalDirTree(const CPoint &pt)
{
	HTREEITEM hItem = m_ctrlLocalDirTree.GetSelectedItem();

	CMenu menu;
	menu.CreatePopupMenu();

	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED, ID_EQU_LIB_DIR_ADD, _T("添加目录(&A)"));
	if (!isRootItem(hItem))
	{
		menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED, ID_EQU_LIB_DIR_RENAME, _T("修改名称(&M)"));
		menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED, ID_EQU_LIB_DIR_DEL, _T("删除目录(&D)"));
	}
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED, ID_EQU_LIB_DIR_IN, _T("导入目录(&I)"));
	menu.AppendMenu(MF_BYCOMMAND | MF_STRING | MF_ENABLED, ID_EQU_LIB_DIR_OUT, _T("导出目录(&O)"));
	
	int nID = menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD
		, pt.x
		, pt.y
		, &m_ctrlLocalDirTree);

	switch (nID)
	{
		case ID_EQU_LIB_DIR_ADD:
			OnBnClickedDirAdd();
			break;
		case ID_EQU_LIB_DIR_RENAME:
			OnBnClickedDirRename();
			break;
		case ID_EQU_LIB_DIR_DEL:
			OnBnClickedDirDel();
			break;
		case ID_EQU_LIB_DIR_IN:
			OnBnClickedDirIn();
			break;
		case ID_EQU_LIB_DIR_OUT:
			return OnBnClickedDirOut();
		default:
			break;
	}
	g_result.clear();
}

bool CModelLibDlgBase::helper_selectPath(LPCTSTR pszTitle, CString &strPath)
{
	return selectPath(pszTitle, strPath);
}

CString CModelLibDlgBase::helper_checkFileName(LPCTSTR sfile)
{
	return checkFileName(sfile);
}

CString CModelLibDlgBase::helper_getLastErrorMsg()
{
	return getLastErrorMsg();
}

void CModelLibDlgBase::helper_insertEqu(AecDbEwEquipment *pEqu)
{
	insertEqu(pEqu);
}

void CModelLibDlgBase::helper_ShowWindow(UINT id, CWnd *pParent, const bool &bShow)
{
	CWnd *pWnd = pParent->GetDlgItem(id);
	if (pWnd)
		pWnd->ShowWindow(bShow ? SW_SHOW : SW_HIDE);
}

bool CModelLibDlgBase::helper_putEquFileToDb(CUIISQLiteServer & db, LPCTSTR pszFile, int idClass)
{
	return putEquFileToDb(db, pszFile, idClass);
}

int CModelLibDlgBase::helper_getLastInserId(CUIISQLiteServer &db, LPCTSTR pszTable)
{
	return getLastInserId(db, pszTable);
}

bool CModelLibDlgBase::helper_CopyTable(LPCTSTR pszDbFrom
	, LPCTSTR pszDbTo
	, LPCTSTR pszTableFrom
	, LPCTSTR pszTableTo
)
{
	CUIISQLiteServer db;
	if (!db.InitADOServer(pszDbFrom))
	{
		acutPrintf(_T("打开数据库失败！"));
		return false;
	}

	CString sql(_T(""));
	sql.Format(_T("ATTACH DATABASE '%s' AS db_to"), pszDbTo);
	if (!db.ExecuteSQL(sql)) return false;

	sql.Format(_T("INSERT INTO db_to.%s SELECT * FROM main.%s"), pszTableTo, pszTableFrom);
	return db.ExecuteSQL(sql) ? true : false;
}

void CModelLibDlgBase::helper_initLocalDirTree(CTreeCtrl &tree
	, CImageList &imglist
	, CUIISQLiteServer &db
	, LPCTSTR pszRoot
	, LPCTSTR pszTablePrefix)
{
	if (!pszRoot || !pszTablePrefix) return;

	tree.SetImageList(&imglist, TVSIL_NORMAL);

	CString sTitle(pszRoot), sTbl(pszTablePrefix);

	HTREEITEM hRoot = tree.InsertItem(sTitle, 0, 2, TVI_ROOT);
	tree.SetItemData(hRoot, -1);

	std::vector<std::vector<CString>> folders, dirs;
	std::vector<std::vector<CString>>::const_iterator it_folder, it_dir;
	db.GetSelDataEx(CString(_T("select id, folder from ")) + sTbl + _T("_folder"), folders);
	std::vector<CString> subs;
	for (it_folder = folders.begin(); it_folder != folders.end(); ++it_folder)
	{
		if (it_folder->size() < 2) continue;
		// 一级目录 对应着 aec_folder 表
		HTREEITEM hFolder = findSubDir(tree, hRoot, it_folder->at(1));
		hRoot = tree.InsertItem(it_folder->at(1), 0, 2, hRoot);
		tree.SetItemData(hRoot, TypeConvert::convert<int, LPCTSTR>(it_folder->at(0)));
		// 二级目录 对应着 aec_class 表

		dirs.clear();
		db.GetSelDataEx(
			CString(_T("select id, class from ")) + sTbl + _T("_class where idfolder = ") + it_folder->at(0),
			dirs);

		for (it_dir = dirs.begin(); it_dir != dirs.end(); ++it_dir)
		{
			if (it_dir->size() < 2) continue;
			// 对二级目录进行拆分
			subs.clear();
			CoreTools::SplitString(it_dir->at(1), _T('\\'), subs);
			if (subs.empty()) continue;

			HTREEITEM hSub(NULL);
			HTREEITEM hParent = hRoot;
			for (size_t i = 0; i < subs.size(); ++i)
			{
				hSub = findSubDir(tree, hParent, subs[i]);
				if (!hSub) // 没找到，新建
				{
					hParent = tree.InsertItem(subs[i], 0, 2, hParent);
					tree.SetItemData(hParent, TypeConvert::convert<int, LPCTSTR>(it_dir->at(0)));
				}
				else
					hParent = hSub;
			}
		}

		hRoot = tree.GetRootItem();
	}
	tree.Expand(hRoot, TVE_EXPAND);
	return;
}

void CModelLibDlgBase::filterX3dPartEntity(ads_name ss, AcDbObjectIdArray &ids)
{
	AcDbObjectId EntId;
	ads_name EntName;
	Adesk::Int32 nLength = 0;
	acedSSLength(ss, &nLength);

	AcDbObjectIdArray arWallids, arOpeingids;
	CString sName;
	for (int i(0); i < nLength; ++i)
	{
		acedSSName(ss, i, EntName);
		if (acdbGetObjectId(EntId, EntName) != Acad::eOk) continue;

		AcRxClass *pClass = EntId.objectClass();
		if (!pClass) continue;

		if (pClass == AecDbXOpening::desc())
		{
			arOpeingids.append(EntId);
			continue;
		}

		if (pClass == AecDbXWall::desc())
			arWallids.append(EntId);

		if (pClass == AecDbX3dPartEntity::desc())
		{
			AcDbObjectPointer<AecDbX3dPartEntity> ent(EntId, AcDb::kForRead);
			if (ent.openStatus() != Acad::eOk) continue;

			sName = ent->GetName();

			if (sName.CompareNoCase(_T("洞口")) == 0
				|| sName.CompareNoCase(_T("开洞")) == 0
				|| sName.CompareNoCase(_T("套管")) == 0
				|| sName.Find(_T("井")) != -1
				|| sName.Find(_T("坑")) != -1)
			{
				continue;
			}
			else
			{
				ids.append(EntId);
			}
		}
		else
			ids.append(EntId);
	}

	// 现在所有选中的洞口、套管、井、坑、门窗实体都被过滤掉了
	AcDbObjectId idWall, idParent;
	AcDbObjectIdArray arErrIds, _ar;
	for (int i(0); i < arWallids.length(); ++i)
	{
		idWall = arWallids[i];
		AcDbObjectPointer<AecDbXWall> wall(idWall, AcDb::kForRead);
		if (wall.openStatus() != Acad::eOk) continue;

		_ar.removeAll();
		wall->GetAssocPartIds(_ar);

		for (int j(0); j < _ar.length(); ++j)
		{
			EntId = _ar[j];
			AcRxClass *pClass = EntId.objectClass();
			if (!pClass) continue;

			if (pClass == AecDbColumn::desc())
			{
				// 如果墙实体与柱实体有关联，则删掉关联
				if (wall->upgradeOpen() == Acad::eOk)
				{
					wall->RemoveAssocPart(EntId);
					wall->downgradeOpen();
				}
				continue;
			}

			if (pClass == AecDbXOpening::desc())
			{
				// 下面处理一种老版本的特殊情况
				// 一个门窗实体被多个墙关联，详情查看AecDbXOpening::subTransfromBy()
				// 正确的情况是一个门窗实体只能关联一个墙实体
				// 这种情况必须要清理，否则不同的wall实体的deepclone函数会同时复制同样的门窗实体。
				// 方法是，判断墙体关联的门窗，如果墙体的id与门窗记录的所在墙体id不一致，则把这个门窗实体从ids里面剔除掉
				arErrIds.removeAll();
				AcDbObjectPointer<AecDbXOpening> opening(EntId, AcDb::kForRead);
				if (opening.openStatus() == Acad::eOk)
				{
					idParent == AcDbObjectId::kNull;
					opening->GetAt(KEY_IDCNT1, idParent);
					if (idWall != idParent)
					{
						if (wall->upgradeOpen() == Acad::eOk)
						{
							wall->RemoveAssocPart(EntId);
							wall->downgradeOpen();
						}
					}
				}
				continue;
			}
		}
	}

	return;
}

bool CModelLibDlgBase::getAlignPoint(AcGePoint3d &ptOrg)
{
	// ptOrg 转 wcs
	CoreTools::WCS2UCS(ptOrg, ptOrg) ;

	if (acedGetPoint(asDblArray(ptOrg), _T("\n指定插入点:"), asDblArray(ptOrg)) == RTCAN) return false;

	CoreTools::UCS2WCS(ptOrg, ptOrg);

	return true;
}

#pragma endregion