// InsertOpeningDlg.cpp: implementation of the CInsertOpeningDlg class
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resource.h"
#include "InsertOpeningDlg.h"
#include "OpeningValidateDlg.h"
#include "OpeningValidation.h"
#include "arcWindowDlg.h"
#include "doorWinDlg.h"
#include "InsDoorWinDlg.h"
#include "bayWindowDlg.h"
#include "TwoDoorDlg.h"
#include "RectHoleDlg.h"

#define AUTO_LABEL_FLAG _T("自动编号")
extern BOOL ValidateLabelInCurDwg(TDbOpening &Op);
//add by xlc on 070514
extern BOOL ValidateCurLabel(TDbOpening &pWin);

void GetOpeningIdList(DList<AcDbDatabase> &dbList, DList<AcDbObjectId> &idList) 
{
	XStringList lstFiles;
	::GetFloorFiles(lstFiles);
	CString sCurDwg=curDoc()->fileName();
	for(int i=0; i<lstFiles.Length(); i++) 
	{
		if (_tcsicmp(sCurDwg, lstFiles[i])==0)
			continue; // Disalbe CurDwg
        AcDbDatabase *dwgDb=new AcDbDatabase(false, true);
		dbList.Append(dwgDb);
#if ADS < 21
        if (dwgDb->readDwgFile(lstFiles[i], _SH_DENYNO, false)==Acad::eOk)
#else
        if (dwgDb->readDwgFile(lstFiles[i], AcDbDatabase::kForReadAndAllShare, false)==Acad::eOk)
#endif
		{
			GetEntityFromDatabase(idList, *dwgDb, _T("TCH_OPENING"), 0, ACDB_MODEL_SPACE);
		}
	}
    GetEntFromBlockByDxf(idList, _T("TCH_OPENING"));
}

void GetOpeningIdList2(BOOL bCurrDwgOnly, DList<AcDbDatabase> &dbList, DList<AcDbObjectId> &idList)
{
	if (bCurrDwgOnly) // 本图
	{
		GetEntFromBlockByDxf(idList, _T("TCH_OPENING"));
	}
	else // 本工程
	{
		GetOpeningIdList(dbList, idList);
	}
}

// 赋值操作
TWallAxisData & TWallAxisData::operator = (const TWallAxisData &src)
{
	m_idWall = src.m_idWall;

	int nLength = m_aryAxisIds.logicalLength();
	for (int i=0; i<nLength; i++)
		m_aryAxisIds.removeAt(0);
	m_aryAxisIds.append(src.m_aryAxisIds);
	return *this;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
/////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CInsertOpeningDlg, CModelessDialog)
int CInsertOpeningDlg::g_nInsertMode=0; //最近一次的插入方式
//add by lgy 20120119	点取拾取参数之后隐藏对话框需要积累上次对话框的样式
int CInsertOpeningDlg::g_iOldInsertMode=1; 

BOOL CInsertOpeningDlg::g_bChSide = FALSE; //是否单侧改宽
CString CInsertOpeningDlg::g_csDist=_T("300");

// add by xly on 110113 增加ID_HASHOLE_INSERT一项，表示在已有洞口插入
//add by lgy 20120517	增加ID_BUTTON_APTITUDE一项，用来智能插入门窗
UINT buttonID[]={   ID_FREE_INSERT, ID_SEQUENCE_INSERT, ID_LINE_INSERT, ID_WALL_INSERT, 
					ID_FIXDIST_ONPIER, ID_FIXDIST_ONAXIS, ID_ARCWALL_INSERT, ID_BUTTON_APTITUDE,
                    ID_COLUMN_INSERT, ID_UPLEVEL_INSERT, ID_HASHOLE_INSERT, ID_REPLACE_INSERT,
					ID_BUTTON_OPENINQUIRE,ID_DOOR,ID_WIN,ID_DOORWIN,ID_TWODOOR,ID_ARCWIN,ID_BAYWIN,ID_RECTHOLE,ID_SELECT_GJK
};
CInsertOpeningDlg::CInsertOpeningDlg(UINT id, CWnd *pParent)
: CModelessDialog(id, pParent)
{
    m_nWidth=m_nHeight=1000;
    m_nSill=0;
	m_pOpeningAttach = NULL;
	m_strAutoLabel = _T(""); 
	m_bOldLabel = true;

    
	////add by whl on 061226
	//m_csLabel=AUTO_LABEL_FLAG;

	if (!CInsertOpeningDlg::bRefreshDlg)//add by whl
		if (g_nInsertMode<0 || g_nInsertMode>7)    //modify by lgy 20120612	g_nInsertMode>6改为>7原因是添加了智能添加门窗方式
			g_nInsertMode=0;
}
CInsertOpeningDlg::~CInsertOpeningDlg()
{
}
BOOL CInsertOpeningDlg::GetParamCheck(UINT id) const
{
    for(int n=0; n<m_lstParam.Length(); n++) {
        const XOpeningParam &para=m_lstParam[n];
        if (para.m_nId==id)
            return para.m_bCheck;
    }
    return FALSE;
}
// 对话框的用途
int CInsertOpeningDlg::GetUsage() const
{
    if (!m_bModeless)
        return USE_EDIT;
    //return (GetInsertMode()==IDC_REPLACE? USE_REPLACE : USE_INSERT);
    return (GetInsertMode()==ID_REPLACE_INSERT? USE_REPLACE : USE_INSERT);
}
BOOL CInsertOpeningDlg::PreCreateWindow(CREATESTRUCT& cs) 
{
	// TODO: Add your specialized code here and/or call the base class
    //if (m_bModeless)
	//    cs.style |= WS_MINIMIZEBOX;
    //else
    //    cs.style &= ~WS_MINIMIZEBOX;
	return CModelessDialog::PreCreateWindow(cs);
}
void CInsertOpeningDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CInsertOpeningDlg)
	DDX_Control(pDX, IDC_HEIGHT, m_lstHeightBox);
	DDX_Control(pDX, IDC_WIDTH, m_lstWidthBox);
	DDX_Control(pDX, IDC_SILL, m_lstSillBox);
	DDX_Control(pDX, IDC_LABEL, m_lstLabelBox);
	DDX_Check(pDX, IDC_CHSIDE, g_bChSide);
	DDX_Control(pDX, IDC_PARAM_LIST, m_lstParamEdit);
    DDX_Control(pDX, IDC_DIST, m_lstDistBox);
    DDX_CBString(pDX, IDC_DIST, g_csDist);
	//}}AFX_DATA_MAP
    if (pDX->m_bSaveAndValidate) { //更新数据
        CString csLabel;
        m_lstLabelBox.GetWindowText(csLabel);
        CString csTemp;
        m_lstWidthBox.GetWindowText(csTemp); 
        double nWidth = _tstof(csTemp);
        m_lstHeightBox.GetWindowText(csTemp); 
        double nHeight = _tstof(csTemp);
        m_lstSillBox.GetWindowText(csTemp); 
        double nSill = _tstof(csTemp);
        if (nWidth<_DIST_SNAP || nHeight<-_DIST_SNAP) { //高度可以为0
            pDX->Fail();
        }
        SetOpeningLabel(csLabel);
        SetOpeningWidth(nWidth);
        SetOpeningHeight(nHeight);
        SetOpeningSill(nSill);
		if (csLabel.Compare(AUTO_LABEL_FLAG) != 0)
		{ // 如果当前的数据不是 自动编号，则把该数据读取到AutoLabel中。
			m_strAutoLabel = csLabel;
		}
		
/* removed by whl
        for(int i=0; i<10; i++) {
            if (m_toolbar.IsButtonChecked(buttonID[i])){
               g_nInsertMode=i;
               break;
            }	
        }*/
       // m_lstParam is automatic update
    } else {
        m_lstLabelBox.SetWindowText(GetOpeningLabel());
        m_lstWidthBox.SetWindowText(XString(_T("%.f"), GetOpeningWidth()));
        m_lstHeightBox.SetWindowText(XString(_T("%.f"), GetOpeningHeight()));
        m_lstSillBox.SetWindowText(XString(_T("%.f"), GetOpeningSill()));
        
		m_toolbar.CheckButton(buttonID[g_nInsertMode], TRUE);//modified by whl
		if (curType>=0)
			//modify by lgy 20120201	中间添加拾取门窗参数按钮
			//m_toolbar.CheckButton(buttonID[curType+11],TRUE);//modify by xly on 110114 增加一个按钮
			//modify by lgy 20120607	中间添加智能插入门窗按钮
			//m_toolbar.CheckButton(buttonID[curType+12],TRUE);
		{
			m_toolbar.CheckButton(buttonID[curType+13],TRUE);
		}

        for(int i=0; i<m_lstParam.Length(); i++) {
            UINT id=m_lstParam[i]->m_nId;
            CWnd *pWnd=GetDlgItem(id);
            if (pWnd) {
                BOOL bEnable=m_lstParam[i]->m_bCheck;
                if (GetUsage()!=USE_REPLACE) {
                    bEnable=TRUE;
                }
                pWnd->EnableWindow(bEnable);
            }
        }

        if (m_bModeless) {
            // 柱间插入或上层插入时, 禁止输入宽度
            if (GetUsage()==USE_INSERT) {
                CWnd *pWnd=GetDlgItem(IDC_WIDTH);
                if (pWnd) 
                    pWnd->EnableWindow(buttonID[g_nInsertMode]!=ID_COLUMN_INSERT && buttonID[g_nInsertMode]!=ID_UPLEVEL_INSERT);
            }
            GetDlgItem(IDC_SILL_TEXT)->EnableWindow(buttonID[g_nInsertMode]!=ID_UPLEVEL_INSERT);
            GetDlgItem(IDC_SILL)->EnableWindow(buttonID[g_nInsertMode]!=ID_UPLEVEL_INSERT);
            GetDlgItem(IDC_DIST_TEXT)->EnableWindow(buttonID[g_nInsertMode]==ID_FIXDIST_ONAXIS ||
                buttonID[g_nInsertMode]==ID_FIXDIST_ONPIER ||
                buttonID[g_nInsertMode]==ID_UPLEVEL_INSERT || buttonID[g_nInsertMode]==ID_BUTTON_APTITUDE);//add by lgy 20120522	智能插入门窗时距离项亮显
            GetDlgItem(IDC_DIST)->EnableWindow(buttonID[g_nInsertMode]==ID_FIXDIST_ONAXIS ||
                buttonID[g_nInsertMode]==ID_FIXDIST_ONPIER ||
                buttonID[g_nInsertMode]==ID_UPLEVEL_INSERT || buttonID[g_nInsertMode]==ID_BUTTON_APTITUDE);//add by lgy 20120522	智能插入门窗时距离项亮显

			// add by xly on 110220 增加支持多个数门窗插入门窗
			if (curType==0||curType==1||curType==4)
			{
				GetDlgItem(IDC_CMB_WINDOORNUMS)->EnableWindow(buttonID[g_nInsertMode]!=ID_REPLACE_INSERT &&
					buttonID[g_nInsertMode]!=ID_UPLEVEL_INSERT && buttonID[g_nInsertMode]!=ID_COLUMN_INSERT);
			}
			
			// add by xly on 110113 已有洞口插入时门宽、门高、门槛高不可用
			if (buttonID[g_nInsertMode]==ID_HASHOLE_INSERT)
			{
				GetDlgItem(IDC_WIDTH)->EnableWindow(FALSE);
				GetDlgItem(IDC_HEIGHT)->EnableWindow(FALSE);
				GetDlgItem(IDC_SILL)->EnableWindow(FALSE);
			}
        }
    }
}
BOOL CInsertOpeningDlg::OnInitDialog() 
{
	CModelessDialog::OnInitDialog();

	//add by whl
	/*
	if (oldPos.x!=-10000&&oldPos.y!=-10000)
	{
		CRect rect;
		GetWindowRect(&rect);
		MoveWindow(oldPos.x,oldPos.y,rect.Width(),rect.Height(),FALSE);
	}*/

    XString sKeyTitle;
    GetTitleKeyString(sKeyTitle);
    if (m_bModeless) { //插入方式, 隐藏〖确定〗、〖取消〗、〖单侧改宽〗
        CWnd *pOk=GetDlgItem(IDOK);
        if (pOk) pOk->ShowWindow(SW_HIDE);
        CWnd *pCancel=GetDlgItem(IDCANCEL);
        if (pCancel) pCancel->ShowWindow(SW_HIDE);
        GetDlgItem(IDC_CHSIDE)->ShowWindow(SW_HIDE);
        GetDlgItem(IDC_DIST_TEXT)->ShowWindow(SW_SHOW);
        GetDlgItem(IDC_DIST)->ShowWindow(SW_SHOW);

        int distArray[]={0, 60, 100, 120, 180, 200, 240, 300, 360, 400, 500, 600, 700, 800, 900, 1000};
        for(int i=0; i<ELEMENTS(distArray); i++) {
            CString csItem;
            csItem.Format(_T("%d"), distArray[i]);
            m_lstDistBox.AddString(csItem);
        }

        //XString sTitle(256);
        //sTitle << _T("输入") << sKeyTitle;
        //SetWindowText(sTitle);
        //读入上一次的参数
        ReadParamFromRegistry();
		createToolBar();          // 创建 toolbar
    } else {
        GetDlgItem(IDC_DIST_TEXT)->ShowWindow(SW_HIDE);
        GetDlgItem(IDC_DIST)->ShowWindow(SW_HIDE);
        //XString sTitle(256);
        //sTitle << _T("编辑") << sKeyTitle;
        //SetWindowText(sTitle);
    }

    // 填充编号列表
    SetupLabelList();
    InitParamList(m_lstParam);
	m_lstParamEdit.ResetContent();
	for( int i=0; i<m_lstParam.Length(); i++ )	{
		int n = m_lstParamEdit.AddString(m_lstParam[i]->m_csText);
        ASSERT(i==n);
		m_lstParamEdit.SetCheck( n, m_lstParam[i]->m_bCheck );
	}

    if (GetUsage()!=USE_EDIT && GetOpeningKind()==TOpeningData::OP_ARCWIN) {
        // 弧窗不能有柱间插入
        //if (GetInsertMode()==ID_COLUMN_INSERT)
        //    g_nInsertMode=0;
		//m_toolbar.EnableButton(ID_COLUMN_INSERT, TRUE);
    }

    if (GetUsage()!=USE_REPLACE)
        ResizeDialog(FALSE);

    UpdateData(FALSE); //更新对话框
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}
// toolbar
void CInsertOpeningDlg::createToolBar()
{
	CAcModuleResourceOverride vTmp;
	m_toolbar.Create( WS_VISIBLE | WS_CHILD | CCS_BOTTOM    | TBSTYLE_TOOLTIPS 
	                 | CCS_ADJUSTABLE ,CRect(0,0,0,0),this,  IDR_WINDOW);

	//modify by lgy 20120118 增加一个按钮
// 	modify by xly on 110113 增加一个按钮
// 		TBBUTTON *pIndex, *pRTF_Button = new TBBUTTON[19];//+7
	TBBUTTON *pIndex, *pRTF_Button = new TBBUTTON[21]; //+1  add by lgy 20120517 增加一个button智能插入门窗
	
	pIndex = pRTF_Button;
	for(long lIndex = 0; lIndex < 18; lIndex++) {
		memset(pIndex ,NULL, sizeof(TBBUTTON));
		pIndex->iBitmap = lIndex; 
		pIndex->idCommand  = buttonID[lIndex];  
		pIndex->fsStyle =  TBSTYLE_CHECKGROUP;
		pIndex->fsState = TBSTATE_ENABLED;
		pIndex++;
	}
	memset(pIndex ,NULL, sizeof(TBBUTTON));
	pIndex->iBitmap = 18; 
	pIndex->idCommand  = buttonID[18];  
	pIndex->fsState = TBSTATE_ENABLED;
	pIndex->fsStyle =  TBSTYLE_CHECKGROUP;

	pIndex++;
	memset(pIndex ,NULL, sizeof(TBBUTTON));
	pIndex->iBitmap = 19; 
	pIndex->idCommand  = buttonID[19];  
	pIndex->fsState = TBSTATE_ENABLED;
	pIndex->fsStyle =  TBSTYLE_BUTTON;

	//add by lgy 20120517	添加智能添加门窗
	pIndex++;
	memset(pIndex ,NULL, sizeof(TBBUTTON));
	pIndex->iBitmap = 20; 
	pIndex->idCommand  = buttonID[20];  
	pIndex->fsState = TBSTATE_ENABLED;
	pIndex->fsStyle =  TBSTYLE_BUTTON;

	CSize size(16, 15);
	m_toolbar.SetButtonSize(size);
	//modify by lgy 20120118	添加一个按钮 用来提取门窗信息
	//m_toolbar.AddButtons(19, pRTF_Button);
	//modify by lgy 20120517 添加一个按钮，用来智能布置门窗
	//m_toolbar.AddButtons(20, pRTF_Button); 
	m_toolbar.AddButtons(21, pRTF_Button);

	pIndex=new TBBUTTON;
	memset(pIndex ,NULL, sizeof(TBBUTTON));
	pIndex->fsStyle =  TBSTYLE_SEP;
	// modify by xly增加一个按钮
	//m_toolbar.InsertButton(17,pIndex);
	//modify by lgy 20120201	分隔条应该向后错一位
// 	m_toolbar.InsertButton(11,pIndex);
// 	m_toolbar.InsertButton(11,pIndex);
	m_toolbar.InsertButton(13,pIndex);
	m_toolbar.InsertButton(13,pIndex);

	delete pIndex;
	delete[] pRTF_Button;

	m_toolbar.SetBitmapSize(size);
	m_toolbar.ModifyStyle(0,TBSTYLE_FLAT);
	//modify by lgy 20120118	添加一个按钮 用来提取门窗信息
	//m_toolbar.AddBitmap(19, IDR_WINDOW);
	m_toolbar.AddBitmap(21, IDR_WINDOW);	//+1添加智能添加门窗按钮
}

// 填充对话框的编号列表
void CInsertOpeningDlg::SetupLabelList()
{
    CString csTemp;
    m_lstLabelBox.GetWindowText(csTemp);
    m_lstLabelBox.ResetContent();
    XStringList lstLabels;
    if (GetLabelListFromDwg(lstLabels)) {
        lstLabels.QuickSort(_tcscmp);
		
		//add by whl on 061226
		m_lstLabelBox.AddString(AUTO_LABEL_FLAG);

        for(int i=0; i<lstLabels.Length(); i++)
            m_lstLabelBox.AddString(lstLabels[i]);
    }
    m_lstLabelBox.SetWindowText(csTemp);
}

void CInsertOpeningDlg::OnOK() 
{
    if (!UpdateData(TRUE)) {
        AfxMessageBox(_T("数据输入不合适!"));
        return;
    }
	CModelessDialog::OnOK();
}

BOOL CInsertOpeningDlg::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
{
     ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);

     // if there is a top level routing frame then let it handle the message
     if (GetRoutingFrame() != NULL) return FALSE;

     // to be thorough we will need to handle UNICODE versions of the message also !!
     TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
     TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
     //TCHAR szFullText[512];
     CString strTipText;
	 // Zyu modify on 100723，消除64位编译警告
	 //UINT nID = pNMHDR->idFrom;
     UINT nID = (UINT)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);
	      return FALSE;//Add by whl on 060308
     }

     if (nID != 0) {// will be zero on a separator
         {
		  CAcModuleResourceOverride vTmp;
          strTipText.LoadString(nID); //=szFullText;
         }

#ifndef _UNICODE
          if (pNMHDR->code == TTN_NEEDTEXTA)          {
               lstrcpyn(pTTTA->szText, strTipText, sizeof(pTTTA->szText));
          }          else          {
               _mbstowcsz(pTTTW->szText, strTipText, sizeof(pTTTW->szText));
          }
#else
          if (pNMHDR->code == TTN_NEEDTEXTA)          {
               _wcstombsz(pTTTA->szText, strTipText,sizeof(pTTTA->szText));
          }          else          {
               lstrcpyn(pTTTW->szText, strTipText, sizeof(pTTTW->szText));
          }
#endif

          *pResult = 0;

          // bring the tooltip window above other popup windows
          ::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,SWP_NOACTIVATE|
               SWP_NOSIZE|SWP_NOMOVE|SWP_NOOWNERZORDER); return TRUE;
     }
	 return TRUE;
} 

// 能否允许整个项目的验证？
void CInsertOpeningDlg::OnLookup() 
{
    //PickSet ss(SS_FREE);
    //if (GetEntByDxf(ss, _T("TCH_OPENING"), 0)!=Acad::eOk)
    //    return;

	DList<AcDbDatabase> dbList;
	DList<AcDbObjectId> ss;
	static BOOL bShowOnlyOpInCurDwg = TRUE;
	if (bShowOnlyOpInCurDwg) // 本图
	{
		GetEntFromBlockByDxf(ss, _T("TCH_OPENING"));
	}
	else // 本工程
	{
		GetOpeningIdList(dbList, ss);
	}

	if (!ss)
		return;

	TOpeningValidateTable opTable;
    int lCount=ss.Length();
    for(int i=0; i<lCount; i++)
	{
        AcDbObjectId &ent=*ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pOpening);
		if (pOpening != NULL)
		{
			if (pOpening->GetKind()!=TOpeningData::OP_CORNWIN &&
				//pOpening->GetKind()!=TOpeningData::OP_HOLE &&
				!(pOpening->m_nOpStyle&OPS_LIFTDOOR) &&
				!(pOpening->m_nOpStyle&OPS_LVTRY) &&
				_tcsicmp(pOpening->GetSubKind(), _T("隔断门"))!=0 && // sg add 110309，增加对新增子类型的判断
				_tcsicmp(pOpening->GetSubKind(), _T("电梯门"))!=0)
			{
				opTable.Validate(pOpening);
			}
		}
        OPENOBJ_END();
    }
    opTable.QuickSort(TOpeningValidation::CompareForSort);

	XPushAutoHide noAutoHide(this);

	// modify by xlc on 080925
    // COpeningValidateDlg dlg(&opTable, this);
	COpeningValidateNewDlg dlg(&opTable, this);

    dlg.SetWorkMode(1, (TOpeningData::OpeningKind)GetOpeningKind()); //选择
	// Zyu modify on 100722，支持64位
	//UINT idRet=IDOK;
    INT_PTR idRet = IDOK;
    {
        CAcModuleResourceOverride vTemp;
        idRet = dlg.DoModal();
    }

	BOOL bShowOnlyOpInCurDwgKeep = bShowOnlyOpInCurDwg;
    if (idRet==IDOK)
	{
		bShowOnlyOpInCurDwg = dlg.m_bShowOnlyCurDwg;

		AcDbObjectId idTemplate=dlg.GetFinalSelect();
		if (!!idTemplate && idTemplate.isValid())
		{
            OPENOBJ_BEGIN(idTemplate, AcDb::kForRead, TDbOpening, pWin);
			if (pWin != NULL) // sg add 110309，解决崩溃问题
			{
				ASSERT(pWin->GetKind()==GetOpeningKind());
		        SetDlgParamFrom(*pWin);
			}
            OPENOBJ_END();
            UpdateData(FALSE);    
        }
    }
	else // 有点不合理，但是IDCANCLE时，也要接受静态变量值，防止再次打开对话框时出现不一致
	{
		bShowOnlyOpInCurDwg = dlg.m_bShowOnlyCurDwg;
	}

	if (bShowOnlyOpInCurDwgKeep != bShowOnlyOpInCurDwg)
	{ // 重新读取一下门窗表
		SetupLabelList();
	}

}
BOOL CInsertOpeningDlg::InitParamList(DList<XOpeningParam> &lstParam) const
{
    lstParam.Append(new XOpeningParam(IDC_LABEL, _T("编号")));
    lstParam.Append(new XOpeningParam(IDC_WIDTH, _T("宽度")));
    lstParam.Append(new XOpeningParam(IDC_HEIGHT, _T("高度")));
    lstParam.Append(new XOpeningParam(IDC_SILL, _T("底高")));
    return TRUE;
}
BOOL CInsertOpeningDlg::GetRegLocation(XString &sRegLoc) const
{
    sRegLoc = _T("\\General Opening parameters");
    return TRUE;
}
BOOL CInsertOpeningDlg::GetTitleKeyString(XString &sKeyTitle) const
{
    sKeyTitle = _T("门窗参数");
    return TRUE;
}
// 从注册表读入参数
BOOL CInsertOpeningDlg::ReadParamFromRegistry()
{
    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);

    double nSill, nHeight, nWidth;
    int nInsMode=0;
    CString csLab;
    if (!regProp.GetValue(_T("Label"), csLab) ||
        !regProp.GetValue(_T("Width"), nWidth) ||
        !regProp.GetValue(_T("Height"), nHeight) ||
        !regProp.GetValue(_T("Sill"), nSill))
        return FALSE;
    regProp.GetValue(_T("InsertMode"), nInsMode);

	if (!CInsertOpeningDlg::bRefreshDlg)
	{
		//modify by lgy 20120612	添加了智能插入门窗之后需要记录上次的值
		//if (nInsMode>=0 && nInsMode<=5)
		  if (nInsMode>=0 && nInsMode<=7)
			g_nInsertMode=nInsMode;
		else 
			g_nInsertMode=0;
	}

    SetOpeningLabel(csLab);
    SetOpeningWidth(nWidth);
    SetOpeningHeight(nHeight);
    SetOpeningSill(nSill);
    return TRUE;
}
// 把最近的参数写入注册表
BOOL CInsertOpeningDlg::WriteParamToRegistry() const
{
    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);
    regProp.SetValue(_T("Label"), GetOpeningLabel());
    regProp.SetValue(_T("Width"), GetOpeningWidth());
    regProp.SetValue(_T("Height"), GetOpeningHeight());
    regProp.SetValue(_T("Sill"), GetOpeningSill());
	//modify by lgy 20120612	添加智能插入门窗方式，记录上次使用的数值
   // if (g_nInsertMode>=0 && g_nInsertMode<=5)
	if (g_nInsertMode>=0 && g_nInsertMode<=7)
        regProp.SetValue(_T("InsertMode"), (int)g_nInsertMode);
    return TRUE;
}
// add by xly on 110228 圆弧墙的判断
extern XPointDir2d GetPtArc(XCurveSegment seg,double nDist, bool bFromStart, XPoint pt);
//////////////////////////////////////////////////////////////////
// 交换数据, MFC的同名函数不是虚函数, 因此本函数不能由框架自动调用
// 只能自己控制

// 在指定位置, 创建一新实体并加入到模型空间
// pWall--以读的方式打开的指针
// 返回: TRUE-成功, FALSE--失败
AcDbObjectId CInsertOpeningDlg::NewEntityToModelSpace(TDbWall *pWall, const XPoint &ptLoc0, BOOL bUplevel, double nWidth, double nSill) 
{
	AcDbObjectId idRet;
    if (pWall->Is(CURVE_LINE) && GetOpeningKind()==TOpeningData::OP_ARCWIN)
        return idRet;
    if (!bUplevel)
        nSill = GetOpeningSill();
    XPoint ptLoc1=ptLoc0;
    ptLoc1.z=pWall->GetElevation()+nSill;

    TDbOpening *pWin = NewOpening();
    pWin->SetWidth(bUplevel? nWidth : GetOpeningWidth());
    if (bUplevel) 
	{
        pWin->m_nOpStyle |= OPS_HIGH_LEVEL;

		// sg modify 101125，根据8.5需求，解决Bug，上层门窗编号按照实际宽度显示
 		if (_tcscmp(AUTO_LABEL_FLAG, GetOpeningLabel()) == 0)
 		{
// 			// modify by xly on 110224 增加bool变量
// 			//pWin->SetLabel(pWin->GetAutoLabel());
// 			bool bAddNum(true);
// 			pWin->SetLabel(pWin->GetAutoLabel(bAddNum));

			// sg modify 110805，修改一下算法，如果是上层门窗，并且是自动编号，直接调用函数，不考虑维护m_strAutoLabel和m_bOldLabel了
			pWin->SetLabel(CalcAutoLabel(pWin));
 		}
 		else
// 			pWin->SetLabel(GetOpeningLabel());
			pWin->SetLabel(GetAutoLabel(pWin));
	}

    double nThick = GetOpeningKind()==TOpeningData::OP_HOLE? pWall->GetWidth():pWall->GetWidth()/2.0;
    pWin->SetThickness(nThick);
    pWin->m_ptLocation = ptLoc1;
    pWin->SetWallId(pWall->objectId());
    if (!ValidateLabelInCurDwg(*pWin)) {
        adsout << _T("\n同样编号的门窗参数不一致!");
        delete pWin;
        return idRet;
    }

    if (!pWall->CanInsertOpening(*pWin)) {
        delete pWin;
        return idRet;
    }

	// sg add 110818，解决“沿墙顺序插入”等方式下，非穿透的洞口显示错误问题
	// 主要是设置洞深数据的时候，还没有设置墙体数据，所以对应的代码没有执行，如果是墙洞对象，再调用一次更新函数
	if (pWin->GetKind() ==TOpeningData::OP_HOLE)
	{
		ModifySpecialProperty(*pWin);
	}

	//if (GetOpeningKind()==TOpeningData::OP_HOLE)
    //    pWin->setLinetype(_T("DASHED"));
	pWin->InitHardPointerId();

	// add by xly on 110125 设置门窗对象的转角布局
	pWin->SetLayoutRotation(Ucs2Wcs(0));

	// add by xly on 110224 设置门窗类型
	////////////////////////////////////start////////////////////////////////
	CString csLayerNow = pWin->layer(),
		csDefaultLayer = pWin->GetDefaultLayer();

	int nType = pWin->GetKind();
	if (nType==TOpeningData::OP_DOOR || nType==TOpeningData::OP_WINDOW || nType==TOpeningData::OP_ARCWIN)
	{
		pWin->SetSubKind(m_csWinDoorType);
	}

	// 设置门窗的图层
	if (_tcsicmp(csLayerNow, csDefaultLayer) == 0)
	{
		csDefaultLayer = pWin->GetDefaultLayer();
		pWin->setLayer(InitLayer(csDefaultLayer));

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

	// modify by xly on 110228 增加判断不是按角度插入时插入门窗
	//idRet = pWin->AddToMSpace(Adesk::kFalse);
	//if (pWall->upgradeOpen()!=Acad::eOk) {
	//	//		ASSERT(FALSE);
	//	pWin->close();
	//	return idRet;
	//}
	int nNums = GetOpeningNums();
	
	// add by xly on 110316 增加对个数的判断
	if (nNums==0)
	{
		nNums = 1;
	}
	if (g_nInsertMode!=6 || (g_nInsertMode==6&&nNums%2!=0))
	{
		idRet = pWin->AddToMSpace(Adesk::kFalse);
		if (pWall->upgradeOpen()!=Acad::eOk) {
			//		ASSERT(FALSE);
			pWin->close();
			return idRet;
		}	
		pWall->InsertOpening(pWin);
	}
   
    pWin->close();
    pWall->downgradeOpen();

	// add by xly on 110220 增加支持多个数门窗插入门窗
	if (!bUplevel && nNums>1)// 顺序插入或者圆弧插入
	{
		XPoint ptOld,ptIns;
		double dAngle = pWin->GetRotation();
		double dDis = pWin->GetWidth();
		ptOld = pWin->GetLocation();

		// 记录起始端点
		bool bIsStart(false);
		if (g_nInsertMode == 6)
		{
			double dWidth = pWin->GetWidth();
			for (int i=0; i<nNums;i++)
			{
				bIsStart = !bIsStart;
				TDbOpening *pNewOpen = (TDbOpening *)pWin->clone();
				if (nNums%2==0)// 偶数个门窗
				{
					if (i==0)
					{
						dDis = dWidth/2.0;
					}
					else if (i%2 == 0)
					{
						dDis += dWidth;
					}
				}
				else		   // 奇数个门窗
				{
					if (i==0)
					{
						continue;
					}
				}
				
				// 计算门的插入点
				if (pWall->Is(CURVE_ARC))// 圆弧门窗插入
				{
					XCurveSegment segSide(*(TGGeCurveSegment*)pWall);
					ptIns = GetPtArc(segSide, dDis, bIsStart, ptOld);
				}
				else
				{
					ads_polar(ptOld,dAngle, dDis,ptIns);
				}
				pNewOpen->SetLocation(ptIns);

				if(i%2==0&&nNums%2==0)
				{
					dAngle = PI+dAngle;
				}
				else if(nNums%2!=0)
				{
					if (i%2==0)
					{
						dDis += dWidth;
					}
					else
					{
						dAngle = PI+dAngle;
					}
				}

				pNewOpen->SetWallId(pWall->objectId());
				if (!ValidateLabelInCurDwg(*pNewOpen)) {
					adsout << _T("\n同样编号的门窗参数不一致!");
					delete pNewOpen;
					return idRet;
				}

				if (!pWall->CanInsertOpening(*pNewOpen)) {
					delete pNewOpen;
					return idRet;
				}

				pNewOpen->InitHardPointerId();
				pNewOpen->SetLayoutRotation(Ucs2Wcs(0));

				// add by xly on 110316 设置窗高
				pNewOpen->SetSill(GetOpeningSill());
				idRet = pNewOpen->AddToMSpace(Adesk::kFalse);
				if (pWall->upgradeOpen()!=Acad::eOk)
				{
					pNewOpen->close();
					return idRet;
				}
				pWall->InsertOpening(pNewOpen);

				pNewOpen->close();
				pWall->downgradeOpen();
			}
		}
		else
		{
			for (int i=1; i<nNums;i++)
			{	
				if (dAngle>PI/2.0 && dAngle<PI*1.5)// 逆时针方向
				{
					dAngle += PI;
				}
				if (pWin->GetRotation()>PI/2.0 && pWin->GetRotation()<PI*1.5)
				{
					bIsStart = false;
				}
				else
				{
					bIsStart = true;
				}	

				TDbOpening *pNewOpen = (TDbOpening *)pWin->clone();
				
				// 计算门的插入点
				if (pWall->Is(CURVE_ARC))// 圆弧门窗插入
				{
					XCurveSegment segSide(*(TGGeCurveSegment*)pWall);
					ptIns = GetPtArc(segSide, dDis, bIsStart, ptOld);
				}
				else
				{
					ads_polar(ptOld,dAngle, dDis,ptIns);
				}
			
				pNewOpen->SetLocation(ptIns);

				if(g_nInsertMode==6 && i%2==0)
				{
					dDis+=GetOpeningWidth();
					dAngle += PI;
				}
				else
				{
					dDis+=GetOpeningWidth();
				}

				// add by xly on 110316 设置窗高
				pNewOpen->SetSill(GetOpeningSill());
				pNewOpen->SetWallId(pWall->objectId());
				if (!ValidateLabelInCurDwg(*pNewOpen)) {
					adsout << _T("\n同样编号的门窗参数不一致!");
					delete pNewOpen;
					return idRet;
				}

				if (!pWall->CanInsertOpening(*pNewOpen)) {
					delete pNewOpen;
					return idRet;
				}

				pNewOpen->InitHardPointerId();

				// delete by xly on 11o224 提到前面设置类型
				/*	int nType = pWin->GetKind();
				if (nType==TOpeningData::OP_DOOR || nType==TOpeningData::OP_WINDOW || nType==TOpeningData::OP_ARCWIN)
				{
				pNewOpen->SetSubKind(GetOpeningStyle());
				}*/

				pNewOpen->SetLayoutRotation(Ucs2Wcs(0));

				idRet = pNewOpen->AddToMSpace(Adesk::kFalse);
				if (pWall->upgradeOpen()!=Acad::eOk)
				{
					pNewOpen->close();
					return idRet;
				}
				pWall->InsertOpening(pNewOpen);
				pNewOpen->close();
				pWall->downgradeOpen();
			}
		}
	}
    //成功的添加了门窗, 那么把最近一次的参数写入注册表
    WriteParamToRegistry();
    SetupLabelList();
    return idRet;
}
TDbOpening * CInsertOpeningDlg::NewOpening()
{
	TDbOpening *pWin = new TDbOpening;
	if (GetOpeningKind()==TOpeningData::OP_HOLE)
		pWin->setLinetype(_T("DASHED"));
	pWin->InitHardPointerId();
	UpdateOpening(*pWin);
    return pWin;
}
void CInsertOpeningDlg::UpdateOpening(TDbOpening &op, BOOL bLoadStyle)
{
    UpdateData(TRUE);
    TDbOpening *pWin = &op;
    if (bLoadStyle)
	{
        AcDbObjectId id2d, id3d;
        GetStyles(id2d, id3d);
        pWin->m_nIdStyle2d=id2d;
        pWin->m_nIdStyle3d=id3d;
    }

    pWin->SetKind((TOpeningData::OpeningKind)GetOpeningKind());
    pWin->m_pBayWin = AllocBayWinData();
    pWin->SetWidth(GetOpeningWidth());
    pWin->SetHeight(GetOpeningHeight());
    pWin->SetThickness(100.0);
	pWin->SetSill(GetOpeningSill());

// 	if (_tcscmp(AUTO_LABEL_FLAG,GetOpeningLabel())==0)
// 	{
// 		// modify by xly on 110224 增加bool变量
// 		//pWin->SetLabel(pWin->GetAutoLabel());
// 		bool bAddNum(true);
// 		pWin->SetLabel(pWin->GetAutoLabel(bAddNum));
// 	}
// 	else
// 		pWin->SetLabel(GetOpeningLabel());
}
// 用对话框上的参数更新实体数据, 不重新计算插入点
BOOL CInsertOpeningDlg::ModifyOpeningWithDlgParam(TDbOpening &op) 
{
    ASSERT(op.isWriteEnabled());
    int nUsageFlag=GetUsage();
    if (nUsageFlag==USE_EDIT || GetParamCheck(IDC_WIDTH))
        op.SetWidth(GetOpeningWidth());
    if (nUsageFlag==USE_EDIT || GetParamCheck(IDC_HEIGHT))
        op.SetHeight(GetOpeningHeight());
    if (nUsageFlag==USE_EDIT || GetParamCheck(IDC_SILL))
        op.SetSill(GetOpeningSill());
    if (nUsageFlag==USE_REPLACE)
        op.SetKind((TOpeningData::OpeningKind)GetOpeningKind());
    if (nUsageFlag==USE_EDIT || GetParamCheck(IDC_LABEL))
	{
		if (_tcscmp(AUTO_LABEL_FLAG,GetOpeningLabel())==0)
		{
			// modify by xly on 110224 增加bool变量
			//op.SetLabel(op.GetAutoLabel());
			bool bAddNum(true);
			op.SetLabel(CalcAutoLabel(&op));
		}
		else
			op.SetLabel(GetOpeningLabel());
	}
    return TRUE; 
}
// 修改门窗位置及参数, 门联窗对话框必须重载本函数
BOOL CInsertOpeningDlg::ModifyOpeningPos(TDbOpening &op, const XPoint &ptNewLoc) 
{
    op.m_ptLocation = ptNewLoc;
    return ModifyOpeningWithDlgParam(op);
}
XPoint CInsertOpeningDlg::GetLocation(const TDbOpening &op) const
{
    return op.m_ptLocation;
}
double CInsertOpeningDlg::GetTotalWidth(const TDbOpening &op) const
{
    return op.GetWidth();
}

// 用于对象编辑
// 修改具有相同编号的门窗，仅仅限于当前图形
// op--读的方式
BOOL CInsertOpeningDlg::ModifyOpeningWithSameLabel(TDbOpening &op, BOOL bAskUser) 
{
	ASSERT(!op.isWriteEnabled());
	AcDbObjectId idOpening=op.objectId();
	ASSERT(!!idOpening);

	//modify by lxb on 2011/12/02

	//搜索同编号门窗
	AcDbObjectIdArray otherOps;
	XString sLabel0;
	if (GetLabel(op, sLabel0, TRUE) && !!sLabel0) 
	{ 
		//询问是否需要同时修改其他同编号的门窗
		AcDbObjectId idThis=idOpening;
		if (!idThis) 
		{
			adsout << _T("\n门连窗有错误,需要审核!");//门联窗-》门连窗 090622 by fxj
			return FALSE;
		}

		DList<AcDbObjectId> lstOthers;
		GetEntFromBlockByDxf(lstOthers, _T("TCH_OPENING"));
		for(int i=0; i<lstOthers.Length(); i++)
		{
			if (*lstOthers[i]==idThis)
			{
				continue;
			}
			OPENOBJ_BEGIN(*lstOthers[i], AcDb::kForRead, TDbOpening, pWin);
			XString sLabel;
			if (pWin && GetLabel(*pWin, sLabel, FALSE) && _tcscmp(sLabel0, sLabel)==0)
			{
				otherOps.append(*lstOthers[i]);
			}
			OPENOBJ_END();
		}
	}

	//修改双击编辑对象属性
	BOOL bRet=ModifyOpening(op);

	//修改其他同编号对象属性
	if (otherOps.length() && bAskUser) 
	{
		CString sPrompt;
		sPrompt.Format(_T("\n其他%d个相同编号的门窗是否同时参与修改?[全部(A)/部分(S)/否(N)]<A>:"), int(otherOps.length()));
		CString sKey;
		{
			THook hook(sPrompt,_T("A S N"));
			sKey = hook.GetKeyWord();
		}
		if (sKey == _T("") || sKey == _T("A"))//全部
		{
			int nCount=otherOps.length();
			for(int n=0; n<nCount; n++) 
			{
				OPENOBJ_BEGIN(otherOps[n], AcDb::kForRead, TDbOpening, pOther);
				ModifyOpening(*pOther);
				OPENOBJ_END();
			}
		}
		else if (sKey == _T("S"))             //部分   
		{
			TRBList rbMask(RTDXF0,_T("TCH_OPENING"),NULL);
			const TCHAR *szPrompts[2]={_T("\n请选择同时参与修改的门窗<退出>:"), _T("")};

			TPickEntSetEx ssEx;

			int ista = ssEx.Get(_T(":S:$"),szPrompts,NULL,rbMask,otherOps);
			if(ista == TPickEntSetEx::eOK)
			{
				for(long n=0; n<ssEx.Length(); n++) 
				{
					OPENOBJ_BEGIN(ssEx[n], AcDb::kForRead, TDbOpening, pOpening);
					ModifyOpening(*pOpening);
					OPENOBJ_END();
				}
			}
		}
	}

	return bRet;
	/*
    ASSERT(!op.isWriteEnabled());
    AcDbObjectId idOpening=op.objectId();
    ASSERT(!!idOpening);

    AcDbObjectIdArray otherOps;
    BOOL bChangeOther=FALSE;
    XString sLabel0;
    if (GetLabel(op, sLabel0, TRUE) && !!sLabel0) 
	{ 
		//询问是否需要同时修改其他同编号的门窗
        AcDbObjectId idThis=idOpening;
        if (!idThis) 
		{
            adsout << _T("\n门连窗有错误,需要审核!");//门联窗-》门连窗 090622 by fxj
            return FALSE;
        }
        DList<AcDbObjectId> lstOthers;
        GetEntFromBlockByDxf(lstOthers, _T("TCH_OPENING"));
        for(int i=0; i<lstOthers.Length(); i++)
		{
            if (*lstOthers[i]==idThis)
			{
                continue;
			}
            OPENOBJ_BEGIN(*lstOthers[i], AcDb::kForRead, TDbOpening, pWin);
            XString sLabel;
            if (pWin && GetLabel(*pWin, sLabel, FALSE) && _tcscmp(sLabel0, sLabel)==0)
			{
                    otherOps.append(*lstOthers[i]);
            }
            OPENOBJ_END();
        }
        if (otherOps.length() && bAskUser) 
		{
			XString sPrompt(_T("\n是否其他%d个相同编号的门窗也同时参与修改"), int(otherOps.length()));
            bChangeOther=YesNoQuestion(sPrompt)==Q_YES;
        }
    }

    BOOL bRet=ModifyOpening(op);
    if (bChangeOther) 
	{
        int nCount=otherOps.length();
        for(int n=0; n<nCount; n++) 
		{
            OPENOBJ_BEGIN(otherOps[n], AcDb::kForRead, TDbOpening, pOther);
            ModifyOpening(*pOther);
            OPENOBJ_END();
        }
    }
    return bRet;
	*/
}
/////////////////////////////////////////////////////////
// 修改门窗对象, 包括可能引起变化的插入点
// 用于对象编辑, 门窗替换
BOOL CInsertOpeningDlg::ModifyOpening(TDbOpening &op) 
{
    OPENOBJ_BEGIN(op.GetWallId(), AcDb::kForRead, TDbWall, pWall);
    if (pWall && GetOpeningKind()==TOpeningData::OP_ARCWIN && pWall->Is(CURVE_LINE)) 
        return FALSE; //不能在直墙上插入弧窗
    OPENOBJ_END();
                
    ASSERT(!op.isWriteEnabled());
    TDbOpening *pOpening=&op;
    double nOpWidth=GetTotalWidth(op);
    BOOL bRelocate=fabs(GetOpeningWidth()-nOpWidth)>0.1;
    XPoint ptNewLoc=GetLocation(*pOpening);
    if (GetUsage()==USE_REPLACE && !GetParamCheck(IDC_WIDTH))
        bRelocate=FALSE;  //不改变宽度
    BOOL bChangeOther=FALSE;

    if (g_bChSide && GetUsage()==USE_EDIT && bRelocate) { 
        //单侧改宽时, 只能单个编辑
          XPoint ptDest;
          ads_initget(RSG_NONULL,NULL);
          if (ads_getpoint(ptNewLoc, _T("\n点取发生变化的一侧:"), ptDest)!=RTNORM)
             return RTCAN;

          ads_real nDrt=ads_angle(ptNewLoc, ptDest);
          XSector sector(pOpening->GetRotation(), CT_std_angle(pOpening->GetRotation()+PI));
		  // [2010-3-16 10:37 wubo] 移植到新Geo库
		  // 新库中的定义没有对应的语义，原来是基于地址的比较，暂时修改为值的比较
          // if (sector.NearAngle(nDrt)==&sector.startAngle)
			if (*sector.NearAngle(nDrt) == sector.GetStarAngle())
              ads_polar(XPoint(ptNewLoc), pOpening->GetRotation(), (GetOpeningWidth()-nOpWidth)/2.0, ptNewLoc);
          else ads_polar(XPoint(ptNewLoc), pOpening->GetRotation()+PI, (GetOpeningWidth()-nOpWidth)/2.0, ptNewLoc);
    }

    if (bRelocate) { //需要重新定位门窗, 弧墙上直门窗宽度的改变导致定位点的改变
        AcDbObjectId idWall=pOpening->GetWallId();
        if (!!idWall) {
            XDbObject objWall(idWall, AcDb::kForRead);
            TDbWall *pWall = !objWall? NULL : TDbWall::cast(objWall.m_pObject);
            if (pWall) {
               pWall->GetOpeningLocation(XPoint(ptNewLoc), pOpening->GetKind(), GetOpeningWidth(), ptNewLoc);
            }
        }
    }     

    // 修改门窗数据
    Acad::ErrorStatus es=Acad::eOk;
    if ((es=pOpening->upgradeOpen())==Acad::eOk) {
        pOpening->assertWriteEnabled();
		//pOpening->BackupPoints();
        ModifyOpeningPos(*pOpening, ptNewLoc); 
		
		// add by xly on 110125 设置门窗对象的转角布局
		pOpening->SetLayoutRotation(Ucs2Wcs(0));

        VERIFY(pOpening->downgradeOpen()==Acad::eOk);
        return TRUE;
    }
    return FALSE;
}
// 取得插入方式
UINT CInsertOpeningDlg::GetInsertMode() const//modified by whl
{
    return buttonID[g_nInsertMode];
}
void CInsertOpeningDlg::SetOpeningLabel(const TCHAR *pszLabel) 
{ 
    m_csLabel=pszLabel;
}


// 如果不需要初始化编号列表, 则返回FALSE
BOOL CInsertOpeningDlg::GetLabelListFromDwg(XStringList &lstLabels) const
{
    // 初始化编号
    DList<AcDbObjectId> lstBayWinEnt;
	DList<AcDbDatabase> dbList;
//	GetOpeningIdList(dbList, lstBayWinEnt);
	GetOpeningIdList2(COpeningValidateNewDlg::m_bShowOnlyCurDwg, dbList, lstBayWinEnt);

	TOpeningValidateTable opTable;
    for(int i=0; i<lstBayWinEnt.Length(); i++) 
	{
        OPENOBJ_BEGIN(*lstBayWinEnt[i], AcDb::kForRead, TDbOpening, pOpening);
        if (pOpening &&
			pOpening->GetKind()!=TOpeningData::OP_CORNWIN &&
            !(pOpening->m_nOpStyle&OPS_LIFTDOOR) &&
			!(pOpening->m_nOpStyle&OPS_LVTRY) &&
			_tcsicmp(pOpening->GetSubKind(), _T("隔断门"))!=0 && // sg add 110309，增加对新增子类型的判断
			_tcsicmp(pOpening->GetSubKind(), _T("电梯门"))!=0)
		{
            opTable.Validate(pOpening);
		}
        OPENOBJ_END();
    }
    
    opTable.GetValidLabels((TOpeningData::OpeningKind)GetOpeningKind(), lstLabels);
    return TRUE;
}




// 门联窗需要重载本方法, 从其中的门获取编号, 如果op与对话框类型不一致, 则返回FALSE
BOOL CInsertOpeningDlg::GetLabel(const TDbOpening &op, XString &sLabel, BOOL bGetOther) const
{
    if (op.GetKind()==GetOpeningKind()) {
        sLabel=op.GetLabel();
        return TRUE;
    }
    return FALSE;
}
BOOL CInsertOpeningDlg::GetStyles(AcDbObjectId &id2d, AcDbObjectId &id3d)
{
    return FALSE;
}

int CInsertOpeningDlg::ObjToDlg(TDbOpening* pOpening)
{
	CString strTemp;
	strTemp.Format(_T("%.0f"), pOpening->GetWidth());
	m_lstWidthBox.SetWindowText(strTemp);
	strTemp.Format(_T("%.0f"), pOpening->GetHeight());
	m_lstHeightBox.SetWindowText(strTemp);
	strTemp.Format(_T("%.0f"), pOpening->GetSill());
	m_lstSillBox.SetWindowText(strTemp);
	strTemp = pOpening->GetLabel();
	m_lstLabelBox.SetWindowText(strTemp);
	UpdateData(TRUE);
	return 1;
}

// 根据给定的门窗, 设置对话框参数
BOOL CInsertOpeningDlg::SetDlgParamFrom(const TDbOpening &op)
{
    SetOpeningLabel(op.GetLabel());
    SetOpeningWidth(op.GetWidth());
    SetOpeningHeight(op.GetHeight());
    SetOpeningSill(op.GetSill());

    return TRUE;
}
//////////////////////////////////////////////////////////////////
// 选择已有编号， 更新对话框参数
void CInsertOpeningDlg::OnSelchangeLabel() 
{
    int nSel=m_lstLabelBox.GetCurSel();
    if (nSel>=0) {
		UpdateData();//add by whl on 070418
        CString csLabel;
        m_lstLabelBox.GetLBText(nSel, csLabel);
        SetOpeningLabel(csLabel);

        // 初始化编号
        DList<AcDbObjectId> lstBayWinEnt;
		DList<AcDbDatabase> dbList;
//		GetOpeningIdList(dbList, lstBayWinEnt);
		GetOpeningIdList2(COpeningValidateNewDlg::m_bShowOnlyCurDwg, dbList, lstBayWinEnt);
	
		//GetEntFromBlockByDxf(lstBayWinEnt, _T("TCH_OPENING"));
        for(int i=0; i<lstBayWinEnt.Length(); i++) {
            OPENOBJ_BEGIN(*lstBayWinEnt[i], AcDb::kForRead, TDbOpening, pWin);
            XString sLabel;
            if (!GetLabel(*pWin, sLabel, FALSE))
                continue;

            if (csLabel.Compare(sLabel)==0) {
                SetDlgParamFrom(*pWin);
                break;
            }
            OPENOBJ_END();
        }
        UpdateData(FALSE);
    }
}
void CInsertOpeningDlg::OnSelchangeParamList() 
{
    //UpdateData(TRUE);
	int nIndex = m_lstParamEdit.GetCurSel();
	ASSERT( nIndex < m_lstParam.Length());
    BOOL bCheck=m_lstParam[nIndex]->m_bCheck;
	m_lstParam[nIndex]->m_bCheck = m_lstParamEdit.GetCheck(nIndex);
    UpdateData(FALSE);
}
//  替换插入时, 扩大对话框, 否则缩小对话框
void CInsertOpeningDlg::ResizeDialog(BOOL bExpand)
{
    CRect rectDlg, rectParam;
    GetWindowRect(rectDlg);
    GetDlgItem(IDC_PARAM_LIST)->GetWindowRect(rectParam);
	
    if (!bExpand) 
	{
		rectDlg.right -= rectParam.Width() + 5;
		GetDlgItem(IDC_PARAM_LIST)->ShowWindow(SW_HIDE);
	}
	else 
	{
		rectDlg.right += rectParam.Width() + 5 ;
		GetDlgItem(IDC_PARAM_LIST)->ShowWindow(SW_SHOW);
	}
    MoveWindow(rectDlg);
}
// 点取了插入方式按钮
void CInsertOpeningDlg::OnChangeInsertMode(UINT id)//obsolete!
{
	ASSERT(GetUsage() != USE_EDIT);
	if (id!=ID_REPLACE_INSERT) 
	{
        if (GetInsertMode()== ID_REPLACE_INSERT)
            ResizeDialog(FALSE);// 如果上一次状态为“替换” ：缩小对话框
    } 
	else 
        ResizeDialog(TRUE);// 扩大对话框
    UpdateData(TRUE);
    UpdateData(FALSE);
    acedPostCommand(_T("\n"));// 点取插入方式时, 发送_T("回车"), 以便结束前一插入方式的交互
}

//add by lgy 20120517	智能插入门窗
void CInsertOpeningDlg::OnBtnAptitude()
{
	if (g_nInsertMode != 7)	//将智能插入门窗定义为7
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
		{
			ResizeDialog(FALSE);
		}
	
		g_nInsertMode = 7;
		UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}

// 点取自由插入按钮
void CInsertOpeningDlg::OnFreeInsert() 
{
	if (g_nInsertMode!=0)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=0;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
void CInsertOpeningDlg::OnSequenceInsert() 
{
	if (g_nInsertMode!=1)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=1;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 点取等分插入按钮
void CInsertOpeningDlg::OnIsolineInsert() 
{
	if (g_nInsertMode!=2)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=2;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 点取墙段等分按钮
void CInsertOpeningDlg::OnIsowall() 
{
	if (g_nInsertMode!=3)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=3;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 点取定距插入按钮
void CInsertOpeningDlg::OnFixdistOnPier() 
{
	if (g_nInsertMode!=4)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=4;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 点取定距插入按钮
void CInsertOpeningDlg::OnFixdistOnAxis() 
{
	if (g_nInsertMode!=5)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=5;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 点取定距插入按钮
void CInsertOpeningDlg::OnArcWallInsert() 
{
	if (g_nInsertMode!=6)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=6;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 点取满墙插入按钮
void CInsertOpeningDlg::OnColumnInsert()
{
	if (g_nInsertMode!=7+1)//add by lgy +1 20120529	智能插入门窗
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=7+1;
		UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 上层插入
void CInsertOpeningDlg::OnUplevel() 
{
	if (g_nInsertMode!=8+1)//add by lgy +1 20120529	智能插入门窗
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=8+1;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
// 点取墙段等分按钮
void CInsertOpeningDlg::OnReplace() 
{
	if (g_nInsertMode!=10+1)
	{
		ResizeDialog(TRUE);
		g_nInsertMode=10+1;
	    UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}

// 已有洞口插入按钮
void CInsertOpeningDlg::OnHasHoleInsert()
{
	if (g_nInsertMode!=9+1)
	{
		if (GetInsertMode()==ID_REPLACE_INSERT)
			ResizeDialog(FALSE);
		g_nInsertMode=9+1;
		UpdateData(TRUE);
		UpdateData(FALSE);
		acedPostCommand(_T("\n"));
	}
}
void CInsertOpeningDlg::SetReplacing()
{
	ResizeDialog(TRUE);
	g_nInsertMode=10+1;
	UpdateData(FALSE);
}
void CInsertOpeningDlg::OnClose() 
{
    if (m_bModeless)
        acedPostCommand(_T("\33\33"));
	else
        CModelessDialog::OnClose();
}

bool CheckDoorWinLabel(CString strName);
bool CanSameLabel(TDbEntity* pOpening1, TDbEntity *pOpening2);
int GetSequenceNum(CString strlabel);
CString GetSequenceHead(CString strlabel);
bool TestOpeningKind(TDbOpening *pOp1, TDbOpening *pOp2);
CString CInsertOpeningDlg::CalcAutoLabel(TDbOpening *pOpening)
{
	bool bReName = false;
	if (pOpening == NULL)
		return _T("");
	CString strName = pOpening->GetAutoLabel(bReName);
	if (bReName)
	{
		CString strHead;
		if (strName == _T(""))
			strHead = _T("");
		else if (strName.Right(1).CompareNoCase(_T("-")) == 0)
			strHead = strName.Left(strName.GetLength() - 1);
		else
			strHead = strName;

		int nBigNum = 1;
		DList<AcDbDatabase> lstDataBase;
		DList<AcDbObjectId> lstId;
//		GetOpeningIdList(lstDataBase, lstId);
		GetOpeningIdList2(COpeningValidateNewDlg::m_bShowOnlyCurDwg, lstDataBase, lstId);
	
		int iLst = 0;
		for (iLst = 0; iLst < (int)lstId.Length(); iLst++)
		{
			AcDbObjectId id = *(lstId[iLst]);
			if (id == pOpening->id())
				continue;

			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbOpening, pEntDWG)
			{
				if (pEntDWG == NULL)
					continue;

				CString sEntLabel = pEntDWG->GetLabel();
				if (TestOpeningKind(pOpening, pEntDWG))
				{ // 同一个类型
					if (!CheckDoorWinLabel(sEntLabel)) // 检测是不是顺序编号。
						continue;

					if (CanSameLabel(pOpening, pEntDWG))
					{ // 能否一起编号
						return sEntLabel;
					}

					int nSeq = GetSequenceNum(sEntLabel) + 1;
					nBigNum = nBigNum > nSeq ? nBigNum : nSeq;
				}
				else
				{ // 不同的类型
					if (CheckDoorWinLabel(sEntLabel))
					{
						if (GetSequenceHead(sEntLabel).CompareNoCase(strHead) == 0)
						{ // 两编号的前缀相同，
							int nSeq = GetSequenceNum(sEntLabel) + 1;
							nBigNum = nBigNum > nSeq ? nBigNum : nSeq;
						}
					}
				}
			}
			OPENOBJ_END()
		}

		strName.Format(_T("%s%d"), strName, nBigNum);
		return strName;
	}
	else 
	{
		return strName;
	}
}

CString CInsertOpeningDlg::GetAutoLabel(TDbOpening *pOpening)
{
	if (IsAutoName())
	{
		if (!GoodLabel())
		{
			m_strAutoLabel = this->CalcAutoLabel(pOpening);
			ValidateOldLabel(); // 使保存的编号有效
		}
		return m_strAutoLabel;
	}
	else
		return m_csLabel;
}

bool CInsertOpeningDlg::IsAutoName() const 
{
	return m_csLabel.Compare(AUTO_LABEL_FLAG) == 0;
}


BEGIN_MESSAGE_MAP(CInsertOpeningDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CInsertOpeningDlg)

	ON_COMMAND(ID_FREE_INSERT, OnFreeInsert)
	ON_COMMAND(ID_SEQUENCE_INSERT, OnSequenceInsert)
	ON_COMMAND(ID_FIXDIST_ONPIER, OnFixdistOnPier)
	ON_COMMAND(ID_FIXDIST_ONAXIS, OnFixdistOnAxis)
	ON_COMMAND(ID_ARCWALL_INSERT, OnArcWallInsert)
	ON_COMMAND(ID_COLUMN_INSERT, OnColumnInsert)
	ON_COMMAND(ID_LINE_INSERT, OnIsolineInsert)
	ON_COMMAND(ID_WALL_INSERT, OnIsowall)
	ON_COMMAND(ID_UPLEVEL_INSERT, OnUplevel)
	ON_COMMAND(ID_REPLACE_INSERT, OnReplace)
	ON_CBN_SELCHANGE(IDC_LABEL, OnSelchangeLabel)
	ON_LBN_SELCHANGE(IDC_PARAM_LIST, OnSelchangeParamList)

	//add by lgy 20120517 智能插入门窗
	ON_COMMAND(ID_BUTTON_APTITUDE, OnBtnAptitude)
	// add by xly on 110113 
	ON_COMMAND(ID_HASHOLE_INSERT,OnHasHoleInsert)
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_LOOKUP, OnLookup)

	//new
	ON_WM_DESTROY()
	ON_COMMAND(ID_DOOR,OnDoor)
	ON_COMMAND(ID_WIN,OnWin)
	ON_COMMAND(ID_DOORWIN,OnDoorWin)
	ON_COMMAND(ID_TWODOOR,OnTwoDoor)
	ON_COMMAND(ID_ARCWIN,OnArcWin)
	ON_COMMAND(ID_BAYWIN,OnBayWin)
	ON_COMMAND(ID_RECTHOLE,OnRectHole)
	ON_COMMAND(ID_SELECT_GJK,OnGJK)

	//add by lgy 20120118	为拾取按钮响应函数
	ON_COMMAND(ID_BUTTON_OPENINQUIRE, OnInQuite)

	//}}AFX_MSG_MAP
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
END_MESSAGE_MAP()

//new
//modify by lgy 20120201	拾取参数按钮添加在中间部位需要调整对话框类型
int CInsertOpeningDlg::curType=0;
bool CInsertOpeningDlg::bRefreshDlg=false;
CInsertOpeningDlg* CInsertOpeningDlg::g_pCurDlg=NULL;
bool CInsertOpeningDlg::bLineWall=false;

void CInsertOpeningDlg::OnDestroy()//new
{
	CModelessDialog::OnDestroy();	
}
void RefreshInsWDHDlg();

void CInsertOpeningDlg::OnDoor()
{
	if (curType!=0)
	{
		curType=0;
		RefreshInsWDHDlg();
	}
}
void CInsertOpeningDlg::OnWin()
{
	if (curType!=1)
	{
		curType=1;
		RefreshInsWDHDlg();
	}
}
void CInsertOpeningDlg::OnDoorWin()
{
	if (curType!=2)
	{
		curType=2;
		RefreshInsWDHDlg();
	}
}
void CInsertOpeningDlg::OnTwoDoor()
{
	if (curType!=3)
	{
		curType=3;
		RefreshInsWDHDlg();
	}
}
void CInsertOpeningDlg::OnArcWin()
{
	if (curType!=4)
	{		
		curType=4;
		RefreshInsWDHDlg();
	}
}
void CInsertOpeningDlg::OnBayWin()
{
	if (curType!=5)
	{
		curType=5;
		RefreshInsWDHDlg();
	}
}
void CInsertOpeningDlg::OnRectHole()
{
	if (curType!=6)
	{
		curType=6;
		RefreshInsWDHDlg();
	}
}
AcDbEntity* LoadGJKEntity(const TCHAR *pszLib,XString&sBlockName);
void CInsertOpeningDlg::OnGJK()
{
	XString sLibFile,sBlockName=CGroupOpeningDlg::s_csDoor3DStyle;
    sLibFile << g_sDwbPath << _T("Opening.TKW");
	AcDbEntity *pEnt=NULL;
	{
 		XPushAutoHide noAutoHide(this);
		pEnt=LoadGJKEntity(sLibFile,sBlockName); 
	}
	if (pEnt!=NULL)
	{
		if (pEnt->isKindOf(TDbOpening::desc()))
		{
			CGroupOpeningDlg::s_csDoor3DStyle=sBlockName;	
			TDbOpening*pOpening=TDbOpening::cast(pEnt);
			TOpeningData::OpeningKind opKind=pOpening->GetKind();
			if (opKind==TOpeningData::OP_WINDOW)
				OnWin();
			else if (opKind==TOpeningData::OP_DOOR ) 
				OnDoor();
			else if (opKind==TOpeningData::OP_DOORWIN) 
				OnDoorWin();
			else if (opKind==TOpeningData::OP_TWODOOR) 
				OnTwoDoor();
			else if (opKind==TOpeningData::OP_PROWIN)
				OnBayWin();
			else if (opKind==TOpeningData::OP_ARCWIN)
				OnArcWin();
			else if (opKind==TOpeningData::OP_HOLE)
				OnRectHole();
			else
			{
				if (curType!=-1)
				{
					curType=-1;
					RefreshInsWDHDlg();
				}
			}
			
			if (g_pCurDlg!=NULL)
			{
				//add by whl on 070530,标高维持不变
				g_pCurDlg->UpdateData();
				pOpening->SetSill(g_pCurDlg->GetOpeningSill());

				g_pCurDlg->SetDlgParamFrom(*pOpening);
				g_pCurDlg->UpdateData(FALSE);
			}
		}
		else
			MessageBox(_T("请选择普通门窗或组合门窗!"));

		delete pEnt;
    }
}

//add by lgy 20120118	为拾取参数按钮添加消息响应函数
void CInsertOpeningDlg::OnInQuite()
{
	g_iOldInsertMode = 0;
	acedPostCommand(_T("\n"));
}




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

#define CHECK_LABEL_PROP_CHANGE \
{ \
	bool bSame = (__nWid == (int)m_nWidth) && \
	(__nHei == (int)m_nHeight) ; \
	if (!bSame) InvalidateOldLabel();\
}

CString CGroupOpeningDlg::s_csDoor3DStyle=_T("");

CGroupOpeningDlg::CGroupOpeningDlg(CWnd* pParent):CInsertOpeningDlg(CGroupOpeningDlg::IDD,pParent)
{
	m_pOpeningBak=NULL;
}

CGroupOpeningDlg::~CGroupOpeningDlg()
{
	if (m_pOpeningBak!=NULL)
		delete m_pOpeningBak;
}

void CGroupOpeningDlg::DoDataExchange(CDataExchange*pDX)
{
	KEEP_LABEL_PROP;
	CInsertOpeningDlg::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_STYLE3D, m_pic3d);
	if (!pDX->m_bSaveAndValidate)
		ShowSlide();
	CHECK_LABEL_PROP_CHANGE;
}

extern  void GetWinWidthModel(DList<double> &lstWidth);
extern  void GetWinHeightModel(DList<double> &lstHeight);
extern  void GetWinSillModel(DList<double> &lstSill);
void 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);
	}
}

BOOL CGroupOpeningDlg::OnInitDialog()
{
	BOOL bRet=CInsertOpeningDlg::OnInitDialog();
	
    DList<double> lstWidth, lstHeight, lstSill;
    GetWinWidthModel(lstWidth);
    GetWinHeightModel(lstHeight);
    GetWinSillModel(lstSill);
	InitCombox(m_lstWidthBox, lstWidth);
	InitCombox(m_lstHeightBox, lstHeight);
    InitCombox(m_lstSillBox, lstSill);
	
	// add by xly on 110113 已有洞口插入灰显
	m_toolbar.EnableButton(ID_HASHOLE_INSERT, FALSE);
	UpdateData(FALSE);
	return bRet;
}

BEGIN_MESSAGE_MAP(CGroupOpeningDlg, CInsertOpeningDlg)
	//{{AFX_MSG_MAP(CDoorOrWinDlg)
	ON_WM_PAINT()
    ON_WM_SETCURSOR()
	//ON_BN_CLICKED(IDC_STYLE3D, OnGJK)
	ON_BN_CLICKED(IDC_STYLE3D, OnGroupOpeningGJK)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CGroupOpeningDlg::ShowSlide()
{
	CStatic& st=m_pic3d;
	CImageDC& imgdc=m_PicSlide;
	const TCHAR* sldName=s_csDoor3DStyle;

	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 CGroupOpeningDlg::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);	
}

BOOL CGroupOpeningDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
    if (pWnd && 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);
}

TDbOpening* CGroupOpeningDlg::NewOpening()
{
	TDbOpening* pWin=NULL;
	if (m_pOpeningBak!=NULL)
		pWin=(TDbOpening*)m_pOpeningBak->clone();
	else
		pWin=new TDbGroupOpening;
	pWin->InitHardPointerId();
    UpdateOpening(*pWin);
	return pWin;
}

BOOL CGroupOpeningDlg::GetRegLocation(XString &sRegLoc) const
{
	sRegLoc=_T("GroupOpening");
	return TRUE;
}

int CGroupOpeningDlg::GetOpeningKind()const
{
	return TOpeningData::OP_GROUP;
}

// 根据给定的门窗, 设置对话框参数
BOOL CGroupOpeningDlg::SetDlgParamFrom(const TDbOpening &op)
{
	// sg add 110804，这个地方加的方法挺傻的，只是为了备份下来原来的编号是什么，如果由于切换了幻灯片，变成了空的，那么默认还原
	CString csOldLabel = m_csLabel;

	if (CInsertOpeningDlg::SetDlgParamFrom(op))
	{
		if (m_pOpeningBak!=NULL)
			delete m_pOpeningBak;
		m_pOpeningBak=(TDbOpening*)op.clone();

		// sg add 110804，如果由于切换了幻灯片，变成了空的，那么默认还原
		if (!csOldLabel.IsEmpty() && m_csLabel.IsEmpty())
		{
			m_csLabel = csOldLabel;
		}
	}
    return TRUE;
}

// sg add 110803，解决自动编号丢失问题 
void CGroupOpeningDlg::UpdateOpening(TDbOpening &op, BOOL bLoadStyle)
{
    CInsertOpeningDlg::UpdateOpening(op, bLoadStyle);
	op.SetLabel(GetAutoLabel(&op));
}

// sg add 110804，解决点击构件库后，自动编号无效的问题
// 其实还是调用基类的构件库实现，就是增加一个监控标记，如果尺寸发生改变以后，也要重新自动编号
void CGroupOpeningDlg::OnGroupOpeningGJK()
{
	KEEP_LABEL_PROP;
	CInsertOpeningDlg::OnGJK();
	CHECK_LABEL_PROP_CHANGE;
}