#include "StdAfx.h"
#include "resource.h"
#include "DlgParamInsert.h"
#include "KTEntityDragMgr.h"
#include "KTParamService.h"
#include "KTExpressCalc.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

namespace
{
	void EraseObjects(const AcDbObjectIdArray& arid)
	{
		AcDbObject* pObj;
		int iPos = arid.length();
		while ((--iPos) >= 0)
		{
			if (Acad::eOk != acdbOpenObject(pObj, arid[iPos], AcDb::kForWrite))
				continue;
			pObj->erase();
			pObj->close();
		}
	}

	AcDbObjectId CreateBlock(AcDbVoidPtrArray& arpEnt
		, const AcGePoint3d& ptOrigin
		, LPCTSTR pszBlk = NULL
		, AcDbDatabase* pDb = NULL
		, BOOL bDeleteSrc = TRUE)
	{
		AcDbObjectId id;

		if (pDb == NULL)
		{
			pDb = acdbHostApplicationServices()->workingDatabase();
		}
		KTASSERT(pDb != NULL);

		AcDbBlockTable* pBT = NULL;
		pDb->getSymbolTable(pBT, AcDb::kForWrite);
		if (pBT == NULL)
			return id;

		AcDbBlockTableRecord* pBTR = NULL;
		BOOL bAnonymous = (pszBlk == NULL || _tcslen(pszBlk) <= 0);
		if (!bAnonymous && pBT->has(pszBlk))
		{
			pBT->getAt(pszBlk, pBTR, AcDb::kForWrite);
			KTCHECK(pBTR != NULL);
			id = pBTR->objectId();
			pBT->close();

			AcDbBlockTableRecordIterator* pIT = NULL;
			pBTR->newIterator(pIT);
			if (NULL != pIT)
			{
				AcDbEntity* pEnt;
				for (; !pIT->done(); pIT->step())
				{
					if (Acad::eOk == pIT->getEntity(pEnt, AcDb::kForWrite))
					{
						pEnt->erase();
						pEnt->close();
					}
				}
				delete pIT;
			}
		}
		else
		{
			pBTR = new AcDbBlockTableRecord;
			KTCHECK(pBTR != NULL);
			pBT->add(id, pBTR);
			pBT->close();

			if (!id.isValid())
			{
				delete pBTR;
				return id;
			}
		}

		if (bAnonymous)
			pBTR->setName(_T("*U"));
		else
			pBTR->setName(pszBlk);
		pBTR->setOrigin(ptOrigin);

		AcDbEntity* pEnt;
		int iLen = arpEnt.length();
		for (int i = iLen - 1; i >= 0; i--)
		{
			pEnt = (AcDbEntity*)arpEnt[i];
			KTASSERT(pEnt != NULL && pEnt->isKindOf(AcDbEntity::desc()));

			if (pEnt->objectId().isValid())
				continue;

			if (pBTR->appendAcDbEntity(pEnt) == Acad::eOk)
				pEnt->close();
			else
				delete pEnt;

			arpEnt.removeAt(i);
		}

		pBTR->close();

		AcDbEntity* pCpyEnt;
		iLen = arpEnt.length();
		for (i = iLen - 1; i >= 0; i--)
		{
			pEnt = (AcDbEntity*)arpEnt[i];
			KTASSERT(pEnt != NULL && pEnt->isKindOf(AcDbEntity::desc()));
			KTASSERT(pEnt->objectId().isValid());

			pCpyEnt = NULL;
			CKTCadUtility::DeepCloneObject((AcDbObject*&)pCpyEnt, pEnt, id);
			pCpyEnt->close();

			if (bDeleteSrc && (pEnt->isWriteEnabled() || pEnt->upgradeOpen() == Acad::eOk))
				pEnt->erase();
			pEnt->close();

			arpEnt.removeAt(i);
		}

		return id;
	}

	Acad::ErrorStatus AppendEntity(AcDbEntity* pEnt
		, BOOL bClose = TRUE
		, LPCTSTR pszBlk = NULL
		, AcDbDatabase* pDb = NULL)
	{
		if (NULL == pDb)
			pDb = acdbHostApplicationServices()->workingDatabase();
		ASSERT(NULL != pDb);

		if (NULL == pszBlk)
		{
			if (pDb->tilemode())
				pszBlk = acdbSymUtil()->blockModelSpaceName();
			else
				pszBlk = acdbSymUtil()->blockPaperSpaceName();
		}
		ASSERT(NULL != pszBlk);

		AcDbBlockTable* pBT = NULL;
		Acad::ErrorStatus es = pDb->getBlockTable(pBT, AcDb::kForRead);
		if (Acad::eOk == es)
		{
			AcDbBlockTableRecord* pBTR = NULL;
			es = pBT->getAt(pszBlk, pBTR, AcDb::kForWrite);
			if (Acad::eOk == es)
			{
				es = pBTR->appendAcDbEntity(pEnt);
				if (Acad::eOk == es)
				{
					if (bClose)
						pEnt->close();
				}
				pBTR->close();
			}
			pBT->close();
		}

		return es;
	}

}

CDlgParamInsert::CDlgParamInsert(CWnd* pParent)
	: CDialog(CDlgParamInsert::IDD, pParent)
	, m_bAttrModified(FALSE)
	, m_lAttributesCount(0)
{
}

void CDlgParamInsert::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDlgParamInsert)
	DDX_Control(pDX, IDC_CMB_CLASS, m_wndCmbClass);
	DDX_Control(pDX, IDC_RAD_BLOCK, m_wndRadBlock);
	DDX_Control(pDX, IDC_RAD_GROUP, m_wndRadGroup);
	DDX_Control(pDX, IDC_STC_PREVIEW, m_wndViewCtrl);
	DDX_Control(pDX, IDC_STC_DESC, m_wndStcDesc);
	DDX_Control(pDX, IDC_LST_ATTRIBUTE, m_wndLstAttribute);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDlgParamInsert, CDialog)
	//{{AFX_MSG_MAP(CDlgParamInsert)
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_BTN_PREVIEW, OnBtnPreview)
	ON_CBN_SELENDOK(IDC_CMB_CLASS, OnSelendokCmbClass)
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_USER_CHILDVALUECHANGED, OnPropListBoxNotify)
END_MESSAGE_MAP()

BOOL CDlgParamInsert::Create(CWnd* pParentWnd)
{
	return CDialog::Create(IDD, pParentWnd);
}

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

	//if (!m_wndViewCtrl.SubclassDlgItem(IDC_STC_PREVIEW, this))
	//{
	//	// 错误时，结束对话框
	//	EndDialog(IDCANCEL);
	//	return FALSE;
	//}

	m_wndRadBlock.SetCheck(1);

	m_wndLstAttribute.SetNameWidth(100);

	CString sRoot;
	sRoot.LoadString(IDS_CLASSROOTNAME);
	m_wndCmbClass.AddString(sRoot);
	OnInitClassList(0, NULL);

	SetClassCode(m_cClassData.GetCode());

	OnBtnPreview();

	return TRUE;
}

void CDlgParamInsert::OnDestroy() 
{
	CDialog::OnDestroy();

	//if (NULL != m_pDbPreview)
	//{
	//	delete m_pDbPreview;
	//	m_pDbPreview = NULL;
	//}

	OnCleanAttributeList();
}

void CDlgParamInsert::OnInitClassList(ULONG lUpId, LPCTSTR pszPrefix)
{
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	KTParamClassArray arItems;
	pService->GetSubClassItems(lUpId, arItems);
	int iSize = arItems.GetSize() - 1;
	if (iSize < 0)
		return;

	CString sPrefix1(pszPrefix), sPrefix2(pszPrefix);
	sPrefix1 += _T("├");	sPrefix2 += _T("│");

	int iIndex;
	for (int i = 0; i < iSize; i++)
	{
		iIndex = m_wndCmbClass.AddString(sPrefix1 + arItems[i].GetName());
		ASSERT(iIndex >= 0);

		lUpId = arItems[i].GetId();
		m_wndCmbClass.SetItemData(iIndex, lUpId);

		OnInitClassList(lUpId, sPrefix2);
	}

	sPrefix1 = pszPrefix; sPrefix2 = pszPrefix;
	sPrefix1 += _T("└"); sPrefix2 += _T("  ");

	iIndex = m_wndCmbClass.AddString(sPrefix1 + arItems[i].GetName());
	ASSERT(iIndex >= 0);

	lUpId = arItems[i].GetId();
	m_wndCmbClass.SetItemData(iIndex, lUpId);

	OnInitClassList(lUpId, sPrefix2);
}

CPropertyItem::ItemStyle CDlgParamInsert::AsItemStyle(LPCTSTR pszDataType, BOOL bMulti, BOOL bOverride)
{
	if (bMulti)
	{
		if (bOverride)
			return CPropertyItem::CMB_DOWN;
		else
			return CPropertyItem::CMB_LIST;
	}

	if (0 == _tcsicmp(pszDataType, _T("Int")))
	{
		return CPropertyItem::EDT_SPIN;
	}
	else if (0 == _tcsicmp(pszDataType, _T("Real")))
	{
		return CPropertyItem::EDT_REAL;
	}
	else if (0 == _tcsicmp(pszDataType, _T("Char")))
	{
		return CPropertyItem::EDT_NONE;
	}
	else if (0 == _tcsicmp(pszDataType, _T("Bool")))
	{
		return CPropertyItem::CMB_LIST_YESNO;
	}
	else
	{
		return CPropertyItem::EDT_NONE;
	}
}

LPCTSTR CDlgParamInsert::AsItemString(CString& sData, LPCTSTR pszDataType)
{
	if (0 == _tcsicmp(pszDataType, _T("Bool")) && !sData.IsEmpty())
	{
		// 转换数据
		if (_istdigit(sData[sData.GetLength() - 1]))
			sData = (_ttoi(sData) ? _T("TRUE") : _T("FALSE"));
		else if (!sData.IsEmpty() && _istalnum(sData[0]))
			;
		else
			sData = (sData.CompareNoCase(_T("是")) == 0 ? _T("TRUE") : _T("FALSE"));
	}
	return sData;
}

LPCTSTR CDlgParamInsert::AsItemDesc(CString& sDesc, LPCTSTR pszData, LPCTSTR pszVarDesc, const CMapStringToString& mapVarToValue)
{
	if (NULL == pszVarDesc || 0 >= _tcslen(pszVarDesc))
	{
		sDesc = pszData;
		return sDesc;
	}

	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	CStringArray arsTable;
	if (NULL != _tcschr(pszVarDesc, _T(' ')))
	{
		CString sSQL;
		if (pService->ExpandSQL(pszVarDesc, mapVarToValue, sSQL))
			pService->ExecuteSQL(sSQL, arsTable);
	}
	else
		arsTable.Add(pszVarDesc);
	if (1 != arsTable.GetSize() || arsTable[0].IsEmpty())
	{
		sDesc = pszData;
		return sDesc;
	}

	// 取得逻辑值数据
	CMapStringToString mapValueToDesc;
	pService->GetValueToDescMap(arsTable[0], mapValueToDesc);
	if (!mapValueToDesc.Lookup(pszData, sDesc))
		sDesc = pszData;
	return sDesc;
}

LPCTSTR CDlgParamInsert::ByItemDesc(CString& sData, LPCTSTR pszDesc, LPCTSTR pszVarDesc, const CMapStringToString& mapVarToValue)
{
	if (NULL == pszVarDesc || 0 >= _tcslen(pszVarDesc))
	{
		sData = pszDesc;
		return sData;
	}

	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	CStringArray arsTable;
	if (NULL != _tcschr(pszVarDesc, _T(' ')))
	{
		CString sSQL;
		if (pService->ExpandSQL(pszVarDesc, mapVarToValue, sSQL))
			pService->ExecuteSQL(sSQL, arsTable);
	}
	else
		arsTable.Add(pszVarDesc);
	if (1 != arsTable.GetSize() || arsTable[0].IsEmpty())
	{
		sData = pszDesc;
		return sData;
	}

	// 取得逻辑值数据
	CMapStringToString mapDescToValue;
	pService->GetDescToValueMap(arsTable[0], mapDescToValue);
	if (!mapDescToValue.Lookup(pszDesc, sData))
		sData = pszDesc;
	return sData;
}

void CDlgParamInsert::OnCleanAttributeList()
{
	CPropertyItem* pItem;
	CPropertyItemTab* pTab;
	KTParamAttribute* pData;
	POSITION pos1, pos = m_wndLstAttribute.GetFirstTabPositon();
	while (NULL != pos)
	{
		pTab = m_wndLstAttribute.GetNextTab(pos);
		ASSERT(NULL != pTab);
		ASSERT(NULL == pTab->m_dwUserParam);

		pos1 = pTab->m_listItem.GetHeadPosition();
		while (NULL != pos1)
		{
			pItem = pTab->m_listItem.GetNext(pos1);
			pData = (KTParamAttribute*)pItem->m_dwUserData;
			if (NULL != pData)
				delete pData;

			ASSERT(NULL == pItem->m_dwUserDataEx);
		}
	}

	ULONG lIndex;
	pos = m_mapHideAttribute.GetStartPosition();
	while (NULL != pos)
	{
		m_mapHideAttribute.GetNextAssoc(pos, lIndex, pData);
		if (NULL != pData)
			delete pData;
	}

	m_bAttrModified = FALSE;
	m_lAttributesCount = 0;
	m_mapAttrToValue.RemoveAll();
	m_mapHideAttribute.RemoveAll();
	m_wndLstAttribute.ResetContent();
}

LRESULT CDlgParamInsert::OnPropListBoxNotify(WPARAM wParam, LPARAM lParam)
{
	// 取得数据参数
	UINT nType = LOWORD(wParam);
	UINT nCode = LOBYTE(HIWORD(wParam));
	BOOL bEditName = HIBYTE(HIWORD(wParam));
	HWND hPropListBox = (HWND)lParam;

	m_bAttrModified |= (0 == nType && 0 == nCode || 1 == nType);

	// 处理选项变化后，数据重新计算
	if (m_bAttrModified && (1 == nType || 0 == nType && 1 == nCode))
	{
		m_bAttrModified = FALSE;

		// 更新当前数据
		CString sValue;
		KTParamAttribute* pData;
		CPropertyItem* pItem = NULL;
		CPropertyItemTab* pTab = NULL;
		m_wndLstAttribute.GetCurSel(pTab, pItem);
		if (NULL != pItem && NULL != pItem->m_dwUserData)
		{
			pData = (KTParamAttribute*)pItem->m_dwUserData;
			ByItemDesc(sValue, pItem->m_sValue, pData->GetVarDesc(), m_mapAttrToValue);
			AsItemString(sValue, pData->GetDataType());
			m_mapAttrToValue.SetAt(pData->GetCode(), sValue);
		}

		// 检查参数化数据库
		KTParamService* pService = GetKTParamService();
		ASSERT(NULL != pService);

		// 更新其他依赖数据
		m_wndLstAttribute.FindTab(pTab, 0);
		if (NULL != pTab)
		{
			ULONG lIndex = 0;
			CStringArray arsValue;
			POSITION pos = pTab->m_listItem.GetHeadPosition();
			while (NULL != pos)
			{
				pItem = pTab->m_listItem.GetNext(pos);
				ASSERT(NULL != pItem);
				if (NULL == pItem->m_dwUserData)
					continue;

				// 更新序号之前的隐藏条目
				pData = (KTParamAttribute*)pItem->m_dwUserData;
				while (lIndex <= pData->GetIndex())
				{
					if (m_mapHideAttribute.Lookup(lIndex++, pData) && NULL != pData)
					{
						arsValue.RemoveAll();
						GetAvalidValueList(pData->GetValue(), m_mapAttrToValue, arsValue);
						if (arsValue.GetSize() == 1)
						{
							AsItemString(arsValue[0], pData->GetDataType());
							m_mapAttrToValue.SetAt(pData->GetCode(), arsValue[0]);
						}
					}
				}

				// 更新当前条目
				arsValue.RemoveAll();
				pData = (KTParamAttribute*)pItem->m_dwUserData;
				GetAvalidValueList(pData->GetValue(), m_mapAttrToValue, arsValue);
				if (arsValue.GetSize() == 1)
				{
					AsItemString(arsValue[0], pData->GetDataType());
					m_mapAttrToValue.SetAt(pData->GetCode(), arsValue[0]);
					pItem->m_sValue = AsItemDesc(sValue, arsValue[0], pData->GetVarDesc(), m_mapAttrToValue);
				}
			}

			// 更新剩余的隐藏条目
			while (lIndex <= m_lAttributesCount)
			{
				if (m_mapHideAttribute.Lookup(lIndex++, pData) && NULL != pData)
				{
					arsValue.RemoveAll();
					GetAvalidValueList(pData->GetValue(), m_mapAttrToValue, arsValue);
					if (arsValue.GetSize() == 1)
					{
						AsItemString(arsValue[0], pData->GetDataType());
						m_mapAttrToValue.SetAt(pData->GetCode(), arsValue[0]);
					}
				}
			}

			m_wndLstAttribute.Invalidate();
		}
	}

	if (4 == nType)
	{
		// 取得当前条目
		CPropertyItemTab* pTab = NULL;
		CPropertyItem* pItem = NULL;
		m_wndLstAttribute.GetCurSel(pTab, pItem);

		// 取得附加数据
		CString sValue;
		KTParamAttribute* pData = NULL;
		if (NULL != pItem)
		{
			pData = (KTParamAttribute*)pItem->m_dwUserData;
			if (NULL == pData)
				return 0;

			sValue.Format(_T("%s  %s"), pData->GetCode(), pData->GetDesc());
		}
		else if (NULL != pTab)
		{
			sValue = m_cClassData.GetDesc();
		}

		// 更新说明信息
		m_wndStcDesc.SetWindowText(sValue);

		// 处理选择项下拉列表
		// 获得子控件
		CComboBox* pSubCtrl = DYNAMIC_DOWNCAST(CComboBox, m_wndLstAttribute.GetSubCtrl());
		if (NULL == pData || NULL == pSubCtrl || !pSubCtrl->IsWindowVisible())
			return 0;

		// 检查参数化数据库
		KTParamService* pService = GetKTParamService();
		ASSERT(NULL != pService);

		CStringArray arsValue;
		GetAvalidValueList(pData->GetValue(), m_mapAttrToValue, arsValue);

		int iSize = arsValue.GetSize();
		if (iSize > 0)
		{
			// 添加到子控件列表中
			pSubCtrl->ResetContent();
			for (int i = 0; i < iSize; i++)
			{
				AsItemString(arsValue[i], pData->GetDataType());
				AsItemDesc(sValue, arsValue[i], pData->GetVarDesc(), m_mapAttrToValue);
				pSubCtrl->AddString(sValue);
			}

			// 定位当前数据
			if (!pItem->m_sValue.IsEmpty())
			{
				i = pSubCtrl->FindStringExact(-1, pItem->m_sValue);
				if (i < 0) pSubCtrl->InsertString((i = 0), pItem->m_sValue);
				pSubCtrl->SetCurSel(i);
			}
		}
	}

	return 0;
}

BOOL CDlgParamInsert::ExpressCalcVarProc(LPCTSTR pszVariable, double& dValue, WPARAM wParam, LPARAM lParam)
{
	ASSERT(NULL != lParam);
	CMapStringToString* pMapVar = (CMapStringToString*)lParam;

	CString sValue;
	if (!pMapVar->Lookup(pszVariable, sValue))
	{
		if (_tcsicmp(pszVariable, _T("PI")) == 0)
		{
			dValue = PI;
			return TRUE;
		}
		return FALSE;
	}

	dValue = _tcstod(sValue, NULL);

	return TRUE;
}

void CDlgParamInsert::GetAvalidValueList(LPCTSTR pszValueExpress, const CMapStringToString& mapData, CStringArray& arsValue)
{
	if (pszValueExpress == NULL || _tclen(pszValueExpress) <= 0)
		return;

	while (pszValueExpress[0] == _T(' '))
		pszValueExpress++;

	if (pszValueExpress[0] == _T('\0') || _tcsnicmp(pszValueExpress, _T("Keyin"), 5) == 0)
		return;

	if (_T('=') == pszValueExpress[0] && (pszValueExpress++)
		|| _tcsnicmp(pszValueExpress, _T("Equal"), 5) == 0 && (pszValueExpress += 5))
	{
		double dResult;
		KTExpressCalc calc;
		calc.SetVariableProc(ExpressCalcVarProc, NULL, (LPARAM)&m_mapAttrToValue);
		if (calc.Calculate(pszValueExpress, dResult))
		{
			CString sValue;
			sValue.Format(_T("%g"), dResult);
			arsValue.Add(sValue);
		}
	}
	else if (_T('#') == pszValueExpress[0] && (pszValueExpress++)
		|| _tcsnicmp(pszValueExpress, _T("Values"), 6) == 0 && (pszValueExpress += 6))
	{
		CString sValue;
		while (pszValueExpress[0] != _T('\0'))
		{
			switch (pszValueExpress[0])
			{
			case _T(','):
			case _T(' '):
				if (!sValue.IsEmpty())
					arsValue.Add(sValue);
				sValue.Empty();
				break;
			default:
				sValue += pszValueExpress[0];
				break;
			}
			pszValueExpress++;
		}
		if (!sValue.IsEmpty())
			arsValue.Add(sValue);
	}
	else
	{
		// 检查参数化数据库
		KTParamService* pService = GetKTParamService();
		ASSERT(NULL != pService);

		CString sSQL;
		pService->ExpandSQL(pszValueExpress, mapData, sSQL);
		pService->ExecuteSQL(sSQL, arsValue);
	}
}

void CDlgParamInsert::OnSelendokCmbClass() 
{
	int iSel = m_wndCmbClass.GetCurSel();
	if (iSel < 0)
		return;

	SetClassCode(m_wndCmbClass.GetItemData(iSel));

	OnBtnPreview();
}

void CDlgParamInsert::SetClassCode(ULONG lId)
{
	OnCleanAttributeList();

	m_cClassData.SetId(lId);
	if (0 == lId || !IsWindow(m_hWnd))
		return;

	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	if (!pService->GetClassItemById(m_cClassData.GetId(), m_cClassData))
		return;

	lId = m_cClassData.GetId();
	int iSel = m_wndCmbClass.GetCurSel();
	if (iSel < 0 || m_wndCmbClass.GetItemData(iSel) != lId)
	{
		iSel = m_wndCmbClass.GetCount();
		while ((--iSel) >= 0)
		{
			if (m_wndCmbClass.GetItemData(iSel) == lId)
			{
				m_wndCmbClass.SetCurSel(iSel);
				break;
			}
		}
	}

	m_wndStcDesc.SetWindowText(m_cClassData.GetDesc());

	CPropertyItemTab* pTab = m_wndLstAttribute.AddTab(m_cClassData.GetName(), TRUE, FALSE, m_cClassData.GetCode());
	if (NULL == pTab)
		return;

	m_mapAttrToValue.SetAt(_T("Name"), m_cClassData.GetName());
	m_mapAttrToValue.SetAt(_T("Code"), m_cClassData.GetCode());
	OnShowAttributeAttrItems(pTab, lId);
}

void CDlgParamInsert::SetClassCode(LPCTSTR pszCode)
{
	OnCleanAttributeList();

	m_cClassData.SetCode(pszCode);
	if (NULL == m_cClassData.GetCode() || !IsWindow(m_hWnd))
		return;

	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	if (!pService->GetClassItemByCode(m_cClassData.GetCode(), m_cClassData))
		return;

	ULONG lId = m_cClassData.GetId();
	int iSel = m_wndCmbClass.GetCurSel();
	if (iSel < 0 || m_wndCmbClass.GetItemData(iSel) != lId)
	{
		iSel = m_wndCmbClass.GetCount();
		while ((--iSel) >= 0)
		{
			if (m_wndCmbClass.GetItemData(iSel) == lId)
			{
				m_wndCmbClass.SetCurSel(iSel);
				break;
			}
		}
	}

	m_wndStcDesc.SetWindowText(m_cClassData.GetDesc());

	CPropertyItemTab* pTab = m_wndLstAttribute.AddTab(m_cClassData.GetName(), TRUE, FALSE, m_cClassData.GetCode());
	if (NULL == pTab)
		return;

	m_mapAttrToValue.SetAt(_T("Name"), m_cClassData.GetName());
	m_mapAttrToValue.SetAt(_T("Code"), m_cClassData.GetCode());
	OnShowAttributeAttrItems(pTab, lId);
}

void CDlgParamInsert::OnShowAttributeAttrItems(CPropertyItemTab* pTab, ULONG lId)
{
	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	KTParamClass data;
	if (!pService->GetClassItemById(lId, data))
		return;

	if (data.GetUpId() != 0)
		OnShowAttributeAttrItems(pTab, data.GetUpId());

	KTParamAttributePtrArray arpItems;
	if (!pService->GetAttributeItems(lId, arpItems))
		return;

	CString sValue;
	CPropertyItem* pItem;
	KTParamAttribute* pData;
	int iSize = arpItems.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		pData = arpItems[i];
		ASSERT(NULL != pData);

		pData->SetIndex(m_lAttributesCount++);

		if (!pData->IsVisible())
		{
			m_mapHideAttribute.SetAt(pData->GetIndex(), pData);
			continue;
		}

		if (!m_wndLstAttribute.AddItem(pTab, pData->GetName(), _T(""), CPropertyItem::EDT_NONE)
							|| NULL == (pItem = pTab->m_listItem.GetTail()))
		{
			delete pData;
			continue;
		}

		pItem->m_dwUserData = (DWORD_PTR)pData;
		pItem->m_bValueEditable = !pData->IsReadOnly();
		pItem->m_eValueStyle = AsItemStyle(pData->GetDataType(), (_tcslen(pData->GetValue()) > 0), pData->IsOverride());

		CStringArray arsValue;
		GetAvalidValueList(pData->GetValue(), m_mapAttrToValue, arsValue);
		if (arsValue.GetSize() == 1)
		{
			AsItemString(arsValue[0], pData->GetDataType());
			m_mapAttrToValue.SetAt(pData->GetCode(), arsValue[0]);
			AsItemDesc(pItem->m_sValue, arsValue[0], pData->GetVarDesc(), m_mapAttrToValue);
		}
		else
		{
			sValue = pData->GetDefault();
			m_mapAttrToValue.SetAt(pData->GetCode(), AsItemString(sValue, pData->GetDataType()));
			AsItemDesc(pItem->m_sValue, sValue, pData->GetVarDesc(), m_mapAttrToValue);
		}
	}
}

void CDlgParamInsert::OnBtnPreview() 
{
	CWaitCursor waitor;

	// 更新数据
	CPropertyItemTab* pTab = NULL;
	m_wndLstAttribute.FindTab(pTab, 0);
	if (NULL != pTab)
	{
		CString sValue;
		KTParamAttribute* pData;
		CPropertyItem* pItem = NULL;
		POSITION pos = pTab->m_listItem.GetHeadPosition();
		while (NULL != pos)
		{
			pItem = pTab->m_listItem.GetNext(pos);
			ASSERT(NULL != pItem);
			if (NULL == pItem->m_dwUserData)
				continue;

			pData = (KTParamAttribute*)pItem->m_dwUserData;
			ByItemDesc(sValue, pItem->m_sValue, pData->GetVarDesc(), m_mapAttrToValue);
			AsItemString(sValue, pData->GetDataType());
			m_mapAttrToValue.SetAt(pData->GetCode(), sValue);
		}
	}

	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	m_wndViewCtrl.clearAll();
	m_wndViewCtrl.init(true);
	m_wndViewCtrl.SetOrbitFlag(OBF_PAN | OBF_ZOOM | OBF_COTE);

	// 创建实体
	AcDbVoidPtrArray arpPart;
	pService->CreateParamPart(arpPart, m_mapAttrToValue, m_cClassData.GetCode());
	AcDbExtents extAll, ext;
	for (int i = 0; i < arpPart.length(); ++i)
	{
		AcDbEntity *pEnt((AcDbEntity*)arpPart[i]);
		pEnt->getGeomExtents(ext);
		extAll.addExt(ext);
	}
	m_wndViewCtrl.InitFromCurrentView2D(extAll, true);
	for (int i = 0; i < arpPart.length(); ++i)
	{
		AcDbEntity *pEnt((AcDbEntity*)arpPart[i]);
		m_wndViewCtrl.Add(pEnt);
	}

	AcGeMatrix3d mat;
	mat.setToScaling(.8);
	m_wndViewCtrl.model()->setTransform(mat);
	m_wndViewCtrl.view()->invalidate();
	m_wndViewCtrl.Invalidate();
	m_wndViewCtrl.RedrawWindow();
}

void CDlgParamInsert::OnOK() 
{
	CWaitCursor waitor;

	// 更新数据
	CPropertyItemTab* pTab = NULL;
	m_wndLstAttribute.FindTab(pTab, 0);
	if (NULL != pTab)
	{
		CString sValue;
		KTParamAttribute* pData;
		CPropertyItem* pItem = NULL;
		POSITION pos = pTab->m_listItem.GetHeadPosition();
		while (NULL != pos)
		{
			pItem = pTab->m_listItem.GetNext(pos);
			ASSERT(NULL != pItem);
			if (NULL == pItem->m_dwUserData)
				continue;

			pData = (KTParamAttribute*)pItem->m_dwUserData;
			ByItemDesc(sValue, pItem->m_sValue, pData->GetVarDesc(), m_mapAttrToValue);
			AsItemString(sValue, pData->GetDataType());
			m_mapAttrToValue.SetAt(pData->GetCode(), sValue);
		}
	}

	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	// 创建实体
	AcDbVoidPtrArray arpPart;
	pService->CreateParamPart(arpPart, m_mapAttrToValue, m_cClassData.GetCode());
	if (arpPart.isEmpty())
		return;

	CWnd* pFrame = acedGetAcadFrame();
	pFrame->EnableWindow(TRUE);
	ShowWindow(SW_HIDE);

	CKTEntityDragMgr drag(AcGePoint3d::kOrigin, arpPart, TRUE);
	drag.EnableMove(TRUE);
	drag.EnableScale(TRUE);
	drag.EnableRotate(TRUE);
	if (drag.DoDrag())
	{
		if (m_wndRadBlock.GetCheck())
		{
			AcDbObjectId id = CKTCadUtility::CreateBlockTableRecord(arpPart, drag.GetDragPoint());
			AcDbBlockReference *pRef = new AcDbBlockReference(drag.GetDragPoint(), id);
			ASSERT(NULL != pRef);
			AppendEntity(pRef);
		}
		else if (m_wndRadGroup.GetCheck())
		{
			AcDbObjectIdArray arid;
			drag.append(arid);
			CKTCadUtility::CreateAcDbGroup(arid);
		}
		else
		{
			drag.append();
		}
	}

	acTransactionManagerPtr()->flushGraphics();
	acedUpdateDisplay();

	pFrame->EnableWindow(FALSE);
	ShowWindow(SW_SHOW);
	EnableWindow(TRUE);
}