#include "stdafx.h"
#include "resource.h"
#include "SlopeRoofDlg.h"

#include "SearchRangeDlg.h"
#include "buildingArea.h"
#include "rxregsvc.h"
#include "SpaceProperty.h"

#include "Inputpoly.h"
#define _SPACE_DIST_SNAP 0.1 // sg add 081208

// TARCH_IMPEXP void SearchSpace(PickSet &ssWalls,const DList<AcDbObjectId> &lstColu,DList<TDbSpace> &res);
#define AS_LAY2D(s) ((const TCHAR *)XString(_T("2D_%s"), (const TCHAR *)s))
extern TARCH_IMPEXP BOOL	g_bBlaconyHalf;
static ads_real nSanShuiDist = 600.0,
   nRoofDist = 600.0, nElevDiffDist = 0.0;
// [2/19/2008 nsh]
static double nElevMove = 24000.0;
//static double nElevDiff = 600.0;

void MakeWallSet(PickSet &ssWalls)
{
    if (!ssWalls)
        return;

    PickSet ssOpenings;
    ssOpenings += ssWalls;
    RBList maskOpening(RTDXF0,_T("TCH_OPENING"),NULL);
    ssOpenings.BaseFilter(maskOpening);
    ssWalls -= ssOpenings;

    long lCount=ssOpenings.Length();
    for(long idx=0L; idx<lCount; idx++)
	{
        Entity ent = ssOpenings[idx];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pWin);
        if (pWin)
		{
            AcDbObjectId idWall = pWin->GetWallId();
            if (!!idWall)
                ssWalls += idWall;
        }
        OPENOBJ_END();
    }
	
	//过滤隔断 add by fxj 090629
	PickSet ssDiv;
	for(long i=0;i<ssWalls.Length();i++)
	{
		Entity ent=ssWalls[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
		if (pWall)
		{
			if (pWall->GetStyle()==TWallData::kDivider&&pWall->GetUsageFlag()==TWallData::kApartment)
				ssDiv+=ent;

		}
		OPENOBJ_END();
	}
	ssWalls-=ssDiv;
}

// 自动把门窗所在的墙加进选择集中
void MakeWallSet1(PickSet &ssWalls)
{
    if (!ssWalls)
        return;

    PickSet ssOpenings;
    ssOpenings += ssWalls;
    RBList maskOpening(RTDXF0,_T("TCH_OPENING"),NULL);
    ssOpenings.BaseFilter(maskOpening);

    long lCount=ssOpenings.Length();
    for (long idx=0L; idx<lCount; idx++)
	{
        Entity ent = ssOpenings[idx];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pWin);
        if (pWin)
		{
            AcDbObjectId idWall = pWin->GetWallId();
            if (!!idWall)
                ssWalls += idWall;
        }
        OPENOBJ_END();
    }
}

//  屋顶线/散水/室内外高差
// nFlag:  0--屋顶;  1--散水; 2--室内外高差; 
int OffsetExtSpace(int nFlag)
{
	PickSet ssWalls(SS_FREE);
	//adsout << ;
	g_ssPickFirst.Free();
	if (SelectEntities(_T("\n请选择构成一完整建筑物的所有墙体(或门窗):"), ssWalls, RBList(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL,TCH_OPENING"), NULL))!=RTNORM)
		return RTNORM;
	MakeWallSet(ssWalls);
	
    DList<AcDbObjectId> lstColu;
    GetEntFromBlockByDxf(lstColu, _T("TCH_COLUMN"));
	
    XSearchSpaceFromWall aSearch;
    try {
        aSearch.InitStart(ssWalls, lstColu);
    }
	catch(...) {
        adsout << /*UMSG*/_T("\n发生例外情况!");
        return RTERROR;
    }

	XAecSpaceCell * extCell = aSearch.SearchSpaces();
	if (extCell)
	{
		aSearch.UpdateWallFlags();
		XPoly2D poly(1);
		extCell->InternalPoly2D(poly, 0, 0);

		// UCS to WCS
		XPoly2D polyShow(1);
		polyShow=poly;
		polyShow.TransUCS(Groups(0), Groups(1));
		polyShow.SetElevation(0);

		poly.SetElevation(0);
		
		XScreenDc dc(1,1);
		dc << polyShow;
		double &nDist=nFlag==1? nSanShuiDist : (nFlag==0? nRoofDist : nElevDiffDist);
		int nRet = GetDist(_T("\n偏移外皮距离"), nDist);
		if (nRet==RTNORM || nRet==RTNONE)
		{
			XPoly2D dest(1);
			poly.Compress();
			if (poly.PathArea()>0.0) //顺时针的Poly
				poly.Reverse(); //nDist = -nDist;
			if (fabs(nDist)<_DIST_SNAP)
				dest=poly;
			// sg modify 110117，解决生成屋顶线产生自交的错误问题
			// if (fabs(nDist)<_DIST_SNAP ||
			// 	poly.Offset(nDist, dest)==RTNORM)
			if (fabs(nDist)<_DIST_SNAP ||
				poly.QuickOffset(nDist, dest)==RTNORM)
			{
				if (nFlag==2) { // 室内外高差
					double nElevDiff=DocGetElevDiff();
					if (GetDist(_T("\n室内外高差"), nElevDiff, RSG_NONEG|RSG_NOZERO)!=RTCAN) {
                        TDbSlab *pSlab=new TDbSlab;
                        pSlab->SetOutline(dest);
                        pSlab->SetThickness(-nElevDiff);
                        pSlab->SetVisibilityAll(FALSE);
                        pSlab->setLayer(InitLayer(LAY_GROUND, FALSE));
                        AddToModelSpace(pSlab, Adesk::kTrue);
					}
					DocSetElevDiff(nElevDiff);
				}
				else { // 屋顶
					AcDbPolyline *pline=new AcDbPolyline;
					PolyConvert(dest, *pline);
					pline->setLayer(InitLayer(AS_LAY2D(nFlag==0? LAY_ROOF : LAY_GROUND), TRUE));
					AddToModelSpace(pline, Adesk::kTrue);
					if (nFlag==1) { // 散水
						for(int i=0; i<poly.Length(); i++) {
							XLine ln(*poly[i], *dest[i]);
							ln.Make(AS_LAY2D(nFlag==0? LAY_ROOF : LAY_GROUND));
						}
					}
				}
			}
			else 
                adsout << _T("\n给定距离不合适,不能偏移!");
		}
	}
	else {
		adsout << _T("\n找不到外墙!");
	}

    TArchCmdReactor::ResetAll();
	return RTNORM;
}


//////////////////////////////////////////
// Command: 屋顶线
// 必须在WCS下
void RoofOutline()
{
//  InitLayer(AS_LAY2D(LAY_ROOF));
    OffsetExtSpace(0);
}





// 室内外高差
void ElevDiffIO()
{
//    InitLayer(LAY_GROUND);
    OffsetExtSpace(2);
}


//  [3/6/2008 nsh]
// ---------------------------begin---------------------------
// 以下为拖动字体的Jig
class TDragDbTextJig:public AcEdJig
{
public:
	TDragDbTextJig(TDbText * text);
	TDragDbTextJig(TDbSpace * space);
	virtual ~TDragDbTextJig();

	CString m_szPrompt; // 提示信息
	int m_iRetCode;     // 状态返回码
	TDbText * m_tdbtext;
	TDbSpace *m_tdspace;
	XPoint m_ptPoint;

	void SetPrompt(const TCHAR *pTemp);
	int GetRetCode() const;
	int doIt();
	DragStatus sampler();
	Adesk::Boolean update();
	AcDbEntity *entity() const;
};

TDragDbTextJig::TDragDbTextJig(TDbText * text):m_tdbtext(text),m_tdspace(NULL)
{
}

TDragDbTextJig::TDragDbTextJig(TDbSpace *space):m_tdspace(space),m_tdbtext(NULL)
{
}

TDragDbTextJig::~TDragDbTextJig(){};

int TDragDbTextJig::doIt()
{
	m_iRetCode=drag();
	int iRet=GetRetCode();
	return iRet;
}

AcEdJig::DragStatus TDragDbTextJig::sampler()
{
	DragStatus stat=AcEdJig::kCancel; // Init the stat
	setUserInputControls((UserInputControls)
		(AcEdJig::kAccept3dCoordinates|AcEdJig::kNullResponseAccepted));
	stat = acquirePoint(m_ptPoint);
	if (stat==kNormal)
	{
		static XPoint comparePoint;
		if (comparePoint!=m_ptPoint)
			comparePoint=m_ptPoint;
		else
			return AcEdJig::kNoChange;
	}
	return stat;
}

Adesk::Boolean TDragDbTextJig::update()
{
	XPoint pt;
	pt = m_ptPoint;
	if (m_tdbtext==NULL)
	{
		m_tdspace->m_ptLocation=pt;
	}
	else
	{
		pt.y-=m_tdbtext->GetHeight(FALSE)/2;
		m_tdbtext->SetLocation(pt);
	}	
	return Adesk::kTrue;
}

AcDbEntity *TDragDbTextJig::entity() const
{
	return m_tdbtext!=NULL?(AcDbEntity*)m_tdbtext:(AcDbEntity*)m_tdspace;
}

void TDragDbTextJig::SetPrompt(const TCHAR *pTemp)
{
	m_szPrompt=pTemp;
	acutPrintf(m_szPrompt);
}

int TDragDbTextJig::GetRetCode() const
{
	int ret = m_iRetCode;
	if (ret == AcEdJig::kCancel)
		ret = RTCAN;
	else if (ret == AcEdJig::kNull)
		ret = RTNONE;
	else if (ret == AcEdJig::kNormal) 
		ret = RTNORM;
	else 
	{
		ret = RTKWORD;
	}
	return ret;
}
//----------------------------end----------------------------



// add by fxj 080624 套内面积对话框
// sg modify 081119 增加有关填充部分的设置
class CHouseAreaDlg : public CModelessDialog
{
public:
	CHouseAreaDlg(CWnd* pParent = NULL);  // standard constructor
	// remove by lgh, 采用了字符串类型的code数据，因此该数据相关的函数以及变量废弃
	// void SetCode(int nCode);

    // modified by fxj 080819
	// modified by lgh 100810
	// void GetData(int &nCode, CString &sName, BOOL &bShowArea, BOOL &bMask,
	//	BOOL &bShowUnit, BOOL &bShowOutline/*, BOOL &bHalArea*/);
	void GetData(CString &sCode, CString &sName, BOOL &bShowArea, BOOL &bMask,
		BOOL &bShowUnit, BOOL &bShowOutline, BOOL &bShowCode, BOOL &bShowName/*, BOOL &bHalArea*/);

	// add by ligh;
	CString GetCode();
	CString GetName();

	// modify by xly on 100909 支持真彩色
	// sg add 081121，获取填充部分的数据，包括样式、颜色、比例、转角
	// void GetHatch(BOOL &bHatch, CString &csStyle, int &nColor,
	//	double &dScale, double &dAngle);
	void GetHatch(BOOL &bHatch, CString &csStyle, AcCmColor &nColor,
			double &dScale, double &dAngle);

	enum { IDD = IDD_HOUSE_SPACE };
	CListBox	m_listTexts;

//	int m_nCode;

	static CString	m_csName;//modified by fxj 090605 套型编号改为有记忆功能的
    static BOOL m_bMask;
	static BOOL m_bShowArea;
	static BOOL m_bShowUnit;
	static BOOL m_bShowOutline;
	static BOOL m_bCheckCode; // 是否标注户号
	static BOOL m_bCheckName; // 是否标注套型编号
//	static BOOL m_bHalArea; // delete by fxj 080819

	// sg add 081119，与填充相关内容的数据
	static BOOL				m_bShowHatch;	// 是否使用填充
 	static CString			m_csHatch;		// 填充样式
	CHatchPreviewCtrl		m_wndHatch;

	// Zyu modify on 100322,CAcUiColorComboBox换成CAcUiTrueColorComboBox控件
	// Begin
#if (ADS < 16)
	CAcUiColorComboBox		m_ctlColor;
#else
	CAcUiTrueColorComboBox	m_ctlColor;
#endif
	// End

	// modify by xly on 100909 支持真彩色	
//	static int				m_nColor;		// 填充颜色索引号
	static AcCmColor		m_cColor;		// 填充颜色

 	static double			m_dHatchScale;	// 填充比例
 	static int				m_nHatchAngle;	// 填充转角

	// sg add 090121
	CSpinButtonCtrl			m_angleSpin;	// 角度

public: // sg add 081120
 	virtual BOOL DestroyWindow();
	void UpdatePreview();
	// 设置当前code为prevCode，用来做后续解析
	void SetPrevCode(CString prevCode); // add by lgh
	// 移动下一个code
	void NextCode(); // add by lgh 100728

protected:
	virtual void DoDataExchange(CDataExchange* pDX);
 	virtual void PostNcDestroy(); // sg add 081120

	// 处理户号字符串返回下一个户号。
	// 规则如下：
	// 纯数字：+1。
	// XX-*：“-”后边如果只有一个字符，该字符+1，加到Z为止，“-”后边跟的如果是数字，数字+1
	// 其他情况不处理（返回原输入）
	static CString DealNextCode(CString sCode); /// add by lgh on 100728
	// 修改sCode，去除字符串前后的空格，去除横线两端的空格
	static CString CheckCode(CString sCode);	
protected:
	virtual BOOL OnInitDialog();
	afx_msg void OnClose();
	// sg add 081120
	afx_msg void OnClickHatch();			// 是否使用填充
 	afx_msg void OnStaticStyle();			// 选择填充效果
	afx_msg void OnSelchangeComboColor();	// 切换填充颜色
	// sg add 081202
	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
	// sg add 090122
	afx_msg void OnChangeEditSpaceAngle();
	afx_msg void OnKillFocusScale();//add by fxj 090426
	afx_msg void OnClickArea();              //是否显示面积 add by fxj 090514
	afx_msg void OnBnClickedChkCode();
	afx_msg void OnBnClickedChkName();
	DECLARE_MESSAGE_MAP()

private:
	// 私有变量，Add by lgh
	static CString m_sPrevCode; // 先前的户号值，该值用来初始化当前的户号
};



BOOL CHouseAreaDlg::m_bMask = TRUE;
BOOL CHouseAreaDlg::m_bShowArea = TRUE;
// BOOL CHouseAreaDlg::m_bShowUnit = FALSE; // sg modify 081203
BOOL CHouseAreaDlg::m_bShowUnit = TRUE;
BOOL CHouseAreaDlg::m_bShowOutline = TRUE;
// BOOL CHouseAreaDlg::m_bHalArea = FALSE; // delete by fxj 080819
BOOL CHouseAreaDlg::m_bShowHatch = FALSE;  // sg add 081120
CString CHouseAreaDlg::m_csHatch = _T("SOLID"); // sg add 081121

// add by xly on 10909 真彩色
//int CHouseAreaDlg::m_nColor = 256; // 默认Bylayer
AcCmColor CHouseAreaDlg::m_cColor;	// 默认Bylayer

int CHouseAreaDlg::m_nHatchAngle = 0;
double CHouseAreaDlg::m_dHatchScale = 100;
CString CHouseAreaDlg::m_csName = _T("1-A");//add by fxj 090605
BOOL CHouseAreaDlg::m_bCheckCode = TRUE; // 默认的都标注，add by lgh
BOOL CHouseAreaDlg::m_bCheckName = TRUE;
CString CHouseAreaDlg::m_sPrevCode = _T("100");// 初始化

CHouseAreaDlg::CHouseAreaDlg(CWnd* pParent /*=NULL*/)
	: CModelessDialog(CHouseAreaDlg::IDD, pParent)
{
//	m_nCode = 101;
}

void CHouseAreaDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	
//	DDX_Text(pDX, IDC_CODE, m_nCode);
	DDX_Text(pDX, IDC_NAME, m_csName);
    DDX_Check(pDX, IDC_SPACE_MASK, m_bMask);
	DDX_Check(pDX,IDC_CHECK_DIMAREA, m_bShowArea);
	DDX_Check(pDX,IDC_CHECK_AREAUNIT, m_bShowUnit);
	DDX_Check(pDX, IDC_SHOW_OUTLINE, m_bShowOutline);
//	DDX_Check(pDX, IDC_HALAREA,m_bHalArea); // delete by fxj 080819

	// sg add 081120
	DDX_Check(pDX, IDC_CHECK_HATCH, m_bShowHatch);
 	DDX_Control(pDX, IDC_STATIC_STYLE, m_wndHatch);
	DDX_Control(pDX, IDC_COMBO_COLOR, m_ctlColor);
 	DDX_Text(pDX, IDC_EDIT_SCALE , m_dHatchScale);
	DDX_Text(pDX, IDC_EDIT_ANGLE, m_nHatchAngle);
	DDX_Control(pDX, IDC_SPIN_ANGLE, m_angleSpin); // sg add 090122
	DDX_Check(pDX, IDC_CHK_NAME, m_bCheckName);
	DDX_Check(pDX, IDC_CHK_CODE, m_bCheckCode);
}

BEGIN_MESSAGE_MAP(CHouseAreaDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CHouseAreaDlg)
     ON_WM_CLOSE()
	 ON_BN_CLICKED(IDC_CHECK_HATCH, OnClickHatch) // sg add 081120
	 ON_BN_CLICKED(IDC_STATIC_STYLE, OnStaticStyle)
	 ON_CBN_SELCHANGE(IDC_COMBO_COLOR, OnSelchangeComboColor) // sg add 081125
	 ON_WM_SETCURSOR() // sg add 081202
	 ON_EN_CHANGE(IDC_EDIT_ANGLE, OnChangeEditSpaceAngle) // sg add 090122
	 ON_EN_KILLFOCUS(IDC_EDIT_SCALE, OnKillFocusScale)//add by fxj 090426
	 ON_BN_CLICKED(IDC_CHECK_DIMAREA, OnClickArea)//add by fxj 090514
	 ON_BN_CLICKED(IDC_CHK_CODE, OnBnClickedChkCode)
	 ON_BN_CLICKED(IDC_CHK_NAME, OnBnClickedChkName)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/*
void CHouseAreaDlg::SetCode(int nCode)
{
	m_nCode = nCode;
	UpdateData(FALSE);
}
*/

/////////////////////////////////////////////////////////////////////////////
// CSpaceProperty message handlers
BOOL CHouseAreaDlg::OnInitDialog()
{
	CModelessDialog::OnInitDialog();
	m_angleSpin.SetRange(0, 360); // sg add 090122
	XString sAngle = Angle2Str(m_nHatchAngle); // sg add 081215，角度精确度受控制
	GetDlgItem(IDC_EDIT_ANGLE)->SetWindowText(sAngle);
	OnClickHatch(); // sg add 081120，设置“填充”部分是否可用

	// 问题描述:选择颜色时只支持索引颜色一种，希望可以像CAD一样增加对真彩色和配色系统的支持。（TT10）
	// 解决方法:把CAcUiColorComboBox换成CAcUiTrueColorComboBox,并替换相应的函数
	// 修改人,修改时间:Zyu modify on 100322
	// Begin
#if (ADS < 16)
	
	// modify by xly 真彩色的兼容，兼容为一个变量
	// sg add 081121，设置“填充颜色”
	//int nItem = m_ctlColor.FindItemByColorIndex(m_nColor);
	int nTempColor = m_cColor.colorIndex();
	int nItem = m_ctlColor.FindItemByColorIndex(nTempColor);
#else

	// modify by xly on 100909 真彩色使用
	/*AcCmColor clrTemp;
	clrTemp.setColorIndex(m_nColor);
	int nItem = m_ctlColor.FindItemByColor(clrTemp);*/
	int nItem = m_ctlColor.FindItemByColor(m_cColor);
#endif

	if (nItem < 0)
	{
#if (ADS < 16)	
		// modify by xly 真彩色的兼容，兼容为一个变量
		//m_ctlColor.AddColorToMRU(m_nColor);
		//nItem = m_ctlColor.FindItemByColorIndex(m_nColor);
		m_ctlColor.AddColorToMRU(nTempColor);
		nItem = m_ctlColor.FindItemByColorIndex(nTempColor);	
#else
		// modify by xly on 100909 真彩色使用
		/*m_ctlColor.AddColorToMRU(clrTemp);
		nItem = m_ctlColor.FindItemByColor(clrTemp);*/
		m_ctlColor.AddColorToMRU(m_cColor);
		nItem = m_ctlColor.FindItemByColor(m_cColor);
#endif
	}
	// End

	if (nItem >= 0)
	{
		m_ctlColor.SetCurSel(nItem);
	}

	// add by xly on 101213 设置房间对象的显示
	TDbSpace Spce;
	Spce.SetSpaceDispMode(1);
	m_bCheckCode = Spce.IsDimCode();
	m_bCheckName = Spce.IsDimName();	
	m_bShowArea = Spce.IsDimArea();
	m_bShowUnit = Spce.IsDimUnit();

	GetDlgItem(IDC_CODE)->SetWindowText(DealNextCode(m_sPrevCode)); // add by lgh on 100728
	GetDlgItem(IDC_CHECK_AREAUNIT)->EnableWindow(m_bShowArea);//add by fxj 090514
	GetDlgItem(IDC_NAME)->EnableWindow(m_bCheckName); // add by lgh 100727
	GetDlgItem(IDC_CODE)->EnableWindow(m_bCheckCode);	// add by lgh 100727

	UpdatePreview(); // sg add 081121，获取“填充样式”
	UpdateData(FALSE);
	return TRUE;  // return TRUE unless you set the focus to a control
               // EXCEPTION: OCX Property Pages should return FALSE
}

void CHouseAreaDlg::OnClose()
{
	if (m_bModeless)
		acedPostCommand(_T("\33\33"));
	else
		CModelessDialog::OnClose();
}

// modified by fxj 080819
//void CHouseAreaDlg::GetData(int &nCode, CString &sName, BOOL &bShowArea, BOOL &bMask,
//							BOOL &bShowUnit, BOOL &bShowOutline/*, BOOL &bHalArea*/)
void CHouseAreaDlg::GetData(CString &sCode, CString &sName, BOOL &bShowArea, BOOL &bMask,
							BOOL &bShowUnit, BOOL &bShowOutline, BOOL &bShowCode, BOOL &bShowName/*, BOOL &bHalArea*/)
{
	UpdateData(TRUE);
//	nCode = m_nCode;
	GetDlgItem(IDC_CODE)->GetWindowText(sCode);
	sCode = CheckCode(sCode);
	sName = m_csName;
    bMask = m_bMask;
    bShowArea = m_bShowArea;
	bShowUnit = m_bShowUnit;
	bShowOutline = m_bShowOutline;
//	bHalArea = m_bHalArea; // delete by fxj 080819
	bShowCode = m_bCheckCode;
	bShowName = m_bCheckName;
}

// add by ligh;
CString CHouseAreaDlg::GetCode()
{
	CString sCode;
	UpdateData(TRUE);
	GetDlgItem(IDC_CODE)->GetWindowText(sCode);
	return CheckCode(sCode);
}

CString CHouseAreaDlg::GetName()
{
	UpdateData(TRUE);
	return m_csName;
}

// modify by xly  支持真彩色
// sg add 081121，获取填充部分的数据，包括样式、颜色、比例、转角
//void CHouseAreaDlg::GetHatch(BOOL &bHatch, CString &csStyle, int &nColor,
//							 double &dScale, double &dAngle)
void CHouseAreaDlg::GetHatch(BOOL &bHatch, CString &csStyle, AcCmColor &nColor,
							 double &dScale, double &dAngle)
{
	UpdateData(TRUE);
	// Zyu modify on 100322
	// 把CAcUiColorComboBox换成CAcUiTrueColorComboBox后替换相应的函数
	// Begin
#if (ADS < 16)
	int nIndex = m_ctlColor.GetCurrentItemColorIndex();

	// modify by xly  支持真彩色
	nColor.setColorIndex(nIndex);
#else
	// modify by xly  支持真彩色
	//AcCmColor clrTemp;
	//m_ctlColor.GetCurrentItemColor(clrTemp);
	//int nIndex = clrTemp.colorIndex();
	m_ctlColor.GetCurrentItemColor(nColor);
#endif
	// End

	// modify by xly  支持真彩色
	/*if (nIndex >= 0)
	{
		nColor = nIndex;
	}*/

	bHatch = m_bShowHatch;
	csStyle = m_csHatch;
	dScale = m_dHatchScale;
	dAngle = m_nHatchAngle;
}

void CHouseAreaDlg::OnClickHatch() // sg add 081120，控制填充部分是否可编辑
{
	UpdateData(TRUE);
 	GetDlgItem(IDC_STATIC_STYLE)->EnableWindow(m_bShowHatch);
 	GetDlgItem(IDC_COMBO_COLOR)->EnableWindow(m_bShowHatch);
	GetDlgItem(IDC_EDIT_SCALE)->EnableWindow(m_bShowHatch);
	GetDlgItem(IDC_EDIT_ANGLE)->EnableWindow(m_bShowHatch);
	GetDlgItem(IDC_SPIN_ANGLE)->EnableWindow(m_bShowHatch); // sg add 090122
	UpdateData(FALSE);
}

void CHouseAreaDlg::OnClickArea()//add by fxj 090514
{
	m_bShowArea=!m_bShowArea;
	GetDlgItem(IDC_CHECK_AREAUNIT)->EnableWindow(m_bShowArea);
}

void CHouseAreaDlg::OnStaticStyle() // sg add 081120，选择填充效果
{
	acDocManager->lockDocument(acDocManager->curDocument());
	if (!AT_loaded(_T("tch_blklib")))
	{
		int nRet = acrxLoadModule(_T("tch_blklib.arx"), Adesk::kTrue, true);
		if (!nRet)
		{
			acDocManager->unlockDocument(acDocManager->curDocument());
			return;
		}
	}

	RBList rbCmd = ads_buildlist(RTSTR, _T("ITUAN"), RTSTR,
		(const TCHAR*)(m_csHatch), NULL);
	resbuf *rbRes = NULL;
	if (ads_invoke(rbCmd, &rbRes)==RTNORM && rbRes)
	{
		if (rbRes && rbRes->restype==RTSTR)
		{
			m_csHatch = rbRes->resval.rstring;
		}
		ads_relrb(rbRes);
	}
	UpdatePreview();
	acDocManager->unlockDocument(acDocManager->curDocument());
}

void CHouseAreaDlg::UpdatePreview() // sg add 081120，填充效果预览
{
	if (m_csHatch.IsEmpty())
	{
		m_csHatch = _T("SOLID");
	}
	m_wndHatch.SetPattern(m_csHatch);
	
	// modify by xly on 10909 真彩色的使用
	//m_wndHatch.SetColorPattern(m_nColor);
	m_wndHatch.SetColorPattern1(m_cColor);

	m_wndHatch.SetAngle(m_nHatchAngle);
	m_wndHatch.UpdateView();
}

BOOL CHouseAreaDlg::DestroyWindow()
{
  	m_wndHatch.clearAll();
	return CModelessDialog::DestroyWindow();
}

void CHouseAreaDlg::PostNcDestroy()
{
  	m_wndHatch.clearAll();
	CModelessDialog::PostNcDestroy();
}

void CHouseAreaDlg::OnSelchangeComboColor() // sg add 081125，获取最新填充颜色，刷新m_nColor
{
	UpdateData(TRUE);
	// Zyu modify on 100322
	// 把CAcUiColorComboBox换成CAcUiTrueColorComboBox后替换相应的函数
	// Begin
#if ( ADS < 16 )
	int nIndex = m_ctlColor.GetCurrentItemColorIndex();
	
	// add by xly on 100909 真彩色使用
	m_cColor.setColorIndex(nIndex);
#else
	// modify by xly on 100909 真彩色使用
	/*AcCmColor clrTemp;
	m_ctlColor.GetCurrentItemColor(clrTemp);
	int nIndex = clrTemp.colorIndex();*/
	m_ctlColor.GetCurrentItemColor(m_cColor);	
#endif

	// End
	
	// modify by xly on 100909 真彩色使用,提前到(ADS < 16)使用
	// GetCurrentItemColor不支持返回值，不做判断，都更新显示
	//if (nIndex >= 0)
	//{
	/*m_nColor = nIndex;
	m_wndHatch.SetColorPattern(m_nColor);*/
	m_wndHatch.SetColorPattern1(m_cColor);
	m_wndHatch.UpdateView();
	//}
}

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

void CHouseAreaDlg::OnChangeEditSpaceAngle()
{
   CString csTemp;
	GetDlgItem(IDC_EDIT_ANGLE)->GetWindowText(csTemp);
	m_nHatchAngle = _ttoi(csTemp);
	UpdateData(FALSE);
	UpdatePreview();
}
void CHouseAreaDlg::OnKillFocusScale()//add by fxj 090426
{
	UpdateData(TRUE);
}

void CHouseAreaDlg::OnBnClickedChkCode()
{
	UpdateData(TRUE);
	GetDlgItem(IDC_CODE)->EnableWindow(m_bCheckCode);
}

void CHouseAreaDlg::OnBnClickedChkName()
{
	UpdateData(TRUE);
	GetDlgItem(IDC_NAME)->EnableWindow(m_bCheckName);
}

// 设置当前code为prevCode，用来做后续解析
void CHouseAreaDlg::SetPrevCode(CString prevCode)
{
	m_sPrevCode = prevCode;
}

void CHouseAreaDlg::NextCode()
{
	GetDlgItem(IDC_CODE)->SetWindowText(DealNextCode(m_sPrevCode));
}

CString CHouseAreaDlg::DealNextCode(CString sCode)
{
	sCode.TrimLeft();
	sCode.TrimRight();

	if (sCode.IsEmpty())
		return sCode;

	CString sRetString = sCode;

	int nLinePlace = sCode.Find(_T('-'));
	if (nLinePlace != -1) // 字符串中包含连字符
	{
		if (nLinePlace < sCode.GetLength() - 1) // 不是最后一个数，才做处理
		{
			CString strSuffixl = sCode.Mid(nLinePlace+1, sCode.GetLength() - nLinePlace);
			strSuffixl.TrimLeft(); // 去掉连字符左边的空格

			if (IsDigital((LPCTSTR)strSuffixl))
			{
				// 处理数字串的情况
				int i = _ttoi(strSuffixl);
				strSuffixl.Format(_T("%d"), ++i);
			}
			else if (strSuffixl.GetLength() == 1)
			{
				const TCHAR &chNext = strSuffixl[0];
				// 注意：这里没有处理 == Z的情况
				if ( ((chNext >= 'a') && (chNext < 'z'))	|| ((chNext >= 'A') && (chNext < 'Z')) )
				{
					strSuffixl = CString(TCHAR(chNext+1));
				}
			}

			sRetString = sCode.Mid(0, nLinePlace) + _T("-") + strSuffixl;
		}
	}
	else
	{
		if (IsDigital((LPCTSTR)sCode)) // 纯数字
		{
			int i = _ttoi(sCode);
			sRetString.Format(_T("%d"), ++i);
		}
		else
		{
			// 其他情况不处理
		}
	}
	return CheckCode(sRetString);
}

// 处理连字符两侧的空格
CString CHouseAreaDlg::CheckCode(CString sCode)
{
	sCode.TrimLeft();
	sCode.TrimRight();
	if (sCode.IsEmpty())
		return _T("");

	int nFind = sCode.Find(_T('-'));
	if (nFind > -1)
	{
		if (nFind == 0 || nFind == sCode.GetLength() - 1)
			return sCode;
		
		CString strPrefix = sCode.Mid(0, nFind);
		CString strSuffix = sCode.Mid (nFind + 1, sCode.GetLength());
		
		strPrefix.TrimRight();
		strSuffix.TrimLeft();
		return strPrefix + _T("-") + strSuffix;
	}
	else
		return sCode;
}


// add by lgh. 该数值在拖动的时候，希望能够根据对话框更新数据
class TDragHouseAreaDbTextJig : public TDragDbTextJig
{
public:
	TDragHouseAreaDbTextJig(TDbSpace * space, CHouseAreaDlg *pDlg, BOOL bHole) ;

	virtual Adesk::Boolean update();

private:
	CHouseAreaDlg *m_pDlg; // add by lgh 100804, 用来实时更新当前的数据状态
	BOOL m_bHole;
};

TDragHouseAreaDbTextJig::TDragHouseAreaDbTextJig(TDbSpace * space, CHouseAreaDlg *pDlg, BOOL bHole) 
: TDragDbTextJig(space), m_pDlg(pDlg), m_bHole(bHole)
{
	ASSERT(pDlg != NULL);
}

Adesk::Boolean TDragHouseAreaDbTextJig::update()
{
	ASSERT(m_pDlg != NULL);
	ASSERT(m_tdbtext == NULL);
	ASSERT(m_tdspace != NULL);

	m_tdspace->m_ptLocation = m_ptPoint;

	m_pDlg->UpdateData(TRUE);
	CString sName, sCode;
	// delete by fxj 080819
	BOOL bShowArea,bMask,bShowUnit,bShowOutline, bShowCode, bShowName/*,bHalArea*/;
	m_pDlg->GetData(sCode,sName,bShowArea,bMask,bShowUnit,bShowOutline, bShowCode, bShowName/*,bHalArea*/);

	BOOL bHatch; // sg add 081124
	CString csHatch;
	AcCmColor cHatchColor;
	double dHatchAngle(0), dHatchScale(1);
	// modify by xly on 100909 真彩色的使用
	// int nHatchColor(7);
	// m_pDlg->GetHatch(bHatch, csHatch, nHatchColor, dHatchScale, dHatchAngle);
	m_pDlg->GetHatch(bHatch, csHatch, cHatchColor, dHatchScale, dHatchAngle);

	if (m_bHole)
	{
		if (sName.Find(_T("含洞口"))==-1)
			sName+=_T("(含洞口)");
	}

	m_tdspace->SetName(sName);
	m_tdspace->SetCode(sCode);
	m_tdspace->SetMask(bMask);
	m_tdspace->SetShowOutline(bShowOutline);

	// modify by xly on 101111根据8.5需求修改该房间对象，支持房间名和面积都不标注
/*
	int nSpFlag = DocGetSpaceDispMode();
	if (bShowArea)
		nSpFlag |= SPF_AREA;
	else
		nSpFlag &= ~SPF_AREA;

	if (bShowUnit)
		nSpFlag |= SPF_UNIT;
	else
		nSpFlag &= ~SPF_UNIT;
	if (bShowCode)
		nSpFlag |= SPF_CODE;
	else
		nSpFlag &= ~SPF_CODE;

	if (bShowName)
		nSpFlag |= SPF_NAME;
	else
		nSpFlag &= ~SPF_NAME;
	DocSetSpaceDispMode(nSpFlag);
*/
	m_tdspace->SetDimNameAndCode(bShowName, bShowCode);
	m_tdspace->SetDimArea(bShowArea);
	m_tdspace->SetDimUnit(bShowUnit);

	m_tdspace->SetHasHatch(bHatch); // sg add 081124
	m_tdspace->SetHatchStyle(csHatch);
	// modify by xly on 100909 支持真彩色
	// m_tdspace->SetHatchColor(nHatchColor);
	m_tdspace->SetHatchTrueColor(cHatchColor);
	m_tdspace->SetHatchScale(dHatchScale);
	m_tdspace->SetHatchAngle(dHatchAngle*PI/180);

	return Adesk::kTrue;
}



/////////////////////////////////////////////////////
// 套内建筑面积
// by fxj
void ApartmentArea()
{
	//----------modified by fxj 080620-------------
    CAcModuleResourceOverride vTemp;
	CHouseAreaDlg dlg(acedGetAcadFrame());
	if (!dlg.Create(CHouseAreaDlg::IDD, acedGetAcadFrame()))
		return;
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	PickSet ssSpace(SS_FREE);
	RBList spaceMask(RTDXF0, _T("TCH_SPACE"), NULL);
//	int nCode = 101;
	while(1)
	{
//		dlg.SetCode(nCode);
		if (SelectEntities(_T("\n请选择同属一套住宅的所有房间面积对象与阳台面积对象:"), ssSpace, spaceMask)!=RTNORM) 
		{
			dlg.DestroyWindow();
			return;
		}

		//add by fxj ssSpace中找出阳台面积对象
		PickSet ssBalcony(SS_FREE);//阳台
		long n = ssSpace.Length();
		for (long i=0; i<n; i++)
		{
			Entity ent = ssSpace[i];
			TDbSpace *pSpace = NULL;
			OPENOBJ_BEGIN(ent,AcDb::kForRead,TDbSpace,pSpace);
			if (pSpace == NULL)
				continue;
			if (pSpace->GetType()==TDbSpace::kBalconyArea)
			    ssBalcony += ent;		 	
			OPENOBJ_END();
		
		}

		long count = ssSpace.Length();
		DualList<AcDbObjectId> lstWallId; // 套内墙体
		for (i=0; i<count; i++)
		{
			Entity ent = ssSpace[i];
			TDbSpace *pSpace = NULL;
			OPENOBJ_BEGIN(ent,AcDb::kForRead,TDbSpace,pSpace);
			if (pSpace == NULL)
				continue;

			for (long i=0; i<pSpace->m_lstWallEnclosure.Length(); i++)
				lstWallId.FindOrAddTail(*pSpace->m_lstWallEnclosure[i]);
			OPENOBJ_END();
		}
		
		if (!lstWallId.IsEmpty()) // 得到套相关墙
		{
			DList<AcDbObjectId> lstWalls;
			for (lstWallId.MoveToFirst();!lstWallId.IsOut();lstWallId.MoveToNext())
				lstWalls.Append(new AcDbObjectId(lstWallId.GetCurData()));

			// 得到户墙上柱子
			DualList<AcDbObjectId> lstColus;
			for (long i=0;i<lstWalls.Length();i++)
			{
				TDbWall *pWall = NULL;
				acdbOpenObject(pWall,*lstWalls[i],AcDb::kForRead);
				if (pWall != NULL)
				{
					lstColus.FindOrAddTail(pWall->GetStartColumnId());
					lstColus.FindOrAddTail(pWall->GetEndColumnId());
					pWall->close(); // add by fxj 090222
				}
				
			}

			DList<AcDbObjectId> lstColus1;
			for (lstColus.MoveToFirst();!lstColus.IsOut();lstColus.MoveToNext())
				lstColus1.Append(new AcDbObjectId(lstColus.GetCurData()));

			// 找本户户墙的外轮廓
			XSearchSpaceFromWall aSearch;
			try 
			{
			   aSearch.InitStart(lstWalls, lstColus1);
			}   
			catch (...) 
			{
				adsout << _T("\n搜索户墙外轮廓出现例外情况!");
				continue;
			}
			//------------------------------------

			XAecSpaceCell *extCell = aSearch.SearchSpaces();
			if (extCell != NULL) // 成功找到户墙外轮廓
			{
				// removed by lgh. 20101104
				// 这些属性设置语句被删除掉，然后放到了jig中，可以达到实现更新的效果。
//				CString sName, sCode;
				// delete by fxj 080819
//				BOOL bShowArea,bMask,bShowUnit,bShowOutline/*,bHalArea*/;
//				dlg.UpdateData(TRUE);//add by fxj 090222
//				dlg.GetData(nCode,sName,bShowArea,bMask,bShowUnit,bShowOutline/*,bHalArea*/);
//				dlg.GetData(sCode,sName,bShowArea,bMask,bShowUnit,bShowOutline,bShowOutline,bShowOutline/*,bHalArea*/);
//				BOOL bHatch; // sg add 081124
//				CString csHatch;
//				int nHatchColor(7);
//				double dHatchAngle(0), dHatchScale(1);

				// modify by xly on 100909 真彩色的使用
				//int nHatchColor(7);
				//dlg.GetHatch(bHatch, csHatch, nHatchColor, dHatchScale, dHatchAngle);
//				AcCmColor cHatchColor;
//				dlg.GetHatch(bHatch, csHatch, cHatchColor, dHatchScale, dHatchAngle);

				XPoly2D poly(1);
				extCell->GeomCenterPoly2D(poly);
				XPoint ptLoc;
				poly.Center(ptLoc);
				ptLoc.z = 0.0;

				TDbSpace *pDbSpace1 = new TDbSpace;
				//---------标注含洞口 by fxj 0900724---------
				BOOL bHasHole=FALSE;
				for(long j=0;j<ssSpace.Length();j++)
				{
					Entity ent = ssSpace[j];
					TDbSpace *pSpace = NULL;
					OPENOBJ_BEGIN(ent,AcDb::kForRead,TDbSpace,pSpace);
					if (pSpace == NULL)
						continue;
					if (pSpace->GetType()==TDbSpace::kHoleArea)
					{
						bHasHole=TRUE;
						break;
					}
					OPENOBJ_END();
				}
//				if (bHasHole)
//				{
//				    if (sName.Find(_T("含洞口"))==-1)
//					    sName+=_T("(含洞口)");
//				}
				//--------------------------------------
//				pDbSpace1->m_sName = sName;
//				CString sCode;
//				sCode.Format(_T("%d"),nCode);
//				pDbSpace1->m_sCode = sCode;
				

				pDbSpace1->SetType(TDbSpace::kHouseArea); // sg add 081226，增加房间类型
//				pDbSpace1->SetMask(bMask);
			//	pDbSpace1->SetHalfArea(bHalArea); // modifide by fxj 080702 // delete by fxj 080819
                pDbSpace1->SetPathPoly(poly, AcGeVector3d::kZAxis); // add by fxj 080813

//				pDbSpace1->SetHasHatch(bHatch); // sg add 081124
//				pDbSpace1->SetHatchStyle(csHatch);

				// modify by xly on 100909 支持真彩色
				//pDbSpace1->SetHatchColor(nHatchColor);
//				pDbSpace1->SetHatchTrueColor(cHatchColor);	
//				pDbSpace1->SetHatchScale(dHatchScale);
//				pDbSpace1->SetHatchAngle(dHatchAngle*PI/180);
				AcDbObjectId idHatch = InitLayer(LAY_SPACE_HATCH); // modified by fxj 090609
				pDbSpace1->SetHatchLayer(idHatch);

				// modify by xly on 101111根据8.5需求修改该房间对象，支持房间名和面积都不标注
			/*	int nSpFlag = DocGetSpaceDispMode();
			    if (bShowArea)
					nSpFlag |= SPF_AREA;
				else
					nSpFlag &= ~SPF_AREA;

				if (bShowUnit)
					nSpFlag |= SPF_UNIT;
				else
					nSpFlag &= ~SPF_UNIT;

				if (dlg.IsDrawCode())
					nSpFlag |= SPF_CODE;
				else
					nSpFlag &= SPF_CODE;

				if (dlg.IsDrawName())
					nSpFlag |= SPF_NAME;
				else
					nSpFlag &= ~SPF_NAME;
				
				DocSetSpaceDispMode(nSpFlag);*/
//				pDbSpace1->SetDimNameAndCode(dlg.m_bCheckName, dlg.m_bCheckCode);
//				pDbSpace1->SetDimArea(bShowArea);
//				pDbSpace1->SetDimUnit(bShowUnit);

				pDbSpace1->SetTextStyleId(InitTextStyle(TS_SPACE));
				// pDbSpace1->SetRotation(Ucs2Wcs(0)); // ucs对齐 add by fxj 080813
				pDbSpace1->SetLayoutRotation(Ucs2Wcs(0)); // sg modify 090602,8.0的正式版起，将“文字转角”并入“布局转角”

				pDbSpace1->setLayer(InitLayer(LAY_HOUSE_SPACE));
//				pDbSpace1->SetShowOutline(bShowOutline);
				
				// ------add by fxj 080630----------------------------
				// 更换为套内面积专用jig.达到实时更新的效果。 modify by lgh 20101104;
//				TDragDbTextJig jig(pDbSpace1);
				TDragHouseAreaDbTextJig jig(pDbSpace1, &dlg, bHasHole);
				jig.SetPrompt(_T("\n请点取面积标注位置<中心>:"));
				int iRet = jig.doIt();
				AcDbObjectId id;
				if (iRet == RTNORM)
				{
					//pDbSpace1 = (TDbSpace*)jig.entity();
					TDbSpace *pDbSpace2 = (TDbSpace*)jig.entity();
					id=AddToModelSpace((TDbSpace*)(pDbSpace2->clone()),Adesk::kTrue);
				}
				else if (iRet == RTCAN)
				{
					if (pDbSpace1 != NULL)
						delete pDbSpace1; // add by fxj 080825
				    break;
				}
				else
				{
					TDbSpace *pDbSpace2 = (TDbSpace*)jig.entity();
					pDbSpace2->m_ptLocation = ptLoc;
					id=AddToModelSpace((TDbSpace*)(pDbSpace2->clone()),Adesk::kTrue);
				}
				//----------------------------------
				

				//add by fxj 090508 在阳台面积中记录其所属户的id，即套内面积的id
				if (id.isValid())
				{
					for(long i=0;i<ssBalcony.Length();i++)
					{ 
						TDbSpace *pBal = NULL;
						Entity ent=ssBalcony[i];
						OPENOBJ_BEGIN(ent,AcDb::kForWrite,TDbSpace,pBal);
						if (pBal == NULL)
							continue;
						pBal->SetHouseId(id);

						OPENOBJ_END();
					}
				}

				// modify by lgh
				// 采用新的房号方式，
//				nCode++;
				dlg.SetPrevCode(dlg.GetCode());
				dlg.NextCode();
			} 
			else 
			{
			  adsout << _T("\n这些墙不能构成封闭的区域!");
			}
		}
		else//add by fxj 090223
			break;
	}
	
	// add by fxj 080825
	if (::IsWindow(dlg.m_hWnd)) 
        dlg.DestroyWindow();
}


//void ApartmentArea()
//{
//   PickSet ssWalls(SS_FREE);
//   //adsout << ;
//   g_ssPickFirst.Free();
//   if (SelectEntities(_T("\n请选择构成一套房子的所有墙体(或门窗):"), ssWalls, RBList(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL,TCH_OPENING"), NULL))!=RTNORM)
//      return;
//   MakeWallSet(ssWalls);
//
//    DList<AcDbObjectId> lstColu;
//    GetEntFromBlockByDxf(lstColu, _T("TCH_COLUMN"));
//
//    XSearchSpaceFromWall aSearch;
//    try {
//        aSearch.InitStart(ssWalls, lstColu);
//    }catch(...) {
//        adsout << /*UMSG*/_T("\n发生例外情况!");
//        return ;
//    }
//
//       XAecSpaceCell * extCell=aSearch.SearchSpaces();
//       if (extCell) {
//          XPoly2D poly(1);
//          extCell->GeomCenterPoly2D(poly);
//          poly.SetElevation(0);
//          XScreenDc dc(1,1);
//          dc << poly;
//
//		  XString sText;
//
//		  //modified by whl on 061220，解决米单位绘图问题
//		  //sText<<_T("\n套内建筑面积(不含阳台)=") << _AS_SQMETER(poly.Area());
//		  sText<<_T("\n套内建筑面积(不含阳台)=") << _AS_SQMETER(poly.Area());
//
//		  adsout<< sText;
//          if (YesNoQuestion(_T("\n是否生成封闭的多段线"))==Q_YES)
//		  {
//			poly.Make();
//			TDbText*pText=new TDbText;
//			sText<<_T("M^U2^U");
//			pText->SetText(sText);
//			pText->SetHeight(3.5);
//			pText->SetStyleId(InitTextStyle(TS_SPACE));
//			XPoint pt;
//			poly.Center(pt);
//			pText->SetLocation(pt);
//			pText->AddToCSpace(Adesk::kTrue);
//		  }
//       } else {
//          adsout << _T("\n这些墙不能构成封闭的区域!");
//       }
//   return ;
//} 


//  面积累加
void PlusText()
{
    RBList mask(RTDXF0, _T("TEXT,TCH_TEXT,TCH_SPACE"), NULL);
    PickSet ss(SS_FREE);
    if (SelectEntities(_T("\n请选择房间面积对象或面积数值文字:"), ss, mask)==RTNORM)
	{
        long lCount = ss.Length();
        double nArea = 0.0;
        for (long i=0L; i<lCount; i++)
		{
            Entity ent = ss[i];
            OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
            if (pEnt)
			{
                if (pEnt->isKindOf(AcDbText::desc()))
                    nArea += _tstof(((AcDbText *)pEnt)->textString());
                else if (pEnt->isKindOf(TDbText::desc()))
                    nArea += _tstof(((TDbText *)pEnt)->GetText());
                else if (pEnt->isKindOf(TDbSpace::desc()))
				{
					//modified by fxj 090414
					TDbSpace *pSpace=(TDbSpace *)pEnt;
					if (pSpace!=NULL)
					{
						if (pSpace->IsHalfArea())
							nArea += pSpace->m_nUseArea/2.0;
						else
							nArea += pSpace->m_nUseArea;
                        //nArea += ((TDbSpace *)pEnt)->m_nUseArea;
					}
				}
            }
            OPENOBJ_END();
        }

		//  [11/15/2007 nsh]
		CString temp;
		temp.Format(_T("%.3f"),nArea);
		// --------------------------------
        adsout << _T("\n共选中了") << lCount << _T("个对象, 求和结果=") << (LPTSTR)(LPCTSTR)temp;//  [11/15/2007 nsh]

		// add by whl 0401001
		PickSet ss(SS_FREE);
		ss.IncludeBegin();
		XString sTemp;
		sTemp<<_T("面积总和=")<<temp<<_T("m^U2^U");

		TDbText *pText = new TDbText;
		pText->SetText(sTemp);
		pText->SetHeight(3.5);
		pText->SetStyleId(InitTextStyle(TS_SPACE));
		pText->SetLocation(Ucs2Wcs(XPoint())); // [4/1/2008 nsh]
		pText->SetRotation(Ucs2Wcs(0)); // [4/1/2008 nsh]
		pText->AddToCSpace(Adesk::kTrue);
		ss.IncludeEnd();

		extern TARCH_IMPEXP int DragMovePickSet(PickSet &ss, const TCHAR *pszPrompt, const XPoint &ptBase, XPoint &ptFinal);
		if (DragMovePickSet(ss,_T("\n点取面积标注位置<退出>:"),XPoint(),XPoint())!=RTNORM)
			ss.Erase();
    }
}

// 三维散水
void SanShui3d()
{
	// sg modify 090225，支持M单位
//  double nDist = fabs(nSanShuiDist);
//  double nElevDiff = DocGetElevDiff();
    double nDist = _AS_SYS_UNIT(fabs(nSanShuiDist));
    double nElevDiff = _AS_SYS_UNIT(DocGetElevDiff());
	if (GetDist(_T("\n散水偏移外墙距离"), nDist, RSG_NOZERO|RSG_NONEG)==RTCAN ||
		GetDist(_T("\n室内外高差"), nElevDiff, RSG_NONEG|RSG_NOZERO)==RTCAN)
		return;

//  DocSetElevDiff(nElevDiff);
	DocSetElevDiff(_AS_MM(nElevDiff)); // sg modify 090225

    Entity ent;
    RBList mask(RTDXF0, _T("LWPOLYLINE,POLYLINE"), NULL);
    while(ent.FilterSelect(_T("\n选择一段二维散水线: "), mask)==RTNORM)
	{
        XPoly2D poly(ent);
        if (!poly || poly.TotalSegments()<1)
		{
            adsout << _T("\n请正确选择!");
        }

        XPoint ptPick,
			ptRef = Wcs2Ucs(*poly.Head());
        ads_getpoint(ptRef, _T("\n请点取最近的外墙的一侧: "), ptPick);
        ptPick = Ucs2Wcs(ptPick);

        XDirectionCurve cv;
        poly.Nth(0, cv);
        int nSide = cv.OnWhichSide(ptPick);
        double nFactor = nSide==OFFSET_RIGHT? 1.0 : -1.0;
        XPoly2D polyShape(1);
        XPoint ptVert;
        polyShape.AppendNode(ptVert);
        ptVert.x += nFactor*nDist;
        polyShape.AppendNode(ptVert);
        ptVert.y += 20*_UNIT_SCALE;
        polyShape.AppendNode(ptVert);
        ptVert.x = 0;
        ptVert.y = 10*_UNIT_SCALE;
        polyShape.AppendNode(ptVert);
        
//      TDbCurveMesh2 *pMesh = new TDbCurveMesh2;
//      poly.SetElevation(-nElevDiff);
// 		pMesh->SetPathPoly(poly,pMesh->GetNormal());
//      pMesh->SetShapePoly(polyShape);
//      pMesh->SetShapeBase(XPoint());
//      pMesh->SetHas2D(TRUE);
// 		pMesh->SetHasDivide2D(TRUE);
// 		pMesh->SetHas3D(TRUE);
//      pMesh->setLayer(InitLayer(LAY_GROUND, FALSE));
//      AddToModelSpace(pMesh, Adesk::kTrue);
		TDbApron *pApron = new TDbApron; // sg modify 090225，改用散水实体
		poly.SetElevation(-nElevDiff);
		pApron->SetPathPoly(poly, pApron->GetNormal());
		pApron->SetInHeight(_AS_SYS_UNIT(20));
		pApron->SetOutHeight(_AS_SYS_UNIT(10));
		pApron->SetAllDists(nDist);
		pApron->setLayer(InitLayer(LAY_GROUND, FALSE));
		AddToModelSpace(pApron, Adesk::kTrue);
        ent.FreeGroups();
    }
}


// Add by lcf on 20050822
// command:搜索房间
BOOL g_bGround = TRUE;
BOOL g_bShield = TRUE;
BOOL g_bBuildRoom = TRUE; // changed by fxj 080701
extern TARCH_IMPEXP BOOL g_bMakeExtSpace;
extern TARCH_IMPEXP BOOL g_bIgnoreColumn;
// modify by xly on 110413 支持字母数字连字符（"-"）
//int g_nStartCode = 1001;
CString g_csStartCode = _T("1001");
double g_dThick = 120;

double g_dMinSpace = 0; // add by fxj 090617 最小面积
BOOL g_bMaxSpace = FALSE;// add by fxj 090617 有无最大面积限制

// modify by xly 100826 统一单位平方米
//double g_dMaxSpace = 90000000; // add by fxj 090617 最大面积
double g_dMaxSpace = 90; // add by fxj 090617 最大面积

class CSearchRoomDlg : public CModelessDialog
{
public:
	CSearchRoomDlg(CWnd* pParent = NULL);

	enum { IDD = IDD_SEARCH_ROOM };
	CEdit m_editThick;
	CEdit m_editNumber;
// 	BOOL m_bAreaUnit; // sg modify 081128
	static BOOL m_bAreaUnit;

	// modify by xly on 101019 变为静态变量
	//BOOL m_bDimArea;
	static BOOL m_bDimArea;// 是否标注面积

	int m_nVisible;
 	
	// modify by xly 0n 101101 变为静态变量
	//BOOL m_bDimCode; // sg add 081118，是否标注房间编号、名称，替换原来的m_nVisible
	//BOOL m_bDimName;   
	static BOOL m_bDimCode;// 是否标注房间编号
	static BOOL m_bDimName;// 是否标注房间名

	static BOOL m_bMarkWall; // sg add 081118，是否自动识别内外墙

protected:
	virtual void DoDataExchange(CDataExchange* pDX);
	virtual BOOL OnInitDialog();
	DECLARE_MESSAGE_MAP()
	afx_msg void OnBnClickedCheckGround();
	afx_msg void OnBnClickedExtSpace();

	//del by fxj 090426
	//afx_msg void OnEnChangeEditStartnumber();
	//afx_msg void OnEnChangeEditThick();//add by fxj 090409
	afx_msg void OnKillFocusThick();//add by fxj 090426
	afx_msg void OnBnClickedCheckSpaceCode(); // sg add 081118
	afx_msg void OnBnClickedCheckSpaceName();
	afx_msg void OnClose();//add by fxj 090325
	afx_msg void OnClickArea();//add by fxj 090519

};

BOOL CSearchRoomDlg::m_bMarkWall = TRUE; // sg add 081126 //changed by fxj 090601
BOOL CSearchRoomDlg::m_bAreaUnit = TRUE;  // sg add 081128

// add by xly 0n 101019 为静态变量初始化
BOOL CSearchRoomDlg::m_bDimCode = FALSE;
BOOL CSearchRoomDlg::m_bDimName = TRUE;
BOOL CSearchRoomDlg::m_bDimArea = TRUE;

CSearchRoomDlg::CSearchRoomDlg(CWnd* pParent)
: CModelessDialog(CSearchRoomDlg::IDD, pParent)
//, m_bAreaUnit(FALSE) // sg delete 081128，根据林工的意见修改默认值
//, m_bDimArea(TRUE)   // delete by xly on 101101 房间面积为静态变量
, m_nVisible(0)
{
	int nSpFlag = DocGetSpaceDispMode();

	// delete by xly on 101101 房间面积为静态变量
//	m_bDimArea = (nSpFlag&SPF_AREA)!=0;
//// 	m_bAreaUnit = (nSpFlag&SPF_UNIT)!=0; // sg delete 081128
	m_nVisible = (nSpFlag&SPF_CODE)!=0;

	//if ((nSpFlag&SPF_NAME_AND_CODE) != 0) // sg add 081118
	//{
	//	m_bDimCode = TRUE;
	//	m_bDimName = TRUE;
	//}
	//else if ((nSpFlag&SPF_CODE) != 0)
	//{
	//	m_bDimCode = TRUE;
	//	m_bDimName = FALSE;
	//}
	//else
	//{
	//	m_bDimCode = FALSE;
	//	m_bDimName = TRUE;
	//}
}

void CSearchRoomDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	DDX_Check(pDX, IDC_CHECK_AREAUNIT, m_bAreaUnit);
	DDX_Check(pDX, IDC_CHECK_DIMAREA, m_bDimArea);
	DDX_Check(pDX, IDC_CHECK_GROUND, g_bGround);
	DDX_Check(pDX, IDC_EXT_SPACE, g_bMakeExtSpace);
	DDX_Check(pDX, IDC_CHECK_SHIELD, g_bShield);
	DDX_Check(pDX, IDC_NO_COLUMN, g_bIgnoreColumn);
	DDX_Radio(pDX, IDC_RADIO_NAME, m_nVisible);
	DDX_Control(pDX, IDC_EDIT_THICK, m_editThick);
	DDX_Text(pDX, IDC_EDIT_THICK, g_dThick);
	//DDX_Text(pDX, IDC_EDIT_STARTNUMBER, g_nStartCode);
	DDX_Text(pDX, IDC_EDIT_STARTNUMBER, g_csStartCode);
	DDX_Control(pDX, IDC_EDIT_STARTNUMBER, m_editNumber);
	DDX_Check(pDX, IDC_CHECK_SPACECODE, m_bDimCode); // sg add 081118
	DDX_Check(pDX, IDC_CHECK_SPACENAME, m_bDimName);
	DDX_Check(pDX, IDC_CHECK_MARKWALL, m_bMarkWall);
}

BEGIN_MESSAGE_MAP(CSearchRoomDlg, CModelessDialog)
	ON_BN_CLICKED(IDC_CHECK_GROUND, OnBnClickedCheckGround)
	ON_BN_CLICKED(IDC_EXT_SPACE, OnBnClickedExtSpace)
	ON_BN_CLICKED(IDC_CHECK_SPACECODE, OnBnClickedCheckSpaceCode) // sg add 081118
	ON_BN_CLICKED(IDC_CHECK_SPACENAME, OnBnClickedCheckSpaceName)

	//del by fxj 090426
	//ON_EN_CHANGE(IDC_EDIT_STARTNUMBER, OnEnChangeEditStartnumber)
	//ON_EN_CHANGE(IDC_EDIT_THICK, OnEnChangeEditThick)//add by fxj 090409

	ON_EN_KILLFOCUS(IDC_EDIT_THICK, OnKillFocusThick)//add by fxj 090426
	ON_BN_CLICKED(IDC_CHECK_DIMAREA, OnClickArea)//add by fxj 090519
    ON_WM_CLOSE()//add by fxj 090325
END_MESSAGE_MAP()

extern int TARCH_IMPEXP g_nProductId;

BOOL CSearchRoomDlg::OnInitDialog()
{
	CModelessDialog::OnInitDialog();
	OnBnClickedCheckGround();
	GetDlgItem(IDC_NO_COLUMN)->EnableWindow(g_bMakeExtSpace);
	
	// sg add 090319，节能软件中，强制识别内外
	if (g_nProductId==kTBECN || g_nProductId==kTBECP)
	{
		m_bMarkWall = TRUE;
		GetDlgItem(IDC_CHECK_MARKWALL)->EnableWindow(FALSE);
	}

	// add by xly on 101210 设置房间对象的显示
	TDbSpace Spce;
	Spce.SetSpaceDispMode(1);
	m_bDimCode = Spce.IsDimCode();
	m_bDimName = Spce.IsDimName();	
	m_bDimArea = Spce.IsDimArea();
	m_bAreaUnit = Spce.IsDimUnit();
	GetDlgItem(IDC_CHECK_AREAUNIT)->EnableWindow(m_bDimArea);//add by fxj 090519

	UpdateData(FALSE);
	return TRUE;
}

void CSearchRoomDlg::OnBnClickedCheckGround()
{
	CDataExchange dx(this, TRUE);
	DDX_Check(&dx, IDC_CHECK_GROUND, g_bGround);
	m_editThick.EnableWindow(g_bGround);
}
void CSearchRoomDlg::OnBnClickedExtSpace()
{
	CDataExchange dx(this, TRUE);
	DDX_Check(&dx, IDC_EXT_SPACE, g_bMakeExtSpace);
	GetDlgItem(IDC_NO_COLUMN)->EnableWindow(g_bMakeExtSpace);
}
void CSearchRoomDlg::OnClickArea()//add by fxj 090519
{
	m_bDimArea=!m_bDimArea;
	GetDlgItem(IDC_CHECK_AREAUNIT)->EnableWindow(m_bDimArea);
}
//void CSearchRoomDlg::OnEnChangeEditStartnumber()
//{
//	CString szText;
//	m_editNumber.GetWindowText(szText);
//	int nNumber = _ttoi(szText);
//	if (nNumber > 0)
//		g_nStartCode = nNumber;
//    else
//	{//add by fxj 090409
//		this->MessageBox(_T("起始编号不能小于1!"),_T("AutoCAD"),MB_OK);
//		m_editNumber.SetFocus();
//	}
//	CDataExchange dx1(this, FALSE);
//	DDX_Text(&dx1, IDC_EDIT_STARTNUMBER, g_nStartCode);
//}
//void CSearchRoomDlg::OnEnChangeEditThick()//add by fxj 090409
//{
//	CString szText;
//	m_editThick.GetWindowText(szText);
//	double dThick = _tstof(szText);
//	if (dThick > 1E-6)
//		g_dThick = dThick;
//    else
//	{
//		this->MessageBox(_T("板厚需大于0!"),_T("AutoCAD"),MB_OK);
//		m_editThick.SetFocus();
//	}
//	CDataExchange dx1(this, FALSE);
//	DDX_Text(&dx1, IDC_EDIT_THICK, g_dThick);
//}


void CSearchRoomDlg::OnKillFocusThick()//add by fxj 090426
{
	CString szText;
	m_editThick.GetWindowText(szText);
	double dThick = _tstof(szText);
	if (szText== _T("")||dThick<-1E-6)
	{
		//del by fxj 090513
		//this->MessageBox(_T("板厚不能为空或负数!"),_T("AutoCAD"),MB_OK);
		//m_editThick.SetFocus();
	
	}
	else 
		g_dThick = dThick;
  
	CDataExchange dx1(this, FALSE);
	DDX_Text(&dx1, IDC_EDIT_THICK, g_dThick);
}
void CSearchRoomDlg::OnBnClickedCheckSpaceCode() // sg add 081118
{
	UpdateData(TRUE);
	// delete by xly 0n 101101 8.5需求房间名称和编号可以都不显示
	/*if (!m_bDimCode)
	{
		m_bDimName = TRUE;
	}*/
	UpdateData(FALSE);
}

void CSearchRoomDlg::OnBnClickedCheckSpaceName() // sg add 081118
{
	UpdateData(TRUE);
	// delete by xly 0n 101101 8.5需求房间名称和编号可以都不显示
	/*if (!m_bDimName)
	{
		m_bDimCode = TRUE;
	}*/
	UpdateData(FALSE);
}

void CSearchRoomDlg::OnClose()//add by fxj 090325
{
	if (m_bModeless)
		acedPostCommand(_T("\33"));
	else
		CModelessDialog::OnClose();
}


////////////////////////////////////////////////
// 根据用户输入的房间编号csSpaceCode，分析判断编号规则，sg add 081209
// csFixed：编号中的固定部分
// nNum：可变数字部分，程序自动循环加1
// 特殊情况：
// 1）最后1位是字母，如：101A，则固定部分在后，数字部分在前，设置bASCII为TRUE
// 2）nNum部分首位有0，如：A001，则设置nZeroNum为对应的0的数量
void AnalysisSpaceCode(CString csSpaceCode, CString &csFixed, int &nNum,
					   BOOL &bASCII, int &nZeroNum)
{
	int nLeft(-1),						// 固定部分长度
		nLen = csSpaceCode.GetLength(); // 编号总长度
	for (int i = nLen-1; i >= 0; i--)
	{
		if (!_istdigit(csSpaceCode.GetAt(i))) // 逆向查找，得到第1个非数字的位置
		{
			bASCII = i == nLen-1; // 若最后1位是非数字，则bASCII为TRUE
			nLeft = bASCII?(i):(i+1);
			break;
		}
	}

	if (nLeft == -1) // 全部为数字，1001、1002、1003...
	{
		nLeft = 0;
	}
	else if (bASCII) // 数字部分在前，101A、102A、103A...
	{
		for (int j = 0; j<nLen; j++)
		{
			if (!_istdigit(csSpaceCode.GetAt(j))) // 正向查找，得到第1个非数字的位置
			{
				nLeft = j; // 此时的nLeft表示数字部分长度
				break;
			}
		}
	}

	int nRight = nLen - nLeft; // 循环增加部分长度
	if (bASCII) // *1A、*2A、*3A......
	{
		csFixed = csSpaceCode.Right(nRight);   // 固定部分
		nNum = _ttoi(csSpaceCode.Left(nLeft)); // 数字部分
	}
	else // *1、*2、*3......
	{
		csFixed = csSpaceCode.Left(nLeft);
		CString csNum = csSpaceCode.Right(nRight);
		if (csNum.GetAt(0) == _T('0')) // 处理001、002、003...问题
		{
			int j(1);
			nLen = csNum.GetLength();
			while (j<nLen && csNum.GetAt(j)==_T('0'))
			{
				j++;
			}
			nZeroNum = j;
		}
		nNum = _ttoi(csSpaceCode.Right(nRight));
	}
}


class TSpaceCode // sg add 081208，房间排序辅助类
{
public:
	AcDbObjectId	m_id;		// 房间ID
	XPoint			m_ptLoc;	// 房间标注位置点（比较条件），考虑凹多变形，用户会调整默认标注
	double			m_dAngle;	// X轴方向角，其实不应该出现在此类中

public:
	TSpaceCode(double dAngle, AcDbObjectId id, XPoint pt);

public:
	static int CompareYFistAndXYSort(const TSpaceCode *space1,
		const TSpaceCode *space2); // Y坐标优先，Y越大编号越大，X越大编号越大

	// 8.0只完成了一种比较条件，其他情况8.5完成
	// Y坐标优先，Y越大编号越大，X越小编号越大
	// Y坐标优先，Y越小编号越大，X越大编号越大
	// Y坐标优先，Y越小编号越大，X越小编号越大
	// X坐标优先，X越大编号越大，Y越大编号越大
    // X坐标优先，X越大编号越大，Y越小编号越大
	// X坐标优先，X越小编号越大，Y越大编号越大
	// X坐标优先，X越小编号越大，Y越小编号越大
};

TSpaceCode::TSpaceCode(double dAngle, AcDbObjectId id, XPoint pt)
{
	m_id = id;
	m_ptLoc = pt;
	m_dAngle = dAngle;
}

int TSpaceCode::CompareYFistAndXYSort(const TSpaceCode *space1,
									  const TSpaceCode *space2)
{
	XPoint ptLoc1 = space1->m_ptLoc,
		ptLoc2 = space2->m_ptLoc;
	
	ads_matrix matRot;
	double dAngle = space1->m_dAngle;
	XPoint().GetRotationMatrix(dAngle, matRot);
	ptLoc1 = ptLoc1.TransformAs(matRot); // 坐标变化
	ptLoc2 = ptLoc2.TransformAs(matRot);
	
	if (fabs(ptLoc1.y - ptLoc2.y) < _SPACE_DIST_SNAP) // Y坐标相等，比较X
	{
		if (fabs(ptLoc1.x - ptLoc2.x) < _SPACE_DIST_SNAP) // X坐标相等
		{
			return 0;
		}
		
		if (ptLoc1.x > ptLoc2.x + _SPACE_DIST_SNAP) // X越大，编号越大
		{
			return 1;
		}
		return -1;
	}
	
	if (ptLoc1.y > ptLoc2.y + _SPACE_DIST_SNAP) // Y坐标不等，只比较Y，Y越大，编号越大
	{
		return 1;
	}
	return -1;
}


// 编号排序算法，sg add 081204
// ssSpace：待排序选择集，考虑方便“搜索房间”调用，使用选择集传入数据
// csCode：接收用户设置的编号，排序完成后，返回当前编号规则的下一编号，方便在同层、同楼分批排序
// dAnlge：X正向的角度，相当于设置了UCS
// bYFirst：是否Y坐标优先于X坐标考虑，8.0不提供用户设置
// bXAxisSort、bYAxisSort：是否X、Y值越大，编号越大，8.0不提供用户设置
void SortSpace(PickSet &ssSpaces, CString &csCode, double dAngle = 0.0,
			   BOOL bYFirst = TRUE, BOOL bXAxisSort = TRUE, BOOL bYAxisSort = TRUE)
{
	DList<TSpaceCode> lstSpaces;
	long lCount = ssSpaces.Length();
	for (long l=0; l<lCount; l++)
	{
		Entity ent = ssSpaces[l];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSpace, pSpace);
		if (pSpace != NULL)
		{
			XPoint pt = pSpace->m_ptLocation;
			// sg add 090225，dAngle为当前坐标系，因此点应该转化为当前坐标系
			pt = Wcs2Ucs(pt);
			AcDbObjectId id = pSpace->objectId();
			TSpaceCode *pCodeSort = new TSpaceCode(-dAngle, id, pt); // 排序类
			lstSpaces.Append(pCodeSort); // 1、构造排序链表
		}
		OPENOBJ_END();
	}
	
	lstSpaces.QuickSort(TSpaceCode::CompareYFistAndXYSort); // 2、排序
	
	int nNum(0),        // 编号中的数字部分，程序自动循环加1
		nZeroNum(0);	// nNum中开头部分0的数量
	CString csFixed;    // 编号中的固定部分
	BOOL bASCII(FALSE); // 数字部分是否在固定部分之前
	AnalysisSpaceCode(csCode, csFixed, nNum, bASCII, nZeroNum); // 3、分析用户输入的编号规则

	int nCount = lstSpaces.Length();
	for (int i=0; i<=nCount; i++) // 4、修改房间编号
	{
		if (bASCII) // *1A、*2A、*3A......
		{
			csCode = XString(_T("%d"), nNum++) + csFixed;
		}
		else // *1、*2、*3......
		{
			switch(nZeroNum) {
			case 1: // *01、*02、*03......
				csCode = csFixed + XString(_T("%02d"), nNum++);
				break;
			case 2: // *001、*002、*003......
				csCode = csFixed + XString(_T("%03d"), nNum++);
				break;
			case 3: // *0001、*0002、*0003......
				csCode = csFixed + XString(_T("%04d"), nNum++);
				break;
			default:
				csCode = csFixed + XString(_T("%d"), nNum++);
				break;
			}
		}

		if (i == nCount)
		{
			break; // 多循环一次，只为得到下一个编号
		}

		AcDbObjectId id = lstSpaces[i]->m_id;
		OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbSpace, pSpace);
		if (pSpace != NULL)
		{
			pSpace->assertWriteEnabled(); // 通知实体可写
			pSpace->SetCode(csCode);
		}
		OPENOBJ_END();
	}
}


// command: 房间编号排序命令函数，sg add 081204
void SortSpaceCodeCmd()
{
	g_ssPickFirst.Free();
	double dAngle(0);				 // X轴的旋转角度
	CString csFirstNum = _T("1001"); // 起始编号
	RBList spaceMask(RTDXF0, _T("TCH_SPACE"), NULL);
	while (1)
	{
		PickSet ssSpaces(SS_FREE); // 1、选择要排序的房间
		if (SelectEntities(_T("\n请选择房间对象<退出>:"), ssSpaces, spaceMask) != RTNORM)
		{
			break;
		}

		PickSet ssOtherSpace(SS_FREE); // sg add 090225，仅保留普通房间对象进行排序
		long count = ssSpaces.Length();
		for (long i=0; i<count; i++)
		{
			Entity ent = ssSpaces[i];
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSpace, pSpace);
			if (pSpace != NULL)
			{
				TDbSpace::AreaType nType = pSpace->GetType();
				// sg modify 090511，考虑节能需求，公摊面积、洞口面积参与排序
//				if (nType != TDbSpace::kUseArea)
				if (nType!=TDbSpace::kUseArea && nType!=TDbSpace::kShareArea &&
					nType!=TDbSpace::kHoleArea)
					ssOtherSpace += ent;
			}
			OPENOBJ_END();
		}
		ssSpaces -= ssOtherSpace;

		XPoint ptBase;    // UCS基点
		CString csPrompt; // 2、获取X轴的旋转角度
		int nRet = ads_getpoint(NULL, _T("\n指定UCS原点<使用当前坐标系>:"), ptBase);
		if (nRet == RTNORM) // 需要修改X轴的旋转角度，设置UCS
		{
			double dUserNum = dAngle;
			csPrompt.Format(_T("\n指定绕Z轴的旋转角度<%.0f>:"), dAngle*180/PI); // 角度制显示
			nRet = ads_getangle(ptBase, csPrompt, &dUserNum);
			if ((nRet != RTNORM) && (nRet != RTNONE))
			{
				break;
			}
			else if (nRet == RTNORM)
			{
				dAngle = dUserNum;
			}
		}
		else // 使用WCS
		{
			dAngle = 0;
		}
		
		XString sCode;
		csPrompt.Format(_T("\n起始编号<%s>:"), csFirstNum);
		nRet = acedGetString(TRUE, csPrompt, sCode); // 3、获取用户设置的房间编号
		if (nRet != RTNORM)
		{
			break;
		}
		else if (sCode != _T(""))
		{
			csFirstNum = sCode;
		}

		// 8.5在此处增加用户设置X、Y坐标优先级，及排序原则等的询问

		SortSpace(ssSpaces, csFirstNum, dAngle, TRUE, TRUE, TRUE); // 4、排序
	}
}

int GetMaxCodeInOldSpaces()
{
    RBList spaceMask(RTDXF0, _T("TCH_SPACE"), NULL);
	PickSet ssSpaces(SS_FREE); // sg add 081226，首先搜索房间中，已有房间，获取最大编号
	ssSpaces.Get(_T("X"), NULL, NULL, spaceMask);

	int nMaxNum(1000);
	long count = ssSpaces.Length();
	for (long i=0; i<count; i++)
	{
		Entity ent = ssSpaces[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSpace, pSpace);
		if (pSpace != NULL)
		{
			BOOL bASCII(FALSE);
			CString csCode = pSpace->GetCode(),
				csFixed;
			int nCurrentNum(0), nZeroNum(0);
			AnalysisSpaceCode(csCode, csFixed, nCurrentNum, bASCII, nZeroNum);

			if (nMaxNum < nCurrentNum)
			{
				nMaxNum = nCurrentNum;
			}
		}
		OPENOBJ_END();
	}
	return ++nMaxNum;
}
// add by xly on 10413 添加解析房间编号的函数，支持字母数字连字符
// 解析编号中最后几位的数字递增
CString AnalySpaceCode(CString csCode)
{
		int nSelf(0);
	CString csTemp(_T(""));
	if (IsDigital(csCode))
	{
		nSelf = _ttoi(csCode);
		nSelf ++;
		csTemp.Format(_T("%d"),nSelf);
		return csTemp;
	}
	int nLen = csCode.GetLength();
	CString csRet = _T(""),
		csLeft = _T(""),
		csRight = _T("");

	int nFix(0);
	int nNum(0);

	// 倒遍历字符串，找到最后一组数字
	for (int n=nLen-1;n>=0;n--)
	{
		TCHAR sChar = csCode.GetAt(n);
		if (sChar>=_T('0')&&sChar<=_T('9'))
		{
			if (nNum>0)
			{
				if (nFix-n==1)
				{
					nFix = n;
					csRet += sChar;
					nNum++;
				}
			}
			else
			{
				nFix = n;
				csRet += sChar;
				nNum++;
			}
		
		}
	}
	// 导致字符串
	csRet.MakeReverse();

	// 获得左右字符串
	csLeft = csCode.Left(nFix);
	csRight = csCode.Right(nLen-csLeft.GetLength()-csRet.GetLength());
	
	// 将尾部的数字数组递增
	nSelf = _ttoi(csRet);
	nSelf ++;
	csTemp.Format(_T("%d"),nSelf);

	// 拼合字符串
	csRet = csLeft;
	csRet += csTemp;
	csRet += csRight;

	return csRet;
}
////////////////////////////////////////////////
// command: 自动标房间面积
// 必须在WCS下
// TARCH_IMPEXP
void SpaceArea()
{
	// 一、add by fxj 090617，从文件中，获取最大、最小允许面积
	XString sTchSpace;
	if (FindFile(_T("tchspace.ini"), sTchSpace)) 
	{
		INI_struct *inis = NULL;
		if (CT_get_INIs(sTchSpace, _T("Space"), &inis)) 
		{
			TCHAR *pMinSpace = CT_get_INI2(inis, _T("MinSpace"));
			if (pMinSpace)
				g_dMinSpace = _tstof(pMinSpace);

			TCHAR *pMaxSpace = CT_get_INI2(inis, _T("MaxSpace"));
			if (pMaxSpace)
			{
				CString sMaxSpace = pMaxSpace;
				if (sMaxSpace == _T("infinite")) // 不限制
					g_bMaxSpace = FALSE;
				else
				{
					g_bMaxSpace = TRUE;
					g_dMaxSpace = _tstof(pMaxSpace);
				}
			}

			CT_free_INIs(inis);
		}
	} 

	// modify by xly on 110413 支持字母数字连字符
	// 二、sg add 081226，首先搜索房间中，已有房间，获取最大编号
	//g_nStartCode = GetMaxCodeInOldSpaces();
	g_csStartCode.Format(_T("%d"),GetMaxCodeInOldSpaces());


	// 三、初始化对话框
	CSearchRoomDlg dlg(acedGetAcadFrame());
	{
		CAcModuleResourceOverride vTemp;
		if ( !dlg.Create(dlg.IDD, acedGetAcadFrame()) )
			return;
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	// 四、清空选择集，准备开始选择
	g_ssPickFirst.Free();

	RBList spaceMask(RTDXF0, _T("TCH_SPACE"), NULL), // 该过滤表实际上未使用
		wallMask(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL,TCH_OPENING,TCH_SPACE"), NULL);
	PickSet ssSpaces(SS_FREE), ssWalls(SS_FREE),
		ssAllSpaces(SS_FREE); // sg add 081209，全部房间对象，包括选中的，和新生成的
	{
		// sg add 100825，为提高搜索房间质量，强制将墙基线打开
		int nVal = g_bShowBase;
		if (nVal == 0) // 双线
		{
			DocSetShowBase(1); // 单双线显示
			PickSet ssTmpWall(SS_FREE);
			if (GetEntByDxf(ssTmpWall, _T("TCH_WALL,TCH_CURTAIN_WALL"), 1) == Acad::eOk)
			{
				UpdateGraphic(ssTmpWall);
			}
		}

		// modify by xly on 101104 修改搜索房间的命令行提示，与需求文档一致
		// 说明第一次搜索的时候有<退出>，再次选择的时候没有；
		/*if (SelectEntities(_T("\n请选择构成一完整建筑物的所有墙体(或门窗): "), ssWalls, wallMask) != RTNORM)
		{
			dlg.DestroyWindow();
			return;
		}*/
		SelectEnts(_T("\n请选择构成一完整建筑物的所有墙体(或门窗)<退出>:"), _T("\n请选择构成一完整建筑物的所有墙体(或门窗):"),
			ssWalls, wallMask);
		if (ssWalls.Length()<1)
		{
			dlg.DestroyWindow();

			// add by xly on 1026 解决搜索房间墙线不显示，如果退出搜索恢复墙体显示
			if (nVal == 0) // 恢复双线显示
			{
				DocSetShowBase(0); // 双线显示
				PickSet ssTmpWall(SS_FREE);
				if (GetEntByDxf(ssTmpWall, _T("TCH_WALL,TCH_CURTAIN_WALL"), 1) == Acad::eOk)
				{
					UpdateGraphic(ssTmpWall);
				}
			}
			return;
		}

		if (nVal == 0) // 恢复双线显示
		{
			DocSetShowBase(0); // 双线显示
			PickSet ssTmpWall(SS_FREE);
			if (GetEntByDxf(ssTmpWall, _T("TCH_WALL,TCH_CURTAIN_WALL"), 1) == Acad::eOk)
			{
				UpdateGraphic(ssTmpWall);
			}
		}
	}


	// 五、过滤掉选中的“套内面积”
	PickSet ssOtherSpace(SS_FREE);
	long count = ssWalls.Length();
	for (long i=0; i<count; i++)
	{
		Entity ent = ssWalls[i];
		// 		if (ent.Is(_T("TCH_SPACE")))
		// 			ssSpaces += ent;

		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSpace, pSpace);
		if (pSpace != NULL)
		{
			TDbSpace::AreaType nType = pSpace->GetType(); // 获取房间类型
			// chenged by fxj 090420  ssotherspace为套内面积
			// if (nType!=TDbSpace::kUseArea && nType!=TDbSpace::kTotalArea)
			if (nType == TDbSpace::kHouseArea)
				ssOtherSpace += ent;
			else
				ssSpaces += ent;
		}
		OPENOBJ_END();
	}

	if (ssSpaces.Length() > 0) // sg add 081209，获取选中的房间对象
	{
		ssAllSpaces += ssSpaces;
		ssWalls -= ssSpaces;
	}

	if (ssOtherSpace.Length() > 0) // sg add 090225，过滤选中的套内面积
	{
		ssWalls -= ssOtherSpace;
	}


	// 六、获取门窗所在墙，并过滤点矮墙和隔墙
	MakeWallSet(ssWalls);


	// 七、更新对话框中的数据
	dlg.UpdateData();
	BOOL bDimArea = dlg.m_bDimArea;
	BOOL bAreaUnit = dlg.m_bAreaUnit;
	BOOL bGround = g_bGround;
	BOOL bShield = g_bShield;
	//int nVisible = dlg.m_nVisible;// delete by xly on 101111 没有使用
	double dThick = g_dThick;
	BOOL bMarkWall = dlg.m_bMarkWall; // sg add 081118，增加识别内外
	BOOL bDimCode = dlg.m_bDimCode;
	BOOL bDimName = dlg.m_bDimName;
	CString csFirstNum;
	// modify by xly on 110413 支持字母数字连字符
	//csFirstNum.Format(_T("%d"), g_nStartCode);
	csFirstNum = g_csStartCode;
	dlg.DestroyWindow();


	// 八、获得所有柱子对象
	DList<AcDbObjectId> lstColu;
	GetEntFromBlockByDxf(lstColu, _T("TCH_COLUMN"));


	// add by xly on 100831，多轮廓搜索房间时，保存其他轮廓的墙体
	PickSet ssOther(SS_FREE);
	// add by xly on 101012，修改当柱子在墙中时出现死循环提示，设置计数
	int iNum = 1;

	// add by xly on 101104 用于记录用户是否在过程中，选择了放弃产生建筑面积对象；
	bool bDimTotalArea = true;

	// add by xly on 110302 增加变量控制是否为多轮廓
	bool bHasOtherSpace(false);

	// 九、开始循环取得所有的闭合裁剪区域
	// sg modify 100830，搜索区域内如果有被柱子完全遮挡的“小短墙”，自动从选择集中过滤掉
	// 注：此处没有想出更好的办法，只能使用GOTO语句
SEARCHSPACE_LAB_BEGIN:
	XSearchSpaceFromWall aSearch;
	try
	{
		aSearch.InitStart(ssWalls, lstColu);
	}
	catch(TSearchException e) 
	{
		if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_MARK || e.m_nHowToDo == HF_NONE) 
		{
			ssWalls -= e.m_idObj; // 从选择集中过滤掉“小短墙”
			goto SEARCHSPACE_LAB_BEGIN;
		}

		return;
	} 
	catch(...)
	{
		adsout << /*UMSG*/_T("\n发生例外情况!");
		return;
	}


	// 十、得到所有的闭合区域，extCell为最外轮廓
	XAecSpaceCell *extCell = aSearch.SearchSpaces();

	// modify by xly on 100901 对于多轮廓生成房间时，不管是否忽略柱子、是否生成建筑面积仍然区分多轮廓
	XPoly2D polyOut;
	/*
	if (extCell!=NULL && g_bMakeExtSpace && g_bIgnoreColumn)
	{
	extCell->InternalPoly2D(polyOut, 0);
	}
	*/
	if (extCell!=NULL &&  g_bMakeExtSpace) // 生成建筑轮廓
	{
		if (g_bIgnoreColumn) // 忽略柱子
		{
			extCell->InternalPoly2D(polyOut, 0, 0);
		}
		else	  			 // 不忽略柱子
		{
			extCell->InternalPoly2D(polyOut, 2);
		}
	}
	else if (!g_bMakeExtSpace) // 不生成建筑外轮廓
	{
		extCell->InternalPoly2D(polyOut, 0, 0);
	}


	// 十一、 add by xly on 100831 添加多轮廓搜索房间 
	{
		ssOtherSpace.Free();

		// 获得所有房间对象
		int nLenSpaces = aSearch.spaces.Length(); // 房间对象的个数
		for (int n = 0; n<nLenSpaces; n++)
		{
			XAecSpaceCell *pSpace = aSearch.spaces[n];	// 得到房间
			if (pSpace == extCell)						// 判断是否是当前得到的外轮廓，是，则返回
				continue;

			// 获得房间的轮廓
			XPoly2D polySpace(1);
			pSpace->CenterPoly2D(polySpace);

			// 外轮廓与房间的轮廓做布尔交集运算，结果保存在lstPolyRest中
			TDPtrList<TGGePoly2D>  lstPolyRest;
			TchSubExport::Intersect(polyOut, polySpace, lstPolyRest);

			// 判断lstPolyRest的长度，如果长度为零，不存在交集属于两个轮廓
			int nRetLen = lstPolyRest.Length();
			if (nRetLen < 1) // 没有交集
			{
				// 获得组成房间pSpace的所有的墙体
				int nLenth = pSpace->Length();
				for(int j = 0; j<nLenth; j++)
				{
					// 将其他轮廓的结果保存在ssOtherSpace选择集中
					TAecSpaceWall *pSpaceWall = pSpace->GetAt(j);
					ssOtherSpace += pSpaceWall->m_ent;
				}
			}
		}

		// 如果存在其他轮廓，重新搜索
		nLenSpaces = ssOtherSpace.Length();	
		if (nLenSpaces > 0)
		{
			// 保存其他轮廓
			ssOther += ssOtherSpace;

			// 删除不属于该轮廓的墙体
			ssWalls -= ssOtherSpace;

			// modify by xly on 101012 修改当柱子在墙中时出现死循环提示
			// goto SEARCHSPACE_LAB_BEGIN;
			if (ssWalls.Length() > 0)
			{
				goto SEARCHSPACE_LAB_BEGIN;
			}
			else // ssWalls中为空时，把本次添加都图面，然后跳出
			{
				iNum++;
				if (iNum > 2)
				{
					return;
				}
			}
		}

		// 不生成建筑轮廓时，polyOut是空的
		if (!g_bMakeExtSpace)
		{
			polyOut = NULL;
		}
	}


	// 十二、识别内外，add by whl on 060206 
	if (extCell!=NULL && bMarkWall)
	{
		aSearch.UpdateWallFlags();

		XPoly2D poly(1);
		extCell->InternalPoly2D(poly, 0, 0);
		poly.SetElevation(0.0);

		// sg add 081118，全部墙的数组，识别内外用
		AcDbObjectIdArray idWalls;
		ssWalls.AsIdArray(idWalls);
		// ssSpaces.Get(_T("X"), NULL, NULL, spaceMask);

		for (long i=0; i<idWalls.length(); i++) // 对所有外墙设置内外特征
		{
			TDbWall *pWall = NULL;
			acdbOpenObject(pWall, idWalls[i], AcDb::kForWrite);
			if (pWall != NULL)
			{
				if (pWall->IsExternal())
				{
					XCurveSegment lCurve, rCurve;
					pWall->GetSideCurve(lCurve, rCurve, 0.0, TRUE);
					XPoint ptMid = lCurve.MidPoint();
					ptMid.z = 0;

					int iRet = ptMid&poly;
					if (iRet == PR_EDGE) // 左外
					{
						pWall->SetExternal(0, TRUE);
						pWall->SetExternal(1, FALSE);
					}
					else // 右外
					{
						pWall->SetExternal(0, FALSE);
						pWall->SetExternal(1, TRUE);
					}
				}
				pWall->close();
			}
		}
		TArchCmdReactor::ResetAll();
	}
	else if (bMarkWall)
	{
		adsout << _T("\n没有判别出内外墙!请使用指定内墙、指定外墙命令手动指定。");
	}


	// 十三、处理普通房间对象，创建或更新几何关系
	for (int n=0; n<aSearch.spaces.Length(); n++)
	{
		XAecSpaceCell *pSpace = aSearch.spaces[n];
		if (pSpace == extCell) // 判断是否是当前得到的外轮廓
			continue;

		XPoly2D polySpace(1);
		if (pSpace==extCell && polyOut.Length()>2)
			polySpace = polyOut;
		else
			pSpace->CenterPoly2D(polySpace);
		polySpace.SetElevation(0.0); // 投影到z=0的平面上

		long lCount = !ssSpaces ? 0L : ssSpaces.Length();
		PickSet ssInCell(SS_FREE|SS_CREATE); // 在当前SpaceCell中的DbSpace实体

		// del by fxj 090610 套内面积内的非套内面积对象要进行更新
		//-------------add by fxj 090420-------套内面积不进行更新
		//BOOL bHouseArea=FALSE;
		//long lCountOther = !ssOtherSpace? 0L : ssOtherSpace.Length();
		//for(long j=0L; j<lCountOther; j++)
		//{
		//	Entity e=ssOtherSpace[j];
		//	XDbObject obj(e, AcDb::kForRead);
		//  if (!obj)
		//		continue;
		//	TDbSpace *pDbSpace = TDbSpace::cast(obj.m_pObject);
		//    ASSERT(pDbSpace);
		//    XPoint ptLoc = pDbSpace->m_ptLocation;
		//    ptLoc.z = 0.0;
		//     if (pSpace == extCell) // 室外
		//	{
		//        if ((ptLoc&polySpace) == PR_OUTSIDE)
		//		{
		//                  bHouseArea=TRUE;
		//			break;
		//		}
		//  }
		//	else
		//	{
		//              if ((ptLoc&polySpace) == PR_INSIDE)
		//		{
		//                  bHouseArea=TRUE;
		//			break;
		//		}
		//  }
		//}
		//if (bHouseArea)
		//	continue;
		//------------------------------------------------------


		// add by xly 100830 与最大最小面积比较的时候用内墙的面积；
		// 房间的几何更新时，如果内墙面积小于最小值时删除不符合的标注
		// 注：在最大值比较时，遵循原有情况：只提示，仍标出
		// 如果房间面积有最大值限制，内墙面积大于最大面积，弹出提示“面积太大，越界！”可以标出面积
		XPoly2D polySpaceInWall(1);
		pSpace->InternalPoly2D(polySpaceInWall, 1);
		polySpaceInWall.SetElevation(0.0);

		double dArea = polySpaceInWall.Area();
		// add by xly 100826 统一单位平方米
		dArea = _AS_SQMETER(dArea);

		// 保存房间更新时插上的不符合的房间对象
		PickSet ssDel(SS_FREE);
		for (long i=0L; i<lCount; i++)
		{
			Entity e = ssSpaces[i];
			XDbObject obj(e, AcDb::kForRead);
			if (!obj)
				continue;

			TDbSpace *pDbSpace = TDbSpace::cast(obj.m_pObject);
			ASSERT(pDbSpace);
			XPoint ptLoc = pDbSpace->m_ptLocation;
			ptLoc.z = 0.0;
			if (pSpace == extCell) // 室外
			{
				if ((ptLoc&polySpace) == PR_OUTSIDE)
					ssInCell += e;
			}
			else // 室内
			{
				if ((ptLoc&polySpace) == PR_INSIDE)
					ssInCell += e;
			}
		}

		if (ssInCell.Length() == 1) // 更新房间的几何参数
		{
			Entity e = ssInCell[0L];
			XDbObject obj(e, AcDb::kForWrite);
			ASSERT(!!obj);

			// add by xly 100830 与最大最小面积比较的时候用内墙的面积；
			// 房间的几何更新时，如果面积小于最小临界值时删除不符合的标注，大于最大值是提示
			if (dArea - g_dMinSpace < -1E-6)
			{
				ssDel += e;
			}
			if (g_bMaxSpace)
			{
				if (dArea - g_dMaxSpace > 1E-6)
				{
					AfxMessageBox(_T("面积太大，越界！"));
				}
			}

			TDbSpace *pDbSpace = TDbSpace::cast(obj.m_pObject);
			ASSERT(pDbSpace);
			pDbSpace->assertWriteEnabled(); // New Update

			// add by xly on 110303 更新房间对象是设置分数层为0
			pDbSpace->SetStuccoThickness(0.0);

			pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);

			if (pSpace==extCell && polyOut.Length()>2)
				pDbSpace->SetPathPoly(polyOut, AcGeVector3d::kZAxis);
		} 
		else // 创建房间
		{
			if (ssInCell.Length()) // 找到不止一个符合更新条件的房间对象
				ssInCell.Erase();

			// delete by xly 100830 提到前面定义，方便房间更新几何参数时使用
			// modify by xly 100827 与最大最小面积比较的时候用内墙的面积
			// -------add by fxj 090617 面积太小过滤，面积太大给提示
			// double dArea=polySpace.Area();
			// double dArea = polySpaceInWall.Area();
			// add by xly 100826 统一单位平方米
			// dArea = _AS_SQMETER(dArea);

			// 创建房间时，如果面积小于最小临界值时不创建，大于最大值是提示
			if (dArea - g_dMinSpace < -1E-6)
				continue;

			if (g_bMaxSpace)
			{
				if (dArea - g_dMaxSpace > 1E-6)
				{
					AfxMessageBox(_T("面积太大，越界！"));
				}
			}
			//-------------------------------


			// 创建新的房间对象
			TDbSpace *pDbSpace = new TDbSpace();
			XPoint ptLoc;
			polySpace.Center(ptLoc);
			ptLoc.z = 0.0;

			if ((ptLoc&polySpace) != PR_INSIDE)
			{
				XPoly polyTemp;
				polySpace.MapToPolygon(polyTemp, 20);
				if (!!polyTemp)
				{
					XPolygonEx polyTri(polyTemp);
					DList<XTriangle> lstTri;
					if (polyTri.Trianglize(lstTri, TRUE)==RTNORM && !!lstTri) 
					{
						XTriangle *pTri = lstTri[0];
						ptLoc.x = (pTri->vertex1.x+pTri->vertex2.x+pTri->vertex3.x)/3.0;
						ptLoc.y = (pTri->vertex1.y+pTri->vertex2.y+pTri->vertex3.y)/3.0;
					}
				}
			}

			if (pSpace == extCell) // 建筑面积
			{
				pDbSpace->m_sCode = _T("0");
				//              pDbSpace->m_sName =_T("建筑轮廓"); // _T("建筑面积"); //chenged by fxj 080620
				pDbSpace->m_sName =_T("建筑面积"); // sg modify 090603，按照林工提出的意见，恢复建筑面积的名称
				pDbSpace->SetHas3D(FALSE);
				// pDbSpace->SetRotation(Ucs2Wcs(0)); // [3/19/2008 nsh]
				pDbSpace->SetLayoutRotation(Ucs2Wcs(0)); // sg modify 090602，8.0的正式版起，将“文字转角”并入“布局转角”
				pDbSpace->SetType(TDbSpace::kTotalArea); // sg add 081226，设置房间类型
			}
			else // 普通房间对象
			{
				pDbSpace->m_sName = _T("房间");
				// modify by xly on 110413 支持字母数字连字符
				//pDbSpace->m_sCode = XString(_T("%d"), g_nStartCode);
				pDbSpace->m_sCode = g_csStartCode;

				pDbSpace->SetHas3D(bGround);
				pDbSpace->SetMask(bShield);
				pDbSpace->SetFloorThick(dThick);
				// pDbSpace->SetRotation(Ucs2Wcs(0)); // [3/19/2008 nsh]
				pDbSpace->SetLayoutRotation(Ucs2Wcs(0)); // sg modify 090602,8.0的正式版起，将“文字转角”并入“布局转角”

				// modify by xly on 101111根据8.5需求修改该房间对象，支持房间名和面积都不标注
				//int nSpFlag = DocGetSpaceDispMode();
				//if (bDimArea)
				//	nSpFlag |= SPF_AREA;
				//else
				//	nSpFlag &= ~SPF_AREA;

				//if (bAreaUnit)
				//	nSpFlag |= SPF_UNIT;
				//else
				//	nSpFlag &= ~SPF_UNIT;

				//// 				if (nVisible == 0) // sg modify 081118
				//// 					nSpFlag &= ~SPF_CODE;
				//// 				else
				//// 					nSpFlag |= SPF_CODE;
				//if (bDimCode && bDimName) // 同时标注
				//{
				//	nSpFlag &= ~SPF_CODE;
				//	nSpFlag |= SPF_NAME_AND_CODE;
				//}
				//else
				//{
				//	nSpFlag &= ~SPF_NAME_AND_CODE;
				//	if (bDimCode)        // 标编号
				//		nSpFlag |= SPF_CODE;
				//	else                 // 标名称
				//		nSpFlag &= ~SPF_CODE;
				//}
				//DocSetSpaceDispMode(nSpFlag);
				pDbSpace->SetDimNameAndCode(bDimName, bDimCode);
				pDbSpace->SetDimArea(bDimArea);
				pDbSpace->SetDimUnit(bAreaUnit);

				// modify by xly on 110413 支持字母数字连字符
				//g_nStartCode ++;
				g_csStartCode = AnalySpaceCode(g_csStartCode);
			}

			pDbSpace->m_ptLocation = ptLoc;
			pDbSpace->SetTextStyleId(InitTextStyle(TS_SPACE));
			pDbSpace->SetHatchLayer(InitLayer(LAY_SPACE_HATCH)); // moidfied by fxj 090609，设置填充图层
			pDbSpace->AddToMSpace(Adesk::kFalse);

			pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);
			if (pSpace == extCell) // add by fxj 080630，设置图层
			{
				pDbSpace->setLayer(InitLayer(LAY_BUILDING_SPACE));
			}

			if (pSpace==extCell && polyOut.Length()>2)
			{
				pDbSpace->SetPathPoly(polyOut, AcGeVector3d::kZAxis);
			}
			pDbSpace->close();

			if (pSpace != extCell) // sg add 081209，获取新生成的房间对象，过滤“建筑轮廓”，用于房间编号排序
			{
				Entity entLast;
				entLast.GetLast();
				ssAllSpaces += entLast;
			}
		}

		// add by xly 100830 与最大最小面积比较的时候用内墙的面积；
		// 房间的几何更新时，如果面积小于或者大于临界值时删除不符合的标注
		ssDel.Erase();
	}


	// 十四、房间编号排序
	SortSpace(ssAllSpaces, csFirstNum);


	// 十五、add by xly on 100831 存在多轮廓搜索房间时，调整到整图显示，点选建筑轮廓的位置
	if (ssOther.Length()>0 && g_bMakeExtSpace)// 存在多轮廓并且生成建筑面积
	{
		bHasOtherSpace = true;
		// modify by xly on 110406 距中心位置比较大时zoom不正确
//		// 对所有的框选对象整图显示
//		PickSet ssTemp(SS_FREE);
//		ssTemp += ssWalls;
//
//		// modify by xly on 101229 解决04以下平台ZOOM不支持o的操作
//#if (ADS == 16 || ADS == 15)
//		GEOAPI double g_nAcadVer;
//		if (g_nAcadVer>16.07)// 16版本中的05 06支持zoom对象
//		{
//			acedCommand(RTSTR, _T("zoom"), RTSTR, _T("o"), RTPICKS, ssTemp.name, RTSTR, _T(""), RTNONE);	
//		}
//		else
//		{
//			// 获得最后一个添加导数据库的对象，即房间对象
//			ads_name ssName;
//			if(acdbEntLast(ssName) == RTNORM)
//			{
//				// 打开对象
//				AcDbObjectId id;
//				acdbGetObjectId(id, ssName);
//				OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSpace, pSpace);
//				if (pSpace != NULL)
//				{
//					// 获得房间对象的轮廓
//					XPoly2D polyPath;
//					AcGeVector3d normal;
//					pSpace->GetPathPoly(polyPath,normal);
//
//					// 获得轮廓的外包盒
//					XPoint ptL,ptUp;
//					polyPath.GetExtend(ptL, ptUp);	
//
//					// 调整到对象显示
//					acedCommand(RTSTR, _T("zoom"), RTSTR, _T("w"), RT3DPOINT, &ptL, RT3DPOINT, &ptUp, RTNONE);
//				}
//				OPENOBJ_END();
//			}
//		}
//#else
//		acedCommand(RTSTR, _T("zoom"), RTSTR, _T("o"), RTPICKS, ssTemp.name, RTSTR, _T(""), RTNONE);		
//#endif
//		// add by xly on 101213 标注建筑面积的轮廓时，把红色虚线范围放大到全屏的0.7左右
//		acedCommand(RTSTR, _T("zoom"), RTSTR, _T("s"), RTSTR, _T(".7x"), RTNONE);

		{
			if (extCell!=NULL )
			{
				XAecSpaceCell *pSpace = extCell;

				XPoly2D polySpace(1);
				if (pSpace==extCell && polyOut.Length()>2)
					polySpace = polyOut;
				else
					pSpace->CenterPoly2D(polySpace);
				polySpace.SetElevation(0.0); // 投影到z=0的平面上
				XPoint ptL,ptUp;
				polySpace.GetExtend(ptL, ptUp);	
				ArxZoom(ptL, ptUp);
				acedCommand(RTSTR, _T("zoom"), RTSTR, _T("s"), RTSTR, _T(".7x"), RTNONE);
			}
		}
	}
	
	// 十六、产生建筑轮廓对象
	// modify by xly on 101104 用户是否取消生成建筑面积
	//if (extCell!=NULL && g_bMakeExtSpace)
	if (extCell!=NULL && g_bMakeExtSpace && bDimTotalArea)
	{
		XAecSpaceCell *pSpace = extCell;

		XPoly2D polySpace(1);
		if (pSpace==extCell && polyOut.Length()>2)
			polySpace = polyOut;
		else
			pSpace->CenterPoly2D(polySpace);
		polySpace.SetElevation(0.0); // 投影到z=0的平面上

		long lCount = !ssSpaces? 0L : ssSpaces.Length();
		PickSet ssInCell(SS_FREE|SS_CREATE); // 在当前SpaceCell中的DbSpace实体
		for (long i=0L; i<lCount; i++)
		{
			Entity e = ssSpaces[i];
			XDbObject obj(e, AcDb::kForRead);
			if (!obj)
				continue;

			TDbSpace *pDbSpace = TDbSpace::cast(obj.m_pObject);
			ASSERT(pDbSpace);
			XPoint ptLoc = pDbSpace->m_ptLocation;
			ptLoc.z = 0.0;

			if (pSpace == extCell) // 室外
			{
				// modified by fxj 090430 解决建筑轮廓线外面积对象丢失问题
				if ((ptLoc&polySpace) == PR_OUTSIDE)
				{
					if (pDbSpace->GetType()==TDbSpace::kTotalArea)
						ssInCell += e;
				}
			} 
			else // 室内
			{
				if ((ptLoc&polySpace) == PR_INSIDE) 
					ssInCell += e;
			}
		}

		if (ssInCell.Length() == 1) // 更新房间的几何参数
		{
			Entity e = ssInCell[0L];
			XDbObject obj(e, AcDb::kForWrite);
			ASSERT(!!obj);
			TDbSpace *pDbSpace = TDbSpace::cast(obj.m_pObject);
			ASSERT(pDbSpace);
			pDbSpace->assertWriteEnabled(); // New Update

			// add by xly on 110310 更新建筑面积设置粉刷层为0
			pDbSpace->SetStuccoThickness(0.0);
			pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);

			if (pSpace==extCell && polyOut.Length()>2)
				pDbSpace->SetPathPoly(polyOut, AcGeVector3d::kZAxis);
		} 
		else // 创建房间或建筑轮廓面积对象
		{
			if (ssInCell.Length()) // 符合更新条件的面积对象不止一个的时候
				ssInCell.Erase();

			// -------add by fxj 090617 面积太小过滤，面积太大给提示
			double dArea = polySpace.Area();
			// add by xly 100826 统一单位平方米
			dArea = _AS_SQMETER(dArea);

			if (dArea - g_dMinSpace < -1E-6)
			{
				// add by xly on 101213 解决标注完成后门窗对象虚显，更新显示
				PickSet ss(SS_FREE);
				ss.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("TCH_OPENING"), NULL));
				UpdateGraphic(ss);

				return;
			}

			if (g_bMaxSpace)
			{
				if (dArea - g_dMaxSpace > 1E-6)
				{
					AfxMessageBox(_T("面积太大，越界！"));
				}
			}
			//-------------------------------

			XPoint ptLoc;
			polySpace.Center(ptLoc);
			ptLoc.z = 0.0;

			{
				// 凹房间，中心点不在区域内
				int nCodeOfInput = RTNORM;
				XPoint extMin, extMax;
				polySpace.GetExtend(extMin, extMax);
				//              extMin = Wcs2Ucs(extMin);
				//              extMax = Wcs2Ucs(extMax);

				XTempZoomWindow vTemp1(extMin, extMax);
				ads_redraw(NULL,0);
				XScreenDc dc(1, 1);

				XPoly2D polyTemp;
				if (polyOut.Length() > 2)
					polyTemp = polyOut;
				else
					pSpace->InternalPoly2D(polyTemp, 2);
				polyTemp.TransUCS(Groups(0), Groups(1));
				dc << polyTemp;

				while(1)
				{
					int nExpectRelation = (pSpace==extCell)? PR_OUTSIDE:PR_INSIDE;
					adsout << (pSpace!=extCell? _T("\n加亮的空间:") : _T("\n请点取建筑面积")) <<_T("的标注位置<退出>: ");
					nCodeOfInput = ads_getpoint(NULL, _T(""), ptLoc);
					ptLoc.z = 0.0;
					ptLoc = Ucs2Wcs(ptLoc);

					if (nCodeOfInput == RTNORM)
					{
						if ((ptLoc&polySpace) != nExpectRelation)
						{
							adsout << _T("\n请在空间区域内部点取!");
						}
						else
							break;
					}
					else
						break;
				}

				// modify by xly on 101104 用户是否取消生成建筑面积
				if (nCodeOfInput != RTNORM)
					//return;
				{
					if (ssOther.Length()>0)
					{
						bDimTotalArea = false;
						goto SEARCHSPACE_LAB_BEGIN;
					}

					// add by xly on 101213 解决标注完成后门窗对象虚显，更新显示
					PickSet ss(SS_FREE);
					ss.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("TCH_OPENING"), NULL));
					UpdateGraphic(ss);

					return;
				}
			}

			// 创建建筑面积对象
			TDbSpace *pDbSpace = new TDbSpace();
			pDbSpace->m_sCode=_T("0");
			// pDbSpace->m_sName = _T("建筑轮廓"); // _T("建筑面积"); // chenged by fxj 080620
			pDbSpace->m_sName =_T("建筑面积"); // sg modify 090603，按照林工提出的意见，恢复建筑面积的名称
			pDbSpace->SetHas3D(FALSE);
			pDbSpace->SetType(TDbSpace::kTotalArea); // sg add 081226，设置房间类型

			pDbSpace->m_ptLocation = ptLoc;
			pDbSpace->SetTextStyleId(InitTextStyle(TS_SPACE));
			// pDbSpace->SetRotation(Ucs2Wcs(0)); // [3/19/2008 nsh]
			pDbSpace->SetLayoutRotation(Ucs2Wcs(0)); // sg modify 090602,8.0的正式版起，将“文字转角”并入“布局转角”
			pDbSpace->AddToMSpace(Adesk::kFalse);
			pDbSpace->setLayer(InitLayer(LAY_BUILDING_SPACE)); // add by fxj 080620
			pDbSpace->SetHatchLayer(InitLayer(LAY_SPACE_HATCH)); // modified by fxj 090609
			pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);

			if (pSpace==extCell && polyOut.Length()>2)
				pDbSpace->SetPathPoly(polyOut, AcGeVector3d::kZAxis);
			pDbSpace->close();

			Entity entLast; // sg add 081209
			entLast.GetLast();
			ssAllSpaces += entLast;
		}
	}

	// add by xly on 100831 存在多轮廓，继续搜索房间
	if (ssOther.Length()>0)
	{
		ssWalls.Free();
		ssWalls += ssOther;
		ssOther.Free();

		// 清空排序选择集，每个轮廓中的房间独立排序
		ssAllSpaces.Free();

		goto SEARCHSPACE_LAB_BEGIN;
	}

	// modify by xly on 110302 修在多房间搜索时屏幕跳动的问题
	//// add by xly on 101213 解决标注完成最后一个记住面积后调整到整体显示	
	// 获得最后一个添加导数据库的对象，即房间对象
	//acedCommand(RTSTR,_T("zoom"),RTSTR,_T("e"),RTNONE);
	ads_name ssName;
	if (bHasOtherSpace)
	{
		if(acdbEntLast(ssName) == RTNORM)
		{
			// 打开对象
			AcDbObjectId id;
			acdbGetObjectId(id, ssName);
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSpace, pSpace);
			if (pSpace != NULL)
			{
				// 获得房间对象的轮廓
				XPoly2D polyPath;
				AcGeVector3d normal;
				pSpace->GetPathPoly(polyPath,normal);

				// 获得轮廓的外包盒
				XPoint ptL,ptUp;
				polyPath.GetExtend(ptL, ptUp);	

				// 调整到对象显示
				acedCommand(RTSTR, _T("zoom"), RTSTR, _T("w"), RT3DPOINT, &ptL, RT3DPOINT, &ptUp, RTNONE);
				acedCommand(RTSTR, _T("zoom"), RTSTR, _T("s"), RTSTR, _T(".7x"), RTNONE);
			}
			OPENOBJ_END();
		}
	}
	
	// add by xly on 101213 解决标注完成后门窗对象虚显，更新显示
	PickSet ss(SS_FREE);
	ss.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("TCH_OPENING"), NULL));
	UpdateGraphic(ss);
}


// 节能专用
void SpaceArea1()
{
	XPushMemVar<BOOL> vMem(g_bIgnoreColumn,FALSE);

	CSearchRoomDlg dlg(acedGetAcadFrame());
	{
		CAcModuleResourceOverride vTemp;
		if ( !dlg.Create(IDD_SEARCH_ROOM1, acedGetAcadFrame()) )
			return;
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();


    g_ssPickFirst.Free();
    PickSet ssSpaces(SS_FREE), ssWalls(SS_FREE);
    RBList spaceMask(RTDXF0, _T("TCH_SPACE"), NULL), wallMask(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL,TCH_OPENING,TCH_SPACE"), NULL);
    if (SelectEntities(_T("\n请选择构成一完整建筑物的所有墙体(或门窗):"), ssWalls, wallMask)!=RTNORM) 
	{
		dlg.DestroyWindow();
        return;
    }

	long count=ssWalls.Length();
	for(long i=0;i<count;i++)
	{
		Entity ent=ssWalls[i];
		if (ent.Is(_T("TCH_SPACE")))
			ssSpaces+=ent;
	}
	ssWalls-=ssSpaces;
    MakeWallSet(ssWalls);

	AcDbObjectIdArray idWalls;
	ssWalls.AsIdArray(idWalls);
    //ssSpaces.Get(_T("X"), NULL, NULL, spaceMask);

	dlg.UpdateData();
	BOOL bDimArea = dlg.m_bDimArea;
	BOOL bAreaUnit = dlg.m_bAreaUnit;
	BOOL bGround = g_bGround;
	BOOL bShield = g_bShield;
	int nVisible = dlg.m_nVisible;
	double dThick =g_dThick;
	dlg.DestroyWindow();

	//取得所有的裁剪区域
	DList<AcDbObjectId> lstColu;
	XPoly2D polyOut;
	XSearchSpaceFromWall aSearch;
	try 
	{
		GetEntFromBlockByDxf(lstColu, _T("TCH_COLUMN"));
		aSearch.InitStart(ssWalls, lstColu);
	} 
	catch(...) 
	{
		adsout << /*UMSG*/_T("\n发生例外情况!");
		return;
	}

    XAecSpaceCell * extCell=aSearch.SearchSpaces();

	if (extCell!=NULL&&g_bMakeExtSpace&&g_bIgnoreColumn)
		extCell->InternalPoly2D(polyOut,0,0);

    for(int n=0; n<aSearch.spaces.Length(); n++) 
	{
        XAecSpaceCell *pSpace=aSearch.spaces[n];
		if (pSpace==extCell)
			continue;

        XPoly2D polySpace(1);
		if (pSpace==extCell&&polyOut.Length()>2)
			polySpace=polyOut;
		else
			pSpace->CenterPoly2D(polySpace);

        polySpace.SetElevation(0.0); //投影到z=0的平面上

        long lCount=!ssSpaces? 0L : ssSpaces.Length();
        PickSet ssInCell(SS_FREE|SS_CREATE); //在当前SpaceCell中的DbSpace实体
        for(long i=0L; i<lCount; i++)
		{
            Entity e=ssSpaces[i];
            XDbObject obj(e, AcDb::kForRead);
            if (!obj) continue;
            TDbSpace *pDbSpace=TDbSpace::cast(obj.m_pObject);
            ASSERT(pDbSpace);
            XPoint ptLoc = pDbSpace->m_ptLocation;
            ptLoc.z = 0.0;
            if (pSpace==extCell) 
			{ //室外
                if ((ptLoc&polySpace)==PR_OUTSIDE)
                    ssInCell += e;
            } 
			else 
			{
                if ((ptLoc&polySpace)==PR_INSIDE) 
                    ssInCell += e;
            }
        }

        if (ssInCell.Length()==1)
		{ //更新房间的几何参数
            Entity e=ssInCell[0L];
            XDbObject obj(e, AcDb::kForWrite);
            ASSERT(!!obj);
            TDbSpace *pDbSpace=TDbSpace::cast(obj.m_pObject);
            ASSERT(pDbSpace);
            pDbSpace->assertWriteEnabled(); // New Update
            pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);

			if (pSpace==extCell&&polyOut.Length()>2)
				pDbSpace->SetPathPoly(polyOut,AcGeVector3d::kZAxis);
        } 
		else
		{ //创建房间
            if (ssInCell.Length())
                ssInCell.Erase();
            TDbSpace *pDbSpace = new TDbSpace();
            XPoint ptLoc;
            polySpace.Center(ptLoc);
            ptLoc.z = 0.0;

			if ((ptLoc&polySpace)!=PR_INSIDE)
			{
                XPoly polyTemp;
                polySpace.MapToPolygon(polyTemp, 20);
                if (!!polyTemp) {
                    XPolygonEx polyTri(polyTemp);
                    DList<XTriangle> lstTri;
                    if (polyTri.Trianglize(lstTri, TRUE)==RTNORM && !!lstTri) 
					{
                        XTriangle *pTri=lstTri[0];
                        ptLoc.x=(pTri->vertex1.x+pTri->vertex2.x+pTri->vertex3.x)/3.0;
                        ptLoc.y=(pTri->vertex1.y+pTri->vertex2.y+pTri->vertex3.y)/3.0;
                    }
                }
            }
            if (pSpace==extCell) 
			{
                pDbSpace->m_sCode=_T("0");
                pDbSpace->m_sName = _T("外墙轮廓");
				pDbSpace->SetHas3D(FALSE);
            } 
			else 
			{
                pDbSpace->m_sName = _T("房间");
				// modify by xly on 110413 支持字母数字连字符
				//pDbSpace->m_sCode=XString(_T("%d"), g_nStartCode);
				pDbSpace->m_sCode=g_csStartCode;
				pDbSpace->SetHas3D(bGround);
				pDbSpace->SetMask(bShield);
				pDbSpace->SetFloorThick(dThick);

				int nSpFlag=DocGetSpaceDispMode();
				if (bDimArea)
					nSpFlag |= SPF_AREA;
				else
					nSpFlag &= ~SPF_AREA;

				if (bAreaUnit)
					nSpFlag |= SPF_UNIT;
				else
					nSpFlag &= ~SPF_UNIT;

				if (nVisible == 0)
					nSpFlag &= ~SPF_CODE;
				else
					nSpFlag |= SPF_CODE;
				DocSetSpaceDispMode(nSpFlag);

				// modify by xly on 110413 支持字母数字连字符
				//g_nStartCode ++;
				g_csStartCode = AnalySpaceCode(g_csStartCode);
            }

			pDbSpace->m_ptLocation = ptLoc;
			pDbSpace->SetTextStyleId(InitTextStyle(TS_SPACE));
			
            pDbSpace->AddToMSpace(Adesk::kFalse);
            pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);

			if (pSpace==extCell&&polyOut.Length()>2)
				pDbSpace->SetPathPoly(polyOut,AcGeVector3d::kZAxis);

			pDbSpace->close();
        }
    }

	if (extCell!=NULL&&g_bMakeExtSpace)
	{
        XAecSpaceCell *pSpace=extCell;

        XPoly2D polySpace(1);
		if (pSpace==extCell&&polyOut.Length()>2)
			polySpace=polyOut;
		else
			pSpace->CenterPoly2D(polySpace);

        polySpace.SetElevation(0.0); //投影到z=0的平面上

        long lCount=!ssSpaces? 0L : ssSpaces.Length();
        PickSet ssInCell(SS_FREE|SS_CREATE); //在当前SpaceCell中的DbSpace实体
        for(long i=0L; i<lCount; i++)
		{
            Entity e=ssSpaces[i];
            XDbObject obj(e, AcDb::kForRead);
            if (!obj) continue;
            TDbSpace *pDbSpace=TDbSpace::cast(obj.m_pObject);
            ASSERT(pDbSpace);
            XPoint ptLoc = pDbSpace->m_ptLocation;
            ptLoc.z = 0.0;
            if (pSpace==extCell) 
			{ //室外
                if ((ptLoc&polySpace)==PR_OUTSIDE)
                    ssInCell += e;
            } 
			else 
			{
                if ((ptLoc&polySpace)==PR_INSIDE) 
                    ssInCell += e;
            }
        }

        if (ssInCell.Length()==1)
		{ //更新房间的几何参数
            Entity e=ssInCell[0L];
            XDbObject obj(e, AcDb::kForWrite);
            ASSERT(!!obj);
            TDbSpace *pDbSpace=TDbSpace::cast(obj.m_pObject);
            ASSERT(pDbSpace);
            pDbSpace->assertWriteEnabled(); // New Update
            pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);

			if (pSpace==extCell&&polyOut.Length()>2)
				pDbSpace->SetPathPoly(polyOut,AcGeVector3d::kZAxis);
        } 
		else
		{ //创建房间
            if (ssInCell.Length())
                ssInCell.Erase();
            XPoint ptLoc;
            polySpace.Center(ptLoc);
            ptLoc.z = 0.0;
			{ //凹房间,中心点不在区域内
                int nCodeOfInput=RTNORM;
                XPoint extMin, extMax;
                polySpace.GetExtend(extMin, extMax);
                extMin=Wcs2Ucs(extMin);
                extMax=Wcs2Ucs(extMax);
                XTempZoomWindow vTemp1(extMin, extMax);
                ads_redraw(NULL,0);
                XScreenDc dc(1, 1);
                XPoly2D polyTemp;
				if (polyOut.Length()>2)
					polyTemp=polyOut;
				else
					pSpace->InternalPoly2D(polyTemp,2);

                polyTemp.TransUCS(Groups(0), Groups(1));
                dc << polyTemp;
                while(1) 
				{ 
                    int nExpectRelation=(pSpace==extCell)? PR_OUTSIDE:PR_INSIDE;
                    adsout << (pSpace!=extCell? _T("\n加亮的空间:") : _T("\n请点取外墙轮廓")) <<_T("的标注位置<退出>: ");
                    nCodeOfInput=ads_getpoint(NULL, _T(""), ptLoc);
                    ptLoc.z = 0.0;
                    ptLoc=Ucs2Wcs(ptLoc);
                    if (nCodeOfInput==RTNORM) {
                        if ((ptLoc&polySpace)!=nExpectRelation) {
                            adsout << _T("\n请在空间区域内部点取!");
                        } else 
                            break;
                    } else 
                        break;
                }
                if (nCodeOfInput!=RTNORM)
					return;
            }
			TDbSpace *pDbSpace = new TDbSpace();
            pDbSpace->m_sCode=_T("0");
            pDbSpace->m_sName = _T("外墙轮廓");
			pDbSpace->SetHas3D(FALSE);

			pDbSpace->m_ptLocation = ptLoc;
			pDbSpace->SetTextStyleId(InitTextStyle(TS_SPACE));
			
            pDbSpace->AddToMSpace(Adesk::kFalse);
            pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);

			if (pSpace==extCell&&polyOut.Length()>2)
				pDbSpace->SetPathPoly(polyOut,AcGeVector3d::kZAxis);

			pDbSpace->close();
        }
    }

	//识别内外,add by whl on 060206
    if (extCell) 
	{
        aSearch.UpdateWallFlags();
        XPoly2D poly(1);
        extCell->InternalPoly2D(poly, 0, 0);
		poly.SetElevation(0.0);

		//对所有外墙设置内外特征
		for(long i=0;i<idWalls.length();i++)
		{
			TDbWall* pWall=NULL;
			acdbOpenObject(pWall,idWalls[i],AcDb::kForWrite);
			if (pWall!=NULL)
			{
				if (pWall->IsExternal())
				{
					XCurveSegment lCurve,rCurve;
					pWall->GetSideCurve(lCurve,rCurve,0.0,TRUE);
					XPoint ptMid=lCurve.MidPoint();
					ptMid.z=0;
					int iRet=ptMid&poly;
					if (iRet==PR_EDGE)//左外
					{
						pWall->SetExternal(0,TRUE);
						pWall->SetExternal(1,FALSE);
					}
					else//右外
					{
						pWall->SetExternal(0,FALSE);
						pWall->SetExternal(1,TRUE);
					}
				}
				pWall->close();
			}
		}

		TArchCmdReactor::ResetAll();
    }
	else 
        adsout << _T("\n没有判别出内外墙!请使用指定内墙、指定外墙命令手动指定。");
}


// Add by lcf on 20050823
// command:查询面积
struct tbButtom
{
	UINT tbID;
	int BitmapID;
	int Style;
};

// sg modify 081124增加有关填充部分的设置
class CSearchAreaDlg : public CModelessDialog
{
public:
	CSearchAreaDlg(CWnd* pParent = NULL);

public:
	enum { IDD = IDD_SEARCH_AREA };

	CEdit m_editThick;
// 	BOOL m_bAreaUnit; // sg modify 081128
	static BOOL m_bAreaUnit;

	// modify by xly on 101101支持编号和名称都不显示,设置为静态变量
	// BOOL m_bDimArea;
	static BOOL m_bDimArea;	// 是否标注面积

	int m_nVisible;
	static int s_iMode; // add by fxj
	BOOL m_bUseEsc;     // add by fxj

	// modify by xly on 101101支持编号和名称都不显示,设置为静态变量
	// sg add 081119，是否标注房间编号、名称，替换原来的m_nVisible
	// BOOL m_bDimCode;
	// BOOL m_bDimName;
	static BOOL m_bDimCode;	// 是否标注房间编号
	static BOOL m_bDimName;	// 是否标注房间名称

	// add by lgh 100804，是否计一半面积
	BOOL m_bHalfArea;				// 当前界面值
	static BOOL m_bHalfAreaBal;		// 阳台当前值，默认勾选
	static BOOL m_bHalfAreaOther;	// 房间封闭曲线以及任意多边形采用这个默认值，默认不勾选

	// sg add 081124，与填充相关内容的数据
	static BOOL				m_bShowHatch;	// 是否使用填充
	static CString			m_csHatch;		// 填充样式
	CHatchPreviewCtrl		m_wndHatch;

	// Zyu modify on 100322,CAcUiColorComboBox换成CAcUiTrueColorComboBox控件
	// Begin
#if (ADS < 16)
	CAcUiColorComboBox		m_ctlColor;
#else
	CAcUiTrueColorComboBox	m_ctlColor;
#endif
	// End

	// modify by xly on 100909 // 支持真彩颜色使用		
	//static int			m_nColor;		// 填充颜色索引号
	static AcCmColor		m_cColor;		// 填充颜色

	static double			m_dHatchScale;	// 填充比例
	static int				m_nHatchAngle;	// 填充转角

	// sg add 090121
	CSpinButtonCtrl			m_angleSpin;		// 角度

public:	
	CToolBarCtrl m_toolbar;
	tbButtom tbButtm[4];

public: // sg add 081124
	virtual BOOL DestroyWindow();
	void UpdatePreview();

protected:
	virtual void DoDataExchange(CDataExchange* pDX);
	virtual void PostNcDestroy(); // sg add 081124
	virtual BOOL OnInitDialog();
	DECLARE_MESSAGE_MAP()
	afx_msg void OnBnClickedCheckGround();
	afx_msg void OnBnClickedCheckSpace();
	afx_msg void OnClose();

	//--------add by fxj---------
	afx_msg void OnButtonRoom();
	afx_msg void OnButtonPline();
	afx_msg void OnButtonBalcony();
	afx_msg void OnButtonDraw();//add by fxj 090206
	afx_msg BOOL OnToolTipText( UINT, NMHDR * pNMHDR, LRESULT * pResult );

	afx_msg void OnBnClickedCheckSpaceCode(); // sg add 081119
	afx_msg void OnBnClickedCheckSpaceName();

	// sg add 081120
	afx_msg void OnClickHatch();			// 是否使用填充
	afx_msg void OnStaticStyle();			// 选择填充效果
	afx_msg void OnSelchangeComboColor();	// 切换填充颜色
	
	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message); // sg add 081202
 	afx_msg void OnChangeEditSpaceAngle(); // sg add 090122

	afx_msg void OnKillFocusScale();//add by fxj 090426
	afx_msg void OnClickArea();//add by fxj 090514
	afx_msg void OnKillFocusThick();//add by fxj 090521
	afx_msg void OnBnClickedCheckHalfarea(); // add by lgh 100727

private:
	BOOL IsBalconyMode() {return s_iMode == 2;}
};


int CSearchAreaDlg::s_iMode = 0;
BOOL CSearchAreaDlg::m_bShowHatch = FALSE;  // sg add 081124
CString CSearchAreaDlg::m_csHatch = _T("SOLID"); // sg add 081124

// modify by xly on 100909真彩色
//int CSearchAreaDlg::m_nColor = 256; // 默认Bylayer
AcCmColor CSearchAreaDlg::m_cColor;	  // 默认Bylayer
double CSearchAreaDlg::m_dHatchScale = 100;
BOOL CSearchAreaDlg::m_bAreaUnit = TRUE; // sg add 081128
int CSearchAreaDlg::m_nHatchAngle = 0;

// add by xly on 101101 初始化静态变量
BOOL CSearchAreaDlg::m_bDimName = TRUE;
BOOL CSearchAreaDlg::m_bDimCode = FALSE;
BOOL CSearchAreaDlg::m_bDimArea = TRUE;

BOOL CSearchAreaDlg::m_bHalfAreaBal = TRUE;
BOOL CSearchAreaDlg::m_bHalfAreaOther = FALSE;

CSearchAreaDlg::CSearchAreaDlg(CWnd* pParent)
: CModelessDialog(CSearchAreaDlg::IDD, pParent)
//, m_bAreaUnit(FALSE) // sg delete 081128
//, m_bDimArea(TRUE)   // delete by xly on 101101 静态变量
, m_nVisible(0)
//, m_bHalfArea(FALSE)
{
	int nSpFlag = DocGetSpaceDispMode();

	// delete by xly on 101101 转化为静态变量
	//m_bDimArea = (nSpFlag&SPF_AREA)!=0;

//	m_bAreaUnit = (nSpFlag&SPF_UNIT)!=0;
	m_nVisible = (nSpFlag&SPF_CODE)!=0;
    
	//-----------add by fxj--------
	m_bUseEsc = TRUE;

	tbButtm[0].tbID = ID_ROOM_AREA;
	tbButtm[0].BitmapID = 0;
	tbButtm[0].Style = TBSTYLE_CHECKGROUP;

	tbButtm[1].tbID = ID_PLINE_AREA;
	tbButtm[1].BitmapID = 1;
	tbButtm[1].Style = TBSTYLE_CHECKGROUP;
	
	tbButtm[2].tbID = ID_BALCONY_AREA;
	tbButtm[2].BitmapID = 2;
	tbButtm[2].Style = TBSTYLE_CHECKGROUP;

	//add by fxj 090206
	tbButtm[3].tbID = ID_DRAW_AREA;
	tbButtm[3].BitmapID = 3;
	tbButtm[3].Style = TBSTYLE_CHECKGROUP;

	// delete by xly on 101101 转化为静态变量
	//if ((nSpFlag&SPF_NAME_AND_CODE) != 0) // sg add 081119
	//{
	//	m_bDimCode = TRUE;
	//	m_bDimName = TRUE;
	//}
	//else if ((nSpFlag&SPF_CODE) != 0)
	//{
	//	m_bDimCode = TRUE;
	//	m_bDimName = FALSE;
	//}
	//else
	//{
	//	m_bDimCode = FALSE;
	//	m_bDimName = TRUE;
	//}
}

void CSearchAreaDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	DDX_Check(pDX, IDC_CHECK_AREAUNIT, m_bAreaUnit);
	DDX_Check(pDX, IDC_CHECK_DIMAREA, m_bDimArea);
	DDX_Check(pDX, IDC_CHECK_GROUND, g_bGround);
	DDX_Check(pDX, IDC_CHECK_SHIELD, g_bShield);
	DDX_Check(pDX, IDC_CHECK_BUILDROOM, g_bBuildRoom);
	DDX_Radio(pDX, IDC_RADIO_NAME, m_nVisible);
	DDX_Control(pDX, IDC_EDIT_THICK, m_editThick);
	DDX_Text(pDX, IDC_EDIT_THICK, g_dThick);

	if (!pDX->m_bSaveAndValidate)
	{
		m_toolbar.CheckButton(ID_ROOM_AREA, s_iMode==0);
		m_toolbar.CheckButton(ID_PLINE_AREA, s_iMode==1);
		m_toolbar.CheckButton(ID_BALCONY_AREA, s_iMode==2);
        m_toolbar.CheckButton(ID_DRAW_AREA, s_iMode==3);
	}

	DDX_Check(pDX, IDC_CHECK_SHOWAREACODE, m_bDimCode); // sg add 081119
	DDX_Check(pDX, IDC_CHECK_SHOWAREANAME, m_bDimName);
	DDX_Check(pDX, IDC_CHECK_HATCH, m_bShowHatch); // sg add 081124
	DDX_Control(pDX, IDC_STATIC_STYLE, m_wndHatch);
	DDX_Control(pDX, IDC_COMBO_COLOR, m_ctlColor);
	DDX_Text(pDX, IDC_EDIT_SCALE , m_dHatchScale);
	DDX_Text(pDX, IDC_EDIT_AREAANGLE, m_nHatchAngle);
	DDX_Control(pDX, IDC_SPIN_SPACEANGLE, m_angleSpin); // sg add 090122
	DDX_Check(pDX, IDC_CHECK_HALFAREA, m_bHalfArea);
}

BEGIN_MESSAGE_MAP(CSearchAreaDlg, CModelessDialog)
	ON_BN_CLICKED(IDC_CHECK_GROUND, OnBnClickedCheckGround)
	ON_BN_CLICKED(IDC_CHECK_BUILDROOM,OnBnClickedCheckSpace)
	ON_WM_ACTIVATE()
	ON_WM_CLOSE()

	// ----add by fxj---------
	ON_COMMAND(ID_ROOM_AREA, OnButtonRoom)
	ON_COMMAND(ID_PLINE_AREA, OnButtonPline)
	ON_COMMAND(ID_BALCONY_AREA, OnButtonBalcony)
	ON_COMMAND(ID_DRAW_AREA, OnButtonDraw)//add by fxj 090206
	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
    ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)

	ON_BN_CLICKED(IDC_CHECK_SHOWAREACODE, OnBnClickedCheckSpaceCode) // sg add 081119
	ON_BN_CLICKED(IDC_CHECK_SHOWAREANAME, OnBnClickedCheckSpaceName)
	ON_BN_CLICKED(IDC_CHECK_HATCH, OnClickHatch) // sg add 081120
	ON_BN_CLICKED(IDC_STATIC_STYLE, OnStaticStyle)
	ON_CBN_SELCHANGE(IDC_COMBO_COLOR, OnSelchangeComboColor)
	ON_WM_SETCURSOR() // sg add 081202
	ON_EN_CHANGE(IDC_EDIT_AREAANGLE, OnChangeEditSpaceAngle)
	ON_EN_KILLFOCUS(IDC_EDIT_SCALE, OnKillFocusScale)//add by fxj 090426
	ON_BN_CLICKED(IDC_CHECK_DIMAREA, OnClickArea)//add by fxj 090514
	ON_EN_KILLFOCUS(IDC_EDIT_THICK, OnKillFocusThick)//add by fxj 090521
	ON_BN_CLICKED(IDC_CHECK_HALFAREA, OnBnClickedCheckHalfarea)
END_MESSAGE_MAP()

BOOL CSearchAreaDlg::OnInitDialog()
{
	CModelessDialog::OnInitDialog();
	m_angleSpin.SetRange(0, 360); // sg add 090122
	XString sAngle = Angle2Str(m_nHatchAngle); // sg add 081215，角度精确度受控制
	GetDlgItem(IDC_EDIT_AREAANGLE)->SetWindowText(sAngle);

	OnBnClickedCheckGround();
	OnBnClickedCheckSpace();

	// --------------add by fxj--------------
	CAcModuleResourceOverride vTmp;
	m_toolbar.Create( WS_VISIBLE | WS_CHILD  |CCS_BOTTOM| TBSTYLE_TOOLTIPS 
	                 | CCS_ADJUSTABLE ,CRect(0,0,0,0),this,  IDR_SEARCH_AREA);
	
    TBBUTTON *pIndex,
		*pRTF_Button = new TBBUTTON[4];
	pIndex = pRTF_Button;
	for (long lIndex = 0; lIndex < 4; lIndex++)
	{
		memset(pIndex ,NULL, sizeof(TBBUTTON));
		pIndex->iBitmap= tbButtm[lIndex].BitmapID; 
		pIndex->idCommand  = tbButtm[lIndex].tbID;  
		pIndex->fsStyle =  tbButtm[lIndex].Style;
		pIndex->fsState = TBSTATE_ENABLED;
		pIndex++;
	}

    CSize size(16, 15);
	m_toolbar.SetButtonSize(size);
	m_toolbar.AddButtons(4, pRTF_Button);
    delete[] pRTF_Button;
	m_toolbar.AddBitmap(4, IDR_SEARCH_AREA);
	m_toolbar.AutoSize();
    
    m_wndToolTip.Create(this);
    m_wndToolTip.Activate(true);

	OnClickHatch(); // sg add 081124，设置“填充”部分是否可用
	
	// 问题描述:选择颜色时只支持索引颜色一种，希望可以像CAD一样增加对真彩色和配色系统的支持。（TT10）
    // 解决方法:把CAcUiColorComboBox换成CAcUiTrueColorComboBox,并替换相应的函数
	// 修改人,修改时间:Zyu modify on 100322
	// Begin
#if (ADS < 16)
	// modify by xly on 100909  真彩色的兼容，兼容为一个变量
	// sg add 081124，设置“填充颜色”
	//int nItem = m_ctlColor.FindItemByColorIndex(m_nColor);
	
	int nTempClor = m_cColor.colorIndex();
	int nItem = m_ctlColor.FindItemByColorIndex(nTempClor);
#else
	/*AcCmColor clrTemp;
	clrTemp.setColorIndex(m_nColor);
	int nItem = m_ctlColor.FindItemByColor(clrTemp);*/
	int nItem = m_ctlColor.FindItemByColor(m_cColor);

#endif
	if (nItem < 0)
	{
#if (ADS < 16)
		// modify by xly 真彩色的兼容，兼容为一个变量
		//m_ctlColor.AddColorToMRU(m_nColor);
		//nItem = m_ctlColor.FindItemByColorIndex(m_nColor);
		m_ctlColor.AddColorToMRU(nTempClor);
		nItem = m_ctlColor.FindItemByColorIndex(nTempClor);
#else
		// modify by xly on 100908 真彩色的使用
	//	m_ctlColor.AddColorToMRU(clrTemp);
	//	nItem = m_ctlColor.FindItemByColor(clrTemp);
		m_ctlColor.AddColorToMRU(m_cColor);
		nItem = m_ctlColor.FindItemByColor(m_cColor);
#endif
	}
	// End

	if (nItem >= 0)
	{
		m_ctlColor.SetCurSel(nItem);
	}
	
	m_bHalfArea = IsBalconyMode() ? m_bHalfAreaBal : m_bHalfAreaOther; // add by lgh 100804

	UpdatePreview(); // sg add 081124，获取“填充样式”


	// add by xly on 101213 设置房间对象的显示
	TDbSpace Spce;
	Spce.SetSpaceDispMode(1);
	m_bDimCode = Spce.IsDimCode();
	m_bDimName = Spce.IsDimName();	
	m_bDimArea = Spce.IsDimArea();
	m_bAreaUnit = Spce.IsDimUnit();
	GetDlgItem(IDC_CHECK_AREAUNIT)->EnableWindow(m_bDimArea);//add by fxj 090514
	GetDlgItem(IDC_CHECK_HALFAREA)->EnableWindow(m_bDimArea);//add by lgh 100727

	UpdateData(FALSE);
	return TRUE;
}
void CSearchAreaDlg::OnKillFocusThick()//add by fxj 090521
{
	CString szText;
	m_editThick.GetWindowText(szText);
	double dThick = _tstof(szText);
	if (szText== _T("")||dThick<-1E-6)
	{
	}
	else 
		g_dThick = dThick;
  
	CDataExchange dx1(this, FALSE);
	DDX_Text(&dx1, IDC_EDIT_THICK, g_dThick);
}
void CSearchAreaDlg::OnBnClickedCheckSpace()
{
	CDataExchange dx(this, TRUE);
	DDX_Check(&dx, IDC_CHECK_BUILDROOM, g_bBuildRoom);
	GetDlgItem(IDC_CHECK_SHOWAREANAME)->EnableWindow(g_bBuildRoom);//modified by fxj 090326
	GetDlgItem(IDC_CHECK_SHOWAREACODE)->EnableWindow(g_bBuildRoom);//modified by fxj 090326
	GetDlgItem(IDC_CHECK_HATCH)->EnableWindow(g_bBuildRoom);//add by fxj 090401
	GetDlgItem(IDC_CHECK_GROUND)->EnableWindow(g_bBuildRoom);
//	GetDlgItem(IDC_CHECK_SHIELD)->EnableWindow(g_bBuildRoom);//add by lxb on 2011/11/25
	GetDlgItem(IDC_EDIT_THICK)->EnableWindow(g_bBuildRoom&&g_bGround);

	//add by fxj 090512
	GetDlgItem(IDC_STATIC_STYLE)->EnableWindow(g_bBuildRoom && m_bShowHatch);
	GetDlgItem(IDC_COMBO_COLOR)->EnableWindow(g_bBuildRoom && m_bShowHatch);
	GetDlgItem(IDC_EDIT_SCALE)->EnableWindow(g_bBuildRoom && m_bShowHatch);
	GetDlgItem(IDC_EDIT_AREAANGLE)->EnableWindow(g_bBuildRoom && m_bShowHatch);
	GetDlgItem(IDC_SPIN_SPACEANGLE)->EnableWindow(g_bBuildRoom && m_bShowHatch);
}

void CSearchAreaDlg::OnBnClickedCheckGround()
{
	CDataExchange dx(this, TRUE);
	DDX_Check(&dx, IDC_CHECK_GROUND, g_bGround);
	m_editThick.EnableWindow(g_bGround);
}
void CSearchAreaDlg::OnClickArea()//add by fxj 090514
{
	m_bDimArea=!m_bDimArea;
	GetDlgItem(IDC_CHECK_AREAUNIT)->EnableWindow(m_bDimArea);
	GetDlgItem(IDC_CHECK_HALFAREA)->EnableWindow(m_bDimArea); // add by lgh 100727
}
void CSearchAreaDlg::OnClose()
{
	m_bUseEsc = TRUE;
	if (m_bModeless)
		acedPostCommand(_T("\33\33"));
	else
		CModelessDialog::OnClose();
}

void CSearchAreaDlg::OnButtonRoom()
{
	if (s_iMode == 0)
        return;
    UpdateData(TRUE);
	s_iMode = 0;
	m_bHalfArea = m_bHalfAreaOther;
    UpdateData(FALSE);
  
	m_bUseEsc = FALSE;
    acedPostCommand(_T("\33"));
}

void CSearchAreaDlg::OnButtonPline()
{
	if (s_iMode == 1)
        return;
    UpdateData(TRUE);
	s_iMode = 1;
	m_bHalfArea = m_bHalfAreaOther;
    UpdateData(FALSE);
  
	m_bUseEsc = FALSE;
    acedPostCommand(_T("\33"));
}

void CSearchAreaDlg::OnButtonBalcony()
{
	if (s_iMode == 2)
        return;
    UpdateData(TRUE);
	s_iMode = 2;
	m_bHalfArea = m_bHalfAreaBal;
    UpdateData(FALSE);
  
	m_bUseEsc = FALSE;
    acedPostCommand(_T("\33"));
}
void CSearchAreaDlg::OnButtonDraw()
{
	if (s_iMode == 3)
        return;
    UpdateData(TRUE);
	s_iMode = 3;
	m_bHalfArea = m_bHalfAreaOther;
    UpdateData(FALSE);
  
	m_bUseEsc = FALSE;
    acedPostCommand(_T("\33"));
}
BOOL CSearchAreaDlg::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))
     {
			  return FALSE;
     }

     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 CSearchAreaDlg::OnBnClickedCheckSpaceCode() // sg add 081119
{
	UpdateData(TRUE);
	// delete by xly on 101101 8.5需求支持房间编号和名称都不显示
	/*if (!m_bDimCode)
	{
		m_bDimName = TRUE;
	}*/
	UpdateData(FALSE);
}

void CSearchAreaDlg::OnBnClickedCheckSpaceName() // sg add 081119
{
	UpdateData(TRUE);
	// delete by xly on 101101 8.5需求支持房间编号和名称都不显示
	/*if (!m_bDimName)
	{
		m_bDimCode = TRUE;
	}*/
	UpdateData(FALSE);
}

void CSearchAreaDlg::OnClickHatch() // sg add 081124，sg add 090122，控制填充部分是否可编辑
{
	UpdateData(TRUE);
	GetDlgItem(IDC_STATIC_STYLE)->EnableWindow(m_bShowHatch);
	GetDlgItem(IDC_COMBO_COLOR)->EnableWindow(m_bShowHatch);
	GetDlgItem(IDC_EDIT_SCALE)->EnableWindow(m_bShowHatch);
	GetDlgItem(IDC_EDIT_AREAANGLE)->EnableWindow(m_bShowHatch);
	GetDlgItem(IDC_SPIN_SPACEANGLE)->EnableWindow(m_bShowHatch);
	UpdateData(FALSE);
}

void CSearchAreaDlg::OnStaticStyle() // sg add 081124，选择填充效果
{
	acDocManager->lockDocument(acDocManager->curDocument());
	if (!AT_loaded(_T("tch_blklib")))
	{
		int nRet = acrxLoadModule(_T("tch_blklib.arx"), Adesk::kTrue, true);
		if (!nRet)
		{
			acDocManager->unlockDocument(acDocManager->curDocument());
			return;
		}
	}
	
	RBList rbCmd = ads_buildlist(RTSTR, _T("ITUAN"), RTSTR,
		(const TCHAR*)(m_csHatch), NULL);
	resbuf *rbRes = NULL;
	if (ads_invoke(rbCmd, &rbRes)==RTNORM && rbRes)
	{
		if (rbRes && rbRes->restype==RTSTR)
		{
			m_csHatch = rbRes->resval.rstring;
		}
		ads_relrb(rbRes);
	}
	UpdatePreview();
	acDocManager->unlockDocument(acDocManager->curDocument());
}

void CSearchAreaDlg::UpdatePreview() // sg add 081124，填充效果预览
{
	if (m_csHatch.IsEmpty())
	{
		m_csHatch = _T("SOLID");
	}
	m_wndHatch.SetPattern(m_csHatch);

	// modify by xly on 100908 真彩色的设置
	//m_wndHatch.SetColorPattern(m_nColor);
	m_wndHatch.SetColorPattern1(m_cColor);

	m_wndHatch.SetAngle(m_nHatchAngle);
	m_wndHatch.UpdateView();
}

BOOL CSearchAreaDlg::DestroyWindow()
{
	m_wndHatch.clearAll();
	return CModelessDialog::DestroyWindow();
}

void CSearchAreaDlg::PostNcDestroy()
{
	m_wndHatch.clearAll();
	CModelessDialog::PostNcDestroy();
}

void CSearchAreaDlg::OnSelchangeComboColor() // sg add 081124，获取最新填充颜色，刷新m_nColor
{
	UpdateData(TRUE);
	// Zyu modify on 100322
	// 把CAcUiColorComboBox换成CAcUiTrueColorComboBox后替换相应的函数
	// Begin
#if ( ADS < 16 )

	// modify by xly on 100909  真彩色的设置兼容到一个变量m_cColor
	int nIndex = m_ctlColor.GetCurrentItemColorIndex();
	m_cColor.setColorIndex(nIndex);
#else
	// modify by xly on 100908 真彩色的设置
	/*AcCmColor clrTemp;
	m_ctlColor.GetCurrentItemColor(clrTemp);
	int nIndex = clrTemp.colorIndex();*/
	m_ctlColor.GetCurrentItemColor(m_cColor);
#endif
	// End
	
	// modify by xly on 100908 真彩色的设置,提前到(ADS < 16)使用
	// GetCurrentItemColor不支持返回值，不做判断，都更新显示
	//if (nIndex >= 0)
	//{
		/*m_nColor = nIndex;
		m_wndHatch.SetColorPattern(m_nColor);*/
		m_wndHatch.SetColorPattern1(m_cColor);
		m_wndHatch.UpdateView();
	//}
}

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

void CSearchAreaDlg::OnChangeEditSpaceAngle()
{
 	CString csTemp;
 	GetDlgItem(IDC_EDIT_AREAANGLE)->GetWindowText(csTemp);
 	m_nHatchAngle = _ttoi(csTemp);
	UpdateData(FALSE);
 	UpdatePreview();
}
void CSearchAreaDlg::OnKillFocusScale()//add by fxj 090426
{
	UpdateData(TRUE);
}

// add by lgh 100727
void CSearchAreaDlg::OnBnClickedCheckHalfarea()
{
	UpdateData(TRUE);
	if (IsBalconyMode())
		m_bHalfAreaBal = m_bHalfArea;
	else
		m_bHalfAreaOther = m_bHalfArea;
}

// add by lgh. 该数值在拖动的时候，希望能够根据对话框更新数据
class TDragSearchAreaDbTextJig : public TDragDbTextJig
{
public:
	TDragSearchAreaDbTextJig(TDbText * text, CSearchAreaDlg *pDlg, double dArea);
	TDragSearchAreaDbTextJig(TDbSpace * space, CSearchAreaDlg *pDlg);

	CSearchAreaDlg *m_pDlg; // add by lgh 100804, 用来实时更新当前的数据状态
	double m_dArea; // 当前的全面积，用于拖动时，实时更新

	Adesk::Boolean update();
};


TDragSearchAreaDbTextJig::TDragSearchAreaDbTextJig(TDbSpace * space, CSearchAreaDlg *pDlg)
: TDragDbTextJig(space), m_pDlg(pDlg)
{
	ASSERT(pDlg != NULL);
}

TDragSearchAreaDbTextJig::TDragSearchAreaDbTextJig(TDbText * text, CSearchAreaDlg *pDlg, double dArea)
: TDragDbTextJig(text), m_pDlg(pDlg), m_dArea(dArea)
{
	ASSERT(pDlg != NULL);
}

Adesk::Boolean TDragSearchAreaDbTextJig::update()
{
	XPoint pt;
	pt = m_ptPoint;
	if (m_tdbtext==NULL)
	{
		m_tdspace->m_ptLocation=pt;
		m_tdspace->SetHalfArea(m_pDlg->m_bHalfArea);
	}
	else
	{
		XString sArea(256);
		double dHalf = m_pDlg->m_bHalfArea ? 0.5 : 1.0;
	//	sArea << XString(_T("%.2f"), _AS_SQMETER(m_dArea * dHalf));
        sArea << XString(_T("%.*f"), DocGetSpaceAreaPrecision(),  _AS_SQMETER(m_dArea * dHalf));//add by lxb on 2011//11//28
		if (m_pDlg->m_bAreaUnit)
			sArea << _T("m^U2^U");

		pt.y-=m_tdbtext->GetHeight(FALSE)/2;
		m_tdbtext->SetLocation(pt);
		m_tdbtext->SetText(sArea);
	}	
	return Adesk::kTrue;
}

// Add by lcf On 20050824
#include "edjigex.h"
extern TARCH_IMPEXP BOOL g_bFindExtSpace;
// 建筑面积不计算柱子
void SearchSpaceEx(PickSet &ssWalls,const DList<AcDbObjectId> &lstColu,DList<TDbSpace> &res)
{
	//add by lgy 20120223	当图中存在完全包含在柱内的短墙时，查询面积命令无法正常执行
	//此处添加一goto语句的标记
SEARCHSPACE_LAB_BEGIN:
    XSearchSpaceFromWall aSearch;
    try 
	{
       aSearch.InitStart(ssWalls, lstColu);
    }
	//add by lgy 20120223	当图中存在完全包含在柱内的短墙时，查询面积命令无法正常执行
	catch(TSearchException e) 
	{
		if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_MARK || e.m_nHowToDo == HF_NONE) 
		{
			ssWalls -= e.m_idObj;		// 从选择集中过滤掉“小短墙”
			goto SEARCHSPACE_LAB_BEGIN;
		}

		return ;
	}
	catch (...)
	{
        adsout << /*UMSG*/_T("\n发生例外情况!");
		return;
    }
	
    XAecSpaceCell *extCell = aSearch.SearchSpaces();
	TDbSpace *pDbExtSpace = NULL;
    for (int n=0; n<aSearch.spaces.Length(); n++) 
	{
        XAecSpaceCell *pSpace = aSearch.spaces[n];
				
        XPoly2D polySpace(1);
        pSpace->CenterPoly2D(polySpace);
        polySpace.SetElevation(0.0); //投影到z=0的平面上

        XPoint ptLoc;
        polySpace.Center(ptLoc);
        ptLoc.z = 0.0;

		if ((ptLoc&polySpace) != PR_INSIDE)
		{
            XPoly polyTemp;
            polySpace.MapToPolygon(polyTemp, 20);
            if (!!polyTemp) 
			{
                XPolygonEx polyTri(polyTemp);
                DList<XTriangle> lstTri;
                if ( polyTri.Trianglize(lstTri, TRUE)==RTNORM && !!lstTri) 
				{
                    XTriangle *pTri = lstTri[0];
                    ptLoc.x = (pTri->vertex1.x+pTri->vertex2.x+pTri->vertex3.x)/3.0;
                    ptLoc.y = (pTri->vertex1.y+pTri->vertex2.y+pTri->vertex3.y)/3.0;
                }
            }
        }

        TDbSpace *pDbSpace = new TDbSpace;
		pDbSpace->m_sName = _T("房间");
		pDbSpace->m_ptLocation = ptLoc;
		pDbSpace->SetTextStyleId(InitTextStyle(TS_SPACE));
		pDbSpace->UpdateFrom(*pSpace, pSpace==extCell);
		if (pSpace == extCell)
		{
			pDbExtSpace = pDbSpace;
			// pDbExtSpace->m_sName = _T("建筑轮廓"); // 建筑面积-〉建筑轮廓 changed by fxj 080620
			pDbExtSpace->m_sName =_T("建筑面积"); // sg modify 090603，按照林工提出的意见，恢复建筑面积的名称
			pDbExtSpace->SetType(TDbSpace::kTotalArea); // sg add 081226，设置房间类型
			pDbExtSpace->setLayer(InitLayer(LAY_BUILDING_SPACE)); // add by fxj 080620
			pDbExtSpace->m_sCode = _T("0");
			XPoly2D polyExt;
			extCell->InternalPoly2D(polyExt, 0, 0);
			pDbExtSpace->SetPathPoly(polyExt, AcGeVector3d::kZAxis);
		}
		else
			res.Append(pDbSpace);
    }

	if (pDbExtSpace != NULL)
		res.Append(pDbExtSpace);
}


////////////////////////////////////////////////////////////////
// 查询面积
class TAskSpAreaJig : public TSymbEdJig 
{
public:
	DList<TDbSpace> m_allSpace;
	TDbSpace m_space;
	long m_iCurSpace;
    BOOL m_bESC;

	CSearchAreaDlg *m_pDlg; // sg add 090226

public:
//	TAskSpAreaJig(); // sg modify 090226
	TAskSpAreaJig(CSearchAreaDlg *pDlg);

    virtual DragStatus GetPoint(XPoint &pt);
    virtual Adesk::Boolean update();
	virtual AcDbEntity* entity() const{return (AcDbEntity*)&m_space;}//ok
	const TDbSpace* GetPickSpace()const{return !m_allSpace?NULL:&m_allSpace[m_iCurSpace];}//ok
};

// TAskSpAreaJig::TAskSpAreaJig() // sg modify 090226
TAskSpAreaJig::TAskSpAreaJig(CSearchAreaDlg *pDlg)
:m_pDlg(pDlg)
{
    m_bESC = FALSE; // add by fxj
    RBList wallMask(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL"), NULL);
    PickSet ssWalls(SS_FREE);

	// modify by xlc on 071225
	// 添加搜索范围
	//	ssWalls.Get(_T("X"), NULL, NULL, wallMask);
//  CAcModuleResourceOverride vTemp;
// 	CSearchRangeDlg dlg;
// 	dlg.m_strType = _T("TCH_WALL,TCH_CURTAIN_WALL");
// 	if (dlg.DoModal()== IDOK)
// 	{
// 		ssWalls += dlg.m_ssEnt;
// 	}

	{
		// xly add 100826，为提高搜索房间质量，强制将墙基线打开
		int nVal = g_bShowBase;
		if (nVal == 0) // 双线
		{
			DocSetShowBase(1); // 单双线显示
			PickSet ssTmpWall(SS_FREE);
			if (GetEntByDxf(ssTmpWall, _T("TCH_WALL,TCH_CURTAIN_WALL"), 1) == Acad::eOk)
			{
				UpdateGraphic(ssTmpWall);
			}
		}

		// [12/26/2007 nsh]
		// ------------------------------begin----------------------------
		adsout << _T("\n提示: 空选即为全选!");
		int r = SelectEntities(_T("\n请选择查询面积的范围:"),ssWalls, wallMask);

		//modified by fxj 090224
		if (r == RTCAN) // modified by fxj 090426
		{
			m_bESC = TRUE;

			// add by xly on 1026 解决搜索房间墙线不显示，如果退出搜索恢复墙体显示
			if (nVal == 0) // 恢复双线显示
			{
				DocSetShowBase(0); // 双线显示
				PickSet ssTmpWall(SS_FREE);
				if (GetEntByDxf(ssTmpWall, _T("TCH_WALL,TCH_CURTAIN_WALL"), 1) == Acad::eOk)
				{
					UpdateGraphic(ssTmpWall);
				}
			}

			return;
		}
		else if (r != RTNORM)
		{
			ssWalls.Get(_T("X"), NULL, NULL, wallMask);
		}
		//-------------------------------end-----------------------------

		if (nVal == 0) // 恢复双线显示
		{
			DocSetShowBase(0); // 双线显示
			PickSet ssTmpWall(SS_FREE);
			if (GetEntByDxf(ssTmpWall, _T("TCH_WALL,TCH_CURTAIN_WALL"), 1) == Acad::eOk)
			{
				UpdateGraphic(ssTmpWall);
			}
		}
	}
	//过滤隔断 add by fxj 090629
	PickSet ssDiv;
	for(long i=0;i<ssWalls.Length();i++)
	{
		Entity ent=ssWalls[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
		if (pWall)
		{
			if (pWall->GetStyle()==TWallData::kDivider&&pWall->GetUsageFlag()==TWallData::kApartment)
				ssDiv+=ent;

		}
		OPENOBJ_END();
	}
	ssWalls-=ssDiv;

	DList<AcDbObjectId> lstColu;
	GetEntFromBlockByDxf(lstColu, _T("TCH_COLUMN"));
	SearchSpaceEx(ssWalls,lstColu,m_allSpace);
	m_iCurSpace = m_allSpace.Length()-1;
	m_space.setColorIndex(1);
	m_space.SetShowOutline(TRUE);
	m_space.SetTextStyleId(InitTextStyle(TS_SPACE));
}

// 反馈
AcEdJig::DragStatus TAskSpAreaJig::GetPoint(XPoint &pt)
{
	return acquirePoint(pt);
}

// 更新实体数据
Adesk::Boolean TAskSpAreaJig::update()
{
	XPoint ptPick = m_ptResult;
	m_space.m_ptLocation = m_ptResult;

	m_pDlg->UpdateData(TRUE);
	m_space.SetHasHatch(m_pDlg->m_bShowHatch); // sg add 090226

	// modify by xly 支持真彩色的使用
	//m_space.SetHatchColor(m_pDlg->m_nColor);
	m_space.SetHatchTrueColor(m_pDlg->m_cColor);

	m_space.SetHatchStyle(m_pDlg->m_csHatch);
	m_space.SetHatchScale(m_pDlg->m_dHatchScale);
	m_space.SetHatchAngle(m_pDlg->m_nHatchAngle*PI/180);
	m_space.SetHalfArea(m_pDlg->m_bHalfArea);
	AcDbObjectId idHatch = InitLayer(LAY_SPACE_HATCH);//modified by fxj 090609
	m_space.SetHatchLayer(idHatch);

	double minArea = -1;
	for (long i=0;i<m_allSpace.Length();i++)
	{
		TDbSpace*pSpace = m_allSpace[i];
		XPoly2D poly(1);
		AcGeVector3d vt;
		pSpace->GetPathPoly(poly,vt);
		if ((ptPick&poly) == PR_INSIDE)
		{
			if (minArea<0 || poly.Area()<minArea)
			{
				m_space.SetPathPoly(poly, vt);
				m_iCurSpace = i;
				minArea = poly.Area();
			}
		}
		else if (minArea<0 && i==m_allSpace.Length()-1)
		{
			m_space.SetPathPoly(poly, vt);
			m_iCurSpace = i;
			break;
		}
	}	
	return Adesk::kTrue;
}
//add by fxj 090206
//int DrawPoly(XPoly2D &poly2d)
//{
//    XPoint ptStart;
//    while(1) 
//	{
//        adsout << _T("\n多边形的第一点<退出>:");
//		
//        int nCode;
//        nCode=ads_getpoint(NULL, _T(""), ptStart);
//      
//		if (nCode==RTNORM)
//			break;
//		else
//			return nCode;
//        
//    }
//
//    
//    XPoint pt2;
//    XScreenDc dc;
//    dc.m_nDrawMode=1;
//    DStack<XPoint> aStack;
//    aStack.Push(new XPoint(ptStart));
//    while(1) 
//	{
//        XPoint &ptFrom=*aStack.Top();
//        if (aStack.Length()>=3)
//			adsout << _T("\n下一点或 [回退(U)]<封闭>: ");
//        else
//			adsout << _T("\n下一点或 [回退(U)]<退出>: ");
//        int rc;
//        INITGET_BEG(0, _T("U"));
//        rc=ads_getpoint(ptFrom, _T(""), pt2);
//        INITGET_END();
//        if (rc==RTCAN) 
//		{
//            aStack.Reset();
//            return rc;
//        } 
//		else if (rc==RTKWORD)
//		{
//            if (*aStack.Top() != ptStart)  {// Not on first state
//               XPoint *pPt2 = aStack.Pop();
//               XPoint *pPt1 = aStack.Top();
//               dc.SetColor(-1);
//               dc << XLine(*pPt1, *pPt2);
//               delete pPt2;
//          
//			}
//        }
//		else 
//		{
//            if (rc==RTNONE) 
//			{
//                if (aStack.Length()<3)
//                    return RTERROR;
//                else
//                    pt2=ptStart;
//            }
//             XLine ln(*aStack.Top(), pt2);
//             if (ln.Length()>_DIST_SNAP) 
//			 {
//                dc.SetColor(7);
//                dc << ln;
//                if (!(rc==RTNONE))
//                   aStack.Push(new XPoint(pt2));
//                else break;
//             }
//        }
//    }
//    poly2d.Reset();
//    XPoint *ptCur=NULL;
//    while((ptCur=aStack.Pop())!=NULL)
//	{
//       poly2d.AppendNode(*ptCur);
//       delete ptCur;
//    }
//    poly2d.Compress();
//    if (!poly2d || poly2d.Length()<3) 
//        return RTERROR;
//    
//
//	for(long i=0;i<poly2d.Length();i++)
//	{
//		*poly2d[i]=Ucs2Wcs(*poly2d[i]);//modified by fxj 090218
//	}
//    return RTNORM;
//}
// Command: 查询面积
// modified by fxj
void AskSpArea()
{
//	extern TARCH_IMPEXP BOOL g_bFindExtSpace;
	CSearchAreaDlg dlg(acedGetAcadFrame());
	{
		CAcModuleResourceOverride vTemp;
		if ( !dlg.Create(dlg.IDD, acedGetAcadFrame()) )
			return;
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	while(1) // add by fxj
	{
		dlg.UpdateData();
		dlg.m_bUseEsc = TRUE; // add by fxj

		// modify by xly on 101111根据8.5需求修改该房间对象，支持房间名和面积都不标注
//		int nSpFlag = DocGetSpaceDispMode();
//		if (dlg.m_bDimArea)
//			nSpFlag |= SPF_AREA;
//		else
//			nSpFlag &= ~SPF_AREA;
//
//		if (dlg.m_bAreaUnit)
//			nSpFlag |= SPF_UNIT;
//		else
//			nSpFlag &= ~SPF_UNIT;
//
//// 		if (dlg.m_nVisible == 0) // sg modify 081119
//// 			nSpFlag &= ~SPF_CODE;
//// 		else
//// 			nSpFlag |= SPF_CODE;
//		if (dlg.m_bDimCode && dlg.m_bDimName) // 同时标注
//		{
//			nSpFlag &= ~SPF_CODE;
//			nSpFlag |= SPF_NAME_AND_CODE;
//		}
//		else
//		{
//			nSpFlag &= ~SPF_NAME_AND_CODE;
//			if (dlg.m_bDimCode) // 标编号
//				nSpFlag |= SPF_CODE;
//			else // 标名称
//				nSpFlag &= ~SPF_CODE;
//		}
//		DocSetSpaceDispMode(nSpFlag);

        if (dlg.s_iMode == 0)
		{
//			TAskSpAreaJig jig(); // sg modify 090226
			TAskSpAreaJig jig(&dlg);
			if (jig.m_bESC)
			{
				if (dlg.m_bUseEsc)
					break;
				else
					continue;
			}

			BOOL bDistub = FALSE; // add by fxj 080702
			while(1) //add by fxj 080702
			{
				jig.SetPrompt(_T("\n请在屏幕上点取一点<返回>:"));
				// jig.m_space.SetRotation(Ucs2Wcs(0)); // add by fxj 080813 与ucs对齐
				jig.m_space.SetLayoutRotation(Ucs2Wcs(0)); // sg modify 090602,8.0的正式版起，将“文字转角”并入“布局转角”
				int nRet = jig.DoIt(/*&nKeyIdx*/);
				dlg.UpdateData(TRUE);
				if (nRet == RTNORM)
				{
					const TDbSpace* pDbSpacePick = jig.GetPickSpace();
					XPoint ptPick = jig.GetPickPoint();

					if (pDbSpacePick != NULL)
					{				
						double dHalf = dlg.m_bHalfArea ? 0.5 : 1.0;
						adsout << _T("\n面积=") << (pDbSpacePick->m_nUseArea * dHalf)<< _T(" 平方米");
					
						if (g_bBuildRoom)
						{
							TDbSpace *pDbSpace1 = new TDbSpace;
							CopyObject(*pDbSpacePick,*pDbSpace1);

							// modify by xly on 110413 支持字母数字连字符
							//pDbSpace1->m_sCode = XString(_T("%d"), g_nStartCode);
							pDbSpace1->m_sCode = g_csStartCode;
							pDbSpace1->SetHas3D(g_bGround);
							pDbSpace1->SetMask(g_bShield);
							pDbSpace1->SetFloorThick(g_dThick);
							// add by lgh 100804, 增加设置一半面积
							pDbSpace1->SetHalfArea(dlg.m_bHalfArea);

							pDbSpace1->SetHasHatch(dlg.m_bShowHatch); // sg add 081124
							
							//modify by xly on 100909 真彩色使用
							//pDbSpace1->SetHatchColor(dlg.m_nColor);
							pDbSpace1->SetHatchTrueColor(dlg.m_cColor);
							pDbSpace1->SetHatchStyle(dlg.m_csHatch);
							pDbSpace1->SetHatchScale(dlg.m_dHatchScale);
							pDbSpace1->SetHatchAngle(dlg.m_nHatchAngle*PI/180);
							AcDbObjectId idHatch = InitLayer(LAY_SPACE_HATCH); //modified by fxj 090609
							pDbSpace1->SetHatchLayer(idHatch);

							// modify by xly on 101111根据8.5需求修改该房间对象，支持房间名和面积都不标注
//							int nSpFlag = DocGetSpaceDispMode();
//							if (dlg.m_bDimArea)
//								nSpFlag |= SPF_AREA;
//							else
//								nSpFlag &= ~SPF_AREA;
//
//							if (dlg.m_bAreaUnit)
//								nSpFlag |= SPF_UNIT;
//							else
//								nSpFlag &= ~SPF_UNIT;
//
//// 							if (dlg.m_nVisible == 0) // sg modify 081119
//// 								nSpFlag &= ~SPF_CODE;
//// 							else
//// 								nSpFlag |= SPF_CODE;
//							if (dlg.m_bDimCode && dlg.m_bDimName) // 同时标注
//							{
//								nSpFlag &= ~SPF_CODE;
//								nSpFlag |= SPF_NAME_AND_CODE;
//							}
//							else
//							{
//								nSpFlag &= ~SPF_NAME_AND_CODE;
//								if (dlg.m_bDimCode) // 标编号
//									nSpFlag |= SPF_CODE;
//								else // 标名称
//									nSpFlag &= ~SPF_CODE;
//							}
//							DocSetSpaceDispMode(nSpFlag);
							pDbSpace1->SetDimNameAndCode(dlg.m_bDimName, dlg.m_bDimCode);
							pDbSpace1->SetDimArea(dlg.m_bDimArea);
							pDbSpace1->SetDimUnit(dlg.m_bAreaUnit);

				            // pDbSpace1->SetRotation(Ucs2Wcs(0)); // ucs对齐  add by fxj 080813
							pDbSpace1->SetLayoutRotation(Ucs2Wcs(0)); // sg modify 090602,8.0的正式版起，将“文字转角”并入“布局转角”
							pDbSpace1->m_ptLocation = ptPick;
							pDbSpace1->SetTextStyleId(InitTextStyle(TS_SPACE));

							// --------modified by fxj 080630------
							CString sName = pDbSpace1->m_sName;						
							pDbSpace1->AddToMSpace(Adesk::kFalse);
							// if (sName == _T("建筑轮廓"))
							if (sName == _T("建筑面积")) // sg modify 090603，按照林工提出的意见，恢复建筑面积的名称
							{
								pDbSpace1->setLayer(InitLayer(LAY_BUILDING_SPACE, FALSE));
								pDbSpace1->SetType(TDbSpace::kTotalArea); // sg add 081226，设置房间类型
							}
							pDbSpace1->close();
							// ---------------------------
							// modify by xly on 110413 支持字母数字连字符
							//g_nStartCode++;
							g_csStartCode = AnalySpaceCode(g_csStartCode);
						}
						else
						{
							if (dlg.m_bDimArea) 
							{
								AcDbObjectId idStyle = InitTextStyle(TS_SPACE);
								double nTextSize = 3.5;
								TDbText *pText = new TDbText;
								pText->SetHeight(nTextSize);
								pText->SetStyleId(idStyle);
								pText->SetAlignment(XExplodeDraw::kMiddleCenter);
								ptPick.y -= pText->GetHeight(FALSE)/2;
								pText->SetRotation(Ucs2Wcs(0)); // ucs对齐  add by fxj 080813
								pText->SetLocation(ptPick);
								XString sArea(256);
								double dHalf = dlg.m_bHalfArea ? 0.5 : 1.0;
							//	sArea << XString(_T("%.2f"), pDbSpacePick->m_nUseArea * dHalf);
								sArea << XString(_T("%.*f"), DocGetSpaceAreaPrecision(), pDbSpacePick->m_nUseArea * dHalf);//add by lxb on 2011//11//28
								if (dlg.m_bAreaUnit)
									sArea << _T("m^U2^U");
								pText->SetText(sArea);
								pText->setLayer(InitLayer(LAY_SPACE, FALSE));
								pText->SetMaskFlag(g_bShield);//add by lxb on 2011/12/01
								AddToModelSpace(pText, Adesk::kTrue);
							}
						}
					}
					else
						adsout<<_T("请正确点取!");
				}
				else if (nRet == RTCAN)
				{
					if (dlg.m_bUseEsc)
					{
						bDistub = TRUE;
					}
					else
					{
						bDistub = FALSE;
					}
					break;
				}
				else if (nRet == RTNONE) // add by fxj 080815
				{
					break;
				}
			}

			if (bDistub) // add by fxj 080702
				break;
			else
				continue;
		}
		else // 选择多段线或阳台
		{
			XPoly2D poly;
			if (dlg.s_iMode == 1)
			{
				Entity ent;
				int nRetP = ent.UserSelect(_T("\n选择闭合多段线或圆<退出>:"));
			
				if (nRetP == RTCAN)
				{
					if (dlg.m_bUseEsc)
						break;
					else
					    continue;
				}
				else if (nRetP == RTNORM)
				{
					if (!(ent.Is(_T("CIRCLE")) || ent.Is(_T("LWPOLYLINE")) || ent.Is(_T("POLYLINE"))))
					{
						adsout<<_T("请正确选择!");
						continue;
					}
				}
				else
					break;
				poly = XPoly2D(ent);
			}
			else if (dlg.s_iMode == 2)
			{
				RBList mask(RTDXF0, _T("TCH_BALCONY"),NULL);
				Entity ent;
				int nRetB = ent.UserSelect(_T("\n选择阳台<退出>:"));
				
				if (nRetB == RTCAN)
				{
					if (dlg.m_bUseEsc)
						break;
					else
						continue;
				}
				else if (nRetB == RTNORM)
				{
					if (!ent.Is(_T("TCH_BALCONY")))
					{
						adsout<<_T("请正确选择!");
						continue;
					}
				}
				else
					break;

				OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbBalcony, pBalcony)
				if (pBalcony == NULL)
					continue;
				poly = pBalcony->GetOutline();
				OPENOBJ_END()
			}
			else//add by fxj 090206
			{
			//	int nRet=DrawPoly(poly);
				int nRet;
	    		XPoint ptStart;
	   			nRet = ads_getpoint(NULL, _T("\n多边形起点<退出>: "), ptStart);
				XPoly2D poly2dRet;			     
				if (nRet == RTNORM)
				{
				
					ptStart=Ucs2Wcs(ptStart);
				    
					int nOsMode=0;
					xg_getvar(_T("OSMODE"), &nOsMode);
					nOsMode &= ~0x4000;
					nOsMode |=OS_INT;
					XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);

					nRet=DragInputPoly(ptStart, poly2dRet);
				}
				else if (nRet==RTCAN)
				{
					if (dlg.m_bUseEsc)
							break;
						else
							continue;
				}
				else
					break;

				
				//if (nRet == RTCAN)
				//{
				//	if (dlg.m_bUseEsc)
				//		break;
				//	else
				//		continue;
				//}
				//else if (nRet == RTERROR)
				//{
				//	
				//		continue;
				//	
				//}
				//else if (nRet != RTNORM)
				//	break;
			
				if (nRet != RTNORM)
					break;
				poly=poly2dRet;
				poly.SetFlag(1);
				poly.Make();
			}

			poly.SetFlag(1); // 强制封闭
			poly.SetElevation(0);
			poly.Compress();
			
			double nArea = poly.Area();
			double dHalf = dlg.m_bHalfArea ? 0.5 : 1.0;
			// adsout << _T("\n面积=") << _AS_SQMETER(nArea) << _T(" 平方米");
			adsout << _T("\n面积=") << _AS_SQMETER(nArea * dHalf)<< _T(" 平方米");
		    
			XPoint ptLoc;
			poly.Center(ptLoc);
			ptLoc.z = 0.0;
			dlg.UpdateData(TRUE);//add by fxj 090309
			if (g_bBuildRoom)
			{
				TDbSpace *pDbSpace1 = new TDbSpace;
				pDbSpace1->m_sName = dlg.s_iMode==2?_T("阳台"):_T("房间");//modified by fxj 090209
				// modify by xly on 110413 支持字母数字连字符
				//pDbSpace1->m_sCode = XString(_T("%d"), g_nStartCode);
				pDbSpace1->m_sCode = g_csStartCode;

				// pDbSpace1->m_nUseArea = _AS_SQMETER(nArea);
				pDbSpace1->SetPathPoly(poly, AcGeVector3d::kZAxis);
				pDbSpace1->SetHas3D(g_bGround);
				pDbSpace1->SetMask(g_bShield);
				pDbSpace1->SetFloorThick(g_dThick);
				pDbSpace1->SetBalcony(TRUE);
				// add by lgh 100804, 设置是否标志一半面积
				pDbSpace1->SetHalfArea(dlg.m_bHalfArea);

				pDbSpace1->SetHasHatch(dlg.m_bShowHatch); // sg add 081124
				//pDbSpace1->SetHatchColor(dlg.m_nColor);
				pDbSpace1->SetHatchTrueColor(dlg.m_cColor);
				pDbSpace1->SetHatchStyle(dlg.m_csHatch);
				pDbSpace1->SetHatchScale(dlg.m_dHatchScale);
				pDbSpace1->SetHatchAngle(dlg.m_nHatchAngle*PI/180);
				AcDbObjectId idHatch = InitLayer(LAY_SPACE_HATCH); //modified by fxj 090609
				pDbSpace1->SetHatchLayer(idHatch);

				// add by fxj 080620
				if (dlg.s_iMode==2)
				{
					pDbSpace1->setLayer(InitLayer(LAY_BALCONY_SPACE));//modified by fxj 090521 （增加InitLayer）
					pDbSpace1->SetType(TDbSpace::kBalconyArea); // sg add 081226，房间类型
					// add by lgh 100804
					// 新添加了针对所有情况的设置一半面积
//					pDbSpace1->SetHalfArea(g_bBlaconyHalf);//modified by fxj  090625 是否按一半面积计算受全局变量控制 
				}
				else
					pDbSpace1->setLayer(InitLayer(LAY_SPACE));//modified by fxj 090521 

				// modify by xly on 101111根据8.5需求修改该房间对象，支持房间名和面积都不标注
//				int nSpFlag = DocGetSpaceDispMode();
//				if (dlg.m_bDimArea)
//					nSpFlag |= SPF_AREA;
//				else
//					nSpFlag &= ~SPF_AREA;
//
//				if (dlg.m_bAreaUnit)
//					nSpFlag |= SPF_UNIT;
//				else
//					nSpFlag &= ~SPF_UNIT;
//
//// 				if (dlg.m_nVisible == 0) // sg modify 081119
//// 					nSpFlag &= ~SPF_CODE;
//// 				else
//// 					nSpFlag |= SPF_CODE;
//				if (dlg.m_bDimCode && dlg.m_bDimName) // 同时标注
//				{
//					nSpFlag &= ~SPF_CODE;
//					nSpFlag |= SPF_NAME_AND_CODE;
//				}
//				else
//				{
//					nSpFlag &= ~SPF_NAME_AND_CODE;
//					if (dlg.m_bDimCode) // 标编号
//						nSpFlag |= SPF_CODE;
//					else // 标名称
//						nSpFlag &= ~SPF_CODE;
//				}
//				DocSetSpaceDispMode(nSpFlag);

				pDbSpace1->SetDimNameAndCode(dlg.m_bDimName, dlg.m_bDimCode);
				pDbSpace1->SetDimArea(dlg.m_bDimArea);
				pDbSpace1->SetDimUnit(dlg.m_bAreaUnit);

				pDbSpace1->SetTextStyleId(InitTextStyle(TS_SPACE));
				// pDbSpace1->SetRotation(Ucs2Wcs(0)); // ucs对齐 add by fxj 080813
				pDbSpace1->SetLayoutRotation(Ucs2Wcs(0)); // sg modify 090602,8.0的正式版起，将“文字转角”并入“布局转角”
				// [3/6/2008 nsh]
				// -------------------------begin-------------------------
				//TDragDbTextJig jig(pDbSpace1, &dlg);
				TDragSearchAreaDbTextJig jig(pDbSpace1, &dlg);
				jig.SetPrompt(_T("\n请点取面积标注位置<中心>:"));
				int iRet = jig.doIt();
				if (iRet == RTNORM)
				{
					TDbSpace *pDbSpace2 = (TDbSpace*)jig.entity();
					AddToModelSpace((TDbSpace*)(pDbSpace2->clone()),Adesk::kTrue);
				}
				else if (iRet == RTCAN) // add by fxj
				{
					if (dlg.m_bUseEsc)
						break;
					else 
						continue;
				}
				else
				{//moidfid by fxj 解决标注位置在中心时阳台面积图层不正确问题
					TDbSpace *pDbSpace2 = (TDbSpace*)jig.entity();
					pDbSpace2->m_ptLocation = ptLoc;
					AddToModelSpace((TDbSpace*)(pDbSpace2->clone()),Adesk::kTrue);

				//	pDbSpace1->m_ptLocation = ptLoc;
				//	pDbSpace1->AddToMSpace(Adesk::kTrue);
				}
				//-------------------------end-----------------------------
				// modify by xly on 110413 支持字母数字连字符
				//g_nStartCode++;
				g_csStartCode = AnalySpaceCode(g_csStartCode);
			}
			else
			{
				if (dlg.m_bDimArea)
				{
					AcDbObjectId idStyle = InitTextStyle(TS_SPACE);
					double nTextSize = 3.5;
					TDbText *pText = new TDbText;
					pText->SetHeight(nTextSize);
					pText->SetStyleId(idStyle);
					pText->SetAlignment(XExplodeDraw::kMiddleCenter);
					XString sArea(256);
					// sArea << XString(_T("%.2f"), _AS_SQMETER(nArea));
					// add by lgh 100804
					double dHalf = dlg.m_bHalfArea ? 0.5 : 1.0;
				//	sArea << XString(_T("%.2f"), _AS_SQMETER(nArea * dHalf));
                    sArea << XString(_T("%.*f"), DocGetSpaceAreaPrecision(),  _AS_SQMETER(nArea * dHalf));//add by lxb on 2011//11//28
					if (dlg.m_bAreaUnit)
						sArea << _T("m^U2^U");
					pText->SetText(sArea);
					pText->setLayer(InitLayer(LAY_SPACE, FALSE));
					pText->SetRotation(Ucs2Wcs(0)); // ucs对齐 add by fxj 080813
					pText->SetMaskFlag(g_bShield);//add by lxb on 2011/12/01

					//  [12/26/2007 nsh]
					//------------------------------------begin----------------------------------
					// modify by lgh 100804
					//TDragDbTextJig jig(pText, &dlg, nArea);
					TDragSearchAreaDbTextJig jig(pText, &dlg, nArea);
					jig.SetPrompt(_T("\n请点取面积标注位置<中心>:"));
					int iRet = jig.doIt();
					if (iRet == RTNORM)
					{
						TDbText *pDbText = (TDbText*)jig.entity();
						AddToModelSpace((TDbText*)(pDbText->clone()),Adesk::kTrue);
					}
					else if (iRet == RTCAN) // add by fxj
					{
						if (dlg.m_bUseEsc)
							break;
						else 
							continue;
					}
					else
					{
						pText->SetLocation(ptLoc);
						AddToModelSpace((TDbText*)pText->clone(),Adesk::kTrue);
					}
					//------------------------------------end------------------------------------
				}
			}
		}
	}

	if (::IsWindow(dlg.m_hWnd))
		dlg.DestroyWindow();
}



void ShareArea()
{
	PickSet ssSpaces(SS_FREE);
	RBList  spaceMask(RTDXF0, _T("TCH_SPACE"), NULL);
	if (SelectEntities(_T("\n请选择房间面积对象<退出>:"), ssSpaces, spaceMask)!=RTNORM) 
	{
		return;
	}

	// delete by xly on 100827 根据8.5需求，去掉公摊面积类型的设置
	/*TCHAR skword[1024]=_T("");
	int nRet;
	INITGET_BEG(0,_T("A B"))
	nRet=acedGetKword(_T("\n指定公摊类型 [本层公摊(A)/全楼公摊(B)]<A>:"),skword);
	INITGET_END()

	BOOL bAllBudShare=FALSE;
	if (nRet==RTNORM&&skword[0]==_T('B'))
	{
		bAllBudShare=TRUE;
	}
	else if ((nRet==RTNORM && skword[0]==_T('A'))|| nRet==RTNONE)
		bAllBudShare=FALSE;
	else
		return;*/

	BOOL bAllBudShare=FALSE;

    for(long i=0;i<ssSpaces.Length();i++)
	{
		Entity ent=ssSpaces[i];
		TDbSpace *pSpace=NULL;
		
		//------------modified by fxj 090326
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSpace, pSpace);
		if (pSpace)
		{
			CString sName=pSpace->m_sName;
			if (bAllBudShare)
			{
				if (sName.Find(_T("全楼公摊"))==-1)//add by fxj 080708
					sName+=_T("(全楼公摊)");	

			}
			else
			{//add by fxj 080708

                if (sName.Find(_T("(全楼公摊)"))!=-1)
					sName.Replace(_T("(全楼公摊)"),_T(""));		
					
			}
			if (pSpace->upgradeOpen() != Acad::eOk)
			    continue;
            pSpace->assertWriteEnabled();
			pSpace->SetType(TDbSpace::kShareArea);//add by fxj 090416设置类型
			pSpace->setLayer(InitLayer(LAY_SHARE_SPACE));
			pSpace->m_sName=sName;
		    pSpace->downgradeOpen();
			//---------------------------------
		}
		 
		OPENOBJ_END();

	}

	return;

}
//void AskSpArea()
//{
//	extern TARCH_IMPEXP BOOL g_bFindExtSpace;
//	CSearchAreaDlg dlg(acedGetAcadFrame());
//	{
//		CAcModuleResourceOverride vTemp;
//		if ( !dlg.Create(dlg.IDD, acedGetAcadFrame()) )
//			return;
//	}
//	dlg.ShowWindow(SW_SHOW);
//	acedGetAcadDwgView()->SetFocus();
//
//	TAskSpAreaJig jig;
//	jig.SetKeyword(_T("P B"));
//	jig.SetPrompt(_T("\n请在屏幕上点取一点或 [查询闭合PLINE面积(P)/查询阳台面积(B)]<退出>:"));
//	while(1)
//	{
//		int nKeyIdx;
//		int nRet = jig.DoIt(&nKeyIdx);
//
//		dlg.UpdateData();
//		BOOL bDimArea = dlg.m_bDimArea;
//		BOOL bAreaUnit = dlg.m_bAreaUnit;
//		BOOL bGround = g_bGround;
//		BOOL bShield = g_bShield;
//		BOOL bBuildRoom = g_bBuildRoom;
//		int nVisible = dlg.m_nVisible;
//		double dThick = g_dThick;
//
//		int nSpFlag=DocGetSpaceDispMode();
//		if (bDimArea)
//			nSpFlag |= SPF_AREA;
//		else
//			nSpFlag &= ~SPF_AREA;
//
//		if (bAreaUnit)
//			nSpFlag |= SPF_UNIT;
//		else
//			nSpFlag &= ~SPF_UNIT;
//
//		if (nVisible == 0)
//			nSpFlag &= ~SPF_CODE;
//		else
//			nSpFlag |= SPF_CODE;
//		DocSetSpaceDispMode(nSpFlag);
//
//		if (nRet == RTNORM)
//		{
//			const TDbSpace* pDbSpacePick=jig.GetPickSpace();
//			XPoint ptPick=jig.GetPickPoint();
//
//			if (pDbSpacePick!=NULL)
//			{
//			
//				adsout << _T("\n面积=") << pDbSpacePick->m_nUseArea<< _T(" 平方米");
//			
//				if (bBuildRoom)
//				{
//					TDbSpace *pDbSpace1 = new TDbSpace;
//					CopyObject(*pDbSpacePick,*pDbSpace1);
//					pDbSpace1->m_sCode=XString(_T("%d"), g_nStartCode);
//					pDbSpace1->SetHas3D(bGround);
//					pDbSpace1->SetMask(bShield);
//					pDbSpace1->SetFloorThick(dThick);
//					int nSpFlag=DocGetSpaceDispMode();
//					if (bDimArea)
//						nSpFlag |= SPF_AREA;
//					else
//						nSpFlag &= ~SPF_AREA;
//
//					if (bAreaUnit)
//						nSpFlag |= SPF_UNIT;
//					else
//						nSpFlag &= ~SPF_UNIT;
//
//					if (nVisible == 0)
//						nSpFlag &= ~SPF_CODE;
//					else
//						nSpFlag |= SPF_CODE;
//					DocSetSpaceDispMode(nSpFlag);
//
//					pDbSpace1->m_ptLocation = ptPick;
//					pDbSpace1->SetTextStyleId(InitTextStyle(TS_SPACE));
//					pDbSpace1->AddToMSpace(Adesk::kTrue);
//
//					g_nStartCode++;
//				}
//				else
//				{
//					if (bDimArea) 
//					{
//						AcDbObjectId idStyle=InitTextStyle(TS_SPACE);
//						double nTextSize=3.5;
//						TDbText *pText=new TDbText;
//						pText->SetHeight(nTextSize);
//						pText->SetStyleId(idStyle);
//						pText->SetAlignment(XExplodeDraw::kMiddleCenter);
//						ptPick.y-=pText->GetHeight(FALSE)/2;
//						pText->SetLocation(ptPick);
//						XString sArea(256);
//						sArea << XString(_T("%.2f"), pDbSpacePick->m_nUseArea);
//						if (bAreaUnit)
//							sArea << _T("m^U2^U");
//						pText->SetText(sArea);
//						pText->setLayer(InitLayer(LAY_SPACE, FALSE));
//						AddToModelSpace(pText, Adesk::kTrue);
//					}
//				}
//			}
//			else
//				adsout<<_T("请正确点取!");
//		}
//		else if (nRet == RTKWORD)
//		{
//			XPoly2D poly;
//			if (nKeyIdx == 0)
//			{
//				RBList mask(RTDXF0, _T("CIRCLE,LWPOLYLINE,POLYLINE"),NULL);
//				Entity ent;
//				if (ent.FilterSelect(_T("\n选择闭合多段线或圆<返回>:"),mask)!=RTNORM)
//					continue;
//				poly=XPoly2D(ent);
//			}
//			else if (nKeyIdx==1)
//			{
//				RBList mask(RTDXF0, _T("TCH_BALCONY"),NULL);
//				Entity ent;
//				if (ent.FilterSelect(_T("\n选择阳台<返回>:"),mask)!=RTNORM)
//					continue;
//				OPENOBJ_BEGIN(ent,AcDb::kForRead,TDbBalcony,pBalcony)
//				if (pBalcony==NULL)
//					continue;
//				poly=pBalcony->GetOutline();
//				OPENOBJ_END()
//			}
//
//			poly.flag=1;//强制封闭
//			poly.SetElevation(0);
//			poly.Compress();
//
//			if (nKeyIdx == 0 ||nKeyIdx== 1)
//			{
//				double nArea=poly.Area();
//
//				//adsout << _T("\n面积=") << _AS_SQMETER(nArea) << _T(" 平方米");
//				adsout << _T("\n面积=") << _AS_SQMETER(nArea) << _T(" 平方米");
//			
//				XPoint ptLoc;
//				poly.Center(ptLoc);
//				ptLoc.z = 0.0;
//				if (bBuildRoom)
//				{
//					TDbSpace *pDbSpace1 = new TDbSpace;
//					pDbSpace1->m_sName = nKeyIdx==0?_T("房间"):_T("阳台");
//					pDbSpace1->m_sCode=XString(_T("%d"), g_nStartCode);
//					//pDbSpace1->m_nUseArea = _AS_SQMETER(nArea);
//					pDbSpace1->SetPathPoly(poly, AcGeVector3d::kZAxis);
//					pDbSpace1->SetHas3D(bGround);
//					pDbSpace1->SetMask(bShield);
//					pDbSpace1->SetFloorThick(dThick);
//					pDbSpace1->SetBalcony(TRUE);
//					int nSpFlag=DocGetSpaceDispMode();
//					if (bDimArea)
//						nSpFlag |= SPF_AREA;
//					else
//						nSpFlag &= ~SPF_AREA;
//
//					if (bAreaUnit)
//						nSpFlag |= SPF_UNIT;
//					else
//						nSpFlag &= ~SPF_UNIT;
//
//					if (nVisible == 0)
//						nSpFlag &= ~SPF_CODE;
//					else
//						nSpFlag |= SPF_CODE;
//					DocSetSpaceDispMode(nSpFlag);
//					pDbSpace1->SetTextStyleId(InitTextStyle(TS_SPACE));
//					//  [3/6/2008 nsh]
//					//-------------------------begin-------------------------
//					TDragDbTextJig jig(pDbSpace1);
//					jig.SetPrompt(_T("\n请点取面积标注位置<中心>:"));
//					int iRet=jig.doIt();
//					if (iRet==RTNORM)
//					{
//						TDbSpace *pDbSpace2=(TDbSpace*)jig.entity();
//						AddToModelSpace((TDbSpace*)(pDbSpace2->clone()),Adesk::kTrue);
//					}
//					else
//					{
//						pDbSpace1->m_ptLocation = ptLoc;
//						pDbSpace1->AddToMSpace(Adesk::kTrue);
//					}
//					//-------------------------end-----------------------------
//					g_nStartCode++;
//				}
//				else
//				{
//					if (bDimArea) 
//					{
//						AcDbObjectId idStyle=InitTextStyle(TS_SPACE);
//						double nTextSize=3.5;
//						TDbText *pText=new TDbText;
//						pText->SetHeight(nTextSize);
//						pText->SetStyleId(idStyle);
//						pText->SetAlignment(XExplodeDraw::kMiddleCenter);
//						XString sArea(256);
//						//sArea << XString(_T("%.2f"), _AS_SQMETER(nArea));
//						sArea << XString(_T("%.2f"), _AS_SQMETER(nArea));
//						if (bAreaUnit)
//							sArea << _T("m^U2^U");
//						pText->SetText(sArea);
//						pText->setLayer(InitLayer(LAY_SPACE, FALSE));
//						//  [12/26/2007 nsh]
//						//------------------------------------begin----------------------------------
//						TDragDbTextJig jig(pText);
//						jig.SetPrompt(_T("\n请点取面积标注位置<中心>:"));
//						int iRet=jig.doIt();
//						if (iRet==RTNORM)
//						{
//							TDbText *pDbText=(TDbText*)jig.entity();
//							AddToModelSpace((TDbText*)(pDbText->clone()),Adesk::kTrue);
//						}
//						else
//						{
//							pText->SetLocation(ptLoc);
//							AddToModelSpace((TDbText*)pText->clone(),Adesk::kTrue);
//						}
//						//------------------------------------end------------------------------------
//						
//						
//					}
//				}
//			}
//		}
//		else
//		{
//			if (::IsWindow(dlg.m_hWnd))
//				dlg.DestroyWindow();
//			return;
//		}
//	}
//	if (::IsWindow(dlg.m_hWnd))
//		dlg.DestroyWindow();
//}




////only for AskArea,add by whl
//int XGetPoint1(const ads_point ref, const char *prompt, ads_point res,bool &bPLine)
//{
//	char prmt[256]=_T("");
//	if (!prompt) strcpy(prmt, _T("\n请在屏幕上点取一点"));
//	else strcpy(prmt, prompt);
//	XString prmt1(256);
//	prmt1 <<  prmt << _T("或{查询闭合PLINE面积[P]/参考点[R]}<退出>:"); 
//
//	int rt=RTKWORD;
//
//	XPoint refPt;
//	const ads_real *base=ref;
//	char buf[256];
//	while(rt==RTKWORD) 
//	{
//		INITGET_BEG(0, _T("P R"));
//		rt=ads_getpoint(base, prmt1, res);
//		INITGET_END();
//
//		if (rt==RTKWORD)
//		{ 
//			acedGetInput(buf);
//			if (buf[0]==_T('P'))
//			{
//				bPLine=true;
//				return RTNORM;
//			}
//			else
//			{
//				int rc=ads_getpoint(NULL, _T("\n参考点: "), refPt);
//				if (rc==RTCAN) return rc;
//				else if (rc==RTNORM)
//				base=&refPt.x;
//			}
//		}
//	}
//	return rt;
//}
//// Command: 查询面积
//void AskSpArea()
//{
//	extern TARCH_IMPEXP BOOL g_bFindExtSpace;
//
//	XPoint ptPick;
//	bool bPLine=false;
//	while(XGetPoint1(NULL, _T("\n请指定房间内一点"), ptPick,bPLine)==RTNORM) 
//	{//modified by whl
//		if (bPLine)
//		{
//			bPLine=false;
//			RBList mask(RTDXF0, _T("LWPOLYLINE,POLYLINE"),70,1,NULL);
//			Entity ent;
//			if (ent.FilterSelect(_T("\n选择闭合多段线<返回>:"),mask)!=RTNORM)
//				continue;
//			XPoly2D poly(ent);
//			double nArea=poly.Area();
//			adsout << _T("\n房间面积=") << _AS_SQMETER(nArea) << _T(" 平方米");
//		
//			int nSpFlag=DocGetSpaceDispMode();
//			if (nSpFlag&SPF_AREA) 
//			{
//				AcDbObjectId idStyle=InitTextStyle(TS_SPACE);
//				double nTextSize=3.5;
//				TDbText *pText=new TDbText;
//				pText->SetHeight(nTextSize);
//				pText->SetStyleId(idStyle);
//				pText->SetAlignment(XExplodeDraw::kMiddleCenter);
//				XPoint ptCenter;
//				poly.Center(ptCenter);
//				pText->SetLocation(ptCenter);
//				XString sArea(256);
//				sArea << XString(_T("%.2f"), _AS_SQMETER(nArea));
//				if (nSpFlag&SPF_UNIT)
//					sArea << _T("m^U2^U");
//				pText->SetText(sArea);
//				pText->setLayer(InitLayer(LAY_SPACE, FALSE));
//				AddToModelSpace(pText, Adesk::kTrue);
//			}
//		}
//		else
//		{
//			ptPick=Ucs2Wcs(ptPick);
//			XPoly2D polySpace(1);
//			if (GenSpacePoly(ptPick, polySpace)==RTNORM)
//			{
//				XScreenDc dc(1,1);
//				XPoly2D polyTemp(polySpace);
//				XPoint ptMin, ptMax;
//				polyTemp.GetExtend(ptMin, ptMax);
//				AssureOnScreen(ptMin, ptMax);
//				polyTemp.TransUCS(Groups(0), Groups(1));
//				dc << polyTemp;
//
//				XPoly poly;
//				polyTemp.MapToPolygon(poly);
//				RBList rbPolygon=poly.Polygon();
//				RBList rbColuMask(RTDXF0, _T("TCH_COLUMN"), NULL);
//				PickSet ss(SS_FREE);
//				double nArea=polySpace.Area();
//				if (!g_bFindExtSpace && ss.Get(_T("WP"), rbPolygon, NULL, rbColuMask)==RTNORM) {
//					long lCount=ss.Length();
//					for(long lIndex=0L; lIndex<lCount; lIndex++) {
//						Entity ent=ss[lIndex];
//						XDbObject obj(ent, AcDb::kForRead);
//						if (!obj) continue;
//						TDbColumn *pColu=TDbColumn::cast(obj.m_pObject);
//						ASSERT(pColu);
//						XPoly2D polyColu(1);
//						pColu->GetOutline(polyColu);
//						if (!!polyColu) {
//							dc << polyColu;
//							nArea -= polyColu.Area();
//						}
//					}
//				}
//				adsout << _T("\n房间面积=") << _AS_SQMETER(nArea) << _T(" 平方米");
//			
//				int nSpFlag=DocGetSpaceDispMode();
//				if (nSpFlag&SPF_AREA) 
//				{
//					AcDbObjectId idStyle=InitTextStyle(TS_SPACE);
//					double nTextSize=3.5;
//					TDbText *pText=new TDbText;
//					pText->SetHeight(nTextSize);
//					pText->SetStyleId(idStyle);
//					pText->SetAlignment(XExplodeDraw::kMiddleCenter);
//					pText->SetLocation(ptPick);
//					XString sArea(256);
//					sArea << XString(_T("%.2f"), _AS_SQMETER(nArea));
//					if (nSpFlag&SPF_UNIT)
//						sArea << _T("m^U2^U");
//					pText->SetText(sArea);
//					pText->setLayer(InitLayer(LAY_SPACE, FALSE));
//					AddToModelSpace(pText, Adesk::kTrue);
//				}
//			} 
//			else
//				adsout << _T("\n请正确选择!");
//		}
//	}
//}


//////////////////////////////////////
// Command: 生成房间轮廓线
// 必须在WCS下
void SpOutline()
{
   XPoint ptPick;
   while(XGetPoint(NULL, _T("\n请指定房间内一点"), ptPick)==RTNORM) {
       ptPick=Ucs2Wcs(ptPick);
      XPoly2D polySpace(1);
      if (GenSpacePoly(ptPick, polySpace)==RTNORM) {
         XScreenDc dc(1,1);
         XPoly2D polyTemp(polySpace);
         polyTemp.TransUCS(Groups(0), Groups(1));
         dc << polyTemp;
         if (YesNoQuestion(_T("\n是否生成封闭的多段线"))==Q_YES)
            polySpace.Make();
         ads_redraw(NULL, 0);
      } else {
         adsout << _T("\n请正确选择!");
      }
   }
}

//int PLineToFace(Entity &entPline, Entity &entPface);

///////////////////////////////////////////
// Command: 坡屋顶
// 必须在WCS下
void ConvertRoof()
{
	//修改静态变量的初始化，来适应米单位绘图
	//  [11/8/2007 nsh]
	nSanShuiDist=_AS_SYS_UNIT(600.0);
	nRoofDist=_AS_SYS_UNIT(600.0);
	//-----------------------------------
    Entity ent;
    RBList rbMask(RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, NULL);
    if (SelectEntity(_T("\n选择一封闭的多段线<退出>:"), ent, rbMask)==RTNORM) {
        XPoly2D poly(ent);
        if (!!poly) {
		    double nElevOrg=poly[0]->z;
            double nThick=0.0;
            ent.GetData(39, &nThick);
            nElevOrg += nThick;
            double nSlant=30.0;
            adsout << _T("\n请输入坡度角 <") << AS_INT(nSlant) << _T(">: ");
            ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
            int nRet=ads_getreal(_T(""), &nSlant);
            if (nRet==RTERROR || nRet==RTCAN)
                return;
            if (nSlant>89.999) {
                adsout << _T("\n坡度范围为0~90度!");
                return;
            }

			if (GetDist(_T("\n出檐长"), nRoofDist, RSG_NONEG)==RTCAN)
				return;
			double nElevMove=-nRoofDist*tan(nSlant*PI/180);
            if (poly.PathArea()>0)  {//确保逆时针
                poly.Reverse();
            }
            poly.Compress();
            XPoly2D polyDest(1);
            poly.Disperse(polyDest);
			polyDest.SetElevation(nElevOrg+nElevMove);

            TDbSlopeRoof *pRoof = new TDbSlopeRoof;
            pRoof->InitEqualSlope(polyDest, nSlant*PI/180.0);
            if (fabs(nThick)<_DIST_SNAP) {
                int bDelObj;
                VERIFY(xg_getvar(_T("DELOBJ"), &bDelObj)==RTNORM);
                if (bDelObj) 
                    ent.Delete();
            }
            pRoof->AddToMSpace(Adesk::kTrue);
        }
    }
}
//  [2/19/2008 nsh]
//------------------begin---------------------
void ConvertRoof2()
{
	//修改静态变量的初始化，来适应米单位绘图
	//  [11/8/2007 nsh]
	nSanShuiDist=_AS_SYS_UNIT(600.0);
	nElevMove=_AS_SYS_UNIT(24000.0);
	//-----------------------------------
	Entity ent;
	RBList rbMask(RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, NULL);
	if (SelectEntity(_T("\n选择一封闭的多段线<退出>:"), ent, rbMask)==RTNORM) {
		XPoly2D poly(ent);
		if (!!poly) {
			double nElevOrg=poly[0]->z;
			double nThick=0.0;
			ent.GetData(39, &nThick);
			nElevOrg += nThick;
			double nSlant=30.0;
			adsout << _T("\n请输入坡度角 <") << AS_INT(nSlant) << _T(">: ");
			ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
			int nRet=ads_getreal(_T(""), &nSlant);
			if (nRet==RTERROR || nRet==RTCAN)
				return;
			if (nSlant>89.999) {
				adsout << _T("\n坡度范围为0~90度!");
				return;
			}

			if (GetDist(_T("\n底标高"), nElevMove,RSG_NONEG)==RTCAN)
				return;
			if (poly.PathArea()>0)  {//确保逆时针
				poly.Reverse();
			}
			poly.Compress();
			XPoly2D polyDest(1);
			poly.Disperse(polyDest);
			polyDest.SetElevation(nElevMove);//  [2/20/2008 nsh]
			
			TDbSlopeRoof *pRoof = new TDbSlopeRoof;
			pRoof->InitEqualSlope(polyDest, nSlant*PI/180.0);
			if (fabs(nThick)<_DIST_SNAP) {
				int bDelObj;
				VERIFY(xg_getvar(_T("DELOBJ"), &bDelObj)==RTNORM);
				if (bDelObj) 
					ent.Delete();
			}
			pRoof->AddToMSpace(Adesk::kTrue);
		}
	}
}
//--------------------------end-------------------------
////////////////////////////////////////////////////////
// Command: 生成房间地面
void SpGround()
{
    
    XPoint ptPick;
    while(XGetPoint(NULL, _T("\n请指定房间内一点"), ptPick)==RTNORM) {
        ptPick=Ucs2Wcs(ptPick);
      XPoly2D polySpace(1);
      if (GenSpacePoly(ptPick, polySpace)==RTNORM) {
         XScreenDc dc(1,1);
         XPoly2D polyTemp(polySpace);
         polyTemp.TransUCS(Groups(0), Groups(1));
         dc << polyTemp;
         if (YesNoQuestion(_T("\n是否生成房间地面"))==Q_YES) {
              TDbSlab *pGround= new TDbSlab;
              pGround->setLayer(InitLayer(LAY_GROUND, FALSE));
              pGround->SetOutline(polySpace);
              pGround->SetThickness(-200.0);
              for(int i=0; i<polySpace.TotalSegments(); i++)
                  pGround->SetVisibilityAt(i, FALSE);
              AddToModelSpace(pGround, Adesk::kTrue);
         }
         ads_redraw(NULL,0);
      } else {
         adsout << _T("\n请正确选择!");
      }
    }
}



// Debug only
void TestSpace()
{
    XPoint pt;
    if (ads_getpoint(NULL, _T("\nPick a point: "), pt)!=RTNORM)
        return;
    TDbSpace space;
    if (GenSpaceInfo(pt, space)==1) {
        XScreenDc dc;
        dc << space.m_outline;
    }
}