2335 lines
57 KiB
C++
2335 lines
57 KiB
C++
#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
|