// CDoorOrWinDlg.cpp : implementation file
//
#include "stdafx.h"
#include "resource.h"
#include "InsDoorWinDlg.h"
#include "OpeningLabelData.h"

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


BOOL g_bAutoChangeDoor=TRUE;//是否自动切换门样式 add by fxj 090319
double g_bMinTwoDoorWidth=1100;//双扇门最小宽度 add by fxj 090319

//extern int LoadArxApp(const TCHAR *pszAppReg, const TCHAR *pszFileName);
extern GEOAPI void StringToList(const TCHAR *s, XStringList &res, TCHAR cSep);



// 取得门宽模数系列
void GetWallLengthModel(DList<double> &lstWidth)
{
    lstWidth.Reset();
    double widthArray[] = {
       1500, 1800, 2100, 2400, 2700, 3000, 3300, 3600, 3900, 4200,
       4500, 4800, 5400, 6000, 9000, 
    };
    for(int i=0; i<ELEMENTS(widthArray); i++) {
        lstWidth.Append(new double(widthArray[i]));
    }
}

// 取得门宽模数系列
void GetDoorWidthModel(DList<double>&lstWidth)
{
    lstWidth.Reset();
	// sg add 101221，根据8.5需求，增加1600的默认门宽
//	double widthArray[] = {700,800,900,1000,1100,1200,1500,1800,2400,2700,
//						   3000,3600};
	double widthArray[] = {700,800,900,1000,1100,1200,1500,1600,1800,2400,2700,
						   3000,3600};
    for(int i=0; i<ELEMENTS(widthArray); i++) {
        lstWidth.Append(new double(widthArray[i]));
    }
}

// 取得门高模数系列
void GetDoorHeightModel(DList<double>&lstHeight)
{
    lstHeight.Reset();
	double heightArray[] = {2000,2100,2400,2500,2700,3000,3300};
    for(int i=0; i<ELEMENTS(heightArray); i++) {
        lstHeight.Append(new double(heightArray[i]));
    }
}

// 取得窗的宽度模数系列
void GetWinWidthModel(DList<double> &lstWidth)
{
    lstWidth.Reset();
    double widthArray[]={600, 900, 1200, 1500, 1800, 2100, 2400, 2700, 3000, 3300, 3600};
    for(int i=0; i<ELEMENTS(widthArray); i++) {
        lstWidth.Append(new double(widthArray[i]));
    }
}

// 取得窗的高度模数系列
void GetWinHeightModel(DList<double> &lstHeight)
{
    lstHeight.Reset();
    int heightArray[]={600, 900, 1200, 1400, 1500, 1800, 2100, 2400, 2700, 3000};
    for(int i=0; i<ELEMENTS(heightArray); i++) {
        lstHeight.Append(new double(heightArray[i]));
    }
    return;
}

// 取得窗台的高度模数系列
void GetWinSillModel(DList<double> &lstSill)
{
    lstSill.Reset();
    int sillArray[]={0, 300, 400, 500, 600, 700, 800, 900, 1000, 1200};
    for(int i=0; i<ELEMENTS(sillArray); i++) {
        lstSill.Append(new double(sillArray[i]));
    }
    return;
}

// sg add 110530，取得门槛的高度模数系列
void GetDoorSillModel(DList<double> &lstSill)
{
    lstSill.Reset();
    int sillArray[]={0, 50, 60, 100, 150, 200, 300, 600};
    for(int i=0; i<ELEMENTS(sillArray); i++) {
        lstSill.Append(new double(sillArray[i]));
    }
    return;
}


// 把近似数模数化
// 顺序查找法, 因此效率不是最快, 但是最简洁
double GetModelNumber(DList<double> &lstModel, double nNearNumber)
{
    double nRes=nNearNumber;
    int nLen=lstModel.Length();
    for(int i=0; i<nLen; i++) {
        double &nCurNum = *lstModel[i];
        if (i==0) {
            nRes=nCurNum;
        } else if (fabs(nCurNum-nNearNumber)<fabs(nRes-nNearNumber)) {
            nRes=nCurNum;
        }
    }
    return nRes;
}



AcDbObjectId GetAnotherOfDoorWin(const TDbOpening& opening);
extern BOOL InvokeTkwMan(const TCHAR *pszLib, BOOL bSelOnly, XString &sBlockName);
extern TARCH_IMPEXP void CheckOp3dStyle(AcDbObjectId idStyle3d);
extern TARCH_IMPEXP void CheckOp2dStyle(AcDbObjectId idStyle2d);

extern HINSTANCE _hdllInstance;




//IMPLEMENT_DYNAMIC(CDoorOrWinDlg, CInsertOpeningDlg)
/////////////////////////////////////////////////////////////////////////////

// sg add 110217，增加对类型的记忆功能
CString CDoorOrWinDlg::m_csMemWinSubType = _T("普通窗");
CString CDoorOrWinDlg::m_csMemDoorSubType = _T("普通门");

// add by xly on 110223 增加门窗个数记忆功能
CString CDoorOrWinDlg::m_csOpeningNums = _T("1");
// CDoorOrWinDlg dialog
CDoorOrWinDlg::CDoorOrWinDlg(int nDlgType, CWnd* pParent /*=NULL*/)
	: CInsertOpeningDlg(CDoorOrWinDlg::IDD, pParent), m_bInitMe(FALSE)
{
	//{{AFX_DATA_INIT(CDoorOrWinDlg)
    m_bAsHigh=FALSE;
	//}}AFX_DATA_INIT
    m_nOpeningFlag = (TOpeningData::OpeningKind)nDlgType;

    m_csWin3DStyle=SYS_WIN3D;
    m_csDoor3DStyle = SYS_DOOR3D;
    m_csDoor2DStyle = SYS_DOOR2D;
    m_csWin2DStyle = SYS_WIN2D;

	// add by xly on 110119 增加门窗个数和类型
	m_csWinDoorNumms = m_csOpeningNums;
    if (m_nOpeningFlag==TOpeningData::OP_DOOR)
	{
        m_nWidth=900;
        m_nHeight=2100;
        m_nSill=0;
    }
	else
	{
        m_nWidth=1800;
        m_nHeight=1500;
        m_nSill=900;//modified by fxj 090330
    }
}

//根据给定的门窗 设置二,三维样式
void CDoorOrWinDlg::SetStyle(const TDbOpening& opening)
{
	XString sDwb2D, sDwb3D, sDwg2D, sDwg3D;
	if (opening.GetStyle2dName(sDwb2D, sDwg2D)==Acad::eOk) 
	{
		if (opening.GetKind() == TOpeningData::OP_DOOR) 
            m_csDoor2DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb2D, (TCHAR *)sDwg2D);
		else if (opening.GetKind() == TOpeningData::OP_WINDOW)
            m_csWin2DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb2D, (TCHAR *)sDwg2D);
    }
	else 
	{ //旧版图纸转化而来
		if (opening.GetKind() == TOpeningData::OP_DOOR) 
            m_csDoor2DStyle = _T("");
		else if (opening.GetKind() == TOpeningData::OP_WINDOW)
            m_csWin2DStyle = _T("");
    }

	if (opening.GetStyle3dName(sDwb3D, sDwg3D)==Acad::eOk)
	{
			if (opening.GetKind() == TOpeningData::OP_DOOR)
			{
				m_csDoor3DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb3D, (TCHAR *)sDwg3D);
			}
			else if (opening.GetKind() == TOpeningData::OP_WINDOW)
			{
				m_csWin3DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb3D, (TCHAR *)sDwg3D);
			}          	   
	} 
}



// 保存编号相关属性：如果变动并且当前是自动编号的时候，则需要更新编号：
#define KEEP_LABEL_PROP \
	int __nWid = (int)m_nWidth;\
	int __nHei = (int)m_nHeight;\
	CString __strStyle2d = Get2dStyleName();\
	CString __strStyle3d = Get3dStyleName();\
	CString __strWindDoorType = m_csWinDoorType 

#define CHECK_LABEL_PROP_CHANGE \
{ \
	bool bSame = (__nWid == (int)m_nWidth) && \
		(__nHei == (int)m_nHeight) &&  \
		(__strStyle2d.CompareNoCase(Get2dStyleName()) == 0) && \
		(__strStyle3d.CompareNoCase(Get3dStyleName()) == 0) &&\
		(__strWindDoorType.CompareNoCase(m_csWinDoorType) == 0); \
	if (!bSame) InvalidateOldLabel(); \
}

void CDoorOrWinDlg::DoDataExchange(CDataExchange* pDX)
{
	KEEP_LABEL_PROP;

	CInsertOpeningDlg::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDoorOrWinDlg)
	DDX_Control(pDX, IDC_STYLE3D, m_pic3d);
	DDX_Control(pDX, IDC_STYLE2D, m_pic2d);
    DDX_Check(pDX, IDC_AS_HIGHWIN, m_bAsHigh);
	//}}AFX_DATA_MAP
	if (!pDX->m_bSaveAndValidate) 
	{
		GetDlgItem(IDC_STYLE2D)->EnableWindow(!m_bAsHigh);

        // 显示幻灯
	    ShowSld3D();
        XString sSlidePath(256);
        CString &cs2d=Get2dStyleName();
        sSlidePath << (const TCHAR *)cs2d;
	    ShowSlide(m_pic2d, m_PicSlide1, sSlidePath);
    }

	// add by xly on 110119 增加门窗个数和类型
	DDX_CBString(pDX, IDC_CMB_TYPE, m_csWinDoorType);
	DDX_CBString(pDX, IDC_CMB_WINDOORNUMS, m_csWinDoorNumms);
	// sg add 110215，增加类型对应的控制变量，以便从编号设置中获得类型
	DDX_Control(pDX, IDC_CMB_TYPE, m_lstTypeBox);

	CHECK_LABEL_PROP_CHANGE;
}

BEGIN_MESSAGE_MAP(CDoorOrWinDlg, CInsertOpeningDlg)
	//{{AFX_MSG_MAP(CDoorOrWinDlg)
	ON_WM_PAINT()
    ON_WM_SETCURSOR()
	ON_BN_CLICKED(IDC_STYLE3D, OnPictureup)
	ON_BN_CLICKED(IDC_STYLE2D, OnPicturedn)
	ON_BN_CLICKED(IDC_AS_HIGHWIN, OnAsHighwin)
	ON_CBN_KILLFOCUS(IDC_CMB_TYPE, OnKillFocusSubType)
	ON_CBN_KILLFOCUS(IDC_CMB_WINDOORNUMS, OnKillFocusNums)// add by xly on 112223 对输入的门窗个数判断
//	ON_CBN_KILLFOCUS(IDC_WIDTH, OnKillFocus)//add by fxj 090318
	ON_CBN_SELCHANGE(IDC_CMB_TYPE, OnSelChangeCmbSubType)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CDoorOrWinDlg message handlers
BOOL CDoorOrWinDlg::OnInitDialog() 
{
	CInsertOpeningDlg::OnInitDialog();
    CRect rect;
    GetWindowRect(rect);
	if (m_nOpeningFlag == TOpeningData::OP_DOOR) 
	{
		GetDlgItem(IDC_WIDTH_TEXT)->SetWindowText(_T("门宽"));
		GetDlgItem(IDC_HEIGHT_TEXT)->SetWindowText(_T("门高"));
		GetDlgItem(IDC_SILL_TEXT)->SetWindowText(_T("门槛高"));
		GetDlgItem(IDC_AS_HIGHWIN)->ShowWindow(SW_HIDE);

		//add by xlc on 090211
		SetWindowText(_T("门"));
	}
	else if (m_nOpeningFlag == TOpeningData::OP_WINDOW) 
	{
		// sg add 110530，已有洞口插入灰显
		m_toolbar.EnableButton(ID_HASHOLE_INSERT, FALSE);
	
		GetDlgItem(IDC_WIDTH_TEXT)->SetWindowText(_T("窗宽"));
		GetDlgItem(IDC_HEIGHT_TEXT)->SetWindowText(_T("窗高"));
		GetDlgItem(IDC_SILL_TEXT)->SetWindowText(_T("窗台高"));
		GetDlgItem(IDC_AS_HIGHWIN)->ShowWindow(SW_SHOW);

		// add by xly on 110119
		if (m_bModeless) 
		{
			GetDlgItem(IDC_AS_HIGHWIN)->SetWindowText(_T("高窗"));
			CRect rect1, rect2;
			GetDlgItem(IDC_AS_HIGHWIN)->GetWindowRect(rect1);
			GetDlgItem(IDC_CHSIDE)->GetWindowRect(&rect2);
			ScreenToClient(&rect2);
			GetDlgItem(IDC_AS_HIGHWIN)->SetWindowPos(NULL,rect2.left,rect2.top,rect1.Width(),rect1.Height(),SWP_FRAMECHANGED);
		}
		
		//add by xlc on 090211
		SetWindowText(_T("窗"));
    }

	// add by xly on 110119 对话框编辑时调整控件
	if (!m_bModeless) 
	{
		// 调整对话框大小和控件位置
		GetDlgItem(IDC_CMB_WINDOORNUMS)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_STATIC_NUMS)->ShowWindow(SW_HIDE);
		CRect rectParam, rect1, rect2;
		GetDlgItem(IDC_STYLE3D)->GetWindowRect(&rectParam);
		GetDlgItem(IDC_DIST_TEXT)->GetWindowRect(&rect1); // for left
		ScreenToClient(&rect1);
		GetDlgItem(IDC_STYLE2D)->GetWindowRect(&rect2);
		ScreenToClient(&rect2);
//		GetDlgItem(IDC_STYLE3D)->SetWindowPos(NULL,340,5,rectParam.Width(),rectParam.Height(),SWP_FRAMECHANGED);
		GetDlgItem(IDC_STYLE3D)->SetWindowPos(NULL,rect1.left,rect2.top,rectParam.Width(),rectParam.Height(),SWP_FRAMECHANGED);
//		SetWindowPos(NULL,rect.left,rect.top,rect.Width()-110,rect.Height(),SWP_FRAMECHANGED);
		GetDlgItem(IDC_STYLE3D)->GetWindowRect(&rectParam);
		// "rectParam.right - rect.left + rect2.left",该宽度保持两侧对称
		SetWindowPos(NULL,rect.left,rect.top,rectParam.right - rect.left + rect2.left,rect.Height(),SWP_FRAMECHANGED);
	
		// 编辑窗对象
		if (m_nOpeningFlag == TOpeningData::OP_WINDOW) 
		{
// 			GetDlgItem(IDOK)->GetWindowRect(rectParam);
// 			GetDlgItem(IDOK)->SetWindowPos(NULL,180,85,rectParam.Width(),rectParam.Height(),SWP_FRAMECHANGED);
// 			GetDlgItem(IDCANCEL)->SetWindowPos(NULL,260,85,rectParam.Width(),rectParam.Height(),SWP_FRAMECHANGED);
		}
	}
	
	// sg add 110123，增加类型提示语
	AddTip(IDC_STATIC_OPENING_KIND, _T("类型可通过【编号设置】命令设置。当选择隔断门或电梯门时，其门不进行自动编号，也不参与门窗检查和门窗表的统计。"));
	
	// sg add 110215，以便从编号设置中获得类型，初始化对话框
	InitWinTypeCombox();

	// add by xly on 110222，增加类型提示语
	AddTip(IDC_STATIC_NUMS, _T("此处为连续相邻门窗的个数，生成的多个门窗间的间距为0。"));
	InitCombox();

	// add by xly on 110223 隔断门和电梯门不编号
	if (m_nOpeningFlag == TOpeningData::OP_DOOR) 
	{	
		if (m_bModeless)
		{ // 创建对话框
			if (m_csMemDoorSubType==_T("隔断门") || m_csMemDoorSubType==_T("电梯门"))
			{
				m_csLabel = _T("");
			}
		}
		else
		{
			if (m_csWinDoorType ==_T("隔断门") || m_csWinDoorType ==_T("电梯门"))
			{
				m_csLabel = _T("");
			}
		}
	}
    m_bInitMe=TRUE;
	UpdateData(FALSE);

	// add by xly on 110223 隔断门和电梯门不编号
	if (m_nOpeningFlag == TOpeningData::OP_DOOR) 
	{	
		if (m_bModeless)
			GetDlgItem(IDC_LABEL)->EnableWindow(m_csMemDoorSubType!=_T("隔断门") 
				&& m_csMemDoorSubType!=_T("电梯门"));
		else 
			GetDlgItem(IDC_LABEL)->EnableWindow(m_csWinDoorType!=_T("隔断门") 
				&& m_csWinDoorType!=_T("电梯门"));
	}

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

// sg add 110215，以便从编号设置中获得类型，初始化对话框
void CDoorOrWinDlg::InitWinTypeCombox()
{
	CString csMemType; // 获得记忆中的类型

	CStringArray arSubType;
	TOpeningLabelData openinglabel;
	if (m_nOpeningFlag == TOpeningData::OP_DOOR) // 门
	{
		openinglabel.GetSubType(_T("Door"), arSubType);
		csMemType = m_csMemDoorSubType;
	}
	else if (m_nOpeningFlag == TOpeningData::OP_WINDOW) // 窗
	{
		openinglabel.GetSubType(_T("Window"), arSubType);
		csMemType = m_csMemWinSubType;
	}

	int nSize = (int)arSubType.GetSize();
	for (int i = 0; i < nSize; i++)
	{
		m_lstTypeBox.AddString(arSubType[i]);
	}

	// add by xly 对象编辑时增加没有的类型
	if (!m_bModeless)
	{
		int nFind = m_lstTypeBox.FindString(0,m_csWinDoorType);
		//if (nFind < 1)
		if (nFind < 0) // sg add 110623，解决如果是普通门、普通窗，会多一个错误的情况
		{
			m_lstTypeBox.AddString(m_csWinDoorType);
		}
	}

	// sg add 110217，增加“隔断门”和“电梯门”两项，始终存在，与“编号设置”无关
	if (m_nOpeningFlag == TOpeningData::OP_DOOR) // 门
	{
		if (m_lstTypeBox.FindString(0, _T("隔断门")) == -1) // 避免重复设置
		{
			m_lstTypeBox.AddString(_T("隔断门"));
		}

		if (m_lstTypeBox.FindString(0, _T("电梯门")) == -1)
		{
			m_lstTypeBox.AddString(_T("电梯门"));
		}
	}

	if (m_bModeless)
	{ // 门窗创建对话框
		int nCurSel = m_lstTypeBox.FindString(0, csMemType);
		if (nCurSel == -1) // 未找到
		{
			nCurSel = 0;
			m_lstTypeBox.GetLBText(0, m_csWinDoorType);
		}
		else // 找到
		{
			m_csWinDoorType = csMemType;
		}
		m_lstTypeBox.SetCurSel(nCurSel);
	}
}


//void CDoorOrWinDlg::OnKillFocus()//add by fxj 090318
//{
//	UpdateData(TRUE);
//	
//	
//}

//初始化组合框
void CDoorOrWinDlg::InitCombox()
{
   if (m_nOpeningFlag==TOpeningData::OP_DOOR) {
			//int width[] = {700,800,900,1000,1100,1200,1500,1800,2400,2700,
			//			   3000,3600};
			//int height[] = {2000,2100,2400,2500,2700,3000,3300};
            DList<double> lstWidth, lstHeight;
            GetDoorWidthModel(lstWidth);
            GetDoorHeightModel(lstHeight);
			InitCombox(m_lstWidthBox, lstWidth);
			InitCombox(m_lstHeightBox, lstHeight);

			// sg add 110530，增加门槛高默认设置
			DList<double> lstSill;
            GetDoorSillModel(lstSill);
            InitCombox(m_lstSillBox, lstSill);
	}
	else if (m_nOpeningFlag==TOpeningData::OP_WINDOW) {
            DList<double> lstWidth, lstHeight, lstSill;
            GetWinWidthModel(lstWidth);
            GetWinHeightModel(lstHeight);
            GetWinSillModel(lstSill);
			InitCombox(m_lstWidthBox, lstWidth);
			InitCombox(m_lstHeightBox, lstHeight);
            InitCombox(m_lstSillBox, lstSill);
			//int width[] = {600,900,1200,1500,1800,2100,2400,2700,3000,3600};
			//int height[] = {600,900,1200,1500,1600,1800,2100,2400,2700,3000};
			//int high[] = {0,300,500,600,900,1000,1200,1500,1800};
	}
}

//初始化组合框
void CDoorOrWinDlg::InitCombox(CComboBox& combox, DList<double> &lstModelNum) 
{
	CString szItem;
	combox.ResetContent();
	for (int i = 0 ; i < lstModelNum.Length(); i++) {
		szItem.Format(_T("%d"), AS_INT(*lstModelNum[i]));
		combox.AddString(szItem);
	}
}

//显示幻灯
void CDoorOrWinDlg::ShowSlide(CStatic& st, CImageDC& imgdc, const TCHAR* sldName)
{
	//--------------------add by fxj 090323--------
	
	//if (m_nWidth>=g_bMinTwoDoorWidth && g_bAutoChangeDoor)
	//{
	//    if (sldName==_T("DorLib2D(00000001)"))
	//	{
	//		sldName=_T("DorLib2D(00000002)");
	//    }
	//}
	//else if (m_nWidth<g_bMinTwoDoorWidth && g_bAutoChangeDoor)
	//{
	//    if (sldName==_T("DorLib2D(00000002)"))
	//	{
	//		sldName=_T("DorLib2D(00000001)");
	//    }
	//}
	//------------------------------------------
	XString sFullSld(256);
	if (sldName && sldName[0])
		sFullSld << g_sDwbPath << sldName;
	CRect cR;
	CDC* pDC = st.GetDC();
	st.GetClientRect(&cR);
	imgdc.InitDC(pDC,cR, GetAcadBackColor());
	imgdc.PaintSlide(sFullSld);
	st.ReleaseDC(pDC);
}


// 点取三维样式
void CDoorOrWinDlg::OnPictureup() 
{
	KEEP_LABEL_PROP;

	XPushAutoHide noAutoHide(this);

    XString sLibFile, sBlockName;
    sLibFile << g_sDwbPath << _T("WDLib3D.TKW");
    sBlockName=m_nOpeningFlag==TOpeningData::OP_DOOR? m_csDoor3DStyle : m_csWin3DStyle;
    if (InvokeTkwMan(sLibFile, TRUE, sBlockName)) {
        ShowSlide(m_pic3d,m_PicSlide, sBlockName);
        if (m_nOpeningFlag==TOpeningData::OP_DOOR) 
            m_csDoor3DStyle=XPathParser(sBlockName).m_sFileName;
        else
            m_csWin3DStyle=XPathParser(sBlockName).m_sFileName;
    }
	CHECK_LABEL_PROP_CHANGE;
}

// 点取二维样式
void CDoorOrWinDlg::OnPicturedn() 
{
	KEEP_LABEL_PROP;
	XPushAutoHide noAutoHide(this);

    XString sLibFile, sBlockName;
    sLibFile << g_sDwbPath << (m_nOpeningFlag==TOpeningData::OP_DOOR? _T("DorLib2D.TKW") : _T("WinLib2D.TKW"));
    sBlockName=Get2dStyleName();
    if (InvokeTkwMan(sLibFile, TRUE, sBlockName)) {
        ShowSlide(m_pic2d,m_PicSlide1, sBlockName);
        Get2dStyleName()=(const TCHAR *)(XPathParser(sBlockName).m_sFileName);
    }
	CHECK_LABEL_PROP_CHANGE;
}

void CDoorOrWinDlg::OnPaint() 
{
	CDC* pDC;
	CRect cR,cR1;
	CPaintDC dc(this); // device context for painting
	
	// TODO: Add your message handler code here
	pDC = m_pic3d.GetDC();
	m_pic3d.GetClientRect(&cR);
	m_PicSlide.InitDC(pDC, cR,GetAcadBackColor());
	m_PicSlide.Redraw();
	m_pic3d.ReleaseDC(pDC);	

	pDC = m_pic2d.GetDC();
	m_pic2d.GetClientRect(&cR1);
	m_PicSlide1.InitDC(pDC,cR1,GetAcadBackColor());	
	m_PicSlide1.Redraw();
	m_pic2d.ReleaseDC(pDC);
}

//显示三维样式幻灯
void CDoorOrWinDlg::ShowSld3D()
{
    XString sSlidePath(256);
    sSlidePath << Get3dStyleName();
    ShowSlide(m_pic3d,m_PicSlide,sSlidePath);
}


//设置对话框类型
void CDoorOrWinDlg::SetOpeningFlag(const TDbOpening::OpeningKind nOpFlag)
{
	m_nOpeningFlag = nOpFlag;
}


// 取得二维库名
const TCHAR * CDoorOrWinDlg::LibraryFile() const
{
    const TCHAR *szLib;
    if (m_nOpeningFlag==TOpeningData::OP_WINDOW)
       szLib=_T("WIN2D");
    else if (m_nOpeningFlag==TOpeningData::OP_DOOR) 
        szLib=_T("DOOR2D");
    else {
        ASSERT(0);
    }
    return szLib;
}

int CDoorOrWinDlg::LoadStyles(AcDbObjectId &idStyle2d, AcDbObjectId &idStyle3d, CString& sz2dName,
							  CString& sz3dName) 
{
    XString sBlock2D;
    XString sBlock2d(_T("%s%s"), g_sDwbPath, (const TCHAR *)Get2dStyleName());
    XString szBlock3d;
    XString szBlock2d;
    Adesk::Boolean bLoad2d=(LoadDwbBlock(sBlock2d, szBlock2d)==RTNORM);
    Adesk::Boolean bLoad3d =(LoadDwbBlock(XString(_T("%s%s"), g_sDwbPath, (const TCHAR *)Get3dStyleName()), szBlock3d)==RTNORM);
    if (!bLoad2d && !bLoad3d)
       return RTERROR;
	   
    sz2dName = szBlock2d;
	sz3dName = szBlock3d;
    idStyle2d=InitBlock(szBlock2d);
    idStyle3d=InitBlock(szBlock3d);

    if (!idStyle3d)
        return RTNORM;

    CheckOp3dStyle(idStyle3d);
	//if (m_nOpeningFlag==TOpeningData::OP_DOOR)//removed by whl on 051229
		CheckOp2dStyle(idStyle2d);
    return RTNORM;
}

// abstract from dlgwin1
CString& CDoorOrWinDlg::Get2dStyleName()
{
	if (m_nOpeningFlag == TOpeningData::OP_DOOR) 
        return m_csDoor2DStyle;
	else if (m_nOpeningFlag == TOpeningData::OP_WINDOW) 
        return m_csWin2DStyle;
	return m_csDoor2DStyle;
}

CString& CDoorOrWinDlg::Get3dStyleName()
{
	if (m_nOpeningFlag == TOpeningData::OP_DOOR) 
        return m_csDoor3DStyle;
	else if (m_nOpeningFlag == TOpeningData::OP_WINDOW) 
        return m_csWin3DStyle;
	return m_csDoor3DStyle;
}


BOOL CDoorOrWinDlg::InitParamList(DList<XOpeningParam> &lstParam) const
{
    CInsertOpeningDlg::InitParamList(lstParam);
    lstParam.Append(new XOpeningParam(IDC_STYLE2D, _T("二维样式")));
    lstParam.Append(new XOpeningParam(IDC_STYLE3D, _T("三维样式")));
    //if (m_nOpeningFlag == TOpeningData::OP_WINDOW)
    //    lstParam.Append(new XOpeningParam(IDC_AS_HIGHWIN, _T("高窗性质")));
    return TRUE;
}

// 用于编辑以及改选编号时
BOOL CDoorOrWinDlg::SetDlgParamFrom(const TDbOpening &opening)
{
    if (!CInsertOpeningDlg::SetDlgParamFrom(opening))
        return FALSE;

	SetOpeningFlag(opening.GetKind());
    // 设置门或者窗的样式, 包括2D & 3D
	SetStyle(opening);
    if (opening.GetKind()==TOpeningData::OP_WINDOW)
        m_bAsHigh = opening.IsHigh();
	m_csWinDoorType = opening.GetSubKind();
    return TRUE;
}


BOOL CDoorOrWinDlg::GetStyles(AcDbObjectId &id2d, AcDbObjectId &id3d)
{
	CString sz2dName,sz3dName;
	AcDbObjectId idStyle2d, idStyle3d;
	if (LoadStyles(idStyle2d, idStyle3d, sz2dName, sz3dName)!=RTNORM) 
        return FALSE;
	id2d = idStyle2d;
	id3d = idStyle3d;

    return TRUE;
}

void CDoorOrWinDlg::UpdateOpening(TDbOpening &op, BOOL bLoadStyle)
{
	// add by xly on 110223 对象编辑时设置门窗的类型
	CString csLayerNow = op.layer(),
		csDefaultLayer = op.GetDefaultLayer();

	// add by xly on 110224 设置门窗类型
	op.SetSubKind(m_csWinDoorType);

    CInsertOpeningDlg::UpdateOpening(op, bLoadStyle);
    if (m_nOpeningFlag == TOpeningData::OP_WINDOW)  
	{
        if (m_bAsHigh) op.m_nOpStyle |= OPS_ATHIGH;
        else op.m_nOpStyle &= ~OPS_ATHIGH;
    }

	// add by xly on 110223 对象编辑时设置门窗的类型
	if (_tcsicmp(csLayerNow, csDefaultLayer) == 0)
	{
		csDefaultLayer = op.GetDefaultLayer();
		op.setLayer(InitLayer(csDefaultLayer));

		// 修改标注图层
		CString csSubType = op.GetSubKind();
		if (csSubType.Find(_T("防火门"))>=0 || csSubType.Find(_T("防火卷帘"))>=0 
			|| csSubType.Find(_T("防火窗"))>=0)
		{
			op.SetLayerText(InitLayer(LAY_FILEOPENING_DIM));
		}
		else
		{
			op.SetLayerText(InitLayer(LAY_OPENING_DIM));
		}
	}
	op.SetLabel(GetAutoLabel(&op));
}


/////////////////////////////////////////////////////////////
// 用对话框上的参数更新实体数据
// op--门/窗
BOOL CDoorOrWinDlg::ModifyOpeningWithDlgParam(TDbOpening &op)
{
	AcDbObjectId id2d, id3d;
	GetStyles(id2d, id3d);
    int nUsageFlag=GetUsage();

	// add by xly on 110223 对象编辑时设置门窗的类型
	CString csLayerNow = op.layer(),
		csDefaultLayer = op.GetDefaultLayer();

	op.SetSubKind(m_csWinDoorType);

	// sg add 110804，将下面两行代码从CInsertOpeningDlg::ModifyOpeningWithDlgParam函数之后，提前到这里，主要是解决自动编号问题
	// 在CInsertOpeningDlg::ModifyOpeningWithDlgParam函数中，进行了自动编号，而编号规则需要考虑是否2D、3D图块样式
	if ((nUsageFlag==USE_EDIT || GetParamCheck(IDC_STYLE2D)) && !!id2d)
		op.m_nIdStyle2d=id2d;
	if ((nUsageFlag==USE_EDIT || GetParamCheck(IDC_STYLE3D)) && !!id3d)
		op.m_nIdStyle3d=id3d;

	if (!CInsertOpeningDlg::ModifyOpeningWithDlgParam(op))
        return FALSE;

    //if (nUsageFlag==USE_EDIT || GetParamCheck(IDC_AS_HIGHWIN)) {
    if (m_nOpeningFlag == TOpeningData::OP_WINDOW)  
	{
        if (m_bAsHigh) op.m_nOpStyle |= OPS_ATHIGH;
        else op.m_nOpStyle &= ~OPS_ATHIGH;
    }
    //}

	// add by xly on 110223 对象编辑时设置门窗的类型
	if (_tcsicmp(csLayerNow, csDefaultLayer) == 0)
	{
		csDefaultLayer = op.GetDefaultLayer();
		op.setLayer(InitLayer(csDefaultLayer));

		// 修改标注图层
		CString csSubType = op.GetSubKind();
		if (csSubType.Find(_T("防火门"))>=0 || csSubType.Find(_T("防火卷帘"))>=0 
			|| csSubType.Find(_T("防火窗"))>=0)
		{
			op.SetLayerText(InitLayer(LAY_FILEOPENING_DIM));
		}
		else
		{
			op.SetLayerText(InitLayer(LAY_OPENING_DIM));
		}
	}
    return TRUE;
}


BOOL CDoorOrWinDlg::GetTitleKeyString(XString &sKeyTitle) const
{
    switch(m_nOpeningFlag) {
    case TOpeningData::OP_WINDOW:
        sKeyTitle = _T("窗参数");
        break;
    case TOpeningData::OP_DOOR:
        sKeyTitle = _T("门参数");
        break;
    }
    return TRUE;
}

//关键注册位置, 子类需要重载本方法
BOOL CDoorOrWinDlg::GetRegLocation(XString &sRegLoc) const 
{
    switch(m_nOpeningFlag) {
    case TOpeningData::OP_WINDOW:
        sRegLoc = _T("Window");
        break;
    case TOpeningData::OP_DOOR:
        sRegLoc = _T("Door");
        break;
    }
    return TRUE;
}


// 从注册表读入参数
BOOL CDoorOrWinDlg::ReadParamFromRegistry()
{
    if (!CInsertOpeningDlg::ReadParamFromRegistry())
        return FALSE;
    XString sRegSubLoc, sRegLoc(1024);
    BOOL bOk=GetRegLocation(sRegSubLoc);
    if (!bOk)
        return FALSE;
    sRegLoc << ::GetRegLocation() << _T("\\Settings");
    CRegProperty regProp(sRegLoc, sRegSubLoc);
    regProp.SetTopRootKey(HKEY_CURRENT_USER);


        BOOL bWin=m_nOpeningFlag==TOpeningData::OP_WINDOW;
        if (!regProp.GetValue(_T("3DStyle"), (bWin? m_csWin3DStyle:m_csDoor3DStyle)) ||
            !regProp.GetValue(_T("2DStyle"), bWin? m_csWin2DStyle:m_csDoor2DStyle) )
            return FALSE;
    return TRUE;
}

// 把最近的参数写入注册表
BOOL CDoorOrWinDlg::WriteParamToRegistry() const
{
    if (!CInsertOpeningDlg::WriteParamToRegistry())
        return FALSE;

    XString sRegSubLoc, sRegLoc(1024);
    BOOL bOk=GetRegLocation(sRegSubLoc);
    if (!bOk)
        return FALSE;
    sRegLoc << ::GetRegLocation() << _T("\\Settings"); 
    CRegProperty regProp(sRegLoc, sRegSubLoc);
    regProp.SetTopRootKey(HKEY_CURRENT_USER);

    BOOL bWin=m_nOpeningFlag==TOpeningData::OP_WINDOW;
    const CString &cs3D = bWin? m_csWin3DStyle:m_csDoor3DStyle;
    if (!cs3D.IsEmpty())
        regProp.SetValue(_T("3DStyle"), cs3D);
    const CString &cs2D=bWin? m_csWin2DStyle:m_csDoor2DStyle;
    if (!cs2D.IsEmpty())
        regProp.SetValue(_T("2DStyle"), cs2D);
    return TRUE;
}

BOOL CDoorOrWinDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
    if (pWnd && (pWnd->m_hWnd==m_pic2d.m_hWnd || pWnd->m_hWnd==m_pic3d.m_hWnd)) {
        CAcModuleResourceOverride vTemp;
		HCURSOR hIcon = AfxGetApp()->LoadCursor( IDC_CUR_PICK );
		SetCursor( hIcon );        
		return TRUE;
    } 
	return CInsertOpeningDlg::OnSetCursor(pWnd, nHitTest, message);

}

void CDoorOrWinDlg::OnKillFocusSubType()
{
	UpdateData(TRUE);
	int nCurSel = m_lstTypeBox.GetCurSel();
	if (nCurSel > -1)
	{
		if (m_nOpeningFlag == TOpeningData::OP_DOOR) // 门
		{
			m_lstTypeBox.GetLBText(nCurSel, m_csMemDoorSubType);

			// add by xly on 110223 隔断门和电梯门不编号
			if (m_csMemDoorSubType==_T("隔断门") || m_csMemDoorSubType==_T("电梯门"))
			{
				m_csLabel = _T("");
			}
			UpdateData(FALSE);

			GetDlgItem(IDC_LABEL)->EnableWindow(m_csMemDoorSubType!=_T("隔断门") 
				&& m_csMemDoorSubType!=_T("电梯门"));
			
		}
		else if (m_nOpeningFlag == TOpeningData::OP_WINDOW) // 窗
		{
			m_lstTypeBox.GetLBText(nCurSel, m_csMemWinSubType);
		}
	}
}

void CDoorOrWinDlg::OnSelChangeCmbSubType()
{
	UpdateData(TRUE);

	int nCurSel = m_lstTypeBox.GetCurSel();
	if (nCurSel > -1)
	{
		if (m_nOpeningFlag == TOpeningData::OP_DOOR) // 门
		{
			m_lstTypeBox.GetLBText(nCurSel, m_csMemDoorSubType);

			GetDlgItem(IDC_LABEL)->EnableWindow(m_csMemDoorSubType!=_T("隔断门") 
				&& m_csMemDoorSubType!=_T("电梯门"));
		}
	}

}

/////////////////////////////////////////////////////////////////
void CDoorOrWinDlg::OnAsHighwin() 
{
    UpdateData(TRUE);
    UpdateData(FALSE);	
}

// add by xly on 112223 对输入的门窗个数判断
void CDoorOrWinDlg::OnKillFocusNums()
{
	CString csTemp = m_csWinDoorNumms;
	UpdateData(TRUE);
	if (!IsDigital(m_csWinDoorNumms) || m_csWinDoorNumms==_T("0") || m_csWinDoorNumms.GetAt(0) == _T('0'))
	{
		MessageBox(_T("个数输入正整数！"));
		m_csWinDoorNumms = csTemp;
	}
	else
	{
		m_csOpeningNums = m_csWinDoorNumms;
	}
	UpdateData(FALSE);
}



// Command: 插入门窗
void InsOpening(TOpeningData::OpeningKind opFlag)
{

}

int CDoorOrWinDlg::ObjToDlg(TDbOpening* pOpening)
{
	CInsertOpeningDlg::ObjToDlg(pOpening);
	m_csWinDoorType = pOpening->GetSubKind();
	m_bAsHigh = pOpening->IsHigh();
	
	XString sDwb2D, sDwb3D, sDwg2D, sDwg3D;
	if (pOpening->GetStyle2dName(sDwb2D, sDwg2D)==Acad::eOk) 
	{
		if (pOpening->GetKind() == TOpeningData::OP_DOOR) 
			m_csDoor2DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb2D, (TCHAR *)sDwg2D);
		else if (pOpening->GetKind() == TOpeningData::OP_WINDOW)
			m_csWin2DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb2D, (TCHAR *)sDwg2D);
	}

	if (pOpening->GetStyle3dName(sDwb3D, sDwg3D)==Acad::eOk)
	{
		if (pOpening->GetKind() == TOpeningData::OP_DOOR)
		{
			m_csDoor3DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb3D, (TCHAR *)sDwg3D);
		}
		else if (pOpening->GetKind() == TOpeningData::OP_WINDOW)
		{
			m_csWin3DStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb3D, (TCHAR *)sDwg3D);
		}          	   
	} 

	//显示幻灯片
	ShowSld3D();
	XString sSlidePath(256);
	CString &cs2d=Get2dStyleName();
	sSlidePath << (const TCHAR *)cs2d;
	ShowSlide(m_pic2d, m_PicSlide1, sSlidePath);

	UpdateData(FALSE);
	return 1;
}