// DrawingFrameDlg.cpp : 实现文件
//

#include "stdafx.h"

#include "DrawingFrameDlg.h"
#include "dbpl.h" 
#include <deque>
#include "TgAs.h"
#include "utility.h"

static DRAWFRAME::PAGEGRPS g_pagegrp;

extern BOOL InvokeTkwMan(const TCHAR *pszLib, BOOL bSelOnly, XString &sBlockName);
// extern TARCH_IMPEXP int DragMovePickSet(PickSet &ss, const TCHAR *pszPrompt, const XPoint &ptBase, XPoint &ptFinal,const TCHAR*sKeyword);
// extern TARCH_IMPEXP int DragMovePickSet(PickSet &ss, const TCHAR *pszPrompt, const XPoint &ptBase, XPoint &ptFinal);
#define APP_TCH_KERNCMD _T("_TCH_KERNCMD")

// 图幅描述写到图框图块的扩展数据中
void SaveFrameSize(Entity ent, const TCHAR *sSize)
{
	OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbBlockReference,pEnt);
	if (pEnt != NULL)
	{
		ads_regapp(APP_TCH_KERNCMD);
		pEnt->assertWriteEnabled();
		resbuf *xd = ads_buildlist(1001,APP_TCH_KERNCMD,1000,sSize,NULL);
		pEnt->setXData(xd);
		ads_relrb(xd);
	}
	OPENOBJ_END();
}

// 取图框图块的图幅描述，不存在则返回空字符串
void GetFrameSize(AcDbBlockReference*pEnt, CString &sSize)
{
	sSize=_T("");
	pEnt->assertReadEnabled();
	resbuf *xd = pEnt->xData(APP_TCH_KERNCMD);
	if (xd == NULL)
		return;
	resbuf* xdId = xd->rbnext;
	if (xdId == NULL)
	{
		ads_relrb(xd);
		return;
	}
	
	if (xdId->resval.rstring!=NULL)
		sSize=xdId->resval.rstring;
	ads_relrb(xd);
	return;
}



// 保存专版定制软件中，各个子院或所的信息
CSpecialtyOffice::CSpecialtyOffice()
{
	m_csName = _T("");
	
	m_csTkName = _T("");

	m_sMidBlock.m_nHasMidBlock = 0;
	m_sMidBlock.csDwbName = _T("");
	m_sMidBlock.csUpDownBlock = _T("");
	m_sMidBlock.csLeftBlock = _T("");
	m_sMidBlock.csRightBlock = _T("");
}

CSpecialtyOffice::CSpecialtyOffice(const CSpecialtyOffice& srcSpecialtyOffice)
{
	// 下属设计院名或设计所名称
	m_csName = srcSpecialtyOffice.m_csName;

	// 保存通长标题栏的图库名，所有图幅和样式下的通长标题栏，肯定都放到一个TK里
	m_csTkName = srcSpecialtyOffice.m_csTkName;

	// 各个图幅以及横式、立式样式下的通长标题栏图块名数组
	m_aryLongTitle.RemoveAll();

	int nCount = (int)srcSpecialtyOffice.m_aryLongTitle.GetSize();
	for (int i=0; i<nCount; i++)
	{
		CSpecialtyOffice::SLongTitle title = srcSpecialtyOffice.m_aryLongTitle.GetAt(i);
		m_aryLongTitle.Add(title);
	}

	// 各个位置下的对中标志图块名
	m_sMidBlock.m_nHasMidBlock = srcSpecialtyOffice.m_sMidBlock.m_nHasMidBlock;
	m_sMidBlock.csDwbName = srcSpecialtyOffice.m_sMidBlock.csDwbName;
	m_sMidBlock.csUpDownBlock = srcSpecialtyOffice.m_sMidBlock.csUpDownBlock;
	m_sMidBlock.csLeftBlock = srcSpecialtyOffice.m_sMidBlock.csLeftBlock;
	m_sMidBlock.csRightBlock = srcSpecialtyOffice.m_sMidBlock.csRightBlock;
}

// 根据图幅和样式获得通长标题栏图块名
CString CSpecialtyOffice::FindLongTitleBlkName(int nRow, int nBreadth)
{
	CString csResult;

	int nSize = (int)m_aryLongTitle.GetSize(),
		nTmp(0);
	for (int j=0; j<nSize; j++)
	{
		CSpecialtyOffice::SLongTitle title = m_aryLongTitle.GetAt(j);
		nTmp = _ttoi(title.csBreadth);

		if (nRow==title.nRow && nTmp==nBreadth)
		{
			csResult = title.csLongTitle;
			break;
		}
	}
	return csResult;
}

// 判断是否有横栏
BOOL CSpecialtyOffice::HasRANGEFrame()
{
	BOOL bResult = FALSE;

	int nSize = (int)m_aryLongTitle.GetSize();
	for (int j=0; j<nSize; j++)
	{
		CSpecialtyOffice::SLongTitle title = m_aryLongTitle.GetAt(j);
		if (title.nRow == 1)
		{
			bResult = TRUE;
			break;
		}
	}

	return bResult;
}





// sg add 100916，保存用户上次选择的院别
int	CDrawingFrameDlg::m_nLastOffice = 0;

// CDrawingFrameDlg 对话框
IMPLEMENT_DYNAMIC(CDrawingFrameDlg, CAcUiDialog)
CDrawingFrameDlg::CDrawingFrameDlg(CWnd* pParent /*=NULL*/)
: CAcUiDialog(CDrawingFrameDlg::IDD, pParent)
, m_iStandard(2)
, m_strLength(_T(""))
, m_strWidth(_T(""))
, m_iRow(0)
, m_bStandard(TRUE)
, m_bLong(FALSE)
, m_bTicket(TRUE)
, m_bPosition(TRUE)
, m_bAdjunct(FALSE)
, m_PreviewCtrl(6)
, m_PreviewDb(true,true)
, m_strScale(_T(""))
, m_bSpace(FALSE)
, m_bDirect(FALSE)
, m_iLengthen(0)
, m_iCustomSize(0)
, m_bPreview(true)
{
	m_hIcon = NULL;

	// sg add 111014，m_bTicket默认值的备份，放置经过用户一系列操作后，解决会签栏不正确的有或者没有了
	// 默认为TRUE，主要为通用版开绿灯
	m_bDefaultTicket = TRUE;

	// sg add 111102，根据选择的院别，确定“立式”是否可以选择
	m_bRANGE = FALSE;

	m_bDefaultAdjunct = TRUE;

	m_bA0 = m_bA1 = m_bA2 = m_bA3 = m_bA4 = TRUE;

	// sg add 100907，判断当前软件是否是专版定制软件，并通过文件读取，控制对话框显示及功能
	// 说明，上述2个变量，必须要放在本函数上面，因为这个函数内部可能会改变这个值
	GetOfficeInfoFromXML();
}

CDrawingFrameDlg::~CDrawingFrameDlg()
{
	if (m_hIcon)
		::DestroyIcon(m_hIcon);
}


// sg add 100907，通过tch.ini文件，判断当前软件是否是专版
bool CDrawingFrameDlg::IsSpecialtyVer()
{
	// 判断是否是专版软件
	bool bSpecialty = false;

	TCString sTchIni;
	// 查找tch.ini文件是否存在
	if (FindFile(_T("tch.ini"), sTchIni)) 
	{
		// 获取EName
		CString csEName;
		GetPrivateProfileString(_T("Product"), _T("EName"), _T(""), csEName.GetBuffer(MAX_PATH), MAX_PATH, sTchIni);
		csEName.ReleaseBuffer();

		if (!csEName.IsEmpty())
		{
			int nPos = csEName.Find(_T("版"), 0);
			bSpecialty = nPos!=-1;
		}
	}
	return bSpecialty;
}


// 从XML文件中，解析图框线宽
void CDrawingFrameDlg::GetLineWidthXML(const CXMLDOMNodePtr &pXMLChildNodePtr)
{
	// sg modify 111021，增加图框的线宽可以定制的功能
	// <图框线宽 widthA0="3.0" widthA1="2.0" widthA2="1.0" widthA3="0.5" widthA4="0"></图框线宽>
	if (pXMLChildNodePtr->GetAttributeNum() != 5)
	{
		return;
	}

	CString csKey, csValue, csTmp1, csTmp2;
	for (int n=0; n<5; n++) // 循环获得从A0到A4的图幅大小
	{
		csKey = pXMLChildNodePtr->GetAttributeName(n);
		if (csKey.IsEmpty()) // 键不能为空
		{
			m_aryFrameWidth.append(1.0);
			continue;
		}

		csTmp1 = csKey.Right(1);
		csTmp2.Format(_T("%d"), n);
		if (_tcsicmp(csTmp2, csTmp1) != 0) // 必须控制从A0到A4的顺序书写
		{
			m_aryFrameWidth.append(1.0);
			continue;
		}

		csValue = pXMLChildNodePtr->GetAttributeValue(csKey);
		if (csValue.IsEmpty()) // 值不能为空
		{
			csValue = _T("1.0");
		}
		m_aryFrameWidth.append(_tstof(csValue));
	}
}

// 从XML文件中，会签
void CDrawingFrameDlg::GetTicketXML(const CXMLDOMNodePtr &pXMLChildNodePtr)
{
	// sg modify 111014，增加根据XML设置是否绘制会签
	// <会签栏 ticket="0"></会签栏>
	if (pXMLChildNodePtr->GetAttributeNum() != 1)
	{
		return;
	}

	CString csKey, csValue;
	csKey = pXMLChildNodePtr->GetAttributeName(0);
	if (_tcsicmp(csKey, _T("ticket")) != 0)
	{
		return;
	}

	csValue = pXMLChildNodePtr->GetAttributeValue(csKey);
	if (csValue.IsEmpty())
	{
		return;
	}

	// 获得是否有会签栏
	m_bDefaultTicket = _ttoi(csValue);
}

// 从XML文件中，通长标题栏
void CDrawingFrameDlg::GetLongTitleXML(const CXMLDOMNodePtr &pXMLChildNodePtr, CSpecialtyOffice &info)
{
	// <通长标题栏 dwb="西南院">
	if (pXMLChildNodePtr->GetAttributeNum() != 1)
	{
		return;
	}
	
	CString csKey, csValue;
	csKey = pXMLChildNodePtr->GetAttributeName(0); // dwb="西南院"
	if (_tcsicmp(csKey, _T("dwb")) != 0)
	{
		return;
	}

	CXMLDOMNodesPtr pSubChildrens = pXMLChildNodePtr->GetChildrenNodes(csKey);
	int nCount = pSubChildrens->GetCount();
	if (nCount < 1)
	{
		return; // 没有具体给出通长标题栏的块名
	}

	csValue = pXMLChildNodePtr->GetAttributeValue(csKey);
	if (csValue.IsEmpty())
	{
		return;
	}

	// sg add 100908，获得TK文件名
	info.m_csTkName = csValue;

	for (int m=0; m<nCount; m++) // 循环获得子节点
	{
		CXMLDOMNodePtr pTitle = pSubChildrens->GetItem(m); // <横栏 breadth="0" longtitle="00000014"></横栏>
		if (pTitle->GetAttributeNum() != 2)
		{
			continue;
		}

		// 构造一个通长标题栏与图幅对应关系信息
		CSpecialtyOffice::SLongTitle title;

		csKey = pTitle->GetAttributeName(0);
		if (_tcsicmp(csKey, _T("breadth")) != 0)
		{
			continue;
		}

		csValue = pTitle->GetAttributeValue(csKey);
		if (csValue.IsEmpty())
		{
			continue;
		}
		title.csBreadth = csValue; // 图幅

		csKey = pTitle->GetAttributeName(1);
		if (_tcsicmp(csKey, _T("longtitle")) != 0)
		{
			continue;
		}

		csValue = pTitle->GetAttributeValue(csKey);
		if (csValue.IsEmpty())
		{
			continue;
		}
		title.csLongTitle = csValue; // 块名

		csKey = pTitle->GetNodeName();
		if (_tcsicmp(csKey, _T("横栏")) == 0)
		{
			title.nRow = 1;	// 立式图幅
		}
		else
		{
			title.nRow = 0; // 横式图幅
		}

		info.m_aryLongTitle.Add(title); // 保存
	}
}

// 从XML文件中，对中标志
void CDrawingFrameDlg::GetMidBlockXML(const CXMLDOMNodePtr &pXMLChildNodePtr, CSpecialtyOffice &info)
{
	// sg add 111021，增加对中标志的支持
	// <对中标志 dwb="对中标志">
	if (pXMLChildNodePtr->GetAttributeNum() != 1)
	{
		return;
	}
	
	CString csKey, csValue;
	csKey = pXMLChildNodePtr->GetAttributeName(0); // dwb="对中标志"
	if (_tcsicmp(csKey, _T("dwb")) != 0)
	{
		return;
	}

	CXMLDOMNodesPtr pSubChildrens = pXMLChildNodePtr->GetChildrenNodes(csKey);
	int nCount = pSubChildrens->GetCount();
	if (nCount < 1)
	{
		return; // 没有给图块名
	}

	csValue = pXMLChildNodePtr->GetAttributeValue(csKey);
	if (csValue.IsEmpty())
	{
		return;
	}

	// 从XML里获得“对中标志”节点并且DWB文件存在，才可以将该标志变成是
	info.m_sMidBlock.m_nHasMidBlock = 1;
	info.m_sMidBlock.csDwbName = csValue;

	for (int n=0; n<nCount; n++) // 循环获得子节点
	{
		CXMLDOMNodePtr pBlock = pSubChildrens->GetItem(n); // <上下图块 blockid="00000006"></上下图块>
		if (pBlock->GetAttributeNum() != 1)
		{
			continue;
		}

		csKey = pBlock->GetAttributeName(0);
		if (_tcsicmp(csKey, _T("blockid")) != 0)
		{
			continue;
		}

		csValue = pBlock->GetNodeName();
		if (_tcsicmp(csValue, _T("上下图块")) == 0)
		{
			info.m_sMidBlock.csUpDownBlock = pBlock->GetAttributeValue(csKey);
		}
		else if (_tcsicmp(csValue, _T("左图块")) == 0)
		{
			info.m_sMidBlock.csLeftBlock = pBlock->GetAttributeValue(csKey);
		}
		else if (_tcsicmp(csValue, _T("右图块")) == 0)
		{
			info.m_sMidBlock.csRightBlock = pBlock->GetAttributeValue(csKey);
		}
	}
}

// sg add 100907，解析TSpecialtyOffice.xml文件，初始化m_lstOfficeInfo列表
bool CDrawingFrameDlg::GetOfficeInfoFromXML()
{
	// 判断是否是专版定制软件，不是专版，则不考虑XML
	if (!IsSpecialtyVer())
	{
		return true;
	}

	// 判断文件是否存在，没有XML的专版，也当成标准版试用
	TCString fullFile;
	if (!FindFile(_T("TSpecialtyOffice.xml"), fullFile)) 
	{
		return true;
	}

	CString strPath = fullFile;
	CXMLDOMFile *pXMLDoc = new CXMLDOMFile;
	if (!pXMLDoc->IsFileExist(strPath))
	{
		delete pXMLDoc;
		return true;
	}

	// 开始读取XML文件内容，从此往下，如果不成功，则给出提示，但是不认为是标准版
	if (!pXMLDoc->Open(strPath))
	{
#ifndef _WIN64
		MessageBox(_T("打开XML文档失败！请安装MSXML4.0SP2组件"));
#else
		MessageBox(_T("打开XML文档失败！请安装MSXML6.0组件"));
#endif
		delete pXMLDoc;
		return false;
	}

	// 获取根节点，仅仅是标题，专版名称，<上华专版 name="中国建筑专版">
	CXMLDOMNodePtr pRoot = pXMLDoc->GetRoot();
	CString csNodeName = pRoot->GetNodeName();
	if (!pRoot->HasChildNodes() || _tcsicmp(csNodeName, _T("上华专版"))!=0)
	{
		MessageBox(_T("TSpecialtyOffice.xml文件格式发生错误！"));
		delete pXMLDoc;
		return false;
	}
	
	csNodeName = pRoot->GetAttributeName(0); // name

	// 获得专版下的各个下属设计院或设计所、会签、图框线宽等等内容
	CXMLDOMNodesPtr pAllChildrens = pRoot->GetChildrenNodes(csNodeName);
	
	CString csOfficeName,sTmp;
	int nCount = pAllChildrens->GetCount(),
		nTitlesNum(0), j(0);
	for (int i=0; i<nCount; i++) // 循环获得子节点
	{
		CXMLDOMNodePtr pChild = pAllChildrens->GetItem(i);

		csNodeName = pChild->GetNodeName();
		if (_tcsicmp(csNodeName, _T("会签栏")) == 0)
		{
			GetTicketXML(pChild);
			continue;
		}
		//wlw add 130314 读xml附件栏
		else if (_tcsicmp(csNodeName, _T("附件栏")) == 0)
		{
			sTmp = pChild->GetAttributeValue(_T("ticket"));
			m_bDefaultAdjunct = _ttoi(sTmp);
			continue;
		}
		//wlw add 130314 读xml附件栏
		else if (_tcsicmp(csNodeName, _T("图幅可用")) == 0)
		{
			sTmp = pChild->GetAttributeValue(_T("A0"));
			m_bA0 = _ttoi(sTmp);
			sTmp = pChild->GetAttributeValue(_T("A1"));
			m_bA1 = _ttoi(sTmp);
			sTmp = pChild->GetAttributeValue(_T("A2"));
			m_bA2 = _ttoi(sTmp);
			sTmp = pChild->GetAttributeValue(_T("A3"));
			m_bA3 = _ttoi(sTmp);
			sTmp = pChild->GetAttributeValue(_T("A4"));
			m_bA4 = _ttoi(sTmp);
			continue;
		}

		else if (_tcsicmp(csNodeName, _T("图框线宽")) == 0)
		{
			GetLineWidthXML(pChild);
			continue;
		}


		if (_tcsicmp(csNodeName, _T("院别")) != 0) // <院别 name="西南院">
		{
			continue;
		}

		csNodeName = pChild->GetAttributeName();
		csOfficeName = pChild->GetAttributeValue(csNodeName); // 如：西南院
		if (csOfficeName.IsEmpty())
		{
			continue;
		}

		// 开始构造下属设计院或设计所的对象
		CSpecialtyOffice info;
		info.m_csName = csOfficeName;
		
		// 获得专版下的各个下属设计院或设计所内容
		CXMLDOMNodesPtr pAllOffices = pChild->GetChildrenNodes(csNodeName);
		nTitlesNum = pAllOffices->GetCount();
		for (j=0; j<nTitlesNum; j++) // 一个一个设计所进行循环
		{
			CXMLDOMNodePtr pSubChild = pAllOffices->GetItem(j);

			csNodeName = pSubChild->GetNodeName();
			if (_tcsicmp(csNodeName, _T("对中标志")) == 0)
			{
				GetMidBlockXML(pSubChild, info);
				continue;
			}
			else if (_tcsicmp(csNodeName, _T("通长标题栏")) == 0)
			{
				GetLongTitleXML(pSubChild, info);
				continue;
			}
		}

		// 保存有效信息
		m_lstOfficeInfo.Append(new CSpecialtyOffice(info));
	}
	
	delete pXMLDoc;
	return true;
}

// sg add 111102，根据选择的下属院别，获得对中标记图块名称
BOOL CDrawingFrameDlg::GetMidAlignBlock(XString &szUpDownBlock, XString &szLeftBlock, XString &szRightBlock)
{
	BOOL bResult = false;

	int nLength = m_lstOfficeInfo.Length();
	if (nLength < 1) // 不是专版或者没有XML
	{
		return bResult;
	}

	int nCurSel = m_cmbOffice.GetCurSel();
	if (nCurSel < 0) // 获得当前选择的下属设计院或设计所名称
	{
		return bResult;
	}

	CString csOffice, csBlkName;
	m_cmbOffice.GetLBText(nCurSel, csOffice); // 获得下属设计院或设计所名称

	for (int i=0; i<nLength; i++)
	{
		CSpecialtyOffice *pOffice = m_lstOfficeInfo.GetAt(i);

		// 首先找到对应的下属设计院或设计所
		if (_tcsicmp(pOffice->m_csName, csOffice) == 0)
		{
			bResult = (pOffice->m_sMidBlock.m_nHasMidBlock == 1); // 是否有对中标志
			
			if (!pOffice->m_sMidBlock.csUpDownBlock.IsEmpty()) // 再获得块名
			{
				szUpDownBlock << pOffice->m_sMidBlock.csDwbName << _T("(") << pOffice->m_sMidBlock.csUpDownBlock << _T(")");
			}

			if (!pOffice->m_sMidBlock.csLeftBlock.IsEmpty())
			{
				szLeftBlock << pOffice->m_sMidBlock.csDwbName << _T("(") << pOffice->m_sMidBlock.csLeftBlock << _T(")");
			}

			if (!pOffice->m_sMidBlock.csRightBlock.IsEmpty())
			{
				szRightBlock << pOffice->m_sMidBlock.csDwbName << _T("(") << pOffice->m_sMidBlock.csRightBlock << _T(")");
			}
			break;
		}
	}
	return bResult;
}

bool CDrawingFrameDlg::GetLongTitleBlkName()
{
	int nLength = m_lstOfficeInfo.Length();
	if (nLength < 1) // 不是专版或者没有XML
	{
		return false;
	}

	int nCurSel = m_cmbOffice.GetCurSel();
	if (nCurSel < 0) // 获得当前选择的下属设计院或设计所名称
	{
		return false;
	}

	m_nLastOffice = nCurSel; // sg add 100916，保存用户本次选择的院别
	
	CString csOffice, csBlkName;
	m_cmbOffice.GetLBText(nCurSel, csOffice); // 获得下属设计院或设计所名称

	XString szTmp;
	for (int i=0; i<nLength; i++)
	{
		CSpecialtyOffice *pOffice = m_lstOfficeInfo.GetAt(i);

		// 首先找到对应的下属设计院或设计所
		if (_tcsicmp(pOffice->m_csName, csOffice) == 0)
		{
			// 判断是否有立式图框
			m_bRANGE = pOffice->HasRANGEFrame();

			// 再根据图幅和横式、立式的样式获得通长标题栏图块名
			csBlkName = pOffice->FindLongTitleBlkName(m_iRow, m_iStandard);
			if (!csBlkName.IsEmpty())
			{
				szTmp << pOffice->m_csTkName << _T("(") << csBlkName << _T(")");
			}
			break;
		}
	}

	if (szTmp.Length() != 0) // 根据图块名是否为空，判断是否找到了指定的块
	{
		m_strLong = szTmp;
	}
	else if (m_bLong) // 未找到对应的图幅信息
	{
		if (!m_bRANGE && m_iRow==1)
			return false;
			
		::AfxMessageBox(_T("请选择正确的通长标题栏"));
		return false;
	}
	return true;
}

void CDrawingFrameDlg::DoDataExchange(CDataExchange* pDX)
{
	CAcUiDialog::DoDataExchange(pDX);
	DDX_Radio(pDX, IDC_RADIO_A0, m_iStandard);
	DDX_Radio(pDX, IDC_RADIO_ROW, m_iRow);
	DDX_Text(pDX, IDC_EDIT_LENGTH, m_strLength);
	DDX_Text(pDX, IDC_EDIT_WIDTH, m_strWidth);
	DDX_Control(pDX, IDC_COMBO_LENGTHEN, m_colLenthen);
	DDX_Control(pDX, IDC_COMBO_CUSTOMSIZE, m_colCustomSize);
	DDX_Check(pDX, IDC_CHECK_TITLE_STANDARD, m_bStandard);
	DDX_Check(pDX, IDC_CHECK_TITLE_LONG, m_bLong);
	DDX_Check(pDX, IDC_CHECK_TICKET, m_bTicket);
	DDX_Check(pDX, IDC_CHECK_POSITION, m_bPosition);
	DDX_Check(pDX, IDC_CHECK_ADJUNCT, m_bAdjunct);
	DDX_CBString(pDX, IDC_COMBO_SCALE, m_strScale);
	DDX_Check(pDX, IDC_CHECK_SPACE, m_bSpace);
	DDX_Check(pDX, IDC_CHECK_DIRECT, m_bDirect);
	DDX_CBIndex(pDX, IDC_COMBO_LENGTHEN, m_iLengthen);
	DDX_CBIndex(pDX, IDC_COMBO_CUSTOMSIZE, m_iCustomSize);

	// sg add 100907，判断是否有专版定制中的院别信息列表，控制控件是否显示
	DDX_Control(pDX, IDC_COMBO_SECTION_OFFICE, m_cmbOffice);

	bool bShow = m_lstOfficeInfo.Length() != 0;
	GetDlgItem(IDC_STATIC_SECTION_OFFICE)->ShowWindow(bShow);
	GetDlgItem(IDC_COMBO_SECTION_OFFICE)->ShowWindow(bShow);
}

BEGIN_MESSAGE_MAP(CDrawingFrameDlg, CAcUiDialog)
	ON_BN_CLICKED(IDC_RADIO_A0, OnDataChangeAx)
	ON_BN_CLICKED(IDC_RADIO_A1, OnDataChangeAx)
	ON_BN_CLICKED(IDC_RADIO_A2, OnDataChangeAx)
	ON_BN_CLICKED(IDC_RADIO_A3, OnDataChangeAx)
	ON_BN_CLICKED(IDC_RADIO_A4, OnDataChangeAx)
	ON_BN_CLICKED(IDC_RADIO_ROW, OnDataChangeR)
	ON_BN_CLICKED(IDC_RADIO_RANGE, OnDataChangeR)
	ON_CBN_SELCHANGE(IDC_COMBO_LENGTHEN, OnCbnSelchangeComboLenthength)
	ON_CBN_SELCHANGE(IDC_COMBO_CUSTOMSIZE, OnCbnSelchangeComboCustomsize)
	ON_EN_KILLFOCUS(IDC_EDIT_LENGTH, OnEnKillfocusEditLength)
	ON_EN_KILLFOCUS(IDC_EDIT_WIDTH, OnEnKillfocusEditWidth)
	ON_EN_CHANGE(IDC_EDIT_LENGTH, OnEnChangeEditLength)
	ON_EN_CHANGE(IDC_EDIT_WIDTH, OnEnChangeEditWidth)
	ON_BN_CLICKED(IDC_CHECK_TITLE_STANDARD, OnBnClickedCheckTitleStandard)
	ON_BN_CLICKED(IDC_CHECK_TITLE_LONG, OnBnClickedCheckTitleLong)
	ON_BN_CLICKED(IDC_CHECK_TICKET, OnBnClickedCheckTicket)
	ON_BN_CLICKED(IDC_CHECK_POSITION, OnBnClickedCheckPosition)
	ON_BN_CLICKED(IDC_CHECK_ADJUNCT, OnBnClickedCheckAdjunct)
	ON_BN_CLICKED(IDC_BUTTON_PICKADJUNCT, OnBnClickedButtonPickadjunct)
	ON_BN_CLICKED(IDC_BUTTON_PICKTICKET, OnBnClickedButtonPickticket)
	ON_BN_CLICKED(IDC_BUTTON_PICKTITLE, OnBnClickedButtonPicktitle)
	ON_BN_CLICKED(IDC_BUTTON_PICKDIRECT, OnBnClickedButtonPickdirect)
	ON_CBN_KILLFOCUS(IDC_COMBO_SCALE, OnCbnKillfocusComboScale)
	ON_BN_CLICKED(IDC_CHECK_SPACE, OnBnClickedCheckSpace)
	ON_BN_CLICKED(IDC_CHECK_DIRECT, OnBnClickedCheckDirect)
	// sg add 100908，增加院别选择事件
	ON_CBN_SELCHANGE(IDC_COMBO_SECTION_OFFICE, OnCbnSelchangeComboOffice)
END_MESSAGE_MAP()

// CDrawingFrameDlg 消息处理程序
BOOL CDrawingFrameDlg::OnInitDialog()
{
	CAcUiDialog::OnInitDialog();
	// 按钮图标
	m_hIcon = AfxGetApp()->LoadIcon(IDI_ICON_PICK);
	if (!m_hIcon)
	{
		AfxMessageBox(_T("无法找到指定ICON文件。"));
	}
	else
	{
		((CButton*)GetDlgItem(IDC_BUTTON_PICKTITLE))->SetIcon(m_hIcon);
		((CButton*)GetDlgItem(IDC_BUTTON_PICKADJUNCT))->SetIcon(m_hIcon);
		((CButton*)GetDlgItem(IDC_BUTTON_PICKTICKET))->SetIcon(m_hIcon);
		((CButton*)GetDlgItem(IDC_BUTTON_PICKDIRECT))->SetIcon(m_hIcon);
	}
	
	// 预览
	if (!m_PreviewCtrl.SubclassDlgItem(IDC_PREVIEW, this))
		return FALSE;
	
	// 模型图纸空间
	int nTileMode = 1;
	VERIFY(xg_getvar(_T("TILEMODE"), &nTileMode)==RTNORM);
	if (nTileMode == 0)
		m_bSpace = 1;
	else
		m_bSpace = 0;

	// 读取保存值
	ReadStoreValue();
	
	// sg add 100907，判断是否有专版定制中的院别信息列表，初始化IDC_COMBO_SECTION_OFFICE中的内容
	// begin
	int nLength = m_lstOfficeInfo.Length();
	if (nLength > 0)
	{
		m_cmbOffice.ResetContent();

		for (int i=0; i<nLength; i++)
		{
			CString csName = m_lstOfficeInfo.GetAt(i)->m_csName;
			m_cmbOffice.AddString(csName);
		}

		// sg add 100916，保存用户上次选择的院别
		if (m_nLastOffice > -1 && m_nLastOffice < nLength)
		{
			m_cmbOffice.SetCurSel(m_nLastOffice);
		}
		else
		{
			m_cmbOffice.SetCurSel(0);
		}

		// sg add 100908，根据院别信息，得到正确的通长标题栏，根据选择的院，传回来立式图框是否可选择
		GetLongTitleBlkName();

		// sg modify 100916，控制部分控件不显示
		GetDlgItem(IDC_CHECK_TICKET)->EnableWindow(m_bDefaultTicket && !m_bDirect);	// 会签栏
		GetDlgItem(IDC_BUTTON_PICKTICKET)->EnableWindow(m_bDefaultTicket && !m_bDirect && m_bTicket);

		GetDlgItem(IDC_CHECK_ADJUNCT)->EnableWindow(m_bDefaultAdjunct && !m_bDirect);							// 附件栏
		GetDlgItem(IDC_BUTTON_PICKADJUNCT)->EnableWindow(m_bDefaultAdjunct && !m_bDirect&& m_bAdjunct);

		GetDlgItem(IDC_CHECK_POSITION)->EnableWindow(FALSE);						// 右对齐
		GetDlgItem(IDC_CHECK_TITLE_STANDARD)->EnableWindow(FALSE);					// 标准标题栏
		GetDlgItem(IDC_RADIO_RANGE)->EnableWindow(m_bRANGE && !m_bDirect);			// 立式
	}
	// end

	UpdateData(FALSE);
	UpdateLengthen();
	UpdateSpace();
	UpdateTitle();
	UpdateDirect();
	UpdatePreview();
	
	if (m_iCustomSize >= 0)
	{
		m_colLenthen.SetCurSel(-1);
		UpdateStandard(FALSE);
	}
	else
		SetSizeEdit(m_iStandard, m_iLengthen);

	if (!g_pagegrp.empty())
	{
		DRAWFRAME::PAGEGRPS::const_iterator it = g_pagegrp.begin();
		if (it != g_pagegrp.end())
		{
			GetDlgItem(IDC_RADIO_A0)->SetWindowText(it->_grpname);
			++it;
		}
		else
			GetDlgItem(IDC_RADIO_A0)->EnableWindow(FALSE);

		if (it != g_pagegrp.end())
		{
			GetDlgItem(IDC_RADIO_A1)->SetWindowText(it->_grpname);
			++it;
		}
		else
			GetDlgItem(IDC_RADIO_A1)->EnableWindow(FALSE);

		if (it != g_pagegrp.end())
		{
			GetDlgItem(IDC_RADIO_A2)->SetWindowText(it->_grpname);
			++it;
		}
		else
			GetDlgItem(IDC_RADIO_A2)->EnableWindow(FALSE);

		if (it != g_pagegrp.end())
		{
			GetDlgItem(IDC_RADIO_A3)->SetWindowText(it->_grpname);
			++it;
		}
		else
			GetDlgItem(IDC_RADIO_A3)->EnableWindow(FALSE);

		if (it != g_pagegrp.end())
		{
			GetDlgItem(IDC_RADIO_A4)->SetWindowText(it->_grpname);
			++it;
		}
		else
			GetDlgItem(IDC_RADIO_A4)->EnableWindow(FALSE);

	}
	return true;
}

// 标准图幅
void CDrawingFrameDlg::OnDataChangeAx()
{
	CDataExchange dx(this, true);
	DDX_Radio(&dx, IDC_RADIO_A0, m_iStandard);
	m_colCustomSize.SetCurSel(-1);
	SetSizeEdit(m_iStandard);
	m_iLengthen = 0;
	UpdateLengthen();

	// sg add 100908，根据图幅变化，得到正确的通长标题栏
	GetLongTitleBlkName();

	UpdatePreview();
}

// sg add 100908，增加院别选择事件
void CDrawingFrameDlg::OnCbnSelchangeComboOffice()
{
	UpdateData(TRUE);

	GetLongTitleBlkName();
	
	// sg add 101102，根据GetLongTitleBlkName传回来的信息，控制立式图框是否可选择
	GetDlgItem(IDC_RADIO_RANGE)->EnableWindow(m_bRANGE && !m_bDirect);

	// 没有立式，并且是选择的是立式图框
	if (!m_bRANGE && m_iRow==1)
	{
		m_iRow = 0;
		UpdateData(FALSE);

		GetLongTitleBlkName();
	}
	UpdatePreview();
}

// 横式竖式
void CDrawingFrameDlg::OnDataChangeR()
{
	CDataExchange dx(this, true);
	DDX_Radio(&dx, IDC_RADIO_ROW, m_iRow);

	// sg add 100908，根据图幅变化，得到正确的通长标题栏
	GetLongTitleBlkName();

	UpdatePreview();
}

// 加长图框
void CDrawingFrameDlg::OnCbnSelchangeComboLenthength()
{
	m_iLengthen = m_colLenthen.GetCurSel();
	SetSizeEdit(m_iStandard, m_iLengthen);
	m_colCustomSize.SetCurSel(-1);
	UpdateStandard(TRUE);
	UpdatePreview();
}

// 自定义图框
void CDrawingFrameDlg::OnCbnSelchangeComboCustomsize()
{
	CString string;
	m_iCustomSize = m_colCustomSize.GetCurSel();
	if (m_iCustomSize>=0)
		m_colCustomSize.GetLBText(m_iCustomSize, string);
	int iPosi = string.Find(_T("*"));
	int iLen = string.GetLength();
	if (iPosi > 0)
	{
		m_strLength = string.Left(iPosi);
		m_strWidth = string.Right(iLen-iPosi-1);
		m_colLenthen.SetCurSel(-1);
		UpdateStandard(FALSE);
		UpdateSize();
		UpdatePreview();
	}
}

// 长宽edit
void CDrawingFrameDlg::OnEnKillfocusEditLength()
{
	CDataExchange dx(this, true);
	DDX_Text(&dx, IDC_EDIT_LENGTH, m_strLength);
	UpdatePreview();
}

void CDrawingFrameDlg::OnEnKillfocusEditWidth()
{
	CDataExchange dx(this, true);
	DDX_Text(&dx, IDC_EDIT_WIDTH, m_strWidth);
	UpdatePreview();
}

void CDrawingFrameDlg::OnEnChangeEditLength()
{
	CDataExchange dx(this, true);
	DDX_Text(&dx, IDC_EDIT_LENGTH, m_strLength);
	UpdatePreview();
}

void CDrawingFrameDlg::OnEnChangeEditWidth()
{
	CDataExchange dx(this, true);
	DDX_Text(&dx, IDC_EDIT_WIDTH, m_strWidth);
	UpdatePreview();
}

void CDrawingFrameDlg::OnBnClickedCheckTitleStandard()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_TITLE_STANDARD, m_bStandard);
	if (m_bStandard)
		((CButton*)GetDlgItem(IDC_CHECK_TITLE_LONG))->SetCheck(FALSE);

	UpdateTitle();
	UpdatePreview();
}

void CDrawingFrameDlg::OnBnClickedCheckTitleLong()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_TITLE_LONG, m_bLong);

	if (m_bLong)
	{
		((CButton*)GetDlgItem(IDC_CHECK_TITLE_STANDARD))->SetCheck(FALSE);

		// sg add 100916，保证通长标题栏正确
		GetLongTitleBlkName();
	}

	UpdateTitle();
	UpdatePreview();
}

void CDrawingFrameDlg::OnBnClickedCheckTicket()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_TICKET, m_bTicket);
	
	// sg modify 100916，专版，根据需要控制控件是否显示
	if (m_lstOfficeInfo.Length() > 0)
	{
		// 只要是专版，会签有无，会签的控件是否可用，只取决于XML
		GetDlgItem(IDC_BUTTON_PICKTICKET)->EnableWindow(m_bDefaultTicket && !m_bDirect && m_bTicket);
	}
	else
	{
		GetDlgItem(IDC_BUTTON_PICKTICKET)->EnableWindow(m_bTicket);
	}
	UpdatePreview();
}

void CDrawingFrameDlg::OnBnClickedCheckAdjunct()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_ADJUNCT, m_bAdjunct);
	// sg modify 100916，专版，根据需要控制控件是否显示
	if (m_lstOfficeInfo.Length() > 0)
	{
		GetDlgItem(IDC_BUTTON_PICKADJUNCT)->EnableWindow(m_bDefaultAdjunct && !m_bDirect && m_bAdjunct);
	}
	else
	{
		GetDlgItem(IDC_BUTTON_PICKADJUNCT)->EnableWindow(m_bAdjunct);
	}
	UpdatePreview();
}

// 通长标题栏对齐
void CDrawingFrameDlg::OnBnClickedCheckPosition()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_POSITION, m_bPosition);
	UpdatePreview();
}

// 附件栏选择
void CDrawingFrameDlg::OnBnClickedButtonPickadjunct()
{
	GetBlockName(m_strAdjunct);
	UpdatePreview();
}

// 会签栏选择
void CDrawingFrameDlg::OnBnClickedButtonPickticket()
{
	GetBlockName(m_strTichet);
	UpdatePreview();
}

// 标题栏选择
void CDrawingFrameDlg::OnBnClickedButtonPicktitle()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_TITLE_STANDARD, m_bStandard);

	if (m_bStandard)
		GetBlockName(m_strStandard);
	else
		GetBlockName(m_strLong);

	UpdatePreview();
}

// 图框选择
void CDrawingFrameDlg::OnBnClickedButtonPickdirect()
{
	GetBlockName(m_strDirect);
	double dwidth(0.0), dhigh(0.0);
	GetBlockSize(m_strDirect, dwidth, dhigh);
	m_strLength.Format(_T("%.0f"), dwidth);
	m_strWidth.Format(_T("%.0f"), dhigh);
	UpdateSize(FALSE);
	UpdatePreview();
}

// 比例尺
void CDrawingFrameDlg::OnCbnKillfocusComboScale()
{
	CDataExchange dx(this, true);
	DDX_CBString(&dx, IDC_COMBO_SCALE, m_strScale);
}

// 空间转换
void CDrawingFrameDlg::OnBnClickedCheckSpace()
{
	UpdateSpace();
	UpdatePreview();
}

// 直接插入图框
void CDrawingFrameDlg::OnBnClickedCheckDirect()
{
	UpdateDirect();
	if (!m_bDirect)
	{
		if(m_iCustomSize < 0)
		{
			SetSizeEdit(m_iStandard, m_colLenthen.GetCurSel());
		}
		else
		{
			CString string;
			m_colCustomSize.GetLBText(m_iCustomSize, string);
			int iPosi = string.Find(_T("*"));
			int iLen = string.GetLength();
			if(iPosi > 0)
			{
				m_colLenthen.SetCurSel(-1);
				m_strLength = string.Left(iPosi);
				m_strWidth = string.Right(iLen-iPosi-1);
			}
		}
	}
	else
	{
		double dwidth(0.0), dhigh(0.0);
		GetBlockSize(m_strDirect, dwidth, dhigh);
		m_strLength.Format(_T("%.0f"), dwidth);
		m_strWidth.Format(_T("%.0f"), dhigh);
	}
	UpdateSize(FALSE);
	UpdatePreview();
}

// 刷新尺寸
void CDrawingFrameDlg::UpdateSize(BOOL bSaveAndValidate)
{
	CDataExchange dx(this, bSaveAndValidate);
	DDX_Text(&dx, IDC_EDIT_LENGTH, m_strLength);
	DDX_Text(&dx, IDC_EDIT_WIDTH, m_strWidth);
}

// 刷新图栏
void CDrawingFrameDlg::UpdateTitle()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_TITLE_STANDARD, m_bStandard);
	DDX_Check(&dx, IDC_CHECK_TITLE_LONG, m_bLong);

	// sg modify 100916，专版，根据需要控制控件是否显示
	if (m_lstOfficeInfo.Length() > 0)
	{
		GetDlgItem(IDC_CHECK_ADJUNCT)->EnableWindow(m_bDefaultAdjunct && m_bLong);
		GetDlgItem(IDC_BUTTON_PICKADJUNCT)->EnableWindow(m_bDefaultAdjunct && m_bLong && m_bAdjunct);
		GetDlgItem(IDC_CHECK_POSITION)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_CHECK_ADJUNCT)->EnableWindow(m_bLong);
		GetDlgItem(IDC_BUTTON_PICKADJUNCT)->EnableWindow(m_bLong && m_bAdjunct);
		GetDlgItem(IDC_CHECK_POSITION)->EnableWindow(m_bLong);
	}
	GetDlgItem(IDC_BUTTON_PICKTITLE)->EnableWindow(m_bStandard || m_bLong);
}

// 刷新空间
void CDrawingFrameDlg::UpdateSpace()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_SPACE, m_bSpace);
  	if (m_bSpace)
	{
		GetDlgItem(IDC_COMBO_SCALE)->SetWindowText(_T("1"));
		xg_setvar(_T("TILEMODE"), 0);
		int cvport=1;
		VERIFY(xg_getvar(_T("CVPORT"), &cvport)==RTNORM);
		if (cvport!=1)
			PSpace();
	}
	else
	{
		GetDlgItem(IDC_COMBO_SCALE)->SetWindowText(m_strScale);
		xg_setvar(_T("TILEMODE"), 1);
	}
	GetDlgItem(IDC_COMBO_SCALE)->EnableWindow(!m_bSpace);
}

// 刷新直接插图框
void CDrawingFrameDlg::UpdateDirect()
{
	CDataExchange dx(this, true);
	DDX_Check(&dx, IDC_CHECK_DIRECT, m_bDirect);

	GetDlgItem(IDC_RADIO_A0)->EnableWindow(!m_bDirect && m_bA0);
	GetDlgItem(IDC_RADIO_A1)->EnableWindow(!m_bDirect && m_bA1);
	GetDlgItem(IDC_RADIO_A2)->EnableWindow(!m_bDirect && m_bA2);
	GetDlgItem(IDC_RADIO_A3)->EnableWindow(!m_bDirect && m_bA3);
	GetDlgItem(IDC_RADIO_A4)->EnableWindow(!m_bDirect && m_bA4);

	GetDlgItem(IDC_RADIO_ROW)->EnableWindow(!m_bDirect);

	((CEdit *)GetDlgItem(IDC_EDIT_LENGTH))->SetReadOnly(m_bDirect);
	((CEdit *)GetDlgItem(IDC_EDIT_WIDTH))->SetReadOnly(m_bDirect);

	GetDlgItem(IDC_COMBO_LENGTHEN)->EnableWindow(!m_bDirect);
	GetDlgItem(IDC_COMBO_CUSTOMSIZE)->EnableWindow(!m_bDirect);

	GetDlgItem(IDC_BUTTON_PICKDIRECT)->EnableWindow(m_bDirect);
	GetDlgItem(IDC_CHECK_TITLE_LONG)->EnableWindow(!m_bDirect);

	// sg modify 100916，专版，根据需要控制控件是否显示
	if (m_lstOfficeInfo.Length() > 0)
	{	
		GetDlgItem(IDC_RADIO_RANGE)->EnableWindow(m_bRANGE && !m_bDirect); // 立式
		GetDlgItem(IDC_CHECK_TITLE_STANDARD)->EnableWindow(FALSE);
		// 只要是专版，会签有无，会签的控件是否可用，只取决于XML
		GetDlgItem(IDC_CHECK_TICKET)->EnableWindow(m_bDefaultTicket && !m_bDirect);
		GetDlgItem(IDC_BUTTON_PICKTICKET)->EnableWindow(m_bDefaultTicket && !m_bDirect && m_bTicket);

		GetDlgItem(IDC_CHECK_ADJUNCT)->EnableWindow(m_bDefaultAdjunct && !m_bDirect);
		GetDlgItem(IDC_BUTTON_PICKADJUNCT)->EnableWindow(m_bDefaultAdjunct && !m_bDirect && m_bAdjunct);

		GetDlgItem(IDC_CHECK_POSITION)->EnableWindow(FALSE);
	}
	else // 标准版
	{
		GetDlgItem(IDC_RADIO_RANGE)->EnableWindow(!m_bDirect);
		GetDlgItem(IDC_CHECK_TITLE_STANDARD)->EnableWindow(!m_bDirect);
		GetDlgItem(IDC_CHECK_TICKET)->EnableWindow(!m_bDirect);
	
		GetDlgItem(IDC_CHECK_ADJUNCT)->EnableWindow(!m_bDirect && m_bLong);
		GetDlgItem(IDC_CHECK_POSITION)->EnableWindow(!m_bDirect && m_bLong);
		
		GetDlgItem(IDC_BUTTON_PICKADJUNCT)->EnableWindow(!m_bDirect && m_bLong && m_bAdjunct);
		GetDlgItem(IDC_BUTTON_PICKTICKET)->EnableWindow(!m_bDirect && m_bTicket);
	}
	
	GetDlgItem(IDC_BUTTON_PICKTITLE)->EnableWindow(!m_bDirect && (m_bLong || m_bStandard));
}

// 刷新图栏加长combobox
void CDrawingFrameDlg::UpdateLengthen()
{
	int type = m_iStandard;
	m_colLenthen.ResetContent();

	DRAWFRAME::PAGEGRPS::const_iterator it = g_pagegrp.begin();
	std::advance(it, type);
	for (int i = 0; i < it->_pages.size(); ++i)
	{
		m_colLenthen.AddString(it->_pages.at(i)._pagename);
	}
	m_colLenthen.SetCurSel(m_iLengthen);
}

void CDrawingFrameDlg::UpdateStandard(BOOL bSaveAndValidate)
{
	switch(m_iStandard)
	{
	case 0 :
		((CButton*)GetDlgItem(IDC_RADIO_A0))->SetCheck(bSaveAndValidate);
		break;
	case 1 :
		((CButton*)GetDlgItem(IDC_RADIO_A1))->SetCheck(bSaveAndValidate);
		break;
	case 2 :
		((CButton*)GetDlgItem(IDC_RADIO_A2))->SetCheck(bSaveAndValidate);
		break;
	case 3 :
		((CButton*)GetDlgItem(IDC_RADIO_A3))->SetCheck(bSaveAndValidate);
		break;
	case 4 :
		((CButton*)GetDlgItem(IDC_RADIO_A4))->SetCheck(bSaveAndValidate);
		break;
	}
}

// 获得尺寸
void CDrawingFrameDlg::SetSizeEdit(int type, int curSel)
{
	if (type < 0 || type > 4) return;

	double len = 1189;
	double wid = 841;

	DRAWFRAME::PAGEGRPS::const_iterator it = g_pagegrp.begin();
	std::advance(it, type);

	const DRAWFRAME::PAGES &pages = it->_pages;
	if (curSel >= pages.size()) return;

	wid = pages[curSel]._width;
	len = pages[curSel]._length;

	m_strLength.Format(_T("%.0f"), len);
	m_strWidth.Format(_T("%.0f"), wid);
	UpdateSize();
}

// 获得块名
BOOL CDrawingFrameDlg::GetBlockName(XString &sBlockName)
{
	BeginEditorCommand();
	XString sLibFile;
	CString path = g_sDwbPath;
	sLibFile << path << _T("Titleframe.TKW");
	if(!InvokeTkwMan(sLibFile, TRUE, sBlockName)) {
		CompleteEditorCommand();

		UpdateData(FALSE);
		
		//modify by xlc on 07/05/09(图框比例显示不正确)
		SetDlgItemText(IDC_COMBO_SCALE, m_strScale);

		return FALSE;
	}

	CompleteEditorCommand();
	return TRUE;
}
//wlw 150327查找块中是否有solid填充，09下gsveiw崩溃
BOOL HasSolidFromBlk(AcDbObjectId idBlock)
{
	TADSGePoint3d ptMin, ptMax;
	OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	ASSERT(pBlock);

	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = pBlock->newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
	ASSERT(es == Acad::eOk && pBlockIterator);
	for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step()) 
	{
		AcDbEntity *pEntity = NULL;
		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
		ASSERT(es == Acad::eOk);
		TAcDbObjectPtr obj(pEntity);
		TADSGePoint3d pt1, pt2;
		if (pEntity->isKindOf(AcDbHatch::desc()))
		{
			CString ssolid = ((AcDbHatch*)pEntity)->patternName();
			if (ssolid = _T("SOLID"))
			{
				delete pBlockIterator;
				return TRUE;
			}
		}
		else if (pEntity->isKindOf(AcDbBlockReference::desc())) 
		{
			AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEntity);
			if (HasSolidFromBlk(pInsert->blockTableRecord()))
			{
				delete pBlockIterator;
				return TRUE;
			}
		}
	}
	delete pBlockIterator;
	OPENOBJ_END();

	return FALSE;
}


// 刷新预览图
void CDrawingFrameDlg::UpdatePreview()
{
    m_PreviewCtrl.clearAll();
    m_PreviewCtrl.init(true);

	AcDbBlockTableRecord *pBTRecord = NULL;
	if(acdbOpenObject(pBTRecord, m_idOldBlock, AcDb::kForWrite) == Acad::eOk)
	{
		pBTRecord->erase();
		pBTRecord->close();
	}

	AcDbBlockTable *pBlockTab = NULL;
	if (m_PreviewDb.getSymbolTable(pBlockTab, AcDb::kForWrite)!=Acad::eOk)
		return;
	
	AcDbBlockTableRecord *pBlockTabRecord = new AcDbBlockTableRecord;
	pBlockTabRecord->setName(_T("*U"));
	pBlockTab->add(m_idOldBlock, pBlockTabRecord);
	pBlockTab->close();

	AcGePoint3d ptIns(0,0,0);
	double width(0.0), high(0.0);
	if (m_bDirect)
		//InsertFrame(pBlockTabRecord, ptIns, width, high); wlw mod2015.02.11 该代码无法实现批量入库时的正确预览
	{
#if ADS<18
		AcDbObjectId idLayer = InitLayer(LAY_BORDER);
#else
		AcDbObjectId idLayer = InitLayer(LAY_BORDER,m_bPreview?&m_PreviewDb:acdbCurDwg());
#endif

		if (g_nAcadVer >17.11 && g_nAcadVer < 17.21)
		{//wlw 150327查找块中是否有solid填充，09下gsveiw崩溃
			XString sBlock;
			if (LoadDwbBlock(m_strDirect,sBlock)!=RTNORM)
				return;
			AcDbObjectId BlockId = InitBlock(sBlock);
			if (HasSolidFromBlk(BlockId))
				return;
		}

		XString sBlock;
		if (LoadDwbBlock(m_strDirect,sBlock,&m_PreviewDb)!=RTNORM)
			return;

		AcDbObjectId BlockId = InitBlock(sBlock,&m_PreviewDb);
		AcDbBlockReference *pBlockRef = new AcDbBlockReference;
		pBlockRef->setBlockTableRecord(BlockId);
		pBlockRef->setPosition(ptIns);
		pBlockRef->setRotation(0);
		pBlockRef->setLayer(idLayer);
		Acad::ErrorStatus es=pBlockTabRecord->appendAcDbEntity(AcDbObjectId(), pBlockRef);

		AcDbExtents extents;

		pBlockRef->getGeomExtents(extents);

		ptIns.x = (extents.maxPoint().x + extents.minPoint().x) * .5;
		ptIns.y = (extents.maxPoint().y + extents.minPoint().y) * .5;

		width = extents.maxPoint().x - extents.minPoint().x + 20;
		high = extents.maxPoint().y - extents.minPoint().y + 20;
		if (es == Acad::eOk)
			pBlockRef->close();
		else
		{
			delete pBlockRef;
		}
	}
	else
	{
		DrawFrame(pBlockTabRecord, ptIns, width, high);
	}
	AcGePoint3d target = ptIns;
	AcGePoint3d position(target.x, target.y, 1);
	m_PreviewCtrl.view()->setView(position, target, AcGeVector3d(0, 1, 0), width, high); 
	m_PreviewCtrl.view()->add(pBlockTabRecord,m_PreviewCtrl.model()); 
	pBlockTabRecord->close();

    m_PreviewCtrl.Invalidate();
}

CString CDrawingFrameDlg::GetSizeDesc()//...
{
	double dWid = _tstof(m_strWidth);
	double dLen = _tstof(m_strLength);
	DRAWFRAME::PAGEGRPS::const_iterator grpit = g_pagegrp.begin();
	for (; grpit != g_pagegrp.end(); ++grpit)
	{
		const DRAWFRAME::PAGES &pages = grpit->_pages;
		DRAWFRAME::PAGES::const_iterator pageit = pages.begin();
		for (; pageit != pages.end(); ++pageit)
		{
			const DRAWFRAME::STPage &page = *pageit;
			if (fabs(dWid - page._width) < 1.0E-6 && fabs(dLen - page._length) < 1.0E-6)
				return page._pagename;
		}
	}
	CString szSize = m_strLength + _T("*") + m_strWidth;
	return szSize;
}

// 直接插入图框
void CDrawingFrameDlg::InsertFrame(AcDbBlockTableRecord *pBlockTabRecord, AcGePoint3d ptIns, 
								   double &width, double &high)
{
	//modify by xlc on 090917  解决2010平台预览显示不出来的问题
#if ADS<18
	AcDbObjectId idLayer = InitLayer(LAY_BORDER);
#else
	AcDbObjectId idLayer = InitLayer(LAY_BORDER,m_bPreview?&m_PreviewDb:acdbCurDwg());
#endif

	double dwidth = _tstof(m_strLength);
	double dhigh = _tstof(m_strWidth);
	AcGePoint3d ptLowRight;
	ptLowRight.x = ptIns.x + 0.5 * dwidth;
	ptLowRight.y = ptIns.y - 0.5 * dhigh;
	width = dwidth + 25;
	high = dhigh + 25;
	InsertBlock(pBlockTabRecord, m_strDirect, ptLowRight, 0, idLayer);
	if (!m_bPreview)
	{
		Entity ent;
		ent.GetLast();
		SaveFrameSize(ent,GetSizeDesc());
	}
	else
	{
		m_strLength.Format(_T("%.0f"), dwidth);
		m_strWidth.Format(_T("%.0f"), dhigh);
	}
}

// 绘制图框
void CDrawingFrameDlg::DrawFrame(AcDbBlockTableRecord *pBlockTabRecord, AcGePoint3d ptIns, 
								 double &width, double &high, int flag)
{
	//modify by xlc on 090917  解决2010平台预览显示不出来的问题
#if ADS<18
	AcDbObjectId idLayer = InitLayer(LAY_BORDER);
#else
	AcDbObjectId idLayer = InitLayer(LAY_BORDER,m_bPreview?&m_PreviewDb:acdbCurDwg());
#endif


	double widthOut;
	double highOut;
	if (m_iRow == 0)
	{
		widthOut = _tstof(m_strLength);
		highOut = _tstof(m_strWidth);
	}
	else
	{
		widthOut = _tstof(m_strWidth);
		highOut = _tstof(m_strLength);
	}
	XPoint ptCenOut = ptIns;
	XRectAngle boxOut(ptCenOut, widthOut, highOut);
	AcDbPolyline *plineOut = new AcDbPolyline;
	plineOut->addVertexAt(0, boxOut.GetLowLeft().AsAcGePoint2d());
	plineOut->addVertexAt(1, boxOut.GetLowRight().AsAcGePoint2d());
	plineOut->addVertexAt(2, boxOut.GetUpRight().AsAcGePoint2d());
	plineOut->addVertexAt(3, boxOut.GetUpLeft().AsAcGePoint2d());
	plineOut->setClosed(Adesk::kTrue);
	if (flag == 0)
		plineOut->setConstantWidth(0.0);
	plineOut->setLayer(idLayer);
	Acad::ErrorStatus es=pBlockTabRecord->appendAcDbEntity(AcDbObjectId(), plineOut);
	if (es == Acad::eOk)
		plineOut->close();
	else
	{
		delete plineOut;
	}

	double dEdge1 = 25;
	double dEdge2 = 10;
	if (m_iStandard == 3 || m_iStandard == 4)
		dEdge2 = 5;

	double widthIn;
	double highIn;
	XPoint ptCenIn;
	if (m_iRow == 0)
	{
		widthIn = widthOut - dEdge1 - dEdge2;
		highIn = highOut - 2 * dEdge2;
		ptCenIn.x = ptCenOut.x + 0.5 * (dEdge1 - dEdge2);
		ptCenIn.y = ptCenOut.y;
	}
	else
	{
		widthIn = widthOut - 2 * dEdge2;
		highIn = highOut - dEdge1 - dEdge2;
		ptCenIn.x = ptCenOut.x;
		ptCenIn.y = ptCenOut.y - 0.5 * (dEdge1 - dEdge2);
	}

	XRectAngle boxIn(ptCenIn, widthIn, highIn);
	AcDbPolyline *plineIn = new AcDbPolyline;
	plineIn->addVertexAt(0, boxIn.GetLowLeft().AsAcGePoint2d());
	plineIn->addVertexAt(1, boxIn.GetLowRight().AsAcGePoint2d());
	plineIn->addVertexAt(2, boxIn.GetUpRight().AsAcGePoint2d());
	plineIn->addVertexAt(3, boxIn.GetUpLeft().AsAcGePoint2d());
	plineIn->setClosed(Adesk::kTrue);
	if (flag==0)
	{
		// sg modify 111021，在专版软件中，根据图幅支持设置图框的线宽
		if (m_lstOfficeInfo.Length()>0 && m_aryFrameWidth.length()==5)
		{
			double dWidth = m_aryFrameWidth.at(m_iStandard);
			plineIn->setConstantWidth(dWidth);
		}
		else // 标准版，或者图幅宽度信息不够
		{
			plineIn->setConstantWidth(1.0);
		}
	}

	plineIn->setLayer(idLayer);
	es = pBlockTabRecord->appendAcDbEntity(AcDbObjectId(), plineIn);
	if (es == Acad::eOk)
		plineIn->close();
	else
	{
		delete plineIn;
	}

	width = widthOut + dEdge1;
	high = highOut + dEdge1;

	// 会签栏
	// sg modify 111014，如果是专版，根据XML确定是否绘制会签，m_bDefaultTicket值只从XML文件中读取，用户不能通过对话来改，比较稳定
	//if (m_bTicket && m_strTichet.Length() > 0)
	if (m_bDefaultTicket && m_bTicket && m_strTichet.Length() > 0)
	{
		AcGePoint3d ptTichet = boxIn.GetUpLeft().AsAcGePoint3d();
		double angle = PI/2;
		if (m_iRow == 1)
		{
			ptTichet = boxIn.GetUpRight().AsAcGePoint3d();
			angle = 0;
		}
		if (flag == 1)
		{
			InsertBlock(pBlockTabRecord, m_strTichet, ptTichet, angle, idLayer);
			DrawInsertPoint(pBlockTabRecord, ptTichet);
		}
	}

	// 标准标题栏
	if (m_bStandard && m_strStandard.Length() > 0)
	{
		AcGePoint3d ptTitle = boxIn.GetLowRight().AsAcGePoint3d(); 
		if (flag == 1)
		{
			InsertBlock(pBlockTabRecord, m_strStandard, ptTitle, 0, idLayer);
			DrawInsertPoint(pBlockTabRecord, ptTitle);
		}
	}
	// 通长标题栏
	if (m_bLong && m_strLong.Length() > 0)
	{
		AcGePoint3d ptLowRight = boxIn.GetLowRight().AsAcGePoint3d();
		double dwidth = 0.0;
		double dhigh = 0.0;
		GetBlockSize(m_strLong, dwidth, dhigh);
		AcGePoint2d ptSta, ptEnd;
		if (dwidth > dhigh)
		{
			ptSta.x = ptLowRight.x;
			ptSta.y = ptLowRight.y + dhigh;
			ptEnd.x = ptLowRight.x - widthIn;
			ptEnd.y = ptLowRight.y + dhigh;
		}
		else
		{
			ptSta.x = ptLowRight.x - dwidth;
			ptSta.y = ptLowRight.y;
			ptEnd.x = ptLowRight.x - dwidth;
			ptEnd.y = ptLowRight.y + highIn;
		}

		// sg add 111021，根据SR和HX的要求，以后在专版软件中，不再绘制这个竖线，在图块制作的时候，直接绘制粗线
		if (m_lstOfficeInfo.Length() < 1)
		{
			//AcDbLine *pline = new AcDbLine(ptSta, ptEnd);
			AcDbPolyline *pline=new AcDbPolyline;
			pline->addVertexAt(0,ptSta);
			pline->addVertexAt(1,ptEnd);
			pline->setLayer(idLayer);
			if (flag==0)
				pline->setConstantWidth(0.8);
			es = pBlockTabRecord->appendAcDbEntity(AcDbObjectId(), pline);
			if (es == Acad::eOk)
				pline->close();
			else
			{
				delete pline;
			}
		}

		// 通常横栏左对齐
		AcGePoint3d ptTitle = ptLowRight;
		if (dwidth > dhigh && !m_bPosition)
		{
			ptTitle.x -= widthIn - dwidth;
		}

		if (flag == 1)
		{
			InsertBlock(pBlockTabRecord, m_strLong, ptTitle, 0, idLayer);
			DrawInsertPoint(pBlockTabRecord, ptTitle);
		}

		// 附件栏
		if (m_bDefaultAdjunct && m_bAdjunct && m_strAdjunct.Length() > 0)
		{
			double dwidthAd = 0.0;
			double dhighAd = 0.0;
			GetBlockSize(m_strAdjunct, dwidthAd, dhighAd);
			AcGePoint3d ptAdjunct = ptLowRight;
			if (dwidth > dhigh)
			{
				if (m_bPosition)
					ptAdjunct.x -= widthIn - dwidthAd; 
			}
			else
				ptAdjunct.y += highIn - dhighAd;

			if (flag == 1)
			{
				InsertBlock(pBlockTabRecord, m_strAdjunct, ptAdjunct, 0, idLayer);
				DrawInsertPoint(pBlockTabRecord, ptAdjunct);
			}
		}
	}
}

// 绘制图框
void CDrawingFrameDlg::DrawFrameBlock(AcGePoint3d ptIns,double &width, double &high)
{
	//modify by xlc on 090917  解决2010平台预览显示不出来的问题
#if ADS<18
	AcDbObjectId idLayer = InitLayer(LAY_BORDER);
#else
	AcDbObjectId idLayer = InitLayer(LAY_BORDER,m_bPreview?&m_PreviewDb:acdbCurDwg());
#endif

	double widthOut;
	double highOut;
	if (m_iRow == 0)
	{
		widthOut = _tstof(m_strLength);
		highOut = _tstof(m_strWidth);
	}
	else
	{
		widthOut = _tstof(m_strWidth);
		highOut = _tstof(m_strLength);
	}
	XPoint ptCenOut = ptIns;
	XRectAngle boxOut(ptCenOut, widthOut, highOut);

	double dEdge1 = 25;
	double dEdge2 = 10;
	if (m_iStandard == 3 || m_iStandard == 4)
		dEdge2 = 5;

	double widthIn;
	double highIn;
	XPoint ptCenIn;
	if (m_iRow == 0)
	{
		widthIn = widthOut - dEdge1 - dEdge2;
		highIn = highOut - 2 * dEdge2;
		ptCenIn.x = ptCenOut.x + 0.5 * (dEdge1 - dEdge2);
		ptCenIn.y = ptCenOut.y;
	}
	else
	{
		widthIn = widthOut - 2 * dEdge2;
		highIn = highOut - dEdge1 - dEdge2;
		ptCenIn.x = ptCenOut.x;
		ptCenIn.y = ptCenOut.y - 0.5 * (dEdge1 - dEdge2);
	}

	XRectAngle boxIn(ptCenIn, widthIn, highIn);


	width = widthOut + dEdge1;
	high = highOut + dEdge1;

	// sg add 111102，根据选择的下属院别，并返回对中标记图块名称
	XString szUpDownBlock, szLeftBlock, szRightBlock;
	if (GetMidAlignBlock(szUpDownBlock, szLeftBlock, szRightBlock))
	{
		XPoint ptMidBlockLoc;
		ptMidBlockLoc.x = ptCenOut.x;
		ptMidBlockLoc.y = ptCenOut.y + 0.5 * highOut;

		if (szUpDownBlock.Length() != 0)
			InsertBlock(NULL, szUpDownBlock, ptMidBlockLoc, 0, idLayer); // 上

		ptMidBlockLoc.y -= highOut;
		if (szUpDownBlock.Length() != 0)
			InsertBlock(NULL, szUpDownBlock, ptMidBlockLoc, PI, idLayer); // 下

		ptMidBlockLoc.x = ptCenOut.x - 0.5 * widthOut; 
		ptMidBlockLoc.y = ptCenOut.y;

		if (szLeftBlock.Length() != 0)
			InsertBlock(NULL, szLeftBlock, ptMidBlockLoc, 0, idLayer); // 左

		ptMidBlockLoc.x += widthOut; 

		if (szRightBlock.Length() != 0)
		{
			if (_tcsicmp(szRightBlock, szUpDownBlock) == 0) // 对“上下图块”和“右图块”的名字进行判断，如果是一个名的话，说明是一个块，需要转一个角度
			{
				InsertBlock(NULL, szRightBlock, ptMidBlockLoc, PI*1.5, idLayer); // 右
			}
			else // 如果不是一个块的话，直接输出，不需要转换角度
			{
				InsertBlock(NULL, szRightBlock, ptMidBlockLoc, 0, idLayer); // 右
			}
		}
	}

	// 会签栏
	// sg modify 111014，如果是专版，根据XML确定是否绘制会签，m_bDefaultTicket值只从XML文件中读取，用户不能通过对话来改，比较稳定
	//if (m_bTicket && m_strTichet.Length() > 0)
	if (m_bDefaultTicket && m_bTicket && m_strTichet.Length() > 0)
	{
		AcGePoint3d ptTichet = boxIn.GetUpLeft().AsAcGePoint3d();
		double angle = PI/2;
		if (m_iRow == 1)
		{
			ptTichet = boxIn.GetUpRight().AsAcGePoint3d();
			angle = 0;
		}
		InsertBlock(NULL, m_strTichet, ptTichet, angle, idLayer);
	}

	// 标准标题栏
	if (m_bStandard && m_strStandard.Length() > 0)
	{
		AcGePoint3d ptTitle = boxIn.GetLowRight().AsAcGePoint3d(); 
		InsertBlock(NULL, m_strStandard, ptTitle, 0, idLayer);
		Entity ent;
		ent.GetLast();
		SaveFrameSize(ent,GetSizeDesc());
	}
	// 通长标题栏
	if (m_bLong && m_strLong.Length() > 0)
	{
		AcGePoint3d ptLowRight = boxIn.GetLowRight().AsAcGePoint3d();
		double dwidth = 0.0;
		double dhigh = 0.0;
		GetBlockSize(m_strLong, dwidth, dhigh);
		AcGePoint2d ptSta, ptEnd;
		if (dwidth > dhigh)
		{
			ptSta.x = ptLowRight.x;
			ptSta.y = ptLowRight.y + dhigh;
			ptEnd.x = ptLowRight.x - widthIn;
			ptEnd.y = ptLowRight.y + dhigh;
		}
		else
		{
			ptSta.x = ptLowRight.x - dwidth;
			ptSta.y = ptLowRight.y;
			ptEnd.x = ptLowRight.x - dwidth;
			ptEnd.y = ptLowRight.y + highIn;
		}

		// 通常横栏左对齐
		AcGePoint3d ptTitle = ptLowRight;
		if (dwidth > dhigh && !m_bPosition)
		{
			ptTitle.x -= widthIn - dwidth;
		}

		InsertBlock(NULL, m_strLong, ptTitle, 0, idLayer);
		Entity ent;
		ent.GetLast();
		SaveFrameSize(ent,GetSizeDesc());

		// 附件栏
		if (m_bAdjunct && m_strAdjunct.Length() > 0)
		{
			double dwidthAd = 0.0;
			double dhighAd = 0.0;
			GetBlockSize(m_strAdjunct, dwidthAd, dhighAd);
			AcGePoint3d ptAdjunct = ptLowRight;
			if (dwidth > dhigh)
			{
				if (m_bPosition)
					ptAdjunct.x -= widthIn - dwidthAd; 
			}
			else
				ptAdjunct.y += highIn - dhighAd;

			InsertBlock(NULL, m_strAdjunct, ptAdjunct, 0, idLayer);
		}
	}
}

void CDrawingFrameDlg::DrawInsertPoint(AcDbBlockTableRecord *pBlockTabRecord, AcGePoint3d ptIns)
{
	double dLen = 8;
	AcGePoint3d ptLowLeft, ptLowRight, ptUpRight, ptUpLeft;
	ptLowLeft.x = ptIns.x - dLen;
	ptLowLeft.y = ptIns.y - dLen;
	ptLowRight.x = ptIns.x + dLen;
	ptLowRight.y = ptIns.y - dLen;
	ptUpRight.x = ptIns.x + dLen;
	ptUpRight.y = ptIns.y + dLen;
	ptUpLeft.x = ptIns.x - dLen;
	ptUpLeft.y = ptIns.y + dLen;
	AcDbLine *pline1 = new AcDbLine(ptLowLeft, ptUpRight);
	pline1->setColorIndex(1);
	pBlockTabRecord->appendAcDbEntity(AcDbObjectId(), pline1);
	pline1->close();
	AcDbLine *pline2 = new AcDbLine(ptLowRight, ptUpLeft);
	pline2->setColorIndex(1);
	pBlockTabRecord->appendAcDbEntity(AcDbObjectId(), pline2);
	pline2->close();
}

//模拟insert命令，可以处理属性
void NewInsertInCurrentSpace(AcDbObjectId idBlockRecord,AcGePoint3d ptIns,AcGeScale3d scale,double angle)
{
	AcDbBlockReference *pBlockRef = new AcDbBlockReference;
	pBlockRef->setBlockTableRecord(idBlockRecord);
	pBlockRef->setPosition(ptIns);
	pBlockRef->setScaleFactors(scale);
	pBlockRef->setRotation(angle);
	AddToCurrentSpace(pBlockRef,Adesk::kFalse);

	AcDbBlockTableRecord *pBlockRecord=NULL;
	acdbOpenObject(pBlockRecord,idBlockRecord,AcDb::kForRead);
	if (pBlockRecord!=NULL)
	{
		if (pBlockRecord->hasAttributeDefinitions())//有属性
		{
			AcDbBlockTableRecordIterator *pIter=NULL;
			pBlockRecord->newIterator(pIter);
			if (pIter!=NULL)
			{
				AcGeMatrix3d mat=pBlockRef->blockTransform();

				for(pIter->start();!pIter->done();pIter->step())
				{
					AcDbEntity *pEnt=NULL;
					pIter->getEntity(pEnt,AcDb::kForRead);
					if (pEnt!=NULL)
					{
						AcDbAttributeDefinition*pAttDef=AcDbAttributeDefinition::cast(pEnt);
						if (pAttDef!=NULL)
						{
							AcDbAttribute *pAttr=new AcDbAttribute;
							pAttr->setAttributeFromBlock(pAttDef,mat);
							pBlockRef->appendAttribute(pAttr);
							pAttr->close();
						}

						pEnt->close();
					}
				}

				delete pIter;
			}
		}
		pBlockRecord->close();
	}

	pBlockRef->close();
}

// 插入块
void CDrawingFrameDlg::InsertBlock(AcDbBlockTableRecord *pBlockTabRecord, XString sBlockName, 
								   AcGePoint3d ptIns, double angle, AcDbObjectId idLayer)
{
	if (sBlockName==_T(""))//add by whl on 070516
		return;

	AcDbObjectId BlockId;
	XString sBlock(256);
	if (m_bPreview)
	{
		if (LoadDwbBlock(sBlockName,sBlock,&m_PreviewDb)!=RTNORM)
			return;
	}
	else
	{
		if  (LoadDwbBlock(sBlockName, sBlock)!=RTNORM)
			return;
	}

	if (m_bPreview)
	{
		BlockId = InitBlock(sBlock,&m_PreviewDb);
		AcDbBlockReference *pBlockRef = new AcDbBlockReference;
		pBlockRef->setBlockTableRecord(BlockId);
		pBlockRef->setPosition(ptIns);
		pBlockRef->setRotation(angle);
		pBlockRef->setLayer(idLayer);
		Acad::ErrorStatus es=pBlockTabRecord->appendAcDbEntity(AcDbObjectId(), pBlockRef);
		if (es == Acad::eOk)
			pBlockRef->close();
		else
		{
			delete pBlockRef;
		}
	}
	else
	{
		XPushVarStr vTempLay(_T("CLAYER"),LAY_BORDER);
		extern TARCH_IMPEXP double g_nAcadVer;
		if (g_nAcadVer>17.11)//2009
			NewInsertInCurrentSpace(InitBlock(sBlock),ptIns,AcGeScale3d(1.0,1.0,1.0),angle);
		else//旧方法，会导致2009下DragMovePickset出问题（不动态移动）
		{
			XPushVar<int> vTemp(_T("OSMODE"),0);
			XPushVar<int> attreq(_T("ATTREQ"), 0); 
			XPoint ptBase(ptIns.x,ptIns.y,ptIns.z);
			ptBase=Wcs2Ucs(ptBase);
			ads_command(RTSTR, _T(".INSERT"), RTSTR, (const TCHAR *)sBlock, RT3DPOINT, &ptBase,
				RTREAL, 1.0, RTREAL, 1.0,RTREAL,(angle-Ucs2Wcs(0.0))*180/PI,RTNONE);
		}
	}
}

// 获得块尺寸
void CDrawingFrameDlg::GetBlockSize(XString sBlockName, double &width, double &high)
{
	if (sBlockName==_T(""))//add by whl on 070516
		return;

	AcDbObjectId BlockId;
	XString sBlock(256);
	if (m_bPreview)
	{
		if (LoadDwbBlock(sBlockName,sBlock,&m_PreviewDb)!=RTNORM)
			return;
	}
	else
	{
		if (LoadDwbBlock(sBlockName, sBlock)!=RTNORM)
			return;
	}
	BlockId = InitBlock(sBlock,m_bPreview?&m_PreviewDb:NULL);

	AcDbExtents ext;
	AcDbBlockReference blockRef;
	blockRef.setBlockTableRecord(BlockId);
	
	//modify by xlc on 081113 图框尺寸计算不准确
	//blockRef.geomExtentsBestFit(ext);
	blockRef.getGeomExtents(ext);

	AcGePoint3d maxPt, minPt;
	maxPt = ext.maxPoint();
	minPt = ext.minPoint();
	width = maxPt.x - minPt.x;
	high = maxPt.y - minPt.y;
}

BOOL CDrawingFrameDlg::DestroyWindow() 
{
    m_PreviewCtrl.clearAll();	
	return CAcUiDialog::DestroyWindow();
}

// 读入历史数据
void CDrawingFrameDlg::ReadStoreValue()
{
	CodeBase db;
	XString fullFile;
	if (!FindFile(_T("DataStore.dbf"), fullFile)){
		AfxMessageBox(_T("对不起，没有发现DataStore.dbf文件！"));
		return;
	}
	int Number;
	CString strType, strValue;
	CString remark;
	XDbfTable *pTable = db.Open(fullFile);
	if (pTable == NULL)
	{
		acutPrintf(_T("\n打开文件%s失败！\n"), fullFile);
		return;
	}

	pTable->MoveFirst();
	while(!pTable->IsEOF())
	{
		GET_FIELD(pTable, _T("TypeNumber"), Number);
		GET_FIELD(pTable, _T("TypeName"), strType);
		GET_FIELD(pTable, _T("TypeValue"), strValue);
		GET_FIELD(pTable, _T("REMARK"), remark);
		if (Number != 20)
		{
			pTable->MoveNext();
			continue;
		}

		strValue.TrimLeft();
		strValue.TrimRight();
		if (_tcscmp(strValue, _T("标准图幅")) == 0) 
			m_iStandard = _ttoi(remark);
		else if (_tcscmp(strValue, _T("加长图幅")) == 0) 
			m_iLengthen = _ttoi(remark);
		else if (_tcscmp(strValue, _T("横立式")) == 0) 
			m_iRow = _ttoi(remark);
		else if (_tcscmp(strValue, _T("图长")) == 0) 
			m_strLength = remark;
		else if (_tcscmp(strValue, _T("图宽")) == 0) 
			m_strWidth = remark;
		else if (_tcscmp(strValue, _T("标准标题栏")) == 0) 
		{
			int length = remark.GetLength();
			int position = remark.Find(_T("-"));
			m_bStandard = _ttoi(remark.Left(1));
			m_strStandard = remark.Right(length - position - 1);
		}
		else if (_tcscmp(strValue, _T("通长标题栏")) == 0)
		{
			int length = remark.GetLength();
			int position = remark.Find(_T("-"));
			m_bLong = _ttoi(remark.Left(1));
			m_strLong = remark.Right(length - position - 1);
		}
		else if (_tcscmp(strValue, _T("右对齐")) == 0) 
		{
			m_bPosition = _ttoi(remark);
		}
		else if (_tcscmp(strValue, _T("附件栏")) == 0) 
		{
			int length = remark.GetLength();
			int position = remark.Find(_T("-"));
			m_bAdjunct = _ttoi(remark.Left(1));
			m_strAdjunct = remark.Right(length - position - 1);
		}
		else if (_tcscmp(strValue, _T("会签栏")) == 0)
		{
			int length = remark.GetLength();
			int position = remark.Find(_T("-"));
			m_bTicket = _ttoi(remark.Left(1));
			m_strTichet = remark.Right(length - position - 1);
		}
		else if (_tcscmp(strValue, _T("直接插图框")) == 0)
		{
			int length = remark.GetLength();
			int position = remark.Find(_T("-"));
			m_bDirect = _ttoi(remark.Left(1));
			m_strDirect = remark.Right(length - position - 1);
		}
		else if (_tcscmp(strValue, _T("比例尺")) == 0) 
			m_strScale = remark;

		pTable->MoveNext();
	}

	// 自定义图幅
	if (pTable->MoveTo(_T("TypeValue"), _T("$当前自定义图框")))
		GET_FIELD(pTable, _T("REMARK"), m_iCustomSize);

	int iCount = 0;
	if (pTable->MoveTo(_T("TypeValue"), _T("$自定义图幅数")))
		GET_FIELD(pTable, _T("REMARK"), iCount);

	CString strCusValue, strCusRemark;
	for(long i=0; i<iCount; i++)
	{
		strCusValue.Format(_T("$自定义图框%d"), i); 
		if (pTable->MoveTo(_T("TypeValue"), strCusValue))
		{
			GET_FIELD(pTable, _T("REMARK"), strCusRemark);
			if (m_colCustomSize.FindString(-1, strCusRemark) == CB_ERR)
			{
				if (!strCusRemark.IsEmpty())
					m_colCustomSize.AddString(strCusRemark);
			}
		}
	}
	pTable->Close();
}

// 写出数据
void CDrawingFrameDlg::WriteStoreValue()
{
	CodeBase db;
	XString fullFile;
	if  (!FindFile(_T("DataStore.dbf"), fullFile)){
		AfxMessageBox(_T("对不起，没有发现DataStore.dbf文件！"));
		return;
	}
	int Number;
	CString strType, strValue;
	XDbfTable *pTable = db.Open(fullFile);
	if (pTable == NULL)
	{
		acutPrintf(_T("\n打开文件%s失败！"), fullFile);
		return;
	}

	pTable->MoveFirst();
	while(!pTable->IsEOF())
	{
		GET_FIELD(pTable, _T("TypeNumber"), Number);
		GET_FIELD(pTable, _T("TypeName"), strType);
		GET_FIELD(pTable, _T("TypeValue"), strValue);
		if (Number != 20)
		{
			pTable->MoveNext();
			continue;
		}

		CString str;
		strValue.TrimLeft();
		strValue.TrimRight();
		if (_tcscmp(strValue, _T("标准图幅")) == 0) 
		{
			SET_FIELD(pTable, _T("REMARK"), m_iStandard);
		}
		else if (_tcscmp(strValue, _T("加长图幅")) == 0) 
		{
			SET_FIELD(pTable, _T("REMARK"), m_iLengthen);
		}
		else if (_tcscmp(strValue, _T("横立式")) == 0) 
		{
			SET_FIELD(pTable, _T("REMARK"), m_iRow);
		}
		else if (_tcscmp(strValue, _T("图长")) == 0)
		{		
			SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) m_strLength);
		}
		else if (_tcscmp(strValue, _T("图宽")) == 0) 
		{
			SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) m_strWidth);
		}
		else if (_tcscmp(strValue, _T("标准标题栏")) == 0) 
		{
			str.Format(_T("%d-%s"), m_bStandard, m_strStandard);
			SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) str);
		}
		else if (_tcscmp(strValue, _T("通长标题栏")) == 0)
		{
			str.Format(_T("%d-%s"), m_bLong, m_strLong);
			SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) str);
		}
		else if (_tcscmp(strValue, _T("右对齐")) == 0) 
		{
			SET_FIELD(pTable, _T("REMARK"), m_bPosition);
		}
		else if (_tcscmp(strValue, _T("附件栏")) == 0) 
		{
			str.Format(_T("%d-%s"), m_bAdjunct, m_strAdjunct);
			SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) str);
		}
		else if (_tcscmp(strValue, _T("会签栏")) == 0)
		{
			str.Format(_T("%d-%s"), m_bTicket, m_strTichet);
			SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) str);
		}
		else if (_tcscmp(strValue, _T("直接插图框")) == 0)
		{
			str.Format(_T("%d-%s"), m_bDirect, m_strDirect);
			SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) str);
		}
		else if (_tcscmp(strValue, _T("比例尺")) == 0) 
		{
			if (!m_bSpace)
			{
				str.Format(_T("%s"), m_strScale);
				SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) str);
			}
		}

		pTable->MoveNext();
	}

	BOOL bWFlag = FALSE;
	BOOL bHFlag = FALSE;
	double wid = _tstof(m_strWidth);
	double len = _tstof(m_strLength);

	DRAWFRAME::PAGEGRPS::const_iterator grpit = g_pagegrp.begin();
	for (; grpit != g_pagegrp.end(); ++grpit)
	{
		if (fabs(wid - grpit->_width) < 1.0e-6)
		{
			bWFlag = TRUE;
			const DRAWFRAME::PAGES &pages = grpit->_pages;
			DRAWFRAME::PAGES::const_iterator pageit = pages.begin();
			for (; pageit != pages.end(); ++pageit)
			{
				const DRAWFRAME::STPage &page = *pageit;
				if (fabs(len - page._length) < 1.0E-6)
				{
					bHFlag = TRUE;
					break;
				}
			}
			break;
		}
	}
	
	long iCount = m_colCustomSize.GetCount();
	CString strCusValue, strCusRemark;
	strCusRemark.Format(_T("%s*%s"), m_strLength, m_strWidth);
	int iRet = m_colCustomSize.FindString(-1, strCusRemark);
	if (!bWFlag || !bHFlag)
	{
		if (iRet == CB_ERR)
		{
			m_colCustomSize.InsertString(0,strCusRemark);
			long count=min(10,m_colCustomSize.GetCount());
			if (pTable->MoveTo(_T("TypeValue"), _T("$自定义图幅数")))
				SET_FIELD(pTable, _T("REMARK"), count);
			for(long i=0;i<count;i++)
			{
				strCusValue.Format(_T("$自定义图框%d"), i);
				if (!pTable->MoveTo(_T("TypeValue"),strCusValue))
				{
					pTable->AppendEnd();
					pTable->MoveLast();
				}			
				CString temp;
				m_colCustomSize.GetLBText(i,temp);
				SET_FIELD(pTable, _T("TypeNumber"), 20);
				SET_FIELD(pTable, _T("TypeName"), _T("图框"));
				SET_FIELD(pTable, _T("TypeValue"), (const TCHAR*) strCusValue);
				SET_FIELD(pTable, _T("REMARK"), (const TCHAR*) temp);	
			}
			iRet=0;
		}

		if(pTable->MoveTo(_T("TypeValue"), _T("$当前自定义图框")))
			SET_FIELD(pTable, _T("REMARK"), iRet);
	}
	else
	{
		if (pTable->MoveTo(_T("TypeValue"), _T("$当前自定义图框")))
			SET_FIELD(pTable, _T("REMARK"), -1);
	}
	pTable->Close();
}

void CDrawingFrameDlg::OnOK()
{
	BeginEditorCommand();

	m_bPreview=false;
	CPoint ptCursor;
	XPoint ptIns;
	if (GetCursorPos(&ptCursor)) {
		acedGetAcadDwgView()->ScreenToClient(&ptCursor);
		acedCoordFromPixelToWorld(ptCursor, ptIns);
	}

	PickSet ss(SS_FREE);
	ss.IncludeBegin();

	double width, high;

	if (m_bDirect)
		InsertFrame(NULL, ptIns.AsAcGePoint3d(), width, high);
	else
	{
		AcDbBlockTable *pTable = NULL;
		acdbHostApplicationServices()->workingDatabase() 
			->getSymbolTable(pTable, AcDb::kForRead);
		AcDbBlockTableRecord *pTabRecord = NULL;
		pTable->getAt((m_bSpace)?ACDB_PAPER_SPACE:ACDB_MODEL_SPACE, pTabRecord, AcDb::kForWrite);
		pTable->close();
		DrawFrame(pTabRecord, ptIns.AsAcGePoint3d(), width, high, 0);
		pTabRecord->close();
		DrawFrameBlock(ptIns.AsAcGePoint3d(),width,high);
	}
	ss.IncludeEnd();

	//wlw 13.1.6 修改图框插入的点
	//if (m_bSpace)//图纸空间时基点在左下角
		ss.GetExtend(ptIns,XPoint());
		ptIns.z = 0.0;//wlw 14.6.17 修改图框插入的点为0标高

	ptIns = Wcs2Ucs(ptIns);
	{
		XPushVar<int> osmode(_T("OSMODE"), 0);
		// Zyu modify on 100721，支持64位
		//acedCommand(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ss, RTSTR, _T(""),
		//	RT3DPOINT, &ptIns, RTREAL, Ucs2Wcs(0.0)*180/PI, RTNONE);
		acedCommand(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
			RT3DPOINT, &ptIns, RTREAL, Ucs2Wcs(0.0)*180/PI, RTNONE);

		double scale = _tstof(m_strScale);
		if  (!m_bSpace && scale > 0.0)
		{
			// Zyu modify on 100721，支持64位
			//acedCommand(RTSTR, _T(".SCALE"), RTPICKS, (long *)ss, RTSTR, _T(""),
			//	RT3DPOINT, &ptIns, RTREAL, scale, RTNONE); 
			acedCommand(RTSTR, _T(".SCALE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
				RT3DPOINT, &ptIns, RTREAL, scale, RTNONE); 
		}
	}

	int nRet=RTNORM;
	if  (!m_bSpace)
	{
		//wlw 13.1.6 修改图框插入模式
		//nRet= DragMovePickSet(ss, _T("\n请点取插入位置<返回>: "), ptIns, XPoint());
		nRet= DragPickSet(ss, ptIns);
	}
	else
		nRet= DragMovePickSet(ss,_T("\n请点取插入位置或 [原点(Z)]<返回>:"),ptIns,XPoint(),_T("Z"));

	if (nRet == RTCAN) 
	{ 
		ss.Delete();
		CancelEditorCommand();
	}
	else if (nRet==RTNONE)
	{
		ss.Delete();
		CompleteEditorCommand();
	}
	else if (nRet==RTKWORD)//插在原点
	{
		// Zyu modify on 100721，支持64位
		//acedCommand(RTSTR,_T(".MOVE"),RTPICKS,(long*)ss,RTSTR,_T(""),RT3DPOINT,&ptIns,
		//	RT3DPOINT,&XPoint(),RTNONE);
		acedCommand(RTSTR,_T(".MOVE"),RTPICKS,(TLong_ptr *)ss,RTSTR,_T(""),RT3DPOINT,&ptIns,
			RT3DPOINT,&XPoint(),RTNONE);
		WriteStoreValue();
		CAcUiDialog::OnOK();
	}
	else
	{
		WriteStoreValue();
		CAcUiDialog::OnOK();
	} 

	m_bPreview=true;
}



void DrawingFrame()
{
	CAcModuleResourceOverride vTemp;
	CDrawingFrameDlg dlg;
	dlg.DoModal();
}


//////////////////////////////////////////////////////////////////////////

#define NODE_GROUP _T("GROUP")
#define NODE_PAGE _T("PAGE")
#define ATTR_NAME _T("name")
#define ATTR_IDX _T("idx")
#define ATTR_WIDTH _T("width")
#define ATTR_LENGTH _T("length")


static int init_func()
{
	DRAWFRAME::InitPageGrp();
	return 1;
}

void DRAWFRAME::default_init_func()
{
	DRAWFRAME::PAGES pages;
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0"),		841, 1189));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+1/8"),	841, 1338));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+1/4"),	841, 1486));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+3/8"),	841, 1635));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+1/2"),	841, 1783));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+5/8"),	841, 1932));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+3/4"),	841, 2080));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+7/8"),	841, 2230));
	pages.push_back(DRAWFRAME::STPage(_T("A0"), _T("A0+1"),		841, 2378));
	g_pagegrp.insert(DRAWFRAME::STPageGrp(1, _T("A0"), 841, pages));
	pages.clear();

	
	pages.push_back(DRAWFRAME::STPage(_T("A1"), _T("A1"),		594, 841));
	pages.push_back(DRAWFRAME::STPage(_T("A1"), _T("A1+1/4"),	594, 1051));
	pages.push_back(DRAWFRAME::STPage(_T("A1"), _T("A1+1/2"),	594, 1261));
	pages.push_back(DRAWFRAME::STPage(_T("A1"), _T("A1+3/4"),	594, 1471));
	pages.push_back(DRAWFRAME::STPage(_T("A1"), _T("A1+1"),		594, 1682));
	pages.push_back(DRAWFRAME::STPage(_T("A1"), _T("A1+5/4"),	594, 1892));
	pages.push_back(DRAWFRAME::STPage(_T("A1"), _T("A1+3/2"),	594, 2102));
	g_pagegrp.insert(DRAWFRAME::STPageGrp(2, _T("A1"), 594, pages));
	pages.clear();

	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2"),		420, 594));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+1/4"),	420, 743));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+1/2"),	420, 891));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+3/4"),	420, 1041));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+1"),		420, 1189));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+4/5"),	420, 1338));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+3/2"),	420, 1486));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+7/4"),	420, 1635));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+2"),		420, 1783));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+9/4"),	420, 1932));
	pages.push_back(DRAWFRAME::STPage(_T("A2"), _T("A2+5/2"),	420, 2080));
	g_pagegrp.insert(DRAWFRAME::STPageGrp(3, _T("A2"), 420, pages));
	pages.clear();

	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3"),		297, 420));
	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3+1/2"),	297, 630));
	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3+1"),		297, 841));
	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3+3/2"),	297, 1051));
	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3+2"),		297, 1261));
	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3+5/2"),	297, 1471));
	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3+3"),		297, 1682));
	pages.push_back(DRAWFRAME::STPage(_T("A3"), _T("A3+7/2"),	297, 1892));
	g_pagegrp.insert(DRAWFRAME::STPageGrp(4, _T("A3"), 297, pages));
	pages.clear();

	pages.push_back(DRAWFRAME::STPage(_T("A4"), _T("A4"),		210, 297));
	pages.push_back(DRAWFRAME::STPage(_T("A4"), _T("A4+1/2"),	210, 445));
	pages.push_back(DRAWFRAME::STPage(_T("A4"), _T("A4+1"),		210, 594));
	g_pagegrp.insert(DRAWFRAME::STPageGrp(5, _T("A4"), 210, pages));
	pages.clear();
}

static int g_init = init_func();

void DRAWFRAME::InitPageGrp()
{
	CString xmlpath = utility::getConfigFilePath(_T("ttitleframe.xml"));

	do 
	{
		CXMLDOMFile file;
		if (!file.Open(xmlpath)) break;
		
		CXMLDOMNodesPtr grpLst = file.GetNodesByTagName(NODE_GROUP);
		if (!grpLst.isvalid()) break;

		CXMLDOMNodesPtr pageLst;
		CXMLDOMNodePtr grpPtr, pagePtr;
		CString grpName(_T(""));
		TCHAR pbuf[256];
		int grpidx(-1), grpwidth(-1);
		DRAWFRAME::PAGES pages(0);
		DRAWFRAME::STPage page;
		DRAWFRAME::STPageGrp pagegrp;

		for (int i = 0; i < grpLst->GetCount(); ++i)
		{
			grpPtr = grpLst->GetItem(i);
			if (!grpPtr.isvalid()) continue;

			grpName = grpPtr->GetAttributeValue(ATTR_NAME);
			grpidx = _ttoi(grpPtr->GetAttributeValue(ATTR_IDX));
			grpwidth = _ttoi(grpPtr->GetAttributeValue(ATTR_WIDTH));

			pageLst = grpPtr->GetChildrenNodes(NODE_PAGE);
			if (!pageLst.isvalid()) continue;

			for (int j = 0; j < pageLst->GetCount(); ++j)
			{
				pagePtr = pageLst->GetItem(j);
				if (!pagePtr.isvalid()) continue;
				page._grpname = grpName;
				page._pagename = pagePtr->GetAttributeValue(ATTR_NAME);
				if (pagePtr->IsAttributeExist(ATTR_WIDTH))
					page._width = _ttoi(pagePtr->GetAttributeValue(ATTR_WIDTH));
				else
					page._width = grpwidth;
				page._length = _ttoi(pagePtr->GetAttributeValue(ATTR_LENGTH));
				pages.push_back(page);
			}
			g_pagegrp.insert(DRAWFRAME::STPageGrp(grpidx, grpName, grpwidth, pages));
			pages.clear();
		}
		return;
	} while (false);

	default_init_func();
}