#include "StdAfx.h"
#include "Resource.h"
#include "AfxPriv.h"
#include "DlgParamDefine.h"
#include "DlgParamInsert.h"
#include "DlgParamImport.h"

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

#define SEP_SIZE	3
#define TBAR_SIZE	25

#define BEGIN_ACTIVE_ACAD_IN_DIALOG()	\
	CWnd* pFrame = acedGetAcadFrame();	\
	pFrame->EnableWindow(TRUE);			\
	ShowWindow(SW_HIDE);				\
	pFrame->SetFocus()					\

#define END_ACTIVE_ACAD_IN_DIALOG()		\
	pFrame->EnableWindow(FALSE);		\
	ShowWindow(SW_SHOW);				\
	EnableWindow(TRUE);					\
	if (acedIsInputPending())			\
		EndDialog(IDCANCEL)				\


namespace
{
	BOOL GetArcParam(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd, double dBulge, const AcGeVector3d& vtNormal,
		AcGePoint3d& ptCenter, double& dRadius, double& dStartAngle, double& dEndAngle)
	{
		ASSERT(!_IsZero_(dBulge));
		ASSERT(ptStart != ptEnd);

		// 调整顺序
		const AcGePoint3d* pt1;
		const AcGePoint3d* pt2;
		if (dBulge < 0.0)
		{
			pt1 = &ptEnd;
			pt2 = &ptStart;
			dBulge = -dBulge;
		}
		else
		{
			pt1 = &ptStart;
			pt2 = &ptEnd;
		}

		// 直角三角形对边与斜边关系R = L/sin(A/2)
		// 代入万能公式 sin(A)=2*tg(A/2)/(1+tg(A/2)*tg(A/2))
		// 得到 R = L*(1+B*B) / (2B)  -->L:(p1->p2)/2  B:bulge
		double dL = pt1->distanceTo(*pt2) / 2.0;
		dRadius = dL * (1 + dBulge * dBulge) / (2.0 * dBulge);

		double dA = PI / 2.0 - atan(dBulge) * 2.0;
		AcGeVector3d vt(*pt2 - *pt1);
		vt.rotateBy(dA, vtNormal);
		vt.normalize();
		ptCenter = *pt1 + vt * dRadius;

		acdbWcs2Ecs(asDblArray(AcGeVector3d::kXAxis), asDblArray(vt), asDblArray(vtNormal), true);
		dStartAngle = vt.angleTo(*pt1 - ptCenter, vtNormal);
		dEndAngle = vt.angleTo(*pt2 - ptCenter, vtNormal);

		return TRUE;
	}

}

CDlgParamDefine::CDlgParamDefine(CWnd* pParent)
	: CDialog(CDlgParamDefine::IDD, pParent), m_bPartModified(FALSE),
					m_bMouseDown(FALSE), m_iCurSep(-1), m_bEscape(FALSE),
					m_hCopyClass(NULL)
{
	//{{AFX_DATA_INIT(CDlgParamDefine)
	//}}AFX_DATA_INIT
}

void CDlgParamDefine::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDlgParamDefine)
	DDX_Control(pDX, IDC_TREE_CLASS, m_wndTreeClass);
	DDX_Control(pDX, IDC_STC_PREVIEW, m_wndStcPreview);
	DDX_Control(pDX, IDC_LST_ATTRIBUTE, m_wndLstAttribute);
	DDX_Control(pDX, IDC_LST_RULE, m_wndLstRule);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDlgParamDefine, CDialog)
	//{{AFX_MSG_MAP(CDlgParamDefine)
	ON_WM_SIZE()
	ON_WM_SIZING()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_WM_CAPTURECHANGED()
	ON_WM_SETCURSOR()
	ON_COMMAND(ID_CLASS_NEW, OnClassNew)
	ON_COMMAND(ID_CLASS_DELETE, OnClassDelete)
	ON_COMMAND(ID_CLASS_RENAME, OnClassRename)
	ON_NOTIFY(TVN_BEGINLABELEDIT, IDC_TREE_CLASS, OnBeginLabelEditTreeClass)
	ON_NOTIFY(TVN_ENDLABELEDIT, IDC_TREE_CLASS, OnEndLabelEditTreeClass)
	ON_COMMAND(ID_ATTR_NEW, OnAttrNew)
	ON_COMMAND(ID_ATTR_DELETE, OnAttrDelete)
	ON_COMMAND(ID_ATTR_RENAME, OnAttrRename)
	ON_COMMAND(ID_RULE_NEW, OnRuleNew)
	ON_COMMAND(ID_RULE_SELECT, OnRuleSelect)
	ON_COMMAND(ID_RULE_DELETE, OnRuleDelete)
	ON_NOTIFY(TVN_SELCHANGING, IDC_TREE_CLASS, OnSelchangingTreeClass)
	ON_WM_DESTROY()
	ON_COMMAND(ID_ATTR_UP, OnAttrUp)
	ON_COMMAND(ID_ATTR_DOWN, OnAttrDown)
	ON_COMMAND(ID_RULE_UP, OnRuleUp)
	ON_COMMAND(ID_RULE_DOWN, OnRuleDown)
	ON_COMMAND(ID_CLASS_SAVE, OnClassSave)
	ON_COMMAND(ID_CLASS_TEST, OnClassTest)
	ON_COMMAND(ID_CLASS_COPY, OnClassCopy)
	ON_COMMAND(ID_ATTR_PASTE, OnAttrPaste)
	ON_COMMAND(ID_RULE_PASTE, OnRulePaste)
	ON_COMMAND(ID_CLASS_IMPORT, OnClassImport)
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_USER_CHILDVALUECHANGED, OnPropListBoxNotify)
	ON_MESSAGE(WM_POPMESSAGESTRING, OnSetMessageString)
	ON_MESSAGE(WM_SETMESSAGESTRING, OnSetMessageString)
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipNotify)
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipNotify)
	ON_WM_MENUSELECT()
	ON_WM_EXITMENULOOP()
END_MESSAGE_MAP()

LRESULT CDlgParamDefine::OnSetMessageString(WPARAM wParam, LPARAM lParam)
{
	// set the message bar text
	CString sMsgText;
	if (lParam != 0)
	{
		ASSERT(wParam == 0);    // can't have both an ID and a string
		sMsgText = (LPCTSTR)lParam; // set an explicit string
	}
	else if (wParam != 0)
	{
		if (wParam == AFX_IDS_IDLEMESSAGE || wParam == AFX_IDS_HELPMODEMESSAGE)
		{
			acedRestoreStatusBar();
			return 0;
		}
		else
		{
			sMsgText.LoadString(wParam);
			int iFind = sMsgText.Find(_T('\n'));
			if (iFind > 0)
				sMsgText = sMsgText.Left(iFind);
		}
	}

	acedGetAcadFrame()->SetMessageText(sMsgText);

	return 0;
}

BOOL CDlgParamDefine::OnToolTipNotify(UINT id, NMHDR *pNMHDR, LRESULT *pResult)
{
	// need to handle both ANSI and UNICODE versions of the message
	TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
	TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;

	UINT nID = pNMHDR->idFrom;
	if (pNMHDR->code == TTN_NEEDTEXTA && (pTTTA->uFlags & TTF_IDISHWND) ||
		pNMHDR->code == TTN_NEEDTEXTW && (pTTTW->uFlags & TTF_IDISHWND))
	{
		// idFrom is actually the HWND of the tool
		nID = ::GetDlgCtrlID((HWND)nID);
	}

	// will be zero on a separator
	if (nID != 0)
	{
		CString sTipText;
		sTipText.LoadString(nID);
		int iFind = sTipText.Find(_T('\n'))+1;
		if (iFind > 0)
			sTipText = sTipText.Mid(iFind);

		if (sTipText.IsEmpty())
			return FALSE;

		if (pNMHDR->code == TTN_NEEDTEXTA)
		{
#ifdef UNICODE
			_wcstombsz(pTTTA->szText, sTipText, sizeof(pTTTA->szText) / sizeof(pTTTA->szText[0]));
#else
			strncpy(pTTTA->szText, sTipText, sizeof(pTTTA->szText) / sizeof(TCHAR));
#endif // UNICODE
		}
		else
		{
#ifdef UNICODE
			_tcsncpy(pTTTW->szText, sTipText, sizeof(pTTTW->szText) / sizeof(TCHAR));
#else
			_mbstowcsz(pTTTW->szText, sTipText, sizeof(pTTTW->szText) / sizeof(pTTTW->szText[0]));
#endif // UNICODE
		}

		*pResult = 0;
		return TRUE;
	}

	return FALSE;
}

void CDlgParamDefine::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu) 
{
	CDialog::OnMenuSelect(nItemID, nFlags, hSysMenu);

	if (nItemID > 0 && nItemID < 0xFFFF
		&& (nFlags & MF_POPUP) != MF_POPUP
		&& (nFlags & MF_SEPARATOR) != MF_SEPARATOR)
	{
		CString sText;
		sText.LoadString(nItemID);
		int iFind = sText.Find('\n');
		if (iFind > 0)
			sText = sText.Left(iFind);
		acedGetAcadFrame()->SetMessageText(sText);
	}
}

void CDlgParamDefine::OnExitMenuLoop(BOOL bIsTrackPopupMenu)
{
	CDialog::OnExitMenuLoop(bIsTrackPopupMenu);

	acedRestoreStatusBar();
}

BOOL CDlgParamDefine::PreTranslateMessage(MSG* pMsg) 
{
	if (pMsg->message == WM_KEYDOWN && (pMsg->wParam == VK_RETURN || (m_bEscape = (pMsg->wParam == VK_ESCAPE))))
	{
		CEdit* pEdit = m_wndTreeClass.GetEditControl();
		if (NULL != pEdit)
		{
			pEdit->SendMessage(WM_KEYDOWN, pMsg->wParam, pMsg->lParam);
			return TRUE;
		}
	}

//	m_wndTBarClass.OnUpdateCmdUI((CFrameWnd*)this, TRUE);
//	m_wndTBarAttr.OnUpdateCmdUI((CFrameWnd*)this, TRUE);

	return CDialog::PreTranslateMessage(pMsg);
}

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

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

	if (m_wndTBarClass.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_ALIGN_TOP | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC)
								&& m_wndTBarClass.LoadToolBar(IDR_CLASS))
	{
		CRect rc;
		m_wndTreeClass.GetWindowRect(&rc);
		ScreenToClient(&rc);
		CSize szBar = m_wndTBarClass.CalcFixedLayout(FALSE, TRUE);
		rc.bottom = rc.top;
		rc.top -= TBAR_SIZE;
		rc.right = rc.left + szBar.cx;
		m_wndTBarClass.MoveWindow(&rc);
	}

	if (m_wndTBarAttr.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_ALIGN_TOP | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC)
								&& m_wndTBarAttr.LoadToolBar(IDR_ATTRIBUTE))
	{
		CRect rc;
		m_wndLstAttribute.GetWindowRect(&rc);
		ScreenToClient(&rc);
		CSize szBar = m_wndTBarAttr.CalcFixedLayout(FALSE, TRUE);
		rc.bottom = rc.top;
		rc.top -= TBAR_SIZE;
		rc.right = rc.left + szBar.cx;
		m_wndTBarAttr.MoveWindow(&rc);
	}

	m_imglstIcon.Create(IDB_ICON, 16, 1, RGB(255, 0, 255));
	m_wndTreeClass.SetImageList(&m_imglstIcon, TVSIL_NORMAL);

	m_wndLstAttribute.SetNameWidth(100);
	m_wndLstRule.SetNameWidth(100);

	CRect rc;
	GetClientRect(&rc);
	m_szMin = rc.Size();
	OnRelayout();

	CString sRoot;
	sRoot.LoadString(IDS_CLASSROOTNAME);
	HTREEITEM hRoot = m_wndTreeClass.InsertItem(sRoot, 1, 1);
	ASSERT(NULL != hRoot);
	m_wndTreeClass.SetItemData(hRoot, 0);
	OnInitClassTree(0, hRoot);
	m_wndTreeClass.Expand(hRoot, TVE_EXPAND);

	return TRUE;
}

void CDlgParamDefine::OnSizing(UINT fwSide, LPRECT pRect) 
{
	switch (fwSide)
	{
	case WMSZ_LEFT:
		if (pRect->right - pRect->left < m_szMin.cx)
			pRect->left = pRect->right - m_szMin.cx;
		break;

	case WMSZ_RIGHT:
		if (pRect->right - pRect->left < m_szMin.cx)
			pRect->right = pRect->left + m_szMin.cx;
		break;

	case WMSZ_TOP:
		if (pRect->bottom - pRect->top < m_szMin.cy)
			pRect->top = pRect->bottom - m_szMin.cy;
		break;

	case WMSZ_BOTTOM:
		if (pRect->bottom - pRect->top < m_szMin.cy)
			pRect->bottom = pRect->top + m_szMin.cy;
		break;

	case WMSZ_TOPLEFT:
		if (pRect->right - pRect->left < m_szMin.cx)
			pRect->left = pRect->right - m_szMin.cx;
		if (pRect->bottom - pRect->top < m_szMin.cy)
			pRect->top = pRect->bottom - m_szMin.cy;
		break;

	case WMSZ_TOPRIGHT:
		if (pRect->right - pRect->left < m_szMin.cx)
			pRect->right = pRect->left + m_szMin.cx;
		if (pRect->bottom - pRect->top < m_szMin.cy)
			pRect->top = pRect->bottom - m_szMin.cy;
		break;

	case WMSZ_BOTTOMLEFT:
		if (pRect->right - pRect->left < m_szMin.cx)
			pRect->left = pRect->right - m_szMin.cx;
		if (pRect->bottom - pRect->top < m_szMin.cy)
			pRect->bottom = pRect->top + m_szMin.cy;
		break;

	case WMSZ_BOTTOMRIGHT:
		if (pRect->right - pRect->left < m_szMin.cx)
			pRect->right = pRect->left + m_szMin.cx;
		if (pRect->bottom - pRect->top < m_szMin.cy)
			pRect->bottom = pRect->top + m_szMin.cy;
	}

	CDialog::OnSizing(fwSide, pRect);
}

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

	OnRelayout();
}

void CDlgParamDefine::OnRelayout()
{
	// 取得客户区
	CRect rcClient;
	GetClientRect(&rcClient);
	rcClient.DeflateRect(10, 5 + TBAR_SIZE, 10, 10);

	// 移动预案览窗口到客户区底端
	CRect rc1;
	m_wndStcPreview.GetWindowRect(&rc1);
	ScreenToClient(&rc1);
	rc1.OffsetRect(rcClient.left - rc1.left, rcClient.bottom - rc1.bottom);
	m_wndStcPreview.MoveWindow(&rc1);

	// 调整分类树窗口到的底边
	rc1.bottom = rc1.top - SEP_SIZE;
	rc1.top = rcClient.top;
	m_wndTreeClass.MoveWindow(&rc1);

	// 调整属性窗口的宽度到客户区右边
	CRect rc2;
	m_wndLstAttribute.GetWindowRect(&rc2);
	ScreenToClient(&rc2);
	rc2.OffsetRect(rcClient.right - rc2.right, rcClient.top - rc2.top);
	rc2.left = rc1.right + SEP_SIZE;
	m_wndLstAttribute.MoveWindow(&rc2);

	// 调整工具条位置
	m_wndTBarAttr.SetWindowPos(NULL, rc2.left, rc2.top - TBAR_SIZE, 0, 0, SWP_NOZORDER | SWP_NOSIZE);

	// 调整图形定义窗口尺寸到客户区右下角
	rc2.top = rc2.bottom + SEP_SIZE;
	rc2.bottom = rcClient.bottom;
	m_wndLstRule.MoveWindow(&rc2);
}

void CDlgParamDefine::GetSepRect(CRect* pRecSep)
{
	ASSERT(pRecSep != NULL);

	// 取得客户区
	CRect rcClient;
	GetClientRect(&rcClient);
	rcClient.DeflateRect(10, 5 + TBAR_SIZE, 10, 10);

	CRect rc;
	m_wndTreeClass.GetWindowRect(&rc);
	ScreenToClient(&rc);
	pRecSep[0].SetRect(rc.left, rc.bottom, rc.right, rc.bottom + SEP_SIZE);

	pRecSep[1].SetRect(rc.right, rcClient.top, rc.right + SEP_SIZE, rcClient.bottom);

	m_wndLstAttribute.GetWindowRect(&rc);
	ScreenToClient(&rc);
	pRecSep[2].SetRect(rc.left, rc.bottom, rc.right, rc.bottom + SEP_SIZE);
}

void CDlgParamDefine::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CRect pRect[3];
	GetSepRect(pRect);

	m_iCurSep = 3;
	while ((--m_iCurSep) >= 0)
	{
		if (pRect[m_iCurSep].PtInRect(point))
		{
			SetCapture();
			m_bMouseDown = TRUE;
			m_ptLast = point;
			break;
		}
	}

	CDialog::OnLButtonDown(nFlags, point);
}

void CDlgParamDefine::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if (m_bMouseDown)
	{
		m_bMouseDown = FALSE;
		ReleaseCapture();
	}

	CDialog::OnLButtonUp(nFlags, point);
}

void CDlgParamDefine::OnMouseMove(UINT nFlags, CPoint point) 
{
	if (m_bMouseDown)
	{
		CRect rc1, rc2, rc3, rc4;
		m_wndTBarClass.GetWindowRect(&rc1);
		m_wndTBarAttr.GetWindowRect(&rc2);
		int iTBarClass = rc1.Width();
		int iTBarAttr = rc2.Width();

		m_wndTreeClass.GetWindowRect(&rc1);
		ScreenToClient(&rc1);
		m_wndStcPreview.GetWindowRect(&rc2);
		ScreenToClient(&rc2);
		m_wndLstAttribute.GetWindowRect(&rc3);
		ScreenToClient(&rc3);
		m_wndLstRule.GetWindowRect(&rc4);
		ScreenToClient(&rc4);

		switch (m_iCurSep)
		{
		case 0:
			rc1.bottom += (point.y - m_ptLast.y);
			rc2.top = rc1.bottom + SEP_SIZE;
			if (rc1.Height() >= SEP_SIZE && rc2.Height() >= SEP_SIZE
				&& point.x > rc1.left && point.x < rc1.right
				&& point.y > rc1.bottom && point.y < rc2.top)
			{
				m_wndTreeClass.MoveWindow(&rc1);
				m_wndStcPreview.MoveWindow(&rc2);
			}
			break;

		case 1:
			rc1.right += (point.x - m_ptLast.x);
			rc2.right = rc1.right;
			rc3.left = rc1.right + SEP_SIZE;
			rc4.left = rc3.left;
			if (rc1.Width() >= iTBarClass && rc3.Width() >= iTBarAttr
				&& point.x > rc1.right && point.x < rc3.left
				&& point.y > rc1.top && point.y < rc2.bottom)
			{
				m_wndTreeClass.MoveWindow(&rc1);
				m_wndStcPreview.MoveWindow(&rc2);
				m_wndLstAttribute.MoveWindow(&rc3);
				m_wndLstRule.MoveWindow(&rc4);

				// 调整工具条位置
				m_wndTBarAttr.SetWindowPos(NULL, rc3.left, rc3.top - TBAR_SIZE, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
			}
			break;

		case 2:
			rc3.bottom += (point.y - m_ptLast.y);
			rc4.top = rc3.bottom + SEP_SIZE;
			if (rc3.Height() >= SEP_SIZE && rc4.Height() >= SEP_SIZE
				&& point.x > rc3.left && point.x < rc3.right
				&& point.y > rc3.bottom && point.y < rc4.top)
			{
				m_wndLstAttribute.MoveWindow(&rc3);
				m_wndLstRule.MoveWindow(&rc4);
			}
			break;
		}

		m_ptLast = point;
	}

	CDialog::OnMouseMove(nFlags, point);
}

void CDlgParamDefine::OnCaptureChanged(CWnd *pWnd) 
{
	if (m_bMouseDown)
	{
		m_bMouseDown = FALSE;
		ReleaseCapture();
	}

	CDialog::OnCaptureChanged(pWnd);
}

BOOL CDlgParamDefine::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	if (m_bMouseDown)
	{
		SetCursor(::LoadCursor(NULL, (m_iCurSep == 1 ? IDC_SIZEWE : IDC_SIZENS)));
		return TRUE;
	}

	// 取得分隔区间
	CRect pRect[3];
	GetSepRect(pRect);

	// 取得当前鼠标位置
	CPoint pt;
	GetCursorPos(&pt);
	ScreenToClient(&pt);

	if (pRect[0].PtInRect(pt) || pRect[2].PtInRect(pt))
	{
		SetCursor(::LoadCursor(NULL, IDC_SIZENS));
		return TRUE;
	}

	if (pRect[1].PtInRect(pt))
	{
		SetCursor(::LoadCursor(NULL, IDC_SIZEWE));
		return TRUE;
	}

	return CDialog::OnSetCursor(pWnd, nHitTest, message);
}

void CDlgParamDefine::OnBeginLabelEditTreeClass(NMHDR* pNMHDR, LRESULT* pResult) 
{
	TV_DISPINFO* pTVDispInfo = (TV_DISPINFO*)pNMHDR;

	HTREEITEM hItem = pTVDispInfo->item.hItem;
	if (NULL == hItem || NULL == m_wndTreeClass.GetParentItem(hItem)
		|| m_cCurClass.IsReadOnly())
	{
		*pResult = 1;
	}
	else
	{
		*pResult = 0;
	}
}

void CDlgParamDefine::OnEndLabelEditTreeClass(NMHDR* pNMHDR, LRESULT* pResult) 
{
	TV_DISPINFO* pTVDispInfo = (TV_DISPINFO*)pNMHDR;
	
	if (!m_bEscape)
	{
		m_bEscape = FALSE;

		CString sText;
		CEdit* pEdit = m_wndTreeClass.GetEditControl();
		ASSERT(NULL != pEdit);
		pEdit->GetWindowText(sText);

		HTREEITEM hItem = pTVDispInfo->item.hItem;
		if (sText == m_wndTreeClass.GetItemText(hItem))
		{
			*pResult = 0;
			return;
		}

		BOOL bFind = FALSE;
		while (!bFind && NULL != (hItem = m_wndTreeClass.GetPrevSiblingItem(hItem)))
		{
			bFind = (sText.CompareNoCase(m_wndTreeClass.GetItemText(hItem)) == 0);
		}
		hItem = pTVDispInfo->item.hItem;
		while (!bFind && NULL != (hItem = m_wndTreeClass.GetNextSiblingItem(hItem)))
		{
			bFind = (sText.CompareNoCase(m_wndTreeClass.GetItemText(hItem)) == 0);
		}

		if (bFind)
		{
			CString sMsg;
			sMsg.LoadString(IDS_HASSAMENAME);
			MessageBox(sMsg);

			m_wndTreeClass.EditLabel(pTVDispInfo->item.hItem);

			*pResult = 0;
		}
		else
		{
			int iIndex = -1;
			CPropertyItemTab* pTab = NULL;
			m_wndLstAttribute.FindTab(pTab, 0);
			ASSERT(NULL != pTab);
			KTParamTableAttr* pAttr;
			if (NULL != (pAttr = (KTParamTableAttr*)pTab->m_dwUserDataEx) && 0 == _tcsicmp(pAttr->GetField(), _T("Name")))
			{
				iIndex = 0;
				pTab->m_sName = sText;
			}
			else if (NULL != (pAttr = (KTParamTableAttr*)pTab->m_dwUserData) && 0 == _tcsicmp(pAttr->GetField(), _T("Name")))
			{
				iIndex = 0;
				pTab->m_sValue = sText;
			}
			else
			{
				CPropertyItem* pItem;
				POSITION pos = pTab->m_listItem.GetHeadPosition();
				while (NULL != pos)
				{
					pItem = pTab->m_listItem.GetNext(pos);
					ASSERT(NULL != pItem);
					if (NULL != (pAttr = (KTParamTableAttr*)pItem->m_dwUserDataEx) && 0 == _tcsicmp(pAttr->GetField(), _T("Name")))
					{
						iIndex = m_wndLstAttribute.FindIndex(pItem);
						pItem->m_sName = sText;
						break;
					}
					if (NULL != (pAttr = (KTParamTableAttr*)pItem->m_dwUserData) && 0 == _tcsicmp(pAttr->GetField(), _T("Name")))
					{
						iIndex = m_wndLstAttribute.FindIndex(pItem);
						pItem->m_sValue = sText;
						break;
					}
				}
			}

			if (iIndex >= 0)
			{
				CRect rc;
				m_wndLstAttribute.GetItemRect(iIndex, &rc);
				m_wndLstAttribute.InvalidateRect(rc);
			}

			m_bPartModified |= TRUE;

			*pResult = 1;
		}
	}
	else
	{
		*pResult = 0;
	}
}

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

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

	if (0 == nType)
	{
		if (m_wndLstAttribute.m_hWnd == hPropListBox && nCode == 1)
		{
			CPropertyItem* pItem = NULL;
			CPropertyItemTab* pCurTab = NULL;
			m_wndLstAttribute.GetCurSel(pCurTab, pItem);

			// 类别数据Code项不能重名
			if (NULL != pItem && NULL != pItem->m_dwUserData)
			{
				KTParamTableAttr* pAttr = (KTParamTableAttr*)pItem->m_dwUserData;
				if (_tcsicmp(pAttr->GetField(), _T("Code")) == 0)
				{
					// 检查参数化数据库
					KTParamService* pService = GetKTParamService();
					ASSERT(NULL != pService);

					if (pService->HasSameClassCode(pItem->m_sValue, m_cCurClass.GetId()))
					{
						CString sMsg;
						sMsg.LoadString(IDS_HASSAMENAME);
						MessageBox(sMsg);
						pItem->m_sValue = m_cCurClass.GetCode();
						m_wndLstAttribute.UpdateCtrl();
					}
					m_cCurClass.SetCode(pItem->m_sValue);
				}
			}

			// 属性数据Code项不能重名
			if (NULL != pCurTab && NULL == pItem && bEditName)
			{
				KTParamAttribute* pData = (KTParamAttribute*)pCurTab->m_dwUserParam;
				ASSERT(NULL != pData);

				CPropertyItemTab* pTab;
				POSITION pos = m_wndLstAttribute.GetFirstTabPositon();
				while (NULL != pos)
				{
					pTab = m_wndLstAttribute.GetNextTab(pos);
					if (pTab != pCurTab && pTab->m_sName.CompareNoCase(pCurTab->m_sName) == 0)
					{
						CString sMsg;
						sMsg.LoadString(IDS_HASSAMENAME);
						MessageBox(sMsg);
						pCurTab->m_sName = pData->GetCode();
						m_wndLstAttribute.EditName();
						break;
					}
				}
				pData->SetCode(pCurTab->m_sName);
			}
		}

		return 0;
	}

	// 处理约束中曲线和绘制选择变化
	if (1 == nType)
	{
		if (m_wndLstRule.m_hWnd == hPropListBox)
		{
			// 取得当前条目
			CPropertyItemTab* pTab = NULL;
			CPropertyItem* pItem = NULL;
			m_wndLstRule.GetCurSel(pTab, pItem);
			if (NULL == pTab || NULL != pItem)
				return 0;

			if (bEditName)
			{
				// 曲线变化,删除绘制方式
				pTab->m_sValue.Empty();

				// 删除参数列表
				m_wndLstRule.CollapseTab(pTab);
				POSITION pos = pTab->m_listItem.GetTailPosition();
				while (NULL != pos)
				{
					pItem = pTab->m_listItem.GetPrev(pos);
					if (NULL != pItem && NULL == pItem->m_dwUserData && NULL == pItem->m_dwUserDataEx)
						m_wndLstRule.DeleteItem(pTab, pItem);
				}

				m_wndLstRule.UpdateCtrl();
				SendMessage(WM_USER_CHILDVALUECHANGED, MAKEWPARAM(4, MAKEWORD(0, FALSE)), (LPARAM)hPropListBox);

				// 刷新
				CRect rc;
				int iPos = m_wndLstRule.GetCurSel();
				m_wndLstRule.GetItemRect(iPos, &rc);
				rc.left += m_wndLstRule.GetNameWidth();
				m_wndLstRule.InvalidateRect(rc);
			}
			else
			{
				// 删除参数列表
				m_wndLstRule.CollapseTab(pTab);
				POSITION pos = pTab->m_listItem.GetTailPosition();
				while (NULL != pos)
				{
					pItem = pTab->m_listItem.GetPrev(pos);
					if (NULL != pItem && NULL == pItem->m_dwUserData && NULL == pItem->m_dwUserDataEx)
						m_wndLstRule.DeleteItem(pTab, pItem);
				}

				// 绘制方式变化,更新参数列表
				// 检查参数化数据库
				KTParamService* pService = GetKTParamService();
				ASSERT(NULL != pService);

				KTParamRule* pRule = (KTParamRule*)pTab->m_dwUserParam;
				ASSERT(NULL != pRule);
				KTParamTableAttr* pAttr1 = (KTParamTableAttr*)pTab->m_dwUserDataEx;
				ASSERT(NULL != pAttr1);
				KTParamTableAttr* pAttr2 = (KTParamTableAttr*)pTab->m_dwUserData;
				ASSERT(NULL != pAttr2);

				// 取得属性条目的数据映射
				CMapStringToString mapData;
				pService->GetTableItemById(_T("GetRuleItemById"), pRule->GetId(), mapData);
				// 更新
				CString sValue;
				mapData[pAttr1->GetField()] = ByItemDesc(sValue, pTab->m_sName, pAttr1->GetVarDesc(), mapData);
				mapData[pAttr2->GetField()] = ByItemDesc(sValue, pTab->m_sValue, pAttr2->GetVarDesc(), mapData);

				// 获得参数映射
				CMapStringToString mapParamToDesc;
				AsDescTable(sValue, pAttr1->GetVarDesc(), mapData);
				pService->GetCurveDrawTypeParam(sValue, mapData[pAttr1->GetField()], mapData[pAttr2->GetField()], mapParamToDesc);

				// 添加参数
				CString sKey;
				pos = mapParamToDesc.GetStartPosition();
				while (NULL != pos)
				{
					mapParamToDesc.GetNextAssoc(pos, sKey, sValue);
					m_wndLstRule.AddItem(pTab, sValue, _T(""), CPropertyItem::EDT_NONE);
				}

				m_wndLstRule.ExpandTab(pTab);
			}
		}

		return 0;
	}

	// 处理选择项下拉列表
	if (4 == nType)
	{
		CPropertyListBox* pPropListBox = DYNAMIC_DOWNCAST(CPropertyListBox, CWnd::FromHandle(hPropListBox));
		if (NULL == pPropListBox)
			return 0;

		// 获得子控件
		CComboBox* pSubCtrl = DYNAMIC_DOWNCAST(CComboBox, pPropListBox->GetSubCtrl());
		if (NULL == pSubCtrl || !pSubCtrl->IsWindowVisible())
			return 0;

		// 取得当前条目
		CPropertyItemTab* pTab = NULL;
		CPropertyItem* pItem = NULL;
		pPropListBox->GetCurSel(pTab, pItem);
		if (NULL == pTab)
			return 0;

		// 取得附加数据
		pItem = (NULL == pItem ? pTab : pItem);
		KTParamAttribute* pData = (KTParamAttribute*)pTab->m_dwUserParam;
		KTParamTableAttr* pAttr = (KTParamTableAttr*)(bEditName ? pItem->m_dwUserDataEx : pItem->m_dwUserData);
		if (NULL == pData || NULL == pAttr)
			return 0;

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

		// 取得属性条目的数据映射
		CMapStringToString mapData;
		if (m_wndLstAttribute.m_hWnd == hPropListBox)
			pService->GetTableItemById(_T("GetAttributeItemById"), pData->GetId(), mapData);
		else if (m_wndLstRule.m_hWnd == hPropListBox)
			pService->GetTableItemById(_T("GetRuleItemById"), pData->GetId(), mapData);

		// 更新控件上的数据
		CString sValue;
		CString sDesc1 = pTab->m_sName;
		CString sDesc2 = pTab->m_sValue;
		KTParamTableAttr* pAttr1 = (KTParamTableAttr*)pTab->m_dwUserDataEx;
		KTParamTableAttr* pAttr2 = (KTParamTableAttr*)pTab->m_dwUserData;
		if (NULL != pAttr1 && NULL != pAttr2 && pAttr1->GetIndex() > pAttr2->GetIndex())
		{
			// 更换顺序, 按顺序更新
			sDesc1 = pTab->m_sValue;
			sDesc2 = pTab->m_sName;
			pAttr1 = (KTParamTableAttr*)pTab->m_dwUserData;
			pAttr2 = (KTParamTableAttr*)pTab->m_dwUserDataEx;
		}
		if (NULL != pAttr1)
			mapData[pAttr1->GetField()] = ByItemDesc(sValue, sDesc1, pAttr1->GetVarDesc(), mapData);
		if (NULL != pAttr2)
			mapData[pAttr2->GetField()] = ByItemDesc(sValue, sDesc2, pAttr2->GetVarDesc(), mapData);
		POSITION pos = pTab->m_listItem.GetHeadPosition();
		while (NULL != pos)
		{
			pItem = pTab->m_listItem.GetNext(pos);
			if (NULL == pItem)
				continue;

			sDesc1 = pItem->m_sName;
			sDesc2 = pItem->m_sValue;
			pAttr1 = (KTParamTableAttr*)pItem->m_dwUserDataEx;
			pAttr2 = (KTParamTableAttr*)pItem->m_dwUserData;
			if (NULL != pAttr1 && NULL != pAttr2 && pAttr1->GetIndex() > pAttr2->GetIndex())
			{
				sDesc1 = pItem->m_sValue;
				sDesc2 = pItem->m_sName;
				pAttr1 = (KTParamTableAttr*)pItem->m_dwUserData;
				pAttr2 = (KTParamTableAttr*)pItem->m_dwUserDataEx;
			}
			if (NULL != pAttr1)
				mapData[pAttr1->GetField()] = ByItemDesc(sValue, sDesc1, pAttr1->GetVarDesc(), mapData);
			if (NULL != pAttr2)
				mapData[pAttr2->GetField()] = ByItemDesc(sValue, sDesc2, pAttr2->GetVarDesc(), mapData);
		}

		// 扩展SQL
		CString sSQL;
		pService->ExpandSQL(pAttr->GetValue(), mapData, sSQL);

		// 执行SQL
		CStringArray arsItems;
		pService->ExecuteSQL(sSQL, arsItems);

		// 获取当前数据
		int iCurSel = pSubCtrl->GetCurSel();
		if (iCurSel >= 0) pSubCtrl->GetLBText(iCurSel, sValue);
		else sValue.Empty();

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

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

		return 0;
	}

	return 0;
}

void CDlgParamDefine::OnSelchangingTreeClass(NMHDR* pNMHDR, LRESULT* pResult) 
{
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;

	HTREEITEM hItem = pNMTreeView->itemNew.hItem;
	if (NULL != hItem)
	{
		CWaitCursor waiter;

		if (m_bPartModified)
		{
			CString sMsg;
			sMsg.LoadString(IDS_DATANOTSAVED);
			switch (MessageBox(sMsg, NULL, MB_YESNOCANCEL|MB_ICONQUESTION))
			{
			case IDYES:
				// 代号不得为空
				if (_tcslen(m_cCurClass.GetCode()) <= 0)
				{
					sMsg.LoadString(IDS_EMPTYCLASSCODE);
					MessageBox(sMsg);
					*pResult = TRUE;
					return;
				}
				// 保存旧分类的数据
				if (NULL != pNMTreeView->itemOld.hItem)
					OnUpdateClassItemData(pNMTreeView->itemOld.hItem);
				break;
			case IDCANCEL:
				*pResult = TRUE;
				return;
			}
		}

		// 清除旧分类的属性和约束列表数据
		m_cCurClass = KTParamClass();
		m_bPartModified = FALSE;
		OnCleanAttributeList();
		OnCleanRuleList();

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

		// 取得当前分类数据
		ULONG lId = m_wndTreeClass.GetItemData(hItem);
		pService->GetClassItemById(lId, m_cCurClass);
		//
		BOOL bEdit = (!m_cCurClass.IsReadOnly());

		// 显示分类数据属性条目
		OnShowClassAttrItems(hItem, bEdit);
		// 显示分类属性数据条目
		OnShowClassData(hItem, bEdit);
		// 显示分类约束数据条目
		OnShowRuleData(hItem, bEdit);

		m_wndLstAttribute.ExpandTab(0);
	}

	*pResult = 0;
}

void CDlgParamDefine::OnClassNew() 
{
	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem)
		return;

	// 创建新命名
	CString sName, sText;
	sName.LoadString(IDS_NEWCLASS);
	sText = sName;
	// 找到重名的
	int iIndex = 0;
	HTREEITEM hChild = m_wndTreeClass.GetChildItem(hItem);
	while (NULL != hChild)
	{
		if (sName.CompareNoCase(m_wndTreeClass.GetItemText(hChild)) == 0)
		{
			iIndex++;
			sName.Format(_T("%s%d"), sText, iIndex); 
		}

		hChild = m_wndTreeClass.GetNextSiblingItem(hChild);
	}

	hChild = m_wndTreeClass.InsertItem(sName, hItem);
	if (NULL == hChild)
		return;

	m_wndTreeClass.Expand(hItem, TVE_EXPAND);

	m_wndTreeClass.SelectItem(hChild);
	m_wndTreeClass.EditLabel(hChild);

	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnClassDelete() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem)
		return;

	CString sMsg;
	if (NULL != m_wndTreeClass.GetChildItem(hItem))
	{
		sMsg.LoadString(IDS_HASSUBCLASS);
		MessageBox(sMsg);
		return;
	}

	sMsg.LoadString(IDS_ISDELETECLASS);
	if (IDYES != MessageBox(sMsg, NULL, MB_YESNO|MB_ICONQUESTION))
		return;

	ULONG lId = m_wndTreeClass.GetItemData(hItem);
	if (0 != lId)
	{
		KTParamService* pService = GetKTParamService();
		ASSERT(NULL != pService);

		CStringArray arsItemIds;
		pService->GetRuleItemIds(lId, arsItemIds);
		for (int i = arsItemIds.GetSize() - 1; i >=0; i--)
		{
			pService->DeleteExpressData(_ttol(arsItemIds[i]));
		}
		pService->DeleteRuleData(lId);
		pService->DeleteAttributeData(lId);
		pService->DeleteClassData(lId);
	}

	m_bPartModified = FALSE;
	m_wndTreeClass.DeleteItem(hItem);

	if (m_hCopyClass == hItem)
		m_hCopyClass = NULL;
}

void CDlgParamDefine::OnClassRename() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem)
		return;

	m_wndTreeClass.EditLabel(hItem);
}

void CDlgParamDefine::OnClassSave() 
{
	if (m_bPartModified)
	{
		// 代号不得为空
		if (_tcslen(m_cCurClass.GetCode()) <= 0)
		{
			CString sMsg;
			sMsg.LoadString(IDS_EMPTYCLASSCODE);
			MessageBox(sMsg);
			return;
		}
		// 保存分类的数据
		HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
		if (NULL != hItem)
			OnUpdateClassItemData(hItem);
	}

	m_bPartModified = FALSE;
}

void CDlgParamDefine::OnClassImport() 
{
	CDlgParamImport dlg(&m_wndTreeClass);
	dlg.DoModal();
}

void CDlgParamDefine::OnClassTest() 
{
	if (m_bPartModified)
	{
		HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();

		CString sMsg;
		sMsg.LoadString(IDS_DATANOTSAVED);
		switch (MessageBox(sMsg, NULL, MB_YESNOCANCEL|MB_ICONQUESTION))
		{
		case IDYES:
			// 代号不得为空
			if (_tcslen(m_cCurClass.GetCode()) <= 0)
			{
				sMsg.LoadString(IDS_EMPTYCLASSCODE);
				MessageBox(sMsg);
				return;
			}
			// 保存分类的数据
			if (NULL != hItem)
				OnUpdateClassItemData(hItem);
			m_bPartModified = FALSE;
			break;
		case IDCANCEL:
			return;
		}
	}

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

	CDlgParamInsert dlg;
	dlg.SetClassCode(m_cCurClass.GetCode());
	dlg.DoModal();

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

void CDlgParamDefine::OnAttrNew() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem || NULL == m_wndTreeClass.GetParentItem(hItem))
		return;

	// 创建新命名
	CString sName, sValue;
	sName.LoadString(IDS_NEWATTRIBUTE);
	sValue = sName;
	// 找到重名的
	int iIndex = 0, iPos = 0;
	while (iPos = m_wndLstAttribute.FindTabIndex(sName, iPos) >= 0)
	{
		iIndex++;
		sName.Format(_T("%s%d"), sValue, iIndex);
	}

	// 收起展开的条目
	iIndex = m_wndLstAttribute.GetTabCount();
	while ((--iIndex) >= 0)
		m_wndLstAttribute.CollapseTab(iIndex);

	// 创建属性数据
	KTParamAttribute* pData = new KTParamAttribute;
	if (NULL == pData)
		return;

	// 创建条目
	CPropertyItemTab* pTab = m_wndLstAttribute.AddTab(sName, TRUE);
	if (NULL == pTab)
	{
		delete pData;
		return;
	}

	// 设置数据
	pTab->m_dwUserParam = (DWORD_PTR)pData;

	// 更新数据
	pData->SetClassId(m_cCurClass.GetId());
	pData->SetCode(sName);
	sValue.LoadString(IDS_ATTRIBUTENAME);
	pData->SetName(sValue);

	OnShowAttributeAttrItems(pTab, 0, TRUE);

	m_wndLstAttribute.SetCurSel(pTab, -1);
	m_wndLstAttribute.EditName();
	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnAttrDelete() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	CPropertyItemTab* pTab = NULL;
	CPropertyItem* pItem = NULL;
	m_wndLstAttribute.GetCurSel(pTab, pItem);
	if (NULL == pTab || NULL != pItem)
		return;

	ULONG lId = m_cCurClass.GetId();
	KTParamAttribute* pData = (KTParamAttribute*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	CString sMsg;
	sMsg.LoadString(IDS_ISDELETEATTRIBUTE);
	if (IDYES != MessageBox(sMsg, NULL, MB_YESNO | MB_ICONQUESTION))
		return;

	int iTab = m_wndLstAttribute.FindIndex(pTab);
	ASSERT(iTab >= 0);

	OnCleanAttrTab(pTab);
	m_wndLstAttribute.DeleteTab(pTab);

	if ((int)m_wndLstAttribute.GetTabCount() <= iTab)
		iTab--;
	m_wndLstAttribute.SetCurSel(iTab, -1);
	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnAttrRename() 
{
	CPropertyItemTab* pTab = NULL;
	CPropertyItem* pItem = NULL;
	m_wndLstAttribute.GetCurSel(pTab, pItem);
	if (NULL == pTab || NULL != pItem)
		return;

	m_wndLstAttribute.EditName();
}

void CDlgParamDefine::OnAttrUp() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	int iTab, iIndex;
	m_wndLstAttribute.GetCurSel(iTab, iIndex);
	if (iTab < 1 || iIndex >= 0)
		return;

	CPropertyItemTab* pTab = NULL;
	m_wndLstAttribute.FindTab(pTab, iTab - 1);
	if (NULL == pTab)
		return;

	ULONG lId = m_cCurClass.GetId();
	KTParamAttribute* pData = (KTParamAttribute*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstAttribute.FindTab(pTab, iTab);
	if (NULL == pTab)
		return;

	pData = (KTParamAttribute*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstAttribute.InsertTab(iTab - 1, *pTab);
	m_wndLstAttribute.DeleteTab(pTab);
	m_wndLstAttribute.SetCurSel(iTab - 1, -1);

	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnAttrDown() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	int iTab, iIndex;
	m_wndLstAttribute.GetCurSel(iTab, iIndex);
	if (iTab < 0 || iIndex >= 0)
		return;

	CPropertyItemTab* pTab = NULL;
	m_wndLstAttribute.FindTab(pTab, iTab);
	if (NULL == pTab)
		return;

	ULONG lId = m_cCurClass.GetId();
	KTParamAttribute* pData = (KTParamAttribute*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstAttribute.FindTab(pTab, iTab + 1);
	if (NULL == pTab)
		return;

	pData = (KTParamAttribute*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstAttribute.InsertTab(iTab, *pTab);
	m_wndLstAttribute.DeleteTab(pTab);
	m_wndLstAttribute.SetCurSel(iTab + 1, -1);

	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnRuleSelect() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem || NULL == m_wndTreeClass.GetParentItem(hItem))
		return;

	// 进入AutoCAD命令操作模式
	BEGIN_ACTIVE_ACAD_IN_DIALOG();

	// 加载提示文本
	CAcModuleResourceOverride theResource;
	CString sPrompt;
	sPrompt.LoadString(IDS_SELECTENTITY);

	// 选择对象
	ads_name ssSet;
	struct resbuf rb = {NULL, 0, 0};
	rb.resval.rstring = _tcsdup(_T("LINE,ARC,CIRCLE,ELLIPSE,TEXT,POINT,SOLID,LWPOLYLINE"));
	int iRet = acedSSGet(_T(""), NULL, NULL, &rb, ssSet);

	// 退出AutoCAD命令操作模式
	END_ACTIVE_ACAD_IN_DIALOG();

	// 选择不成功
	if (RTNORM != iRet)
		return;

	// 收起展开的条目
	int iIndex = m_wndLstRule.GetTabCount();
	while ((--iIndex) >= 0)
		m_wndLstRule.CollapseTab(iIndex);

	KTParamRule* pData;
	CPropertyItemTab* pTab;

	CString sCurveType, sDrawType, sText;
	CMapStringToString mapVarTypeToValue;

	double dVal;
	AcGeVector3d vtVal;
	AcGePoint3d ptVal;

	ads_name ent;
	Adesk::Int32 lPos = 0;
	acedSSLength(ssSet, &lPos);
	while ((--lPos) >= 0)
	{
		acedSSName(ssSet, lPos, ent);

		AcDbEntityPtr pEnt(ent, AcDb::kForRead);
		if (NULL == pEnt)
			continue;

		if (pEnt->isKindOf(AcDbLine::desc()))
		{
			AcDbLine* pLine = (AcDbLine*)pEnt.GetObject();

			sCurveType = _T("Line");
			sDrawType = _T("Default");

			ptVal = pLine->startPoint();
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("StartPoint")] = sText;

			ptVal = pLine->endPoint();
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("EndPoint")] = sText;
		}
		else if (pEnt->isKindOf(AcDbArc::desc()))
		{
			AcDbArc* pArc = (AcDbArc*)pEnt.GetObject();

			sCurveType = _T("Arc");
			sDrawType = _T("Default");

			ptVal = pArc->center();
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Center")] = sText;

			dVal = pArc->radius();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("Radius")] = sText;

			dVal = pArc->startAngle();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("StartAngle")] = sText;

			dVal = pArc->endAngle();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("EndAngle")] = sText;
		}
		else if (pEnt->isKindOf(AcDbCircle::desc()))
		{
			AcDbCircle* pCircle = (AcDbCircle*)pEnt.GetObject();

			sCurveType = _T("Circle");
			sDrawType = _T("Default");

			ptVal = pCircle->center();
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Center")] = sText;

			dVal = pCircle->radius();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("Radius")] = sText;
		}
		else if (pEnt->isKindOf(AcDbEllipse::desc()))
		{
			AcDbEllipse* pEllips = (AcDbEllipse*)pEnt.GetObject();

			sCurveType = _T("Ellipse");
			sDrawType = _T("Default");

			ptVal = pEllips->center();
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Center")] = sText;

			dVal = pEllips->majorAxis().length() * 2.0;
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("MajorAxis")] = sText;

			dVal = pEllips->minorAxis().length() * 2.0;
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("MinorAxis")] = sText;

			vtVal = pEllips->majorAxis();
			dVal = vtVal.angleTo(AcGeVector3d::kXAxis, AcGeVector3d::kZAxis);
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("DirectAngle")] = sText;

			dVal = pEllips->startAngle();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("StartAngle")] = sText;

			dVal = pEllips->endAngle();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("EndAngle")] = sText;
		}
		else if (pEnt->isKindOf(AcDbText::desc()))
		{
			AcDbText* pText = (AcDbText*)pEnt.GetObject();

			sCurveType = _T("Text");
			sDrawType = _T("Default");

			ptVal = pText->position();
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Position")] = sText;

			LPTSTR pszStr = pText->textString();
			mapVarTypeToValue[_T("Content")] = pszStr;
			acutDelString(pszStr);

			dVal = pText->height();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("Height")] = sText;

			dVal = pText->rotation();
			sText.Format(_T("%f"), dVal);
			mapVarTypeToValue[_T("Rotation")] = sText;
		}
		else if (pEnt->isKindOf(AcDbPoint::desc()))
		{
			AcDbPoint* pPoint = (AcDbPoint*)pEnt.GetObject();

			sCurveType = _T("Point");
			sDrawType = _T("Default");

			ptVal = pPoint->position();
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Position")] = sText;
		}
		else if (pEnt->isKindOf(AcDbSolid::desc()))
		{
			AcDbSolid* pSolid = (AcDbSolid*)pEnt.GetObject();

			sCurveType = _T("Solid");
			sDrawType = _T("Default");

			pSolid->getPointAt(0, ptVal);
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("First")] = sText;

			pSolid->getPointAt(1, ptVal);
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Second")] = sText;

			pSolid->getPointAt(2, ptVal);
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Third")] = sText;

			pSolid->getPointAt(3, ptVal);
			sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
			mapVarTypeToValue[_T("Fourth")] = sText;
		}
		else if (pEnt->isKindOf(AcDbPolyline::desc()))
		{
			AcDbPolyline* pPline = (AcDbPolyline*)pEnt.GetObject();

			AcGePoint3d pt;
			double dWidth;
			int i = 0, iNums = pPline->numVerts();
			while (i < iNums)
			{
				pPline->getWidthsAt(i, dWidth, dWidth);
				pPline->getBulgeAt(i, dVal);
				pPline->getPointAt(i, ptVal);
				if ((++i) < iNums)
					pPline->getPointAt(i, pt);
				else if (pPline->isClosed())
					pPline->getPointAt(0, pt);
				else
					break;

				sText.Format(_T("%f"), dWidth);
				mapVarTypeToValue[_T("Width")] = sText;

				if (_IsZero_(dVal))
				{
					sCurveType = _T("Line");
					sDrawType = _T("Default");

					sText.Format(_T("%f,%f,%f"), ptVal.x, ptVal.y, ptVal.z);
					mapVarTypeToValue[_T("StartPoint")] = sText;

					sText.Format(_T("%f,%f,%f"), pt.x, pt.y, pt.z);
					mapVarTypeToValue[_T("EndPoint")] = sText;
				}
				else
				{
					sCurveType = _T("Arc");
					sDrawType = _T("Default");

					AcGePoint3d ptCenter;
					double dRadius, dStartAngle, dEndAngle;
					GetArcParam(ptVal, pt, dVal, pPline->normal(), ptCenter, dRadius, dStartAngle, dEndAngle);
					sText.Format(_T("%f,%f,%f"), ptCenter.x, ptCenter.y, ptCenter.z);
					mapVarTypeToValue[_T("Center")] = sText;

					sText.Format(_T("%f"), dRadius);
					mapVarTypeToValue[_T("Radius")] = sText;

					sText.Format(_T("%f"), dStartAngle);
					mapVarTypeToValue[_T("StartAngle")] = sText;

					sText.Format(_T("%f"), dEndAngle);
					mapVarTypeToValue[_T("EndAngle")] = sText;
				}

				pData = new KTParamRule;
				if (NULL == pData)
					continue;

				pTab = m_wndLstRule.AddTab(_T(""));
				if (NULL == pTab)
				{
					delete pData;
					continue;
				}

				pData->SetClassId(m_cCurClass.GetId());

				pData->SetCurveType(sCurveType);
				pData->SetDrawType(sDrawType);
				pTab->m_dwUserParam = (DWORD_PTR)pData;

				OnShowRuleAttrItems(pTab, 0, TRUE);
				OnShowExpression(pTab, mapVarTypeToValue, TRUE);
				mapVarTypeToValue.RemoveAll();

				m_bPartModified |= TRUE;
			}

			continue;
		}
		else
		{
			continue;
		}

		pData = new KTParamRule;
		if (NULL == pData)
			continue;

		pTab = m_wndLstRule.AddTab(_T(""));
		if (NULL == pTab)
		{
			delete pData;
			continue;
		}

		pData->SetClassId(m_cCurClass.GetId());

		pData->SetCurveType(sCurveType);
		pData->SetDrawType(sDrawType);
		pTab->m_dwUserParam = (DWORD_PTR)pData;

		OnShowRuleAttrItems(pTab, 0, TRUE);
		OnShowExpression(pTab, mapVarTypeToValue, TRUE);
		mapVarTypeToValue.RemoveAll();

		m_bPartModified |= TRUE;

		acedSSFree(ssSet);
	}
}

void CDlgParamDefine::OnRuleNew() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem || NULL == m_wndTreeClass.GetParentItem(hItem))
		return;

	// 收起展开的条目
	int iIndex = m_wndLstRule.GetTabCount();
	while ((--iIndex) >= 0)
		m_wndLstRule.CollapseTab(iIndex);

	// 创建属性数据
	KTParamRule* pData = new KTParamRule;
	if (NULL == pData)
		return;

	// 创建条目
	CPropertyItemTab* pTab = m_wndLstRule.AddTab(_T(""), TRUE);
	if (NULL == pTab)
	{
		delete pData;
		return;
	}

	// 设置数据
	pData->SetClassId(m_cCurClass.GetId());
	pData->SetCurveType(_T("Line"));
	pData->SetDrawType(_T("Default"));
	pTab->m_dwUserParam = (DWORD_PTR)pData;

	// 显示约束属性数据
	OnShowRuleAttrItems(pTab, 0, TRUE);
	// 显示约束参数数据
	OnShowExpression(pTab, 0, TRUE);

	m_wndLstRule.SetCurSel(pTab, -1);
	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnRuleDelete() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	CPropertyItemTab* pTab = NULL;
	CPropertyItem* pItem = NULL;
	m_wndLstRule.GetCurSel(pTab, pItem);
	if (NULL == pTab || NULL != pItem)
		return;

	ULONG lId = m_cCurClass.GetId();
	KTParamRule* pData = (KTParamRule*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	int iTab = m_wndLstRule.FindIndex(pTab);
	ASSERT(iTab >= 0);

	OnCleanRuleTab(pTab);
	m_wndLstRule.DeleteTab(pTab);

	if ((int)m_wndLstRule.GetTabCount() <= iTab)
		iTab--;
	m_wndLstRule.SetCurSel(iTab, -1);
	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnRuleUp() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	int iTab, iIndex;
	m_wndLstRule.GetCurSel(iTab, iIndex);
	if (iTab < 1 || iIndex >= 0)
		return;

	CPropertyItemTab* pTab = NULL;
	m_wndLstRule.FindTab(pTab, iTab - 1);
	if (NULL == pTab)
		return;

	ULONG lId = m_cCurClass.GetId();
	KTParamRule* pData = (KTParamRule*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstRule.FindTab(pTab, iTab);
	if (NULL == pTab)
		return;

	pData = (KTParamRule*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstRule.InsertTab(iTab - 1, *pTab);
	m_wndLstRule.DeleteTab(pTab);
	m_wndLstRule.SetCurSel(iTab - 1, -1);

	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnRuleDown() 
{
	if (m_cCurClass.IsReadOnly())
		return;

	int iTab, iIndex;
	m_wndLstRule.GetCurSel(iTab, iIndex);
	if (iTab < 0 || iIndex >= 0)
		return;

	CPropertyItemTab* pTab = NULL;
	m_wndLstRule.FindTab(pTab, iTab);
	if (NULL == pTab)
		return;

	ULONG lId = m_cCurClass.GetId();
	KTParamRule* pData = (KTParamRule*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstRule.FindTab(pTab, iTab + 1);
	if (NULL == pTab)
		return;

	pData = (KTParamRule*)pTab->m_dwUserParam;
	if (NULL == pData || 0 != lId && pData->GetClassId() != lId)
		return;

	m_wndLstRule.InsertTab(iTab, *pTab);
	m_wndLstRule.DeleteTab(pTab);
	m_wndLstRule.SetCurSel(iTab + 1, -1);

	m_bPartModified |= TRUE;
}

void CDlgParamDefine::OnInitClassTree(ULONG lParent, HTREEITEM hParent)
{
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	KTParamClassArray arItems;
	pService->GetSubClassItems(lParent, arItems);

	ULONG lId;
	HTREEITEM hItem;
	int iSize = arItems.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		hItem = m_wndTreeClass.InsertItem(arItems[i].GetName(), hParent);
		ASSERT(NULL != hItem);

		lId = arItems[i].GetId();
		m_wndTreeClass.SetItemData(hItem, lId);

		OnInitClassTree(lId, hItem);
	}
}

void CDlgParamDefine::OnCancel()
{
	if (m_bPartModified)
	{
		HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();

		CString sMsg;
		sMsg.LoadString(IDS_DATANOTSAVED);
		switch (MessageBox(sMsg, NULL, MB_YESNOCANCEL|MB_ICONQUESTION))
		{
		case IDYES:
			// 代号不得为空
			if (_tcslen(m_cCurClass.GetCode()) <= 0)
			{
				sMsg.LoadString(IDS_EMPTYCLASSCODE);
				MessageBox(sMsg);
				return;
			}
			// 保存分类的数据
			if (NULL != hItem)
				OnUpdateClassItemData(hItem);
			m_bPartModified = FALSE;
			break;
		case IDCANCEL:
			return;
		}
	}

	CDialog::OnCancel();
}

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

	OnCleanAttributeList();
	OnCleanRuleList();
}

void CDlgParamDefine::OnCleanAttrTab(CPropertyItemTab* pTab)
{
	CPropertyItem* pItem;
	POSITION pos = pTab->m_listItem.GetHeadPosition();
	while (NULL != pos)
	{
		pItem = pTab->m_listItem.GetNext(pos);
		ASSERT(NULL != pItem);

		if (NULL != pItem->m_dwUserData)
		{
			delete ((KTParamTableAttr*)(pItem->m_dwUserData));
			pItem->m_dwUserData = NULL;
		}
		if (NULL != pItem->m_dwUserDataEx)
		{
			delete ((KTParamTableAttr*)(pItem->m_dwUserDataEx));
			pItem->m_dwUserDataEx = NULL;
		}
	}

	if (NULL != pTab->m_dwUserParam)
	{
		delete ((KTParamAttribute*)(pTab->m_dwUserParam));
		pTab->m_dwUserParam = NULL;
	}
	if (NULL != pTab->m_dwUserData)
	{
		delete ((KTParamTableAttr*)(pTab->m_dwUserData));
		pTab->m_dwUserData = NULL;
	}
	if (NULL != pTab->m_dwUserDataEx)
	{
		delete ((KTParamTableAttr*)(pTab->m_dwUserDataEx));
		pTab->m_dwUserDataEx = NULL;
	}
}

void CDlgParamDefine::OnCleanAttributeList()
{
	CPropertyItemTab* pTab;
	POSITION pos = m_wndLstAttribute.GetFirstTabPositon();
	while (NULL != pos)
	{
		pTab = m_wndLstAttribute.GetNextTab(pos);
		ASSERT(NULL != pTab);

		OnCleanAttrTab(pTab);
	}

	m_wndLstAttribute.ResetContent();
}

void CDlgParamDefine::OnCleanRuleTab(CPropertyItemTab* pTab)
{
	CPropertyItem* pItem;
	POSITION pos = pTab->m_listItem.GetHeadPosition();
	while (NULL != pos)
	{
		pItem = pTab->m_listItem.GetNext(pos);
		ASSERT(NULL != pItem);

		if (NULL != pItem->m_dwUserData)
		{
			delete ((KTParamTableAttr*)(pItem->m_dwUserData));
			pItem->m_dwUserData = NULL;
		}
		if (NULL != pItem->m_dwUserDataEx)
		{
			delete ((KTParamTableAttr*)(pItem->m_dwUserDataEx));
			pItem->m_dwUserDataEx = NULL;
		}
	}

	if (NULL != pTab->m_dwUserParam)
	{
		delete ((KTParamRule*)(pTab->m_dwUserParam));
		pTab->m_dwUserParam = NULL;
	}
	if (NULL != pTab->m_dwUserData)
	{
		delete ((KTParamTableAttr*)(pTab->m_dwUserData));
		pTab->m_dwUserData = NULL;
	}
	if (NULL != pTab->m_dwUserDataEx)
	{
		delete ((KTParamTableAttr*)(pTab->m_dwUserDataEx));
		pTab->m_dwUserDataEx = NULL;
	}
}

void CDlgParamDefine::OnCleanRuleList()
{
	CPropertyItemTab* pTab;
	POSITION pos = m_wndLstRule.GetFirstTabPositon();
	while (NULL != pos)
	{
		pTab = m_wndLstRule.GetNextTab(pos);
		ASSERT(NULL != pTab);

		OnCleanRuleTab(pTab);
	}

	m_wndLstRule.ResetContent();
}

void CDlgParamDefine::OnUpdateClassItemData(HTREEITEM hItem)
{
	CWaitCursor waiter;

	// 为顶层条目，没有分类
	ASSERT(NULL != hItem);
	HTREEITEM hParent = m_wndTreeClass.GetParentItem(hItem);
	if (NULL == hParent)
		return;

	KTParamClass cClassData;
	KTParamAttributePtrArray arpAttrData;
	KTParamRulePtrArray arpRuleData;

	cClassData.SetId(m_wndTreeClass.GetItemData(hItem));
	cClassData.SetUpId(m_wndTreeClass.GetItemData(hParent));
	cClassData.SetName(m_wndTreeClass.GetItemText(hItem));

	int iIndex = 0;
	CPropertyItemTab* pTab;
	KTParamAttribute* pAttr;
	POSITION pos = m_wndLstAttribute.GetFirstTabPositon();
	while (NULL != pos)
	{
		pTab = m_wndLstAttribute.GetNextTab(pos);
		ASSERT(NULL != pTab);

		pAttr = (KTParamAttribute*)pTab->m_dwUserParam;
		if (NULL == pAttr)
		{
			OnUpdateClassAttrData(pTab, cClassData);
		}
		else if (pAttr->GetClassId() == cClassData.GetId())
		{
			OnUpdateAttributeData(pTab, *pAttr);
			pAttr->SetIndex(iIndex++);
			arpAttrData.Add(pAttr);
		}
	}

	iIndex = 0;
	KTParamRule* pRule;
	pos = m_wndLstRule.GetFirstTabPositon();
	while (NULL != pos)
	{
		pTab = m_wndLstRule.GetNextTab(pos);
		ASSERT(NULL != pTab);

		pRule = (KTParamRule*)pTab->m_dwUserParam;
		ASSERT(NULL != pRule);

		//if (pRule->GetClassId() == cClassData.GetId())
		{
			OnUpdateRuleData(pTab, *pRule);
			pRule->SetIndex(iIndex++);
			arpRuleData.Add(pRule);
		}
	}

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

	// 更新类型数据
	BOOL bSuccess = pService->UpdateClassData(&cClassData);
	if (bSuccess)
	{
		if (m_wndTreeClass.GetSelectedItem() == hItem)
			m_cCurClass = cClassData;

		m_wndTreeClass.SetItemData(hItem, cClassData.GetId());
		// 更新属性数据
		bSuccess &= pService->UpdateAttributeData(cClassData.GetId(), arpAttrData);
		// 更新约束数据
		bSuccess &= pService->UpdateRuleData(cClassData.GetId(), arpRuleData);
	}

	if (!bSuccess)
	{
		CString sMsg;
		sMsg.LoadString(IDS_DATAACCESSERROR);
		MessageBox(sMsg);
	}
}

void CDlgParamDefine::OnUpdateClassAttrData(CPropertyItemTab* pTab, KTParamClass& cClassData)
{
	ASSERT(NULL != pTab);

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

	CMapStringToString mapVarToValue;
	pService->GetTableItemById(_T("GetClassItemById"), cClassData.GetId(), mapVarToValue);
	// 更新数据
	if (0 == cClassData.GetId())
		cClassData.MapFieldToValue(mapVarToValue);

	CString sValue;
	KTParamTableAttr* pAttr;

	if (NULL != pTab->m_dwUserData)
	{
		pAttr = (KTParamTableAttr*)pTab->m_dwUserData;
		cClassData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pTab->m_sValue, pAttr->GetVarDesc(), mapVarToValue));
		mapVarToValue[pAttr->GetField()] = sValue;
	}

	if (NULL != pTab->m_dwUserDataEx)
	{
		pAttr = (KTParamTableAttr*)pTab->m_dwUserDataEx;
		cClassData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pTab->m_sName, pAttr->GetVarDesc(), mapVarToValue));
		mapVarToValue[pAttr->GetField()] = sValue;
	}

	CPropertyItem* pItem;
	POSITION pos = pTab->m_listItem.GetHeadPosition();
	while (NULL != pos)
	{
		pItem = pTab->m_listItem.GetNext(pos);
		ASSERT(NULL != pItem);

		if (NULL != pItem->m_dwUserData)
		{
			pAttr = (KTParamTableAttr*)pItem->m_dwUserData;
			cClassData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pItem->m_sValue, pAttr->GetVarDesc(), mapVarToValue));
			mapVarToValue[pAttr->GetField()] = sValue;
		}

		if (NULL != pItem->m_dwUserDataEx)
		{
			pAttr = (KTParamTableAttr*)pItem->m_dwUserDataEx;
			cClassData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pItem->m_sName, pAttr->GetVarDesc(), mapVarToValue));
			mapVarToValue[pAttr->GetField()] = sValue;
		}
	}
}

void CDlgParamDefine::OnUpdateAttributeData(CPropertyItemTab* pTab, KTParamAttribute& cAttrData)
{
	ASSERT(NULL != pTab);

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

	// 取得属性条目的数据映射
	CMapStringToString mapVarToValue;
	pService->GetTableItemById(_T("GetAttributeItemById"), cAttrData.GetId(), mapVarToValue);
	// 更新数据
	if (0 == cAttrData.GetId())
		cAttrData.MapFieldToValue(mapVarToValue);

 	CString sValue;
	KTParamTableAttr* pAttr;

	if (NULL != pTab->m_dwUserData)
	{
		pAttr = (KTParamTableAttr*)pTab->m_dwUserData;
		cAttrData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pTab->m_sValue, pAttr->GetVarDesc(), mapVarToValue));
		mapVarToValue[pAttr->GetField()] = sValue;
	}

	if (NULL != pTab->m_dwUserDataEx)
	{
		pAttr = (KTParamTableAttr*)pTab->m_dwUserDataEx;
		cAttrData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pTab->m_sName, pAttr->GetVarDesc(), mapVarToValue));
		mapVarToValue[pAttr->GetField()] = sValue;
	}

	CPropertyItem* pItem;
	POSITION pos = pTab->m_listItem.GetHeadPosition();
	while (NULL != pos)
	{
		pItem = pTab->m_listItem.GetNext(pos);
		ASSERT(NULL != pItem);

		if (NULL != pItem->m_dwUserData)
		{
			pAttr = (KTParamTableAttr*)pItem->m_dwUserData;
			cAttrData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pItem->m_sValue, pAttr->GetVarDesc(), mapVarToValue));
			mapVarToValue[pAttr->GetField()] = sValue;
		}

		if (NULL != pItem->m_dwUserDataEx)
		{
			pAttr = (KTParamTableAttr*)pItem->m_dwUserDataEx;
			cAttrData.SetValue(pAttr->GetField(), ByItemDesc(sValue, pItem->m_sName, pAttr->GetVarDesc(), mapVarToValue));
			mapVarToValue[pAttr->GetField()] = sValue;
		}
	}
}

void CDlgParamDefine::OnUpdateRuleData(CPropertyItemTab* pTab, KTParamRule& cRuleData)
{
	ASSERT(NULL != pTab);

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

	// 取得属性条目的数据映射
	CMapStringToString mapVarToValue;
	pService->GetTableItemById(_T("GetRuleItemById"), cRuleData.GetId(), mapVarToValue);
	// 更新数据
	if (0 == cRuleData.GetId())
		cRuleData.MapFieldToValue(mapVarToValue);

 	CString sValue;
	KTParamTableAttr* pAttr1 = (KTParamTableAttr*)pTab->m_dwUserDataEx;
	ASSERT(NULL != pAttr1);
	cRuleData.SetValue(pAttr1->GetField(), ByItemDesc(sValue, pTab->m_sName, pAttr1->GetVarDesc(), mapVarToValue));
	mapVarToValue[pAttr1->GetField()] = sValue;

	KTParamTableAttr* pAttr2 = (KTParamTableAttr*)pTab->m_dwUserData;
	ASSERT(NULL != pAttr2);
	cRuleData.SetValue(pAttr2->GetField(), ByItemDesc(sValue, pTab->m_sValue, pAttr2->GetVarDesc(), mapVarToValue));
	mapVarToValue[pAttr2->GetField()] = sValue;

	CMapStringToString mapDescToParam;
	AsDescTable(sValue, pAttr1->GetVarDesc(), mapVarToValue);
	pService->GetCurveDrawTypeParam(sValue, mapVarToValue[pAttr1->GetField()], mapVarToValue[pAttr2->GetField()], mapDescToParam, TRUE);

	KTParamExpression cExpress;
	cExpress.SetRuleId(cRuleData.GetId());

	int iIndex = 0;
	CPropertyItem* pItem;
	POSITION pos = pTab->m_listItem.GetHeadPosition();
	while (NULL != pos)
	{
		pItem = pTab->m_listItem.GetNext(pos);
		ASSERT(NULL != pItem);
		ASSERT(NULL == pItem->m_dwUserData && NULL == pItem->m_dwUserDataEx);

		cExpress.SetVarType(mapDescToParam[pItem->m_sName]);
		cExpress.SetValue(pItem->m_sValue);
		cExpress.SetIndex(iIndex++);
		cRuleData.m_arExpression.Add(cExpress);
	}
}

CPropertyItem::ItemStyle CDlgParamDefine::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 CDlgParamDefine::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 CDlgParamDefine::AsDescTable(CString& sDescTable, LPCTSTR pszVarDesc, const CMapStringToString& mapVarToValue)
{
	if (NULL != _tcschr(pszVarDesc, _T(' ')))
	{
		// 检查参数化数据库
		KTParamService* pService = GetKTParamService();
		ASSERT(NULL != pService);

		CString sSQL;
		if (pService->ExpandSQL(pszVarDesc, mapVarToValue, sSQL))
		{
			CStringArray arsTable;
			if (pService->ExecuteSQL(sSQL, arsTable))
			{
				sDescTable = arsTable[0];
				return sDescTable;
			}
		}
	}

	sDescTable = pszVarDesc;

	return sDescTable;
}

LPCTSTR CDlgParamDefine::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 CDlgParamDefine::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 CDlgParamDefine::OnShowClassData(HTREEITEM hItem, BOOL bEdit)
{
	// 取得分类ID
	ASSERT(NULL != hItem);
	ULONG lId = m_wndTreeClass.GetItemData(hItem);

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

	KTParamClass data;
	if (!pService->GetClassItemById(lId, data))
	{
		// 如果是新建分类，列出父类型数据
		if (NULL != (hItem = m_wndTreeClass.GetParentItem(hItem)))
			OnShowClassData(hItem, FALSE);
		return;
	}

	if (bEdit)
		bEdit = (!data.IsReadOnly());

	if (NULL != (hItem = m_wndTreeClass.GetParentItem(hItem)))
		OnShowClassData(hItem, FALSE);

	OnShowAttributeItems(lId, bEdit);
}

void CDlgParamDefine::OnShowClassAttrItems(HTREEITEM hItem, BOOL bEdit)
{
	// 为顶层条目，没有分类
	ASSERT(NULL != hItem);
	if (NULL == m_wndTreeClass.GetParentItem(hItem))
		return;

	// 取得分类ID
	ULONG lId = m_wndTreeClass.GetItemData(hItem);

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

	// 取得类型条目的数据映射
	CMapStringToString mapData;
	pService->GetTableItemById(_T("GetClassItemById"), lId, mapData);
	mapData[_T("Name")] = m_wndTreeClass.GetItemText(hItem);

	// 取得类型表属性数据
	KTParamTableAttrPtrArray arpItems;
	pService->GetTableAttrItems(_T("Class_Attr"), TRUE, arpItems);

	// 准备构造列表
	CPropertyItem* pItem = NULL;
	CPropertyItemTab* pTab = NULL;

	// 构造列表
	LPCTSTR pszFlags;
	KTParamTableAttr* pAttr;
	int iSize = arpItems.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		// 取得属性表属性项
		pAttr = arpItems[i];
		ASSERT(NULL != pAttr && pAttr->IsVisible());

		// 如果条目为空，且创建不成功，删除属性项
		if (NULL == pTab && NULL == (pTab = m_wndLstAttribute.AddTab(_T(""))))
		{
			delete pAttr;
			continue;
		}

		// 根据标志处理类型内容位置
		pszFlags = pAttr->GetFlags();
		// 如为Tab分类
		if (NULL != _tcschr(pszFlags, _T('C')))
		{
			// 如为Tab的标题域
			if (NULL != _tcschr(pszFlags, _T('T')))
			{
				// 判断是否已经有标题域了或者添加失败，有了或添加不成功则删除属性项
				if (NULL != pTab->m_dwUserDataEx && NULL == (pTab = m_wndLstAttribute.AddTab(_T(""))))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新标题域内容
				pTab->m_dwUserDataEx = (DWORD_PTR)pAttr;
				AsItemDesc(pTab->m_sName, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果标题为空，则使用默认值
				if (pTab->m_sName.IsEmpty())
					pTab->m_sName = pAttr->GetDefault();
				pTab->m_bNameEditable = (bEdit && !pAttr->IsReadOnly());
				pTab->m_eNameStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写数值域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pTab->m_sValue = pAttr->GetName();
			}
			else
			{
				// 判断是否已经有数值域了或者添加失败，有了或添加不成功则删除属性项
				if (NULL != pTab->m_dwUserData && NULL == (pTab = m_wndLstAttribute.AddTab(_T(""))))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新数值域内容
				pTab->m_dwUserData = (DWORD_PTR)pAttr;
				AsItemDesc(pTab->m_sValue, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果数值为空，则使用默认值
				if (pTab->m_sValue.IsEmpty())
					pTab->m_sValue = pAttr->GetDefault();
				pTab->m_bValueEditable = (bEdit && !pAttr->IsReadOnly());
				pTab->m_eValueStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写标题域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pTab->m_sName = pAttr->GetName();
			}
		}
		else
		{
			// 如果条目为空，且创建不成功，删除属性项
			if (NULL == pItem && (!m_wndLstAttribute.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
			{
				delete pAttr;
				continue;
			}

			// 如为Tab的标题域
			if (NULL != _tcschr(pszFlags, _T('T')))
			{
				// 如果已经标题域了，且添加新条目，如果不成功，则删除属性项
				if (NULL != pItem->m_dwUserDataEx && (!m_wndLstAttribute.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新标题域内容
				pItem->m_dwUserDataEx = (DWORD_PTR)pAttr;
				AsItemDesc(pItem->m_sName, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果标题为空，则使用默认值
				if (pItem->m_sName.IsEmpty())
					pItem->m_sName = pAttr->GetDefault();
				pItem->m_bNameEditable = (bEdit && !pAttr->IsReadOnly());
				pTab->m_eNameStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写数值域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pItem->m_sValue = pAttr->GetName();
			}
			else
			{
				// 如果已经数值域了，且添加新条目，如果不成功，则删除属性项
				if (NULL != pItem->m_dwUserData && (!m_wndLstAttribute.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新数值域内容
				pItem->m_dwUserData = (DWORD_PTR)pAttr;
				AsItemDesc(pItem->m_sValue, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果数值为空，则使用默认值
				if (pItem->m_sValue.IsEmpty())
					pItem->m_sValue = pAttr->GetDefault();
				pItem->m_bValueEditable = (bEdit && !pAttr->IsReadOnly());
				pItem->m_eValueStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写标题域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pItem->m_sName = pAttr->GetName();
			}
		}
	}
}

void CDlgParamDefine::OnShowAttributeItems(ULONG lId, BOOL bEdit)
{
	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	// 获取属性内容
	KTParamAttributePtrArray arpItems;
	pService->GetAttributeItems(lId, arpItems);

	// 准备构造列表
	CPropertyItemTab* pTab;
	KTParamAttribute* pAttr;

	// 构造列表
	int iSize = arpItems.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		// 取得属性表属性项
		pAttr = arpItems[i];
		ASSERT(NULL != pAttr);

		// 创建属性分类
		pTab = m_wndLstAttribute.AddTab(_T(""));
		if (NULL == pTab)
		{
			delete pAttr;
			continue;
		}

		// 保存当前属性内容
		pTab->m_dwUserParam = (DWORD_PTR)pAttr;

		// 显示当前属性条目
		OnShowAttributeAttrItems(pTab, pAttr->GetId(), bEdit);
	}
}

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

	// 取得属性条目的数据映射
	CMapStringToString mapData;
	pService->GetTableItemById(_T("GetAttributeItemById"), lId, mapData);
	// 更新数据
	KTParamAttribute* pData = (KTParamAttribute*)pTab->m_dwUserParam;
	if (0 == pData->GetId())
		pData->MapFieldToValue(mapData);

	// 取得属性表属性数据
	KTParamTableAttrPtrArray arpItems;
	pService->GetTableAttrItems(_T("Attribute_Attr"), TRUE, arpItems);

	// 准备构造列表
	CPropertyItem* pItem = NULL;
	ASSERT(NULL != pTab);

	// 构造列表
	LPCTSTR pszFlags;
	KTParamTableAttr* pAttr;
	int iSize = arpItems.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		// 取得属性表属性项
		pAttr = arpItems[i];
		ASSERT(NULL != pAttr && pAttr->IsVisible());

		// 根据标志处理属性内容位置
		pszFlags = pAttr->GetFlags();
		// 如为Tab分类
		if (NULL != _tcschr(pszFlags, _T('C')))
		{
			// 如为Tab的标题域
			if (NULL != _tcschr(pszFlags, _T('T')))
			{
				// 判断是否已经有标题域了，有了则删除属性项
				if (NULL != pTab->m_dwUserDataEx)
				{
					delete pAttr;
					continue;
				}
				// 赋值更新标题域内容
				pTab->m_dwUserDataEx = (DWORD_PTR)pAttr;
				AsItemDesc(pTab->m_sName, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果标题为空，则使用默认值
				if (pTab->m_sName.IsEmpty())
					pTab->m_sName = pAttr->GetDefault();
				pTab->m_bNameEditable = (bEdit && !pAttr->IsReadOnly());
				pTab->m_eNameStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写数值域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pTab->m_sValue = pAttr->GetName();
			}
			else
			{
				// 判断是否已经有数值域了，有了则删除属性项
				if (NULL != pTab->m_dwUserData)
				{
					delete pAttr;
					continue;
				}
				// 赋值更新数值域内容
				pTab->m_dwUserData = (DWORD_PTR)pAttr;
				AsItemDesc(pTab->m_sValue, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果数值为空，则使用默认值
				if (pTab->m_sValue.IsEmpty())
					pTab->m_sValue = pAttr->GetDefault();
				pTab->m_bValueEditable = (bEdit && !pAttr->IsReadOnly());
				pTab->m_eValueStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写标题域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pTab->m_sName = pAttr->GetName();
			}
		}
		else
		{
			// 如果条目为空，且创建不成功，删除属性项
			if (NULL == pItem && (!m_wndLstAttribute.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
			{
				delete pAttr;
				continue;
			}

			// 如为Tab的标题域
			if (NULL != _tcschr(pszFlags, _T('T')))
			{
				// 如果已经标题域了，且添加新条目，如果不成功，则删除属性项
				if (NULL != pItem->m_dwUserDataEx && (!m_wndLstAttribute.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新标题域内容
				pItem->m_dwUserDataEx = (DWORD_PTR)pAttr;
				AsItemDesc(pItem->m_sName, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果标题为空，则使用默认值
				if (pItem->m_sName.IsEmpty())
					pItem->m_sName = pAttr->GetDefault();
				pItem->m_bNameEditable = (bEdit && !pAttr->IsReadOnly());
				pItem->m_eNameStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写数值域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pItem->m_sValue = pAttr->GetName();
			}
			else
			{
				// 如果已经数值域了，且添加新条目，如果不成功，则删除属性项
				if (NULL != pItem->m_dwUserData && (!m_wndLstAttribute.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新数值域内容
				pItem->m_dwUserData = (DWORD_PTR)pAttr;
				AsItemDesc(pItem->m_sValue, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果数值为空，则使用默认值
				if (pItem->m_sValue.IsEmpty())
					pItem->m_sValue = pAttr->GetDefault();
				pItem->m_bValueEditable = (bEdit && !pAttr->IsReadOnly());
				pItem->m_eValueStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写标题域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pItem->m_sName = pAttr->GetName();
			}
		}
	}
}

void CDlgParamDefine::OnShowRuleData(HTREEITEM hItem, BOOL bEdit)
{
	// 取得分类ID
	ASSERT(NULL != hItem);
	ULONG lId = m_wndTreeClass.GetItemData(hItem);

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

	// 获取约束数据
	KTParamRulePtrArray arpItems;
	pService->GetRuleItems(lId, arpItems);

	// 准备构造列表
	CPropertyItemTab* pTab;
	KTParamRule* pRule;

	// 构造列表
	int iSize = arpItems.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		// 取得约束表项
		pRule = arpItems[i];
		ASSERT(NULL != pRule);

		pTab = m_wndLstRule.AddTab(_T(""));
		if (NULL == pTab)
		{
			delete pRule;
			continue;
		}

		// 保存当前约束内容
		pTab->m_dwUserParam = (DWORD_PTR)pRule;

		// 显示当前约束条目
		OnShowRuleAttrItems(pTab, pRule->GetId(), bEdit);
		// 显示当前约束参数
		OnShowExpression(pTab, pRule->GetId(), bEdit);
	}
}

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

	// 取得约束条目的数据映射
	CMapStringToString mapData;
	pService->GetTableItemById(_T("GetRuleItemById"), lId, mapData);
	// 更新
	KTParamRule* pData = (KTParamRule*)pTab->m_dwUserParam;
	mapData[_T("CurveType")] = pData->GetCurveType();
	mapData[_T("DrawType")] = pData->GetDrawType();

	// 取得约束表属性数据
	KTParamTableAttrPtrArray arpItems;
	pService->GetTableAttrItems(_T("Rules_Attr"), TRUE, arpItems);

	// 准备构造列表
	CPropertyItem* pItem = NULL;
	ASSERT(NULL != pTab);

	// 构造列表
	LPCTSTR pszFlags;
	KTParamTableAttr* pAttr;
	int iSize = arpItems.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		// 取得约束表属性项
		pAttr = arpItems[i];
		ASSERT(NULL != pAttr && pAttr->IsVisible());

		// 根据标志处理属性内容位置
		pszFlags = pAttr->GetFlags();
		// 如为Tab分类
		if (NULL != _tcschr(pszFlags, _T('C')))
		{
			// 如为Tab的标题域
			if (NULL != _tcschr(pszFlags, _T('T')))
			{
				// 判断是否已经有标题域了，有了则删除属性项
				if (NULL != pTab->m_dwUserDataEx)
				{
					delete pAttr;
					continue;
				}
				// 赋值更新标题域内容
				pTab->m_dwUserDataEx = (DWORD_PTR)pAttr;
				AsItemDesc(pTab->m_sName, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果标题为空，则使用默认值
				if (pTab->m_sName.IsEmpty())
					pTab->m_sName = pAttr->GetDefault();
				pTab->m_bNameEditable = bEdit;
				pTab->m_eNameStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写数值域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pTab->m_sValue = pAttr->GetName();
			}
			else
			{
				// 判断是否已经有数值域了，有了则删除属性项
				if (NULL != pTab->m_dwUserData)
				{
					delete pAttr;
					continue;
				}
				// 赋值更新数值域内容
				pTab->m_dwUserData = (DWORD_PTR)pAttr;
				AsItemDesc(pTab->m_sValue, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果数值为空，则使用默认值
				if (pTab->m_sValue.IsEmpty())
					pTab->m_sValue = pAttr->GetDefault();
				pTab->m_bValueEditable = bEdit;
				pTab->m_eValueStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写标题域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pTab->m_sName = pAttr->GetName();
			}
		}
		else
		{
			// 如果条目为空，且创建不成功，删除属性项
			if (NULL == pItem && (!m_wndLstRule.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
			{
				delete pAttr;
				continue;
			}

			// 如为Tab的标题域
			if (NULL != _tcschr(pszFlags, _T('T')))
			{
				// 如果已经标题域了，且添加新条目，如果不成功，则删除属性项
				if (NULL != pItem->m_dwUserDataEx && (!m_wndLstRule.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新标题域内容
				pItem->m_dwUserDataEx = (DWORD_PTR)pAttr;
				AsItemDesc(pItem->m_sName, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果标题为空，则使用默认值
				if (pItem->m_sName.IsEmpty())
					pItem->m_sName = pAttr->GetDefault();
				pItem->m_bNameEditable = bEdit;
				pItem->m_eNameStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写数值域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pItem->m_sValue = pAttr->GetName();
			}
			else
			{
				// 如果已经数值域了，且添加新条目，如果不成功，则删除属性项
				if (NULL != pItem->m_dwUserData && (!m_wndLstRule.AddItem(pTab, _T(""), _T(""), CPropertyItem::EDT_NONE)
									|| NULL == (pItem = pTab->m_listItem.GetTail())))
				{
					delete pAttr;
					continue;
				}
				// 赋值更新数值域内容
				pItem->m_dwUserData = (DWORD_PTR)pAttr;
				AsItemDesc(pItem->m_sValue, AsItemString(mapData[pAttr->GetField()], pAttr->GetDataType()), pAttr->GetVarDesc(), mapData);
				// 如果数值为空，则使用默认值
				if (pItem->m_sValue.IsEmpty())
					pItem->m_sValue = pAttr->GetDefault();
				pItem->m_bValueEditable = bEdit;
				pItem->m_eValueStyle = AsItemStyle(pAttr->GetDataType(), (_tcslen(pAttr->GetValue()) > 0), pAttr->IsOverride());
				// 如果不是单项，填写标题域内容
				if (NULL == _tcschr(pszFlags, _T('S')))
					pItem->m_sName = pAttr->GetName();
			}
		}
	}
}

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

	// 取得约束参数表达式数据
	CMapStringToString mapVarTypeToValue;
	pService->GetExpressionItemById(lId, mapVarTypeToValue);

	OnShowExpression(pTab, mapVarTypeToValue, bEdit);
}

void CDlgParamDefine::OnShowExpression(CPropertyItemTab* pTab, CMapStringToString& mapVarTypeToValue, BOOL bEdit)
{
	// 检查参数化数据库
	KTParamService* pService = GetKTParamService();
	ASSERT(NULL != pService);

	KTParamRule* pRule = (KTParamRule*)pTab->m_dwUserParam;
	ASSERT(NULL != pRule);
	KTParamTableAttr* pAttr1 = (KTParamTableAttr*)pTab->m_dwUserDataEx;
	ASSERT(NULL != pAttr1);
	KTParamTableAttr* pAttr2 = (KTParamTableAttr*)pTab->m_dwUserData;
	ASSERT(NULL != pAttr2);

	// 取得约束条目的数据映射
	CMapStringToString mapData;
	pService->GetTableItemById(_T("GetRuleItemById"), pRule->GetId(), mapData);
	// 更新
	CString sValue;
	mapData[pAttr1->GetField()] = ByItemDesc(sValue, pTab->m_sName, pAttr1->GetVarDesc(), mapData);
	mapData[pAttr2->GetField()] = ByItemDesc(sValue, pTab->m_sValue, pAttr2->GetVarDesc(), mapData);

	// 获得参数映射
	CMapStringToString mapParamToDesc;
	AsDescTable(sValue, pAttr1->GetVarDesc(), mapData);
	pService->GetCurveDrawTypeParam(sValue, mapData[pAttr1->GetField()], mapData[pAttr2->GetField()], mapParamToDesc);

	// 准备构造列表
	ASSERT(NULL != pTab);

	// 构造列表
	sValue.Empty();
	CString sKey, sName;
	POSITION pos = mapParamToDesc.GetStartPosition();
	while (NULL != pos)
	{
		mapParamToDesc.GetNextAssoc(pos, sKey, sName);
		mapVarTypeToValue.Lookup(sKey, sValue);
		m_wndLstRule.AddItem(pTab, sName, sValue, CPropertyItem::EDT_NONE, bEdit);
		sName.Empty();
		sValue.Empty();
	}
}

void CDlgParamDefine::OnClassCopy() 
{
	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem || NULL == m_wndTreeClass.GetParentItem(hItem))
		return;

	m_hCopyClass = hItem;
}

void CDlgParamDefine::OnAttrPaste() 
{
	if (NULL == m_hCopyClass)
		return;

	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem || hItem == m_hCopyClass)
		return;

	HTREEITEM hParent = m_wndTreeClass.GetParentItem(hItem);
	if (NULL == hParent || m_cCurClass.IsReadOnly())
		return;

	do
	{
		if (hParent == m_hCopyClass)
			return;
		hParent = m_wndTreeClass.GetParentItem(hParent);
	} while (NULL != hParent);

	ULONG lId = m_wndTreeClass.GetItemData(m_hCopyClass);
	if (0 == lId)
		return;

	UINT nOld = m_wndLstAttribute.GetTabCount();
	OnShowAttributeItems(lId, TRUE);
	UINT nLen = m_wndLstAttribute.GetTabCount();

	ULONG lClassId = m_wndTreeClass.GetItemData(hItem);

	CPropertyItemTab* pTab1;
	CPropertyItemTab* pTab2;
	KTParamAttribute* pAttr1;
	KTParamAttribute* pAttr2;
	for (UINT n = nOld; n < nLen; n++)
	{
		if (NULL == m_wndLstAttribute.FindTab(pTab1, n) || NULL == pTab1->m_dwUserParam)
			continue;

		pAttr1 = (KTParamAttribute*)pTab1->m_dwUserParam;
		pAttr1->SetClassId(lClassId);
		pAttr1->SetId(NULL);

		for (UINT m = 0; m < nOld; m++)
		{
			if (NULL == m_wndLstAttribute.FindTab(pTab2, m) || NULL == pTab2->m_dwUserParam)
				continue;

			pAttr2 = (KTParamAttribute*)pTab2->m_dwUserParam;

			if (0 == _tcsicmp(pAttr1->GetCode(), pAttr2->GetCode()))
			{
				--n;
				--nLen;
				if (pTab2->m_bNameEditable)
				{
					--nOld;
					m_bPartModified |= TRUE;
				}
				else
				{
					pTab2 = pTab1;
				}

				OnCleanAttrTab(pTab2);
				m_wndLstAttribute.DeleteTab(pTab2);

				break;
			}
		}
	}

	m_bPartModified |= (nLen != nOld);
}

void CDlgParamDefine::OnRulePaste() 
{
	if (NULL == m_hCopyClass)
		return;

	HTREEITEM hItem = m_wndTreeClass.GetSelectedItem();
	if (NULL == hItem || hItem == m_hCopyClass || NULL == m_wndTreeClass.GetParentItem(hItem) || m_cCurClass.IsReadOnly())
		return;

	UINT nOld = m_wndLstRule.GetTabCount();
	OnShowRuleData(m_hCopyClass, TRUE);
	UINT nLen = m_wndLstRule.GetTabCount();

	ULONG lClassId = m_wndTreeClass.GetItemData(hItem);

	CPropertyItemTab* pTab;
	KTParamRule* pRule;
	for (UINT n = nOld; n < nLen; n++)
	{
		if (NULL == m_wndLstRule.FindTab(pTab, n) || NULL == pTab->m_dwUserParam)
			continue;

		pRule = (KTParamRule*)pTab->m_dwUserParam;
		pRule->SetClassId(lClassId);
		pRule->SetId(NULL);
	}

	m_bPartModified |= (nLen != nOld);
}