#include "StdAfx.h"
#include "TDbProtectEntity.h"
#include "TDbBlockInsert.h"
#include "TDbColumn.h"
#include "TDbWallPatch.h"
#include "TAecSpaceCell.h"
#include "TAecSpaceWall.h"
#include "TSearchSpaceFromWall.h"
#include "TArchAppDocGlobals.h"
#include "CFindShortWallDlg.h"
#include "CProtectSetDlg.h"
#include "TArchDocReactor.h"

#include "imgdef.h"
#include "imgent.h"
#include "dbobjptr.h"
#include "rxregsvc.h"

#if ADS > 15
#include "AcStatusBar.h"
#endif

using namespace TchGeLib;
extern HINSTANCE _hdllInstance;
static ads_real minLenWall = 200.0;
//extern TCHAR g_sAppPath[];
TARCH_IMPEXP const TCHAR *xgAppname = NULL;
TARCH_IMPEXP BOOL g_bAxisWall = TRUE;
extern double g_nDefaultScale;
extern int g_nRunMode;
extern TARCH_IMPEXP int g_nProductId;

namespace
{
#if ADS <= 18
	double _ttof(LPCTSTR psz)
	{
		if (!psz) return .0;
		USES_CONVERSION;
		return atof(W2A(psz));
	}
#endif
}

void PolyCurveEnt()
{
	TEntitySet ent;
	if (SelectEntity(_T("\n选择多段线:"),ent,TRBList(RTDXF0,_T("LINE,ARC,CIRCLE,POLYLINE,LWPOLYLINE"),NULL)) != RTNORM)
	{
		return;
	}
	
	TDbPolyCurveEnt *pCurve = new TDbPolyCurveEnt;
	TGGePoly3D poly3d(ent);
	AcGeMatrix3d mat;
	mat.setToWorldToPlane(Ucs2Wcs(TADSGePoint3d(0,0,1),TRUE).AsAcGeVector3d());
	poly3d.TransformBy(mat);
	pCurve->SetPathPoly(poly3d,Ucs2Wcs(TADSGePoint3d(0,0,1),TRUE).AsAcGeVector3d());
	ent.Erase();
	
	AddToModelSpace(pCurve,Adesk::kTrue);
}


BOOL IsInsideColumn(const TADSGePoint3d &pt)
{
	TADSGePoint3d ptTemp = pt;
	ptTemp.z = 0;
	
	TDPtrList<TGGePoly2D> lstPoly;
	GetAllColumnBoundry(lstPoly);
	
	for (int i = 0; i<lstPoly.Length(); i++) 
	{
		TGGePoly2D &poly = *lstPoly[i];
		poly.SetElevation(0.0);
		if ((ptTemp & poly) != PR_OUTSIDE)
		{
			return TRUE;
		}
	}

	return FALSE;
}

//AcDbRasterImage不能交换Id
BOOL InitBlockWipeout(AcDbObjectId idBlock, int nMaskFlag)  
{
#if (ADS<16)
	if (!IsArxAppLoaded(_T("wipeout"))) 
	{
		int nRet = acrxLoadModule(_T("wipeout.arx"), Adesk::kFalse, true);
		if (!nRet) 
		{
			TchGeLib::adsout << _T("\n请事先安装AutoCAD快捷工具!");
			return FALSE;
		}
	}
//LH 2013-2-27 修改原因当ADS=19时不执行下面代码
//#else if (ADS<19)
#endif
#if (16<ADS && ADS<19)
	if (!IsArxAppLoaded(_T("AcWipeout"))) 
	{
		int nRet = acrxLoadModule(_T("AcWipeout.arx"), Adesk::kFalse, true);
		if (!nRet) 
		{
			TchGeLib::adsout << _T("\n无法加载AcWipeout.arx!");
			return FALSE;
		}
	}
#endif
//LH 2013-2-28 由于AutoCAD2013版本后去除了AcWipeout.arx文件，所以2013版本需要判断是否加载了acismobj19.dbx
#if (ADS==19)
	if(!AT_loaded(_T("acismobj19"))) 
	{
		int nRet=acrxLoadModule(_T("acismobj19.dbx"), Adesk::kFalse, true);
		if(!nRet) {
			adsout << _T("\n无法加载acismobj19.dbx!");
			return FALSE;
		}
	}
#endif
#if (ADS==20)
	if(!AT_loaded(_T("acismobj20"))) 
	{
		int nRet=acrxLoadModule(_T("acismobj20.dbx"), Adesk::kFalse, true);
		if(!nRet) {
			adsout << _T("\n无法加载acismobj20.dbx!");
			return FALSE;
		}
	}
#endif
	TCString szBlock = GetSymbolName(idBlock);
	TADSGePoint3d ptLow, ptUp;
	if (GetBlockExtents(idBlock, ptLow, ptUp) != RTNORM)
	{
		return FALSE;
	}

	AcRxClass* pClass = AcRxClass::cast(acrxClassDictionary->at(_T("AcDbWipeout")));
	if (pClass == NULL)
	{
		return FALSE;
	}
	AcDbObjectId idFirst;
	BOOL bFirstWipeOut = FALSE;

	OPENOBJ_BEGIN(idBlock, AcDb::kForWrite, AcDbBlockTableRecord, pBlock);
	ASSERT(pBlock);
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = pBlock->newIterator(pBlockIterator);
	ASSERT(es == Acad::eOk && pBlockIterator);
	AcDbEntity *pEnt = NULL;
	if (pBlockIterator->getEntity(pEnt, AcDb::kForRead) == Acad::eOk) 
	{
		idFirst = pEnt->objectId();
		AcRxClass *pMyClass = pEnt->isA();
		if (pMyClass == pClass) 
		{
			bFirstWipeOut = TRUE;
			if (!nMaskFlag) 
			{
				if (pEnt->upgradeOpen() == Acad::eOk) 
				{
					pEnt->erase();
					pEnt->downgradeOpen();
				}
			}

			pEnt->close();
		}
		else 
		{
			BOOL bCanSwapId = TRUE;
			if (pMyClass == AcDb2dPolyline::desc() 
				|| pMyClass == AcDb3dPolyline::desc() 
				|| pMyClass == AcDbPolygonMesh::desc() 
				|| pMyClass == AcDbPolyFaceMesh::desc() 
				|| pMyClass == AcDbMInsertBlock::desc() 
				|| pMyClass == AcDbBlockReference::desc())
			{
				bCanSwapId = FALSE;
			}

			pEnt->close();
			if (nMaskFlag && bCanSwapId)
			{
				AcDbPoint *pPoint = new AcDbPoint(AcGePoint3d(0,0,0));
				pBlock->appendAcDbEntity(pPoint);
				pPoint->swapIdWith(idFirst);
			
				AcDbEntity *pWipeOut = (AcDbEntity *)pClass->create();
				Acad::ErrorStatus es = pPoint->handOverTo(pWipeOut);
				if (es == Acad::eObjectToBeDeleted) 
				{
					pWipeOut->close();
					delete pPoint;
					bFirstWipeOut = TRUE;
				}
				else 
				{
					pPoint->close();
					delete pWipeOut;
				}
			}
		}
	}

	delete pBlockIterator;
	OPENOBJ_END();

	if (!nMaskFlag)
	{
		return TRUE;
	}

	if (!bFirstWipeOut)
	{
		return FALSE;
	}

	TGGePoly2D polyBound(1);
	BOOL bOutline = (GetBlockBoundary(idBlock, polyBound) == RTNORM);

	OPENOBJ_BEGIN(idFirst, AcDb::kForWrite, AcDbRasterImage, pAcDbRasterImage);
	if (pAcDbRasterImage) 
	{
		TADSGePoint3d origin = ptLow;
		double xDir = 0.0;
		double yDir = xDir + PI / 2.0;
		AcGeVector3d u(cos(xDir), sin(xDir), 0),
					 v(cos(yDir), sin(yDir), 0);
		u *= (ptUp.x - ptLow.x);
		v *= (ptUp.y - ptLow.y);

		pAcDbRasterImage->setOrientation(origin, u, v);
		if (!nMaskFlag) 
		{
			pAcDbRasterImage->erase();
		}
		else if (nMaskFlag & BIF_POLYMASK) 
		{
			if (bOutline) 
			{
				AcGeMatrix3d mat3d;
				pAcDbRasterImage->getPixelToModelTransform(mat3d);
				mat3d.invert();

				AcDbRasterImage::ClipBoundaryType ClipBoundaryType;
				AcGePoint2dArray ClipBoundary;
				TGGePoly2D polyDest(1);
				polyBound.Disperse1(polyDest, _AS_SYS_UNIT(g_nCirDeviation));
				int nCount = polyDest.Length();

				for (int i = 0; i <= nCount; i++) 
				{
					TADSGePoint3d ptVert = *polyDest[i == nCount ? 0 : i];
					((AcGePoint3d &)ptVert).transformBy(mat3d);
					ClipBoundary.append(ptVert);
				}

				ClipBoundaryType = AcDbRasterImage::kPoly;
				pAcDbRasterImage->setClipBoundary(ClipBoundaryType, ClipBoundary);
			}
		}
		else 
		{
			pAcDbRasterImage->setClipBoundaryToWholeImage();
		}
	}
	OPENOBJ_END();

	return TRUE;
}
AcDbObjectId GetBlock2dFromBlock3d(AcDbObjectId idBlock)
{
	AcDbObjectId idBlock2d;
	OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	if (pBlock) 
	{
		resbuf *pxData = pBlock->xData(TCHXD);     //  读扩展数据
		if (pxData)
		{
			resbuf *pNext = pxData->rbnext;
			if (pNext && pNext->restype == 1005) 
			{
				AcDbHandle handle(pNext->resval.rstring);
				pBlock->database()->getAcDbObjectId(idBlock2d, false, handle);
			}
			
			ads_relrb(pxData);
		}
	}
	OPENOBJ_END();

	return idBlock2d;
}

void InitAppDocGlobals(BOOL bTrue)
{
	if (bTrue) 
	{
		ASSERT(TArchDocReactor::g_pTArchAppDocGlobals == NULL);
		TArchDocReactor::g_pTArchAppDocGlobals = new TArchAppDocGlobals(); 
		TArchDocReactor::g_pTArchAppDocGlobals->InitDocGlobals(curDoc()); 
	} 
	else 
	{
		ASSERT(TArchDocReactor::g_pTArchAppDocGlobals != NULL);
		TArchDocReactor::g_pTArchAppDocGlobals->OnUnloadApp(); 
		
		delete TArchDocReactor::g_pTArchAppDocGlobals; 
		TArchDocReactor::g_pTArchAppDocGlobals = NULL; 
	}
}

void ModifyWallAtCorner(TADSGePointList &lstCorners0, TDPtrList<TColumnData> &lstColumns,AcDbObjectId idBlock,LPVOID pReserve)
{
	CFindShortWallDlg::g_bAskAgain = TRUE;
	CFindShortWallDlg::m_nHowToDo = 0;

	// 如果没有变化的墙角和柱子, 则返回
	if (!lstCorners0 && !lstColumns)
	{
		return;
	}

	// 复制一份, 以避免Reactor修改墙角表
	TADSGePointList lstCorners;
	for (int idx = 0; idx < lstCorners0.Length(); idx++)
	{
		lstCorners.Append(new TADSGePoint3d(*lstCorners0[idx]));
	}

	//缩小求解范围
	// 过滤出需要局部考虑的墙体
	TADSGePoint3d ptMin, ptMax;
	BOOL bInitExt = FALSE;
	if (!!lstCorners) 
	{
		lstCorners.GetExtend(ptMin,ptMax);
		bInitExt = TRUE;
	}

	TGGePoly2D poly(1);
	TADSGePoint3d pt1, pt2;

	for (idx = 0; idx < lstColumns.Length(); idx++)
	{
		poly.Reset();
		lstColumns[idx]->GetOutline(poly);
	
		poly.GetExtend(pt1, pt2);
		if (!bInitExt) 
		{
			ptMin = pt1;
			ptMax = pt2;
			bInitExt = TRUE;
		}
		else 
		{
			ptMin = Min(ptMin, pt1);
			ptMax = Max(ptMax, pt2);
		}
	}

	// 取得需要更新的墙体集合A, 这些墙体的墙角需要重新计算, 当然连接的墙体需要重新搜索
	double nDistPrec = 800;
	ptMin.x -= nDistPrec;
	ptMin.y -= nDistPrec;
	ptMax.x += nDistPrec;
	ptMax.y += nDistPrec;
	
	TADSGePoint3d ptMinUpd = ptMin, ptMaxUpd = ptMax;		//范围A: ptMinUpd-ptAxUpd
	TPickEntSet ssMin(SS_FREE), ss(SS_FREE);

	if (GetSafeSelectionEx2(ssMin, 1, ptMin, ptMax, TDbWall::desc(),idBlock) != Acad::eOk)
	{
		return;
	}

	// 取得有关的墙体集合C, 要更新的墙体需要参考它们的参数.
	// 集合C-集合A = 集合B, 集合B的墙体的墙角不需要重新计算.
	// 但是计算集合A的墙角需要用到集合B, 因此B也在整个拓扑网路中.
	// V2.0 版直接记录拓扑, 由于集合A的实体发生合并或分解, 这样
	// 集合B中的实体可能记录了对集合A的拓扑连接关系, 这一关系也需要更新
	// 因此: 1. 集合A更新范围A内的端点的拓扑;  2.集合B更新范围B内的端点的拓扑
	TADSGePoint3d ptExtMin, ptExtMax;
	ssMin.GetExtend(ptExtMin, ptExtMax);
	ptMin = Min(ptMin, ptExtMin);
	ptMax = Max(ptMax, ptExtMax);					// Modify on 2003/9/12，缺保范围C大于等于范围A
	
	ptMin.x -= nDistPrec;
	ptMin.y -= nDistPrec;
	ptMax.x += nDistPrec;
	ptMax.y += nDistPrec;
	
	//add by xlc on 100531 提速优化
	if (pReserve != NULL)
	{
		typedef CMap<TLong_ptr,TLong_ptr,AcDbExtents,AcDbExtents> CMapLongToExtents;
		CMapLongToExtents* pMap = (CMapLongToExtents*)pReserve;
		AcDbExtents ext(ptMin,ptMax);
		pMap->SetAt(idBlock.asOldId(),ext);
		if (pMap->Lookup(100,ext))
		{
			return;
		}
	}

	if (GetSafeSelectionEx2(ss, 1, ptMin, ptMax, TDbWall::desc(),idBlock) != Acad::eOk)
	{
		return;
	}

	TPickEntSet ssB(SS_FREE);
	ssB += ss;
	
	//add by xlc on 101125 解决图块在位编辑后墙角更新不全的问题
	if(_tcsicmp(GetCurCommand(), _T("REFCLOSE"))!=0)

	{
		ssB -= ssMin;
	}

	//取得所有的柱子裁剪区域
	TDPtrList<AcDbObjectId> lstClipBoundry;
	TPickEntSet ssColu(SS_FREE);

	if (GetSafeSelection2(ssColu, 1, ptMin, ptMax, TDbColumn::desc(),idBlock) == Acad::eOk) 
	{
		// 过滤出需要局部考虑的柱子
		TEntitySet eColu;
		AcDbObjectId *idColu = NULL;
		long nColuCount = ssColu.Length();
		for (long n = 0; n < nColuCount; n++)
		{
			eColu = ssColu[n];
			
			OPENOBJ_BEGIN(eColu, AcDb::kForRead, TDbColumn, pColu);
			if (pColu && !pColu->IsFortifyColumn()) 
			{
				idColu = new AcDbObjectId;
				VERIFY(acdbGetObjectId(*idColu, eColu) == Acad::eOk);
				lstClipBoundry.Append(idColu);
			}
			OPENOBJ_END();
		}
	}

LAB_BEGIN:
	TSearchSpaceFromWall aSearch;
	try 
	{
		aSearch.InitStart(ss, lstClipBoundry); //实际并不搜索房间,
	} 
	catch(TSearchException e) 
	{
		if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_STOP_DELETE)
		{
			OPENOBJ_BEGIN(e.m_idObj, AcDb::kForWrite, AcDbEntity, pDbEnt);
			if (pDbEnt)
			{
				pDbEnt->erase();
			}
			OPENOBJ_END();
		} 

		if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_MARK || e.m_nHowToDo == HF_NONE) 
		{
			ss -= e.m_idObj;
			goto LAB_BEGIN;
		}
		
		return;
	} 
	catch(TDupWallException e) 
	{
		if (e.m_nHowToDo == HF_DELETEA || e.m_nHowToDo == HF_DELETEB) 
		{
			AcDbObjectId idObj = (e.m_nHowToDo == HF_DELETEA ? e.m_idObjA : e.m_idObjB);
			OPENOBJ_BEGIN(idObj, AcDb::kForWrite, AcDbEntity, pDbEnt);
			if (pDbEnt)
			{
				pDbEnt->erase();
			}
			OPENOBJ_END();
			
			ss -= idObj;
			goto LAB_BEGIN;
		} 

		return;
	}
	catch(...) 
	{
		TchGeLib::adsout << _T("\n出现了例外情况!");
		acedPostCommandPrompt();
		
		return;
	}

	// 加入柱子所包含的墙角
	TADSGePointList lstAllCorners;
	aSearch.GetAllCorners(lstAllCorners);			//取得所有的墙角
	
	if (lstAllCorners.Length() > 0)  //add by xlc on 100517没有墙角时不对柱子进行运算
	{
		TADSGePoint3d ptCorner;
		for (int m = 0; m < lstColumns.Length(); m++) 
		{
			if (lstAllCorners.Length() == 0)
			{
				break;
			}
			const TGGePoly2D &poly = lstColumns[m]->GetOutlinePoly();
			if (!poly)
			{
				continue;
			}
			
			for (int n = 0; n < lstAllCorners.Length(); n++) 
			{
				ptCorner = *lstAllCorners[n];
				ptCorner.z = poly.Head()->z;			// Z add this line on 2003/3/18 
				
				if ((ptCorner & ((TGGePoly2D &)poly)) == PR_INSIDE)
				{
					lstCorners.NewAppend(ptCorner);
					lstAllCorners.Remove(n);
					n -= 1;
				}
			}
		}
	}

	TPickEntSet ssDel(SS_FREE);							//被合并的墙    
	try
	{
		if (lstCorners.Length() > 0)   //add by xlc on 100517没有墙角时不对柱子进行运算
		{
			aSearch.MergeWalls(lstCorners, ssDel);		//先尽量合并墙段, 只处理发生变化的墙角
			ss -= ssDel;								// Z add this line on 2003/11/14
			aSearch.BreakWalls(lstCorners, ss);			//在断点处,或裁剪区域中心打断墙体
		}
	} 
	catch(TDupWallException e)
	{
		if (e.m_nHowToDo == HF_DELETEA || e.m_nHowToDo == HF_DELETEB) 
		{
			AcDbObjectId idObj = (e.m_nHowToDo == HF_DELETEA ? e.m_idObjA : e.m_idObjB);
			OPENOBJ_BEGIN(idObj, AcDb::kForWrite, AcDbEntity, pDbEnt);
			ssDel += idObj;							//Add on 2002/2/27
			
			if (pDbEnt)
			{
				pDbEnt->erase();
			}
			OPENOBJ_END();
			
			ss -= idObj;

			goto LAB_BEGIN;
		} 

		return;
	} 
	catch(...) 
	{
		TchGeLib::adsout << _T("\n出现了例外情况!");
		acedPostCommandPrompt();
		
		return;
	}

	// 更新墙体
	TPickEntSet ssUpdateWalls(SS_FREE);

	//Note: 应当在aSearch范围内搜索更快
	if (GetSafeSelectionEx2(ssUpdateWalls, 1, ptMinUpd, ptMaxUpd, TDbWall::desc(),idBlock) == Acad::eOk) 
	{
		// 更新集合A在范围A内的端点拓扑
		TGGeRectAngle boxA(ptMinUpd, ptMaxUpd);
		TEntitySet ent;
		long len = ssUpdateWalls.Length();
		for (long i = 0; i < len; i++) 
		{
			ent = ssUpdateWalls[i];
			TAcDbObjectPtr obj(ent.name, AcDb::kForWrite);
			if (!obj) 
			{
				//Extend一墙体时, 指针还没有关闭
			}
			else 
			{
				TDbWall *pWall = TDbWall::cast(obj.m_pObject);
				if (pWall)
				{
					pWall->assertWriteEnabled();
					pWall->CalSideParameters(ent, TSearchSpaceFromWall::g_lstAllSortWalls, &boxA);
				}
			}
		}

		for (i = 0; i<len; i++)
		{
			ent = ssUpdateWalls[i];
			TAcDbObjectPtr obj(ent.name, AcDb::kForWrite);
			if (!obj)
			{
				//Extend一墙体时, 指针还没有关闭
			} 
			else 
			{
				TDbWall *pWall = TDbWall::cast(obj.m_pObject);
				if (pWall) 
				{
					pWall->assertWriteEnabled();
					pWall->CalSideParameters1(&boxA);
				}
			}
		}

		// 更新集合B在范围B内的端点拓扑
		TGGeRectAngle boxB(ptMin, ptMax);

		// Modify on 2003/9/8, boxA change to boxB
		// 更新集合C在范围B内的柱子的拓扑
		aSearch.UpdateColuLinkage(&boxB);

		len = ssB.Length();
		for (i = 0L; i < len; i++)
		{
			TEntitySet entB = ssB[i];
			OPENOBJ_BEGIN(entB, AcDb::kForWrite, TDbWall, pWall);
			if (pWall)
			{
				pWall->assertWriteEnabled();
				pWall->CalSideParameters(entB,TSearchSpaceFromWall::g_lstAllSortWalls, &boxB);
			}
			OPENOBJ_END();
		}

		for (i = 0L; i < len; i++) 
		{
			TEntitySet entB = ssB[i];
			OPENOBJ_BEGIN(entB, AcDb::kForWrite, TDbWall, pWall);
			if (pWall)
			{
				pWall->assertWriteEnabled();
				pWall->CalSideParameters1(&boxB);
			}
			OPENOBJ_END();
		}
	}

	if (!!ssDel) 
	{  //清除预先选中的物体
		TPickEntSet gSet(SS_FREE), pSet(SS_FREE);
		if (GetPickFirst(gSet, pSet) == RTNORM) 
		{
			if (gSet.Length() || pSet.Length()) 
			{
				acedPostCommand(_T("\33"));
			}
		}
	}
}

void GetDwgStamp()
{
	TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
	int nRet = (p ? p->GetControlFlag() : 0);
	if (p)
	{
		p->close();
	}
	
	int bInvalidEver = ((nRet & CONF_INVALID_EVER));
	int bInvalidLast = ((nRet & CONF_INVALID_LAST));
	
	if (bInvalidEver && bInvalidLast) 
	{
		TchGeLib::adsout << _T("\n非法使用产生的图形!");
	}
	else if (bInvalidEver)
	{
		TchGeLib::adsout << _T("\n图形曾经用非法软件保存过!");
	}
	else if (bInvalidLast)
	{
		TchGeLib::adsout << _T("\n图形最近用非法软件保存过!");
	}
	else
	{
		TchGeLib::adsout << _T("\n合法软件创建的图形!");
	}
}

BOOL IsAcadIdle()
{
	TArchPerDocData * pDocDat = GetCurDocData();
	return (pDocDat && pDocDat->m_bAcadIdle);
}

BOOL IsCommandLineEmpty()
{
	TArchPerDocData * pDocDat = GetCurDocData();
	return (!pDocDat || pDocDat->m_nPos == 0);
}

int InsertBlock()
{
	AsureWCS();

	TADSGePoint3d ptCen;
	VERIFY(TGGetVar(_T("VIEWCTR"), &ptCen) == RTNORM);
	
	resbuf *rb = ads_getargs();
	if (!rb || rb->restype != RTSTR)
	{
		return RTNORM;
	}

	TRBList rbList = rb;
	TCHAR *pszBlock = rb->resval.rstring;
	rb = rb->rbnext;
	
	double sx = 1.0, sy = 1.0, sz = 1.0;
	if (rb) 
	{
		if (rb->restype == RTSHORT)
		{
			sx = rb->resval.rint;
		}
		else if (rb->restype == RTREAL)
		{
			sx = rb->resval.rreal;
		}
		else 
		{
			return RTNORM;
		}

		rb = rb->rbnext;
		if (rb) 
		{
			if (rb->restype == RTSHORT)
			{
				sy = rb->resval.rint;
			}
			else if (rb->restype == RTREAL) 
			{
				sy = rb->resval.rreal;
			}
			else
			{
				return RTNORM;
			}

			rb = rb->rbnext;
			
			if (rb) 
			{
				if (rb->restype == RTSHORT)
				{
					sz = rb->resval.rint;
				}
				else if (rb->restype == RTREAL)
				{
					sz = rb->resval.rreal;
				}
				else
				{
					return RTNORM;
				}
			}
		}
	}

	int nRet = RTNORM;

	if (!InitBlock(pszBlock))
	{
		return RTERROR;
	}

	MakeTBlockInsert(pszBlock, ptCen, sx, sy, sz, 0.0, 0);

	if (nRet == RTNORM) 
	{
		TEntitySet ent;
		ent.GetLast();

		IDragInsertBlock(ptCen, ent, IBF_ROT90 | IBF_MIRLR | IBF_MIRUD | IBF_FRAME | IBF_ROTATE | IBF_BASEPT);
	}

	return RTNORM;
}


// 通过一点确定一房间的轮廓
int GenSpaceOutline(const TADSGePoint3d &ptPick, TGGePoly2D &poly, int bCenter)
{
	g_bFindExtSpace = FALSE;

	// 找到所有墙,refreshed by W on 050826
	TDPtrList<AcDbObjectId> ssWalls;
	if (GetEntFromBlockByDxf(ssWalls,_T("ATS_WALL,ATS_CURTAIN_WALL"),1) != Acad::eOk)
	{
		return RTERROR;
	}

	TDPtrList<AcDbObjectId> lstColu;
	GetEntFromBlockByDxf(lstColu, _T("ATS_COLUMN"));
	
	int nRet = RTERROR;
	// add by lgy 20120222，9.0房间轮廓命令无法正常执行，添加一goto语句的标记
SEARCHSPACE_LAB_BEGIN:
	TSearchSpaceFromWall aSearch;
	try 
	{
		aSearch.InitStart(ssWalls, lstColu);
	}
	// add by lgy 20120222	当图中存在完全包含在柱内的短墙时，房间轮廓命令无法正常执行
	catch (TSearchException e) 
	{
		if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_MARK || e.m_nHowToDo == HF_NONE) 
		{
			for (int i = 0; i < ssWalls.Length(); i++)
			{
				if (*ssWalls[i] == e.m_idObj)
				{
					ssWalls.Remove(i);	// 从选择集中过滤掉“小短墙”
				}
			}
			goto SEARCHSPACE_LAB_BEGIN;
		}

		return RTERROR;
	} 
	catch (...) 
	{
		TchGeLib::adsout << _T("\n发生例外情况!");
		return RTERROR;
	}

	int nWallNumber = aSearch.walls.Length();
	
	TAecSpaceWall *pNearestWall = NULL;
	ads_real nMinDist = 0.0;
	for (int i = 0; i < nWallNumber; i++) 
	{
		TADSGePoint3d ptProject;
		TAecSpaceWall *pWall = aSearch.walls[i];
	
		if (pWall->ProjectToMe(ptPick, ptProject) != RTNORM || (ptProject & (*pWall)) != PR_INSIDE)
		{
			continue;
		}

		ptProject.z = ptPick.z;					//忽略Z坐标
		ads_real nDist = ads_distance(ptPick, ptProject);
		if (!pNearestWall) 
		{
			nMinDist = nDist;
			pNearestWall = pWall;
		}
		else if (nDist < nMinDist) 
		{
			nMinDist = nDist;
			pNearestWall = pWall;
		}
	}

	int nWho = 0;								//1:left; 2:right
	BOOL bSubtract = TRUE;						//用相减的方法,适合于室内; 否则为室外
	TAecSpaceCell lSpace, rSpace;
	if (pNearestWall && aSearch.SearchTwoSpace(*pNearestWall, lSpace, rSpace) == RTNORM) 
	{
		TGGePoly2D lPoly, rPoly;
		if (bCenter) 
		{
			lSpace.CenterPoly2D(lPoly);
			rSpace.CenterPoly2D(rPoly);
		}
		else 
		{
			lSpace.InternalPoly2D(lPoly, 1);
			rSpace.InternalPoly2D(rPoly, 1);
		}
		
		int nPrFlag1 = ptPick & lPoly;
		int nPrFlag2 = ptPick & rPoly; 
		if (nPrFlag1 == PR_INSIDE && nPrFlag2 == PR_INSIDE) 
		{
			ads_real nArea1 = lPoly.Area();
			ads_real nArea2 = rPoly.Area();
		
			if (nArea1 < nArea2) 
			{
				poly = lPoly;
				nWho = 1; 
			}
			else 
			{
				poly = rPoly;
				nWho = 2; 
			}

			nRet = RTNORM;
		} 
		else if (nPrFlag1 == PR_INSIDE) 
		{
			poly = lPoly;
			nWho = 1;
			nRet = RTNORM;
		}
		else if (nPrFlag2 == PR_INSIDE) 
		{
			poly = rPoly;
			nWho = 2;
			nRet = RTNORM;
		}
		else
		{
			ads_real nArea1 = lPoly.Area();
			ads_real nArea2 = rPoly.Area();
		
			if (nArea1 > nArea2)
			{
				poly = lPoly;
				nWho = 1; 
			}
			else 
			{
				poly = rPoly;
				nWho = 2; 
			}

			nRet = RTNORM;
			bSubtract = FALSE;
		}
	} 
	else if (pNearestWall) 
	{
		lSpace.Reset();
		rSpace.Reset();
	
		if (aSearch.SearchOneSpace(*pNearestWall, 0, lSpace) == RTNORM) 
		{
			if (bCenter) 
			{
				lSpace.CenterPoly2D(poly);
			}
			else
			{
				lSpace.InternalPoly2D(poly, 1);
			}
			
			if ((ptPick & poly) == PR_INSIDE) 
			{
				nWho = 1;
				nRet = RTNORM;
			}
		} 
		else if (aSearch.SearchOneSpace(*pNearestWall, 1, rSpace) == RTNORM) 
		{
			if (bCenter)
			{
				rSpace.CenterPoly2D(poly);
			}
			else 
			{
				rSpace.InternalPoly2D(poly, 1);
			}
			
			if ((ptPick & poly) == PR_INSIDE) 
			{
				nWho = 2;
				nRet = RTNORM;
			}
		}
	}

	if (!bCenter && nWho) 
	{
		//扣除柱子部分
		TAecSpaceCell *pSpace = nWho == 1 ? &lSpace : &rSpace;
		if (bSubtract == FALSE) 
		{
			poly.Reset();
			pSpace->InternalPoly2D(poly, 2);
			g_bFindExtSpace = TRUE;
		}
	}

	poly.Compress();
	if (nRet == RTNORM && poly.PathArea() > 0.0)
	{
		poly.Reverse();						//确保为逆时针
	}

	return nRet;
}
void PrePlot()
{
	g_bPrinting = TRUE;
	TGSetVar(_T("SORTENTS"), 127);
	TPickEntSet ssMaskObj(SS_FREE);

	//  TRBList mask(RTDXF0, _T("ATS_SPACE,ATS_TEXT"), NULL);
	// 房间对象无法使用wipeout方式屏蔽 -- wyg20090804
	// sg modify 091105，暂时恢复房间对象屏蔽CAD填充的功能，等待房间对象屏蔽自身填充功能修改后，再去掉
	//	TRBList mask(RTDXF0, _T("ATS_TEXT"), NULL);
	
	//modify by xlc on 110519 阳台不增加wipeout
	//modify by xlc on 110314 阳台增加wipeout
	TRBList mask(RTDXF0, _T("ATS_SPACE,ATS_TEXT"), NULL);
	//TRBList mask(RTDXF0, _T("ATS_SPACE,ATS_TEXT,ATS_BALCONY"), NULL);
	if (ssMaskObj.Get(_T("X"), NULL, NULL, mask) == RTNORM) 
	{
		long lCount = ssMaskObj.Length();
		for (long idx = 0L; idx < lCount; idx++) 
		{
			TEntitySet ent = ssMaskObj[idx];
			AcDbVoidPtrArray ssWipeouts;
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pEnt);
			if (pEnt != NULL)
			{
				if (pEnt->isKindOf(TDbText::desc())) 
				{
					AcDbEntity *pWipeOut = ((TDbText *)pEnt)->CreateWipeOut();
					if (pWipeOut)
					{
						ssWipeouts.append(pWipeOut);
					}
				}
				else if (pEnt->isKindOf(TDbSpace::desc())) 
				{
					// add by xlc on 101201 解决带填充的房间对象打印预览后顺序变化的问题
					if(((TDbSpace *)pEnt)->HasHatch() && !!((TDbSpace *)pEnt)->GetHatchStyle())
					{
						continue;
					}

					((TDbSpace *)pEnt)->CreateWipeOut(ssWipeouts);
				}

				//else if (pEnt->isKindOf(TDbBalcony::desc())) 
				//{
				//	AcDbEntity *pWipeOut = ((TDbBalcony *)pEnt)->CreateWipeOut();
				//	if (pWipeOut)
				//	{
				//		ssWipeouts.append(pWipeOut);
				//	}
				//}

				int num = ssWipeouts.length();
				for (int n = 0; n < num; n++) 
				{
					AcDbEntity *pWipeOut = (AcDbEntity *)ssWipeouts[n];
					pWipeOut->setLayer(InitLayer(_T("_TCH_WIPEOUT"), FALSE));

					AcDbObjectId idInsert = pEnt->objectId();
					AcDbObjectId idWipeOut = AddToModelSpace(pWipeOut, TRUE);
					pEnt->swapIdWith(idWipeOut);
				}
			}
			OPENOBJ_END();
		}
	}

	AcDbObjectId idLayMask = InitLayer(LAY_MASK, FALSE);
	TPickEntSet ssOld(SS_FREE);
	
	if (ssOld.Get(_T("X"),NULL,NULL,TRBList(RTDXF0, _T("AEC_BLOCK_INSERT,ATS_MVINSERT"), 8, LAY_MASK, NULL)) == RTNORM)
	{
		ssOld.Erase();
	}

	TPickEntSet ssMask(SS_FREE);
	if (ssMask.Get(_T("X"), NULL, NULL, TRBList(RTDXF0, _T("AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL)) == RTNORM) 
	{
		AcDbObjectIdArray idArray;
		AcRxClass* pClass = AcRxClass::cast(acrxClassDictionary->at(_T("AcDbWipeout")));

		long lCount = ssMask.Length();
		for (long idx = 0L; idx < lCount; idx++) 
		{
			TEntitySet ent = ssMask[idx];

			AcDbEntity *pEnt;
			AcDbObjectId idEnt;
			acdbGetObjectId(idEnt, ent.name);
		
			BOOL bMaskWipeOut = FALSE;
			if (acdbOpenObject(pEnt, idEnt, AcDb::kForRead) == Acad::eOk && pEnt != NULL)
			{
				AcDbObjectId idBlock;
				if (pEnt->isKindOf(TDbMultiViewInsert::desc())) 
				{
					TDbMultiViewInsert *pIns = TDbMultiViewInsert::cast(pEnt);
					idBlock = pIns->GetBlockId(FALSE);
				}
				else if (pEnt->isKindOf(TDbBlockInsert::desc()))
				{
					TDbBlockInsert *pIns = TDbBlockInsert::cast(pEnt);
					idBlock = pIns->blockTableRecord();	
				}

				if (idArray.contains(idBlock))
				{
					bMaskWipeOut = TRUE;
				}
				else
				{
					OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
					if (pBlock && IsMaskBlock(*pBlock, pClass)) 
					{
						bMaskWipeOut = TRUE;
					}
					OPENOBJ_END();
					
					if (bMaskWipeOut)
					{
						idArray.append(idBlock);
					}
				}

				pEnt->close();
			}

			if (bMaskWipeOut) 
			{
				if (acdbOpenObject(pEnt, idEnt, AcDb::kForWrite) == Acad::eOk ) 
				{
					AcDbBlockReference *pNewBlock = NULL;
					TCString sBlock3d;
					if (pEnt->isKindOf(TDbMultiViewInsert::desc()))
					{
						TDbMultiViewInsert *pIns = TDbMultiViewInsert::cast(pEnt);
						pNewBlock = pIns->NewBlock(FALSE);
						sBlock3d = GetSymbolName(pIns->GetBlockId(TRUE));
					}
					else if (pEnt->isKindOf(TDbBlockInsert::desc()))
					{
						TDbBlockInsert *pIns = TDbBlockInsert::cast(pEnt);
						pNewBlock = pIns->NewBlockInsert();	
					}
			
					ASSERT(pNewBlock);

					resbuf *rb = NULL;
					if (!sBlock3d) 
					{
						rb = ads_buildlist(1001, _T("_TCH_MASK"), 1070, 1, NULL);
					}
					else
					{
						rb = ads_buildlist(1001, _T("_TCH_MASK"), 1070, 2, 1000, (const TCHAR *)sBlock3d, NULL);
					}

					Acad::ErrorStatus es = pEnt->handOverTo(pNewBlock);
					if (es == Acad::eObjectToBeDeleted) 
					{
						if (!XSymbolTable(_T("APPID"), _T("_TCH_MASK")))
						{
							ads_regapp(_T("_TCH_MASK"));
						}

						pNewBlock->setXData(rb);
						pNewBlock->close();
						delete pEnt;
					} 
					else 
					{
						pEnt->close();
						delete pNewBlock;
					}
					ads_relrb(rb);
				}
			}
		}
	}
}

void PostPlot()
{
	TPickEntSet ssMaskObj(SS_FREE);
	TRBList mask(RTDXF0, _T("WIPEOUT"), 8, _T("_TCH_WIPEOUT"), NULL);
	if (ssMaskObj.Get(_T("X"), NULL, NULL, mask) == RTNORM)		//文字屏蔽产生的临时物体
	{
		ssMaskObj.Erase();
	}

	TPickEntSet ssMask(SS_FREE);
	if (ssMask.Get(_T("X"), NULL, NULL, TRBList(RTDXF0, _T("INSERT"), 1001, _T("_TCH_MASK"), NULL)) == RTNORM)
	{
		long lCount = ssMask.Length();
		for (long idx = 0L; idx < lCount; idx++) 
		{
			TEntitySet ent = ssMask[idx];
			AcDbBlockReference *pInsert1 = NULL;
			AcDbObjectId idEnt;
			acdbGetObjectId(idEnt, ent.name);
		
			if (acdbOpenObject(pInsert1, idEnt, AcDb::kForWrite) == Acad::eOk && pInsert1 != NULL) 
			{
				resbuf *rbXData = pInsert1->xData(_T("_TCH_MASK"));
				AcDbObjectId idBlock3d;
			
				if (rbXData) 
				{
					resbuf *rbNext = rbXData->rbnext;
					if (rbNext && rbNext->restype == 1070 && rbNext->resval.rint == 2) 
					{
						rbNext = rbNext->rbnext;
						if (rbNext && rbNext->restype == 1000) 
						{
							idBlock3d = GetBlockIdFromString(rbNext->resval.rstring);
						}
					}
				
					ads_relrb(rbXData);
				}

				AcDbEntity *pNewEnt = NULL;
				if (idBlock3d.isValid())
				{
					TDbMultiViewInsert *pInsert2 = new TDbMultiViewInsert;
					pInsert2->setPropertiesFrom(pInsert1);
					pInsert2->SetBlockId(FALSE, pInsert1->blockTableRecord());
					pInsert2->SetBlockId(TRUE, idBlock3d);
				
					TADSGePoint3d ptLoc = pInsert1->position();
					pInsert2->SetLocation(ptLoc);
					pInsert2->SetScaleFactors(pInsert1->scaleFactors());
					pInsert2->SetRotation(pInsert1->rotation());
					pNewEnt = pInsert2;
				} 
				else
				{
					TDbBlockInsert *pInsert2 = new TDbBlockInsert;
					pInsert2->setPropertiesFrom(pInsert1);
					pInsert2->setBlockTableRecord(pInsert1->blockTableRecord());
					pInsert2->setNormal(pInsert1->normal());
					pInsert2->setPosition(pInsert1->position());
					pInsert2->setScaleFactors(pInsert1->scaleFactors());
					pInsert2->setRotation(pInsert1->rotation());
					pNewEnt = pInsert2;
				}

				Acad::ErrorStatus es = pInsert1->handOverTo(pNewEnt);
				if (es == Acad::eObjectToBeDeleted) 
				{
					resbuf *xd = ads_buildlist(1001, _T("_TCH_MASK"), NULL);
					if (!XSymbolTable(_T("APPID"), _T("_TCH_MASK")))
					{
						ads_regapp(_T("_TCH_MASK"));
					}

					pNewEnt->setXData(xd);
					pNewEnt->close();
					delete pInsert1;
					ads_relrb(xd);
				}
				else 
				{
					pInsert1->close();
					delete pNewEnt;
				}
			}
		}
	}

	g_bPrinting = FALSE;
}

void InitDbWallPatch(BOOL bTrue)
{
	if (bTrue)
	{
		TDbWallPatch::rxInit();
		TDbWallPatch::SetEditMethod(EditWallPathc0);
		TDbWallPatch::InitMatchProtocol(TRUE);
	}
	else 
	{
		TDbWallPatch::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbWallPatch::desc());
	}
}

void InitDbWall(BOOL bTrue)
{
	if (bTrue) 
	{
		TDbWall::rxInit();
		acrxBuildClassHierarchy();
		TDbWall::InitMatchProtocol(TRUE);
	}
	else 
	{
		TDbWall::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbWall::desc());
	}
}

void InitDbColumn(BOOL bTrue)
{
	if (bTrue) 
	{
		TDbColumn::rxInit();
		acrxBuildClassHierarchy();
		TDbColumn::InitMatchProtocol(TRUE);
	}
	else 
	{
		TDbColumn::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbColumn::desc());
	}
}

void InitDbPolyCurveEnt(BOOL bTrue)
{
	if (bTrue)
	{
		TDbPolyCurveEnt::rxInit();
		acrxBuildClassHierarchy();
		TDbPolyCurveEnt::InitMatchProtocol(TRUE);
	}
	else
	{
		TDbPolyCurveEnt::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbPolyCurveEnt::desc());        
	}
}

void InitDbBlockInsert(BOOL bTrue)
{
	if (bTrue) 
	{
		TDbBlockInsert::rxInit();
		TDbMultiViewInsert::rxInit();
		acrxBuildClassHierarchy();
		TDbMultiViewInsert::InitMatchProtocol(TRUE);
	}
	else 
	{
		deleteAcRxClass(TDbBlockInsert::desc());
		deleteAcRxClass(TDbMultiViewInsert::desc());
	}
}

void InitDbProtectEntity(BOOL bTrue)
{
	if (bTrue) 
	{
		TDbProtectEntity::rxInit();
		acrxBuildClassHierarchy();
		TDbProtectEntity::SetEditMethod(EditProtectEntity);
		TDbProtectEntity::InitMatchProtocol(TRUE);
	}
	else 
	{
		TDbProtectEntity::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbProtectEntity::desc());        
	}
}

//COMMAND:TProtect
void ProtectEntity()
{
	TchGeLib::adsout<<_T("\n执行本命令前，请先备份图形！");
	TPickEntSet ss(SS_FREE);
	TRBList mask1 = ads_buildlist(-4, _T("<NOT"), RTDXF0,_T("ATS_PROTECT_ENTITY"), -4, _T("NOT>"), NULL);
	if (SelectEntities(_T("\n选择需要保护的图元<退出>:"),ss,mask1) != RTNORM)
	{
		return;
	}
	
	TRBList mask(RTDXF0, _T("VIEWPORT"), NULL);
	ss.BaseExclude(mask);
	
	if (ss.Length() < 1)
	{
		return;
	}
	
	TDbProtectEntity *pNewEntity = new TDbProtectEntity;
	AcDbObjectId idEnt = pNewEntity->AddToCSpace(Adesk::kFalse);
	pNewEntity->createExtensionDictionary();
	
	AcDbObjectId idDict = pNewEntity->extensionDictionary();
	pNewEntity->close();
	
	AcDbDictionary *pDict = NULL;
	acdbOpenObject(pDict,idDict,AcDb::kForWrite);
	if (pDict == NULL)
	{
		TchGeLib::adsout<<_T("建立只读对象失败!");
		delete pNewEntity;
		return;
	}
	
	AcDbBlockTableRecord *pRecord = new AcDbBlockTableRecord;
	pRecord->setName(_T("TCH_PR"));
	
	AcDbObjectId idRecord;
	Acad::ErrorStatus es = pDict->setAt(DICT_ENTRY_NAME,pRecord,idRecord);
	pRecord->close();
	pDict->close();
	
	AcDbObjectIdArray idArray;
	ss.AsIdArray(idArray);
	
	long count = idArray.length();
	AcDbIdMapping idMap;
	es = acdbHostApplicationServices()->workingDatabase()->deepCloneObjects(idArray,idRecord,idMap);
	if (es != Acad::eOk)
	{
		TchGeLib::adsout<<_T("建立只读对象失败!");
	}
	else	
	{
		ss.Erase();
	}
	
	EditProtectEntity(idEnt);
}

// 修改图块, 屏蔽或取消屏蔽
int ModifyInsert(Entity ent, int nMaskFlag)
{
    AcDbObjectId idBlock;
    OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
    if(!pEnt)
	{
		return RTERROR;
	}
	
	if(pEnt->isKindOf(TDbMultiViewInsert::desc())) 
	{
		TDbMultiViewInsert *pIns=TDbMultiViewInsert::cast(pEnt);
		idBlock=pIns->GetBlockId(FALSE);
	} 
	else if(pEnt->isKindOf(AcDbBlockReference::desc())) 
	{
		AcDbBlockReference *pIns=AcDbBlockReference::cast(pEnt);
		idBlock=pIns->blockTableRecord();	
	}
    OPENOBJ_END();
	
    if(!idBlock)
	{
        return RTERROR;
	}
    if((nMaskFlag&BIF_POLYMASK)) 
	{
		XPoly2D x(1);
        if(GetBlockBoundary(idBlock, x, TRUE)!=RTNORM) 
		{
            TchGeLib::adsout << _T("\n无法确定图块的精确边界!");
            return RTERROR;
        }
    } 
    if(InitBlockWipeout(idBlock, nMaskFlag)) 
	{
        PickSet ss(SS_FREE);
        if(ss.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL))==RTNORM) 
		{
            UpdateGraphic(ss);
        }
    } 
	else 
	{
        return RTERROR;
	}
    return RTNORM;
}

//COMMAND:TUnProtect
void UnProtect()
{
	TEntitySet ent;
	if (SelectEntity(_T("\n选择保护图元:"),ent,TRBList(RTDXF0,_T("ATS_PROTECT_ENTITY"),NULL)) != RTNORM)
	{
		return;
	}
	
	OPENOBJ_BEGIN(ent,AcDb::kForWrite,TDbProtectEntity,pEnt);
	if (pEnt != NULL)
	{
		if (UnProtect(pEnt))
		{
			pEnt->erase();
		}
	}
	OPENOBJ_END();
}
// Command: 取消屏蔽
//支持删除wipeout,modified by W on 081217
void BlockUnMask()
{
	TPushAcadVar<int> cmdecho(_T("CMDECHO"), 0);
	SHads_command(RTSTR,_T("WIPEOUT"),RTSTR,_T("F"),RTSTR,_T("On"),RTNONE);

	TRBList mask(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT,WIPEOUT"), NULL);
	TPickEntSet ss(SS_FREE);
	if (SelectEntities(_T("\n选择图块或屏蔽对象:"), ss, mask) == RTNORM) 
	{
		long lCount = ss.Length();
		for (long i = 0L; i < lCount; i++) 
		{
			TEntitySet ent = ss[i];
			if (ent.Is(_T("WIPEOUT")))
			{
				ent.Delete();
			}
			else
			{
				if (ModifyInsert(ent, 0) != RTNORM) 
				{

				}
			}
		}
	}

	SHads_command(RTSTR,_T("WIPEOUT"),RTSTR,_T("F"),RTSTR,_T("Off"),RTNONE);	//还无法判断wipeout框状态，所以就关了,(保存在AcDbDictionary系统词典)
}

// Command: 矩形屏蔽
void BringFront1()
{
	TEntitySet ent;
	TRBList mask(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL);
	if (SelectEntity(_T("\n选择图块:"), ent, mask) == RTNORM) 
	{
		if (ModifyInsert(ent, BIF_RECTMASK) != RTNORM)
		{
			TchGeLib::adsout << _T("\n无法完成矩形屏蔽!");
		}
	}
}

// Command: 精确屏蔽
void BringFront2()
{
	TEntitySet ent;
	TRBList mask(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL);
	if (SelectEntity(_T("\n选择图块:"), ent, mask) == RTNORM) 
	{
		if (ModifyInsert(ent, BIF_POLYMASK) != RTNORM)
		{
			TchGeLib::adsout << _T("\n无法完成精确屏蔽!");
		}
	}
}

// Command: 转化图块
void ConvertInsert()
{
	TEntitySet ent;
	TRBList mask(RTDXF0, _T("INSERT"), NULL);
	if (SelectEntity(_T("\n选择图块:"), ent, mask) == RTNORM) 
	{
		int nAttribFlag;
		int nRet = RTERROR;
		if (ent.GetData(66, &nAttribFlag) == RTNORM && nAttribFlag != 0) 
		{
			TchGeLib::adsout << _T("\n存在属性，不能转化!");
			return;
		}
		
		AcDbBlockReference *pInsert1 = NULL;
		AcDbObjectId idEnt;
		acdbGetObjectId(idEnt, ent.name);
		if (acdbOpenObject(pInsert1, idEnt, AcDb::kForWrite) == Acad::eOk &&
				pInsert1 != NULL) 
		{			
			if (pInsert1->isKindOf(AcDbMInsertBlock::desc()))
			{
				TchGeLib::adsout << _T("\n多重引用块，不能转化!");
				pInsert1->close();
				return;
			}
			
			AcDbObjectId idBlock = pInsert1->blockTableRecord();
			TDbBlockInsert *pInsert2 = new TDbBlockInsert;
			pInsert2->setPropertiesFrom(pInsert1);
			pInsert2->setNormal(pInsert1->normal());
			pInsert2->setBlockTableRecord(idBlock);
			pInsert2->setPosition(pInsert1->position());
			pInsert2->setScaleFactors(pInsert1->scaleFactors());
			pInsert2->setRotation(pInsert1->rotation());

			Acad::ErrorStatus es = pInsert1->handOverTo(pInsert2);
			if (es == Acad::eObjectToBeDeleted) 
			{
				pInsert2->close();
				delete pInsert1;
			}
			else 
			{
				delete pInsert2;
				pInsert1->close();
			}
		}
	}
}

// 用在设置宽度的命令
static int _GetWallWidth()
{
	resbuf *rb, *ebuf = ads_getargs();
	if (ebuf) 
	{
        rb = ebuf;
        if (rb)
		{
            if (rb->restype == RTREAL)
			{
				g_nIntWallWidth = _AS_MM(rb->resval.rreal);
			}
            else if (rb->restype == RTSHORT)
			{
				g_nIntWallWidth = _AS_MM(rb->resval.rint);
			}
            rb = rb->rbnext;
        }
        if (rb) 
		{
			if (rb->restype == RTREAL)
			{
				g_nIntWidth = _AS_MM(rb->resval.rreal);
			}
			else if (rb->restype==RTSHORT)
			{
				g_nIntWidth = _AS_MM(rb->resval.rint);
			}
			rb = rb->rbnext;
        }
        if (rb) 
		{
			if (rb->restype == RTREAL)
			{
				g_nExtWidth = _AS_MM(rb->resval.rreal);
			}
			else if (rb->restype == RTSHORT)
			{
				g_nExtWidth = _AS_MM(rb->resval.rint);
			}
			rb = rb->rbnext;
        }
		
        if (rb) 
		{
			ads_real nOldLen = minLenWall;
			if (rb->restype == RTREAL)
			{
				minLenWall = _AS_MM(rb->resval.rreal);
			}
			else if (rb->restype == RTSHORT)
			{
				minLenWall = _AS_MM(rb->resval.rint);
			}
			rb = rb->rbnext;
			if (minLenWall < 0)
			{
				minLenWall = nOldLen;
			}
        }
        ads_relrb(ebuf);
        return RTNORM;
	}
	return RTERROR;
}

// Command:
// 设置缺省的墙宽
int SetWallWidth()
{
	if(_GetWallWidth()==RTNORM)
	{
		return RTNORM;
	}

	TCString iw(_T("\n内墙宽<%g>: "), _AS_SYS_UNIT(g_nIntWallWidth));
	TCString intw(_T("\n外墙内侧宽<%g>: "), _AS_SYS_UNIT(g_nIntWidth));
	TCString extw(_T("\n外墙外侧宽<%g>: "), _AS_SYS_UNIT(g_nExtWidth));

	ads_real r1, r2, r3;
	int rc = -1;
	ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
	rc = ads_getreal(iw, &r1);
	if (rc == RTERROR || rc==RTCAN)
	{
		return rc;
	}
	else if (rc == RTNORM)
	{
		g_nIntWallWidth=_AS_MM(r1);
	}
	
	rc = ads_getreal(intw, &r2);
	if (rc == RTERROR || rc == RTCAN)
	{
		return rc;
	}
	else if (rc == RTNORM)
	{
		g_nIntWidth=_AS_MM(r2);
	}
	
	rc = ads_getreal(extw, &r3);
	if (rc == RTERROR || rc == RTCAN) 
	{
		return rc;
	}
	else if (rc == RTNORM)
	{
		g_nExtWidth = _AS_MM(r3);
	}
	
	return RTNORM;
}

//对象编辑
int EditProtectEntity(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbProtectEntity, pEnt);
	if (pEnt != NULL) 
	{
		if (pEnt->CanExplode())					//可分解时，设置新密码
		{
			if (pEnt->upgradeOpen() == Acad::eOk)
			{
				CTemporaryResourceOverride vTemp;
				CProtectSetDlg dlg(pEnt);
				dlg.DoModal();
				pEnt->downgradeOpen();
			}
		}
		else									//不能分解时，输入旧密码
		{	
			TCHAR sCode1[256] = _T("");
			if (acedGetString(NULL,_T("\n输入密码<退出>:"),sCode1) == RTNORM)
			{
				if (pEnt->upgradeOpen() == Acad::eOk)
				{
					pEnt->SetCode1(sCode1);
					pEnt->downgradeOpen();
					
					if (!pEnt->CanExplode())
					{
						TchGeLib::adsout<<_T("\n密码错误!");
					}
					else
					{
						TchGeLib::adsout<<_T("\n密码正确,此只读对象进入可分解、可通过对象编辑修改保护权限的临时状态!");
					}
				}
			}
		}
		
	}
	OPENOBJ_END();
	
	return RTNORM;
}

bool UnProtect(TDbProtectEntity*pEnt)
{
	AcDbBlockTableRecord *pRecord = NULL;
	acdbOpenObject(pRecord,pEnt->GetBlockRecordId(),AcDb::kForWrite);
	if (pRecord != NULL)
	{
		AcDbBlockTableRecordIterator *pIter = NULL;
		pRecord->newIterator(pIter);
		if (pIter != NULL)
		{
			AcDbObjectIdArray idArray;
			for (pIter->start(); !pIter->done(); pIter->step())
			{
				AcDbObjectId id;
				AcDbEntity *pSubEnt;
				pIter->getEntity(pSubEnt,AcDb::kForWrite);
				
				if (pSubEnt != NULL)
				{
					TDbProtectEntity* pProtect = TDbProtectEntity::cast(pSubEnt);
					if (pProtect != NULL)
					{
						UnProtect(pProtect);
					}
					else
					{
						pIter->getEntityId(id);
						idArray.append(id);
					}
					
					pSubEnt->close();
				}
			}
			
			if (idArray.length() > 0)
			{
				AcDbObjectId idMSpace;
				{
					TAcDbBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForWrite);
					idMSpace = mspace.m_pBlockTableRec->objectId();
				}
				
				AcDbIdMapping idMap;
				Acad::ErrorStatus es = acdbHostApplicationServices()->workingDatabase()->deepCloneObjects(idArray,idMSpace,idMap);
				int pos;
				idArray.find(NULL,pos);
			}
			
			delete pIter;
		}
		
		pRecord->erase();
		pRecord->close();
	}
	
	return true;
}












int DragInsertBlock1(const TCHAR *szBlock, int nFlag, const AcGeScale3d &scales)
{
	TADSGePoint3d ptInsert;
	VERIFY(TGGetVar(_T("VIEWCTR"), &ptInsert) == RTNORM);
	
	AcDbObjectId idInsert = (nFlag&IBF_TINSERT) ? 
		MakeTBlockInsert(szBlock,ptInsert, scales[0], scales[1], scales[2],Ucs2Wcs(0),0) :
		MakeBlockInsert(szBlock,ptInsert, scales[0], scales[1], scales[2], Ucs2Wcs(0));
	if (!idInsert)
	{
		return RTERROR;
	}
	
	TEntitySet ent;
	VERIFY(acdbGetAdsName(ent.name, idInsert) == Acad::eOk);
	
	OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
	ASSERT(pEnt);
	pEnt->draw();
	OPENOBJ_END();
	
	int rc = RTNORM;
	ptInsert = Wcs2Ucs(ptInsert);
	while(rc == RTNORM) 
	{
		rc = IDragInsertBlock(ptInsert, ent, nFlag);
		if (rc == RTNORM && (nFlag&IBF_MINSERT)) 
		{
			TPushAcadVar<int> osmode(_T("OSMODE"), 0);
			SHads_command(RTSTR, _T(".COPY"), RTENAME, (TLong_ptr *)ent, RTSTR, _T(""),
						RT3DPOINT, &ptInsert,RT3DPOINT, &ptInsert, RTNONE);
			ent.FreeGroups();
			ent.GetLast();
		} 
		else
		{
			break;
		}
	}
	return rc;
}

int IDragInsertBlock(TADSGePoint3d &ptBase, TEntitySet &ent, int nFlag)
{
	double nScale = 1.0;
	ent.GetData(41, &nScale);
	TPickEntSet ss(SS_FREE);
	ss += ent;
	
	int nOptFlag = IBF_ROT90|IBF_MIRLR|IBF_MIRUD|IBF_ALIGN|IBF_FRAME|IBF_ROTATE|IBF_BASEPT|IBF_RESEL|IBF_SCALE;
	TCString szPrompt(256);
	szPrompt << _T("\n点取插入点或 ");
	if (nFlag & nOptFlag)
	{
		szPrompt << _T("[");
	}
	BOOL bInitOption = FALSE;
	int nOptionArray[9] = {IBF_ROT90,IBF_MIRLR,IBF_MIRUD,IBF_ALIGN,IBF_FRAME,IBF_ROTATE,IBF_BASEPT,IBF_RESEL,IBF_SCALE};
	const TCHAR * szOptionPrompt[9] = {_T("转90(A)"), _T("左右(S)"), _T("上下(D)"), _T("对齐(F)"), _T("外框(E)"),
		_T("转角(R)"), _T("基点(T)"), _T("更换(C)"), _T("比例(X)"),};
	TCHAR szKeywordArray[10] = _T("ASDFERTCX");
	TCString sKeywords;
	for (int n = 0; n < 9; n++) 
	{
		if (nFlag&nOptionArray[n]) 
		{
			if (bInitOption) 
			{
				szPrompt << _T("/");
				sKeywords << _T(" ");
			}
			bInitOption = TRUE;
			szPrompt <<  szOptionPrompt[n];
			TCHAR szTemp[2] = _T("");
			szTemp[0] = szKeywordArray[n];
			szTemp[1] = EOS;
			sKeywords << szTemp;
		}
	}
	if (nFlag & nOptFlag)
	{
		szPrompt << _T("]");
	}
	szPrompt << _T("<退出>:");
	
	int   rc = 0;
	TCHAR draggenprompt[512] = _T("");
	int   cur = 0;
	TADSGePoint3d ptFinal;
	
	//modify by xlc on 081019  水专业插图库时预览位置不正确
	//g_ptBase = ptBase;
	TAdvanceSampler::g_ptBase = ptBase;

	TchGeLib::adsout << szPrompt;
	
LAB_DRAG:    
	ss.RedrawAll(2);
	sKeywords<<_T(" ~");
	
	INITGET_BEG(0, !sKeywords? NULL : (const TCHAR *)sKeywords);

	//modify by xlc on 081019  水专业插图库时预览位置不正确
	//rc = ads_draggen(ss, draggenprompt, cur,  MoveSamplerStatic, ptFinal);
	rc = ads_draggen(ss, draggenprompt, cur,  TAdvanceSampler::MoveSampler, ptFinal);

	INITGET_END();
	
	if (rc == RTKWORD) 
	{
		TADSGePoint3d g_ptNewBase = GetCursorWcs();
		TCString sKeyChar;
		VERIFY(ads_getinput(sKeyChar) == RTNORM);
		ads_matrix mat;

		//modify by xlc on 081019  水专业插图库时预览位置不正确
		//Ucs2Wcs( g_ptBase).GetMoveMatrix(g_ptNewBase, mat);
		Ucs2Wcs( TAdvanceSampler::g_ptBase).GetMoveMatrix(g_ptNewBase, mat);

		VERIFY(ads_xformss(ss, mat) == RTNORM);
		
		ads_printf(_T("%c%c %c"), 8,8,8);
		
		//modify by xlc on 081019  水专业插图库时预览位置不正确
		//g_ptBase = Wcs2Ucs(g_ptNewBase);
		TAdvanceSampler::g_ptBase = Wcs2Ucs(g_ptNewBase);

		if (sKeyChar[0] == _T('A') || sKeyChar[0] == _T('S') || sKeyChar[0] == _T('D')) 
		{
			TPushAcadVar<int> nMode(_T("OSMODE"), 0);
			TADSGePoint3d ptOther;
				
			//modify by xlc on 081019  水专业插图库时预览位置不正确
			//if (sKeyChar[0] == _T('S')) 
			//{
			//	ptOther =  g_ptBase+TADSGePoint3d(0,100,0);
			//	SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (long *)ss, RTSTR, _T(""),
			//		RT3DPOINT, & g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
			//} 
			//else if (sKeyChar[0] == _T('D'))
			//{
			//	ptOther =  g_ptBase+TADSGePoint3d(100,0,0);
			//	SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (long *)ss, RTSTR, _T(""),
			//		RT3DPOINT, & g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
			//} 
			//else if (sKeyChar[0] == _T('A'))
			//{
			//	SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ss, RTSTR, _T(""),
			//		RT3DPOINT, & g_ptBase, RTREAL, 90.0, RTNONE);
			//}
			if (sKeyChar[0] == _T('S')) 
			{
				ptOther = TAdvanceSampler::g_ptBase+TADSGePoint3d(0,100,0);
				SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
					RT3DPOINT, & TAdvanceSampler::g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
			} 
			else if (sKeyChar[0] == _T('D'))
			{
				ptOther = TAdvanceSampler::g_ptBase+TADSGePoint3d(100,0,0);
				SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
					RT3DPOINT, & TAdvanceSampler::g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
			} 
			else if (sKeyChar[0] == _T('A'))
			{
				SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
					RT3DPOINT, & TAdvanceSampler::g_ptBase, RTREAL, 90.0, RTNONE);
			}

			rc = RTNORM;
		} 
		else if (sKeyChar[0] == _T('C')) 
		{
			rc = IBF_RESEL;
		}
		else if (sKeyChar[0] == _T('X'))
		{
			CString csPrompt;
			double nNewScale(nScale);
			csPrompt.Format(_T("\n请输入比例:<%.1f> "), nScale);
			ads_getreal(csPrompt, &nNewScale);
			nScale = nNewScale / nScale;

			//modify by xlc on 081019  水专业插图库时预览位置不正确
			//SHads_command(RTSTR, _T(".SCALE"), RTPICKS, (long *)ss, RTSTR, _T(""),
			//	RT3DPOINT, & g_ptBase, RTREAL, nScale, RTNONE);
			rc = SHads_command(RTSTR, _T(".SCALE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
						RT3DPOINT, & TAdvanceSampler::g_ptBase, RTREAL, nScale, RTNONE);

			nScale = nNewScale;
			if (rc == RTNORM)
			{
				TchGeLib::adsout << szPrompt;
			}
		} 
		else if (sKeyChar[0] == _T('R')) 
		{
			double nRot = 0.0;
			TchGeLib::adsout << _T("\n旋转角度: ");

			//modify by xlc on 081019  水专业插图库时预览位置不正确
			//rc = SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ss,
			//	RTSTR, _T(""), RT3DPOINT, & g_ptBase, RTSTR, _T("\\"), RTNONE); 
			rc = SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss,
				RTSTR, _T(""), RT3DPOINT, & TAdvanceSampler::g_ptBase, RTSTR, _T("\\"), RTNONE); 

			if (rc == RTNORM)
			{
				TchGeLib::adsout << szPrompt;
			}
		} 
		else if (sKeyChar[0] == _T('T')) 
		{
			int nOsMode = 0;
			TGGetVar(_T("OSMODE"), &nOsMode);
			nOsMode &= ~0x4000;
			nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
			TPushAcadVar<int> vOsMode(_T("OSMODE"), nOsMode);
			
			//modify by xlc on 081019  水专业插图库时预览位置不正确
			//rc = GetPickPoint(NULL, _T("\n输入插入点"),  g_ptBase);
			rc = GetPickPoint(NULL, _T("\n输入插入点"),  TAdvanceSampler::g_ptBase);

			if (rc == RTNORM)
			{
				TchGeLib::adsout << szPrompt;
			}
		} 
		else if (sKeyChar[0] == _T('E')) 
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
			ASSERT(pEnt);
			pEnt->draw();
			OPENOBJ_END();
			ss.RedrawAll(2);
			TADSGePoint3d ptCorn1, ptCorn2;
			rc = GetPickPoint(NULL, _T("\n第一个角点"), ptCorn1);
			if (rc == RTNORM) 
			{
				double m_nRot = 0.0;
				TADSGePoint3d ptIns;
				ent.FreeGroups();
				ent.GetData(50, &m_nRot);
				TVector3D vtRot(cos(m_nRot), sin(m_nRot));
				vtRot = Wcs2Ucs(vtRot, TRUE);
				TchGeLib::adsout << _T("\n另一个角点: ");
				rc = GetRectAngleStatic(ptCorn1, ads_angle(TADSGePoint3d(), vtRot), ptCorn2);
				if (rc == RTNORM) 
				{
					ptCorn1 = Ucs2Wcs(ptCorn1);
					ptCorn2 = Ucs2Wcs(ptCorn2);
					
					double nAngle1 = AngleRangeTo2PI(ads_angle(ptCorn1, ptCorn2)-m_nRot);
					double nDist = ptCorn1.Distance2d(ptCorn2);
					TADSGePoint3d m_ptCen;
					Midpoint(ptCorn1, ptCorn2, m_ptCen);
					double m_nSizeX = nDist*fabs(cos(nAngle1));
					double m_nSizeY = nDist*fabs(sin(nAngle1));
					
					ads_matrix matRotOld, matMove, matScale, matRotNew, matTransform;
					double nSizeX, nSizeY, nSizeZ, nRot;
					TADSGePoint3d ptCen, ptNewCen;
					OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbBlockReference, pBlkSrc);
					ASSERT(pBlkSrc);
					VERIFY(GetBlockRefSizeInfo(pBlkSrc, ptIns, &nRot, ptCen, &nSizeX, &nSizeY, &nSizeZ) == RTNORM);
					
					ptNewCen = m_ptCen;
					ptNewCen.z += nSizeZ/2.0;
					
					// 绕旧中心旋转-nRotOld -> 绕旧中心Scale -> 平移到新中心 -> 旋转 RotNew
					// or
					// 绕旧中心旋转-nRotOld -> 绕旧中心Scale ->  旋转 RotNew -> 平移到新中心 (Current Method)
					AcGeScale3d bScale = pBlkSrc->scaleFactors();
					double sx = 1, sy = 1, sz = 1;
					if (fabs(nSizeX) > 1.0E-6)
					{
						bScale[0] *= sx = m_nSizeX/nSizeX;
					}
					if (fabs(nSizeY) > 1.0E-6) 
					{
						bScale[1] *= sy = m_nSizeY/nSizeY;
					}
					
					ptCen.GetRotationMatrix(-nRot, matRotOld);
					ptCen.GetScaleMatrix(sx, sy, sz, matScale);
					ptCen.GetRotationMatrix(m_nRot, matRotNew);
					ptCen.GetMoveMatrix(ptNewCen, matMove);
					
					MatrixMultiply(matTransform,  matMove, matRotNew, matScale, matRotOld, NULL);
					ptIns.TransformBy(matTransform); //换算新的基点位置
					
					//modify by xlc on 081019  水专业插图库时预览位置不正确
					//TADSGePoint3d ptBaseWcs = Ucs2Wcs( g_ptBase);
					//ptBaseWcs.TransformBy(matTransform);
					//g_ptBase = Wcs2Ucs(ptBaseWcs);
					TADSGePoint3d ptBaseWcs = Ucs2Wcs( TAdvanceSampler::g_ptBase);
					ptBaseWcs.TransformBy(matTransform);
					TAdvanceSampler::g_ptBase = Wcs2Ucs(ptBaseWcs);

					pBlkSrc->setPosition(ptIns);
					pBlkSrc->setScaleFactors(bScale);
					OPENOBJ_END();
					
					//modify by xlc on 081019  水专业插图库时预览位置不正确
					//ptBase = g_ptBase;
					ptBase =  TAdvanceSampler::g_ptBase;
					return RTNORM;
				}
			} 
		}
		else if (sKeyChar[0] == _T('F')) 
		{
			int nOsMode = 0;
			TGGetVar(_T("OSMODE"), &nOsMode);
			nOsMode &= ~0x4000;
			nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
			TPushAcadVar<int> vOsMode(_T("OSMODE"), nOsMode);
			
			//modify by xlc on 081019  水专业插图库时预览位置不正确
			//TADSGePoint3d pt1 = g_ptBase, pt2, qt1, qt2;
			TADSGePoint3d pt1 = TAdvanceSampler::g_ptBase, pt2, qt1, qt2;

			if (ads_getpoint(NULL, _T("\n对齐参考点："), pt1) == RTNORM &&
				ads_getpoint(pt1,  _T("\n对齐参考轴："), pt2) == RTNORM &&
				ads_getpoint(NULL, _T("\n对齐目标点："), qt1) == RTNORM &&
				ads_getpoint(qt1,  _T("\n对齐目标轴："), qt2) == RTNORM) 
			{
				TPushAcadVar<int> osmode(_T("OSMODE"), 0);
				double nRot = AngleRangeTo2PI(ads_angle(qt1, qt2)-ads_angle(pt1, pt2));
				SHads_command(RTSTR, _T(".MOVE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
							RT3DPOINT, &pt1, RT3DPOINT, &qt1, RTNONE);
				SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
							RT3DPOINT, &qt1, RTREAL, nRot*180/PI, RTNONE);
				rc = RTNORM;
				ptBase = qt1;
				return rc;
			}
		}
		else if (sKeyChar[0] == _T('~'))
		{
			return RTNIL;
		}
		
		if (rc == RTNORM)
		{
			goto LAB_DRAG;
		}
	}

	switch (rc) 
	{
	case RTNORM: 
		{
			ads_matrix mat;
			
			//modify by xlc on 081019  水专业插图库时预览位置不正确
			//Ucs2Wcs( g_ptBase).GetMoveMatrix(Ucs2Wcs(ptFinal), mat);
			Ucs2Wcs( TAdvanceSampler::g_ptBase).GetMoveMatrix(Ucs2Wcs(ptFinal), mat);

			VERIFY(ads_xformss(ss, mat) == RTNORM);
			ptBase = ptFinal;
			break;
		}
	case RTCAN:
	case RTNONE: 
	case RTERROR:
	default:
		ent.Delete();
		break;
	}
	return rc;
}


// 从二维图块中提取外轮廓线
int GetBoundaryFromInsert2D(TEntitySet &ent, TGGePoly2D &polyOutline)
{
    if (GetExistOutlineFromInsert(ent, polyOutline) == RTNORM)
	{
        return RTNORM;
	}

    TDPtrList<TGGeCurveSegment> lstSegs;
    if (GetCurveFromInsert2D(ent, lstSegs) != RTNORM || !lstSegs)
	{
        return RTERROR;
	}
    return GetExternalBoundaryFromCurves(lstSegs, polyOutline);
}

void SearchSpace(TPickEntSet &ssWalls,const TDPtrList<AcDbObjectId> &lstColu,TDPtrList<TDbSpace> &res)
{
    TSearchSpaceFromWall aSearch;
    try 
	{
		aSearch.InitStart(ssWalls, lstColu);
    }   
	catch (...) 
	{
        TchGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
		return;
    }
	
    TAecSpaceCell * extCell = aSearch.SearchSpaces();
	TDbSpace *pDbExtSpace = NULL;
    for (int n = 0; n<aSearch.spaces.Length(); n++) 
	{
        TAecSpaceCell *pSpace = aSearch.spaces[n];
		
        TGGePoly2D polySpace(1);
        pSpace->CenterPoly2D(polySpace);
        polySpace.SetElevation(0.0); //投影到z = 0的平面上
		
        TADSGePoint3d ptLoc;
        polySpace.Center(ptLoc);
        ptLoc.z = 0.0;
		
		if ((ptLoc&polySpace) != PR_INSIDE)
		{
            TGGePoly polyTemp;
            polySpace.MapToPolygon(polyTemp, 20);
            if (!!polyTemp) 
			{
                TGGePolygonEx polyTri(polyTemp);
                TDPtrList<TGGeTriangle> lstTri;
                if (polyTri.Trianglize(lstTri, TRUE) == RTNORM && !!lstTri) 
				{
                    TGGeTriangle *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("建筑面积");
			pDbExtSpace->m_sCode = _T("0");
		}
		else
		{
			res.Append(pDbSpace);
		}
    }
	if (pDbExtSpace != NULL)
	{
		res.Append(pDbExtSpace);
	}
}
TCString GetCurCommand()
{
	TCString sCmd;
	TArchPerDocData *pData = GetCurDocData();
	if (pData)
	{
		sCmd = pData->m_sCurCommand;
	}
	return sCmd;
}

AcDbObjectId MakeBlockInsert(const TCHAR *pszBlock, TADSGePoint3d ptInsert,double sx, double sy, double sz, double rot)
{
    AcDbObjectId idBlock = InitBlock(pszBlock);
    if (!idBlock)
	{
        return idBlock;
	}

    AcDbBlockReference *pInsert = new AcDbBlockReference(ptInsert, idBlock);
    pInsert->setScaleFactors(AcGeScale3d(sx, sy, sz));
    pInsert->setRotation(rot);
   
	AcDbObjectId idInsert = AddToCurrentSpace(pInsert, Adesk::kTrue);
    if (!idInsert)
	{
        delete pInsert;
	}

    return idInsert;
}

void GetAllColumnBoundry(TDPtrList<TGGePoly2D> &lstClipBoundry)
{
    TDPtrList<AcDbObjectId> ssColumns;
    GetEntFromBlockByDxf(ssColumns, _T("ATS_COLUMN"));
    int ssLen = ssColumns.Length();
    for (long i = 0; i<ssLen; i++) 
	{
        TAcDbObjectPtr obj(*ssColumns[i], AcDb::kForRead);
        if (!obj) 
		{
			continue;
		}
        TDbColumn *pColumn = TDbColumn::cast(obj.m_pObject);
		if (pColumn && !pColumn->IsFortifyColumn()) 
		{
            const TGGePoly2D &polyOut = pColumn->GetOutlinePoly();
            if (!!polyOut) 
			{
                TGGePoly2D *pPoly = new TGGePoly2D(polyOut);
                lstClipBoundry.Append(pPoly);
            }
        }
    }
}

void UpdateTDbEntity()
{
    BOOL bSaveGlobal = DocGetIsDwgBegin();
    DocSetIsDwgBegin(FALSE);
    TPickEntSet ss(SS_FREE);
    TRBList mask(RTDXF0, _T("TCH_*"), NULL);
    if (ss.Get(_T("X"), NULL, NULL, mask) == RTNORM) 
	{
        long lCount = ss.Length();
        for (long i = 0L; i < lCount; i++)
		{
            TEntitySet ent = ss[i];
            OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pEnt);
            if (pEnt)
			{
                pEnt->assertWriteEnabled();
			}
            OPENOBJ_END();
        }
    }
    DocSetIsDwgBegin(bSaveGlobal);
}

void UpdateGraphic(TPickEntSet &ss)
{
	BOOL bOld = g_bDwgBegin;
	DocSetIsDwgBegin(FALSE);
	
    AcAxDocLock docLock;       
    VERIFY(docLock.lockStatus() == Acad::eOk);
    long lCount = ss.Length();
    for (long i = 0L; i<lCount; i++) 
	{
        TEntitySet ent = ss[i];
        AcDbObjectId objId;
        VERIFY(acdbGetObjectId(objId, ent.name) == Acad::eOk);
        AcDbObjectPointer<AcDbEntity> pSq(objId, AcDb::kForWrite);
        if (pSq.openStatus() == Acad::eOk)
		{
			pSq->recordGraphicsModified();
			pSq->downgradeOpen();
			pSq->draw();
		}
        
    }
	DocSetIsDwgBegin(bOld);
}

void UpdateGraphic(const TDPtrList<AcDbObjectId> &ss)
{
	
	BOOL bOld = g_bDwgBegin;
	DocSetIsDwgBegin(FALSE);
	
    AcAxDocLock docLock;       
    VERIFY(docLock.lockStatus() == Acad::eOk);
    int lCount = ss.Length();
    for (int i = 0; i<lCount; i++) 
	{
        AcDbObjectId ent = ss[i];
        TAcDbObjectPtr obj(ent, AcDb::kForWrite);
        if (!!obj) 
		{
            AcDbEntity &dbEnt = obj;
            dbEnt.recordGraphicsModified();
			dbEnt.downgradeOpen();
			dbEnt.draw();
        }
    }
	DocSetIsDwgBegin(bOld);
}


int GetColumnOutline(const AcDbObjectId &idColu, TGGePoly2D &poly)
{
    int nRetCode = RTNORM;
	poly.Reset();
    OPENOBJ_BEGIN(idColu, AcDb::kForRead, TDbColumn, pColu);
	if (pColu)
	{
		// sg modify 101206，根据8.5需求，搜索房间要考虑柱子保温
//		pColu->GetOutline(poly);
		pColu->GetColSurFacePoly2D(poly);
	}
	else
	{
		nRetCode = RTERROR;
	}
    OPENOBJ_END();
    return nRetCode;
}

TARCH_IMPEXP int GetApplicationPath(TCHAR *vPath)
{
	return GetApplicationPath(vPath,_hdllInstance);
}

// 初始化Aol库的连接
void InitAol(const TCHAR *szAppName)
{
	if (szAppName) 
	{
		TEntitySet::ApplicationName = xgAppname = szAppName;
	}
	
	GetApplicationPath(g_sAppPath,_hdllInstance);
	
	//确保类型之间的等价转换
	assert(sizeof(TADSGePoint3d) == sizeof(AcGePoint3d));
	assert(sizeof(ads_matrix) == sizeof(AcGeMatrix3d));
	
	TCString sAcadVer;
	TGGetVar(_T("ACADVER"), sAcadVer);
	g_nAcadVer = _tstof(sAcadVer);
	
	//提醒tch_kernal导出
	{
		TImageDrawDC dc;
		TImageDrawDCEx dc1;
		TDbWall wall;
		BOOL a = g_bAxisWall;
		TEntityBase *pBase = &wall;
	}
}

TDPtrList<TSortWallOnPt>& GetAllSortWalls()
{
	return TSearchSpaceFromWall::g_lstAllSortWalls;
}


AcDbObjectId MakeTBlockInsert(const TCHAR *pszBlock, TADSGePoint3d ptInsert, double sx, double sy, double sz, double rot, int nMask)
{
	AcDbObjectId idBlock = InitBlock(pszBlock);
	if (!idBlock)
	{
		return idBlock;
	}
	
	TDbBlockInsert *pInsert = new TDbBlockInsert;
	pInsert->setBlockTableRecord(idBlock);
	pInsert->setPosition(ptInsert);
	pInsert->setScaleFactors(AcGeScale3d(sx, sy, sz));
	pInsert->setRotation(rot);
	pInsert->SetMaskFlag(nMask);
	
	AcDbObjectId idInsert = AddToCurrentSpace(pInsert, Adesk::kTrue);
	if (!idInsert)
	{
		delete pInsert;
	}
	return idInsert;
}

void MdiOpenDwgFile(const TCHAR *pszFile, const TCHAR *pszCmdStr)
{
	extern TCHAR g_szFileNameToOpen[];
	extern TCHAR g_szInitCmdStr[];
	extern CWnd *g_pContextMenu;
	if (g_pContextMenu) 
	{
		_tcscpy(g_szFileNameToOpen, pszFile);
		if (pszCmdStr)
		{
			_tcscpy(g_szInitCmdStr, pszCmdStr);
		}
		else
		{
			g_szInitCmdStr[0] = EOS;
		}
		g_pContextMenu->PostMessage(WM_TCH_OPEN_FILE);
	}
}

void OpenDwgWithCurNls(CString &csFileName)
{
    TSplitpathOperator parser(csFileName);
    BOOL bDxf = (_tcsicmp(parser.m_sExt, _T(".DXF")) == 0);
	TchExport::ConvertDwgCodePage(csFileName);
	
    if (bDxf)
	{
        if (SHads_command(RTSTR, _T(".dxfin"), RTSTR, (const TCHAR *)csFileName, RTNONE) != RTNORM)
		{
            TchGeLib::adsout << _T("\n必须为干净的空图才可以输入DXF文件!");
		}
    } 
	else
	{
		MdiOpenDwgFile(csFileName, NULL);
    }
}

int GetViewDrawMode()
{ 
	if ((CFG_DrawMode & DRAW_2D) && !(CFG_DrawMode & DRAW_3D)) 
	{
		return DRAW_2D;
	} 
	else if ((CFG_DrawMode & DRAW_3D) && !(CFG_DrawMode & DRAW_2D)) 
	{
		return DRAW_3D;
	} 
	else if (CFG_DrawMode & (DRAW_3D | DRAW_2D)) 
	{
		TADSGePoint3d viewDir;
		TGGetVar(_T("VIEWDIR"), &viewDir);
		viewDir = Ucs2Wcs(viewDir, TRUE);
		if (fabs(viewDir.x) > 1.0E-6 || fabs(viewDir.y) > 1.0E-6) 
		{
			return DRAW_3D;
		}
		else 
		{
			return DRAW_2D;
		}
	} 
	return 0;
}

// 从图块中寻找_HOLE图层上的PLINE
int GetExistOutlineFromInsert(const TEntitySet &e, TGGePoly2D &polyOutline)
{
    AcDbObjectId idBlock;
	TEntitySet ent = e;
	int nCode = (ent.Is(_T("ATS_MVINSERT")) ? 1 : 2);
	TCString sBlock;
	ent.GetData(nCode, (TCHAR *)sBlock);
	idBlock = GetBlockIdFromString(sBlock);
	if (!idBlock)
	{
		return RTERROR;
	}

    ads_matrix mat;
    GetInsertMatrix(ent, mat);

    OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    VERIFY(pBlock->newIterator(pBlockIterator) == Acad::eOk && pBlockIterator);
    for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())  
	{
        AcDbEntity *pEntity = NULL;
        VERIFY(pBlockIterator->getEntity(pEntity, AcDb::kForRead) == Acad::eOk && pEntity);
        TAcDbObjectPtr obj(pEntity); 
        TCHAR *pszLayer = pEntity->layer();
        if (_tcsicmp(pszLayer, LAY_BOUNDARY) != 0) 
		{
            delete[] pszLayer;
            continue;
        }
        delete[] pszLayer;

        TEntitySet ent0;
        acdbGetAdsName(ent0.name, pEntity->objectId());
        obj.Close();

        if (!(!ent0)) 
		{
            TGGePoly2D poly(ent0);
            if (!poly) 
			{
				;
			}
            else 
			{
                polyOutline = poly;
                polyOutline.TransUCS(mat);
                return RTNORM;
            }
        }
    }
    OPENOBJ_END();
    return RTERROR;
}



// poly2d--UCS
int GetClipBoundary1(TGGePoly2D &poly2d)
{
	TADSGePoint3d ptStart;
	TchGeLib::adsout << _T("\n矩形的第一个角点或 [多边形裁剪(P)/多段线定边界(L)/图块定边界(B)]<退出>:");
	int nCode;
	INITGET_BEG(0, _T("P L B"));
	nCode = ads_getpoint(NULL, _T(""), ptStart);
	INITGET_END();
	if (nCode != RTKWORD && nCode != RTNORM)
	{
		return nCode;
	}
	
	TGGiScreenDrawStream dc;
	dc.m_nDrawMode = 1;
	
	if (nCode == RTNORM) 
	{
		TADSGePoint3d ptOther;
		int nCode = GetCornerPoint(ptStart, _T("\n另一个角点<退出>:"), ptOther);
		if (nCode != RTNORM)
		{
			return nCode;
		}
		TGGeRectAngle rect(ptStart, ptOther);
		rect.AsPoly2D(poly2d);
		dc << poly2d;
	} 
	else 
	{
		nCode = RTNORM;
		TCString sKey;   
		ads_getinput(sKey);
		if (sKey[0] == _T('P')) 
		{
			if (ads_getpoint(NULL, _T("\n多边形起点<退出>:"), ptStart) != RTNORM)
			{
				return RTERROR;
			}
			TADSGePoint3d pt2;
			TDPtrStack<TADSGePoint3d> aStack;
			aStack.Push(new TADSGePoint3d(ptStart));
			while(1) 
			{
				TADSGePoint3d &ptFrom = *aStack.Top();
				if (aStack.Length() >= 3)
				{
					TchGeLib::adsout << _T("\n下一点或 [回退(U)]<封闭>: ");
				}
				else
				{
					TchGeLib::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
						TADSGePoint3d *pPt2 = aStack.Pop();
						TADSGePoint3d *pPt1 = aStack.Top();
						dc.SetColor(-1);
						dc << TGGeLine(*pPt1, *pPt2);
						delete pPt2;
					}
				} 
				else 
				{
					if (rc == RTNONE)
					{
						if (aStack.Length() < 3)
						{
							return RTERROR;
						}
						else
						{
							pt2 = ptStart;
						}
					}
					TGGeLine ln(*aStack.Top(), pt2);
					if (ln.GetLength()>_DIST_SNAP) 
					{
						dc.SetColor(7);
						dc << ln;
						if (!(rc == RTNONE))
						{
							aStack.Push(new TADSGePoint3d(pt2));
						}
						else 
						{
							break;
						}
					}
				}
			}
			poly2d.Reset();
			TADSGePoint3d *ptCur = NULL;
			while((ptCur = aStack.Pop()) != NULL) 
			{
				poly2d.AppendNode(*ptCur);
				delete ptCur;
			}
		}
		else if (sKey[0] == _T('L'))
		{
			TEntitySet entFront;
			if (SelectEntity(_T("\n请选择封闭的多段线作为裁减边界<退出>: "), entFront, TRBList(RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, NULL)) != RTNORM)
			{
				return RTERROR;
			}
			poly2d = TGGePoly2D(entFront);
			poly2d.TransUCS(TGroups(0), TGroups(1));
			dc << poly2d;
		}
		else if (sKey[0] == _T('B'))
		{
			TEntitySet entFront;
			if (SelectEntity(_T("\n请选择图块作为裁减边界<退出>: "), entFront, 
				TRBList(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL)) != RTNORM)
			{
				return RTERROR;
			}
			if (GetBoundaryFromInsert2D(entFront, poly2d) != RTNORM) 
			{
				TchGeLib::adsout << _T("\n无法搜到图块的边界!");
				{
					return RTERROR;
				}
			}
			poly2d.TransUCS(TGroups(0), TGroups(1));
			dc << poly2d;
			int nAnser = YesNoQuestion(_T("\n系统确定的图块轮廓线是否正确"));
			if (nAnser != Q_YES)
			{
				TchGeLib::adsout << _T("\n请用其他方法确定裁减边界!");
				return RTERROR;
			}
		}
	}
	poly2d.Compress();
	if (!poly2d || poly2d.Length() < 3) 
	{
		return RTERROR;
	}

	return RTNORM;
}

template <class T>
void DELETE_ARR_(T *&arr)
{
	if (arr != NULL)
	{
		delete[] arr;
		arr = NULL;
	}
}

bool getSections(LPCTSTR szPath, std::vector<CString> &sections)
{
	if (_taccess(szPath, 0x0) != 0x0) return false;
	DWORD dw(0), len(MAX_PATH);
	TCHAR *buf = new TCHAR[len];
	::memset(buf, 0, sizeof(TCHAR) * len);
	dw = ::GetPrivateProfileSectionNames(buf, len, szPath);
	while (dw == len - 2)
	{
		DELETE_ARR_(buf);
		len += MAX_PATH;
		buf = new TCHAR[len];
		::memset(buf, 0, sizeof(TCHAR) * len);
		dw = ::GetPrivateProfileSectionNames(buf, len, szPath);
	}
	TCHAR *psz(buf);

	while ((len = (DWORD)_tcslen(psz)))
	{
		sections.push_back(psz);
		psz += len + 1;
	}
	DELETE_ARR_(buf);
	return !sections.empty();
}

bool getSectionContent(LPCTSTR szPath, LPCTSTR szSection, std::vector<std::pair<CString, CString>> &mapV)
{
	if (_taccess(szPath, 0x0) != 0x0) return false;

	DWORD dw(0), len(MAX_PATH);
	TCHAR *buf = new TCHAR[len];
	::memset(buf, 0, sizeof(TCHAR) * len);
	dw = ::GetPrivateProfileSection(szSection, buf, len, szPath);
	while (dw == len - 2)
	{
		DELETE_ARR_(buf);
		len += MAX_PATH;
		buf = new TCHAR[len];
		::memset(buf, 0, sizeof(TCHAR) * len);
		dw = ::GetPrivateProfileSection(szSection, buf, len, szPath);
	}

	TCHAR *psz(buf);

	mapV.clear();

	std::map<CString, CString>::const_iterator it;
	int idx(-1);
	CString str(_T("")), pre(_T("")), back(_T(""));
	while ((len = (DWORD)_tcslen(psz)))
	{
		str = psz;
		idx = str.Find(_T('='));
		if (idx != -1)
		{
			pre = str.Left(idx);
			back = str.Right(str.GetLength() - idx - 1);
			mapV.push_back(std::make_pair(pre, back));
		}
		psz += len + 1;
	}
	DELETE_ARR_(buf);

	return !mapV.empty();
}

bool getSectionContent(LPCTSTR szPath, LPCTSTR szSection, std::map<CString, CString> &mapV)
{
	std::vector<std::pair<CString, CString>> bims;
	getSectionContent(szPath, szSection, bims);
	for (size_t i = 0; i < bims.size(); ++i)
	{
		mapV.insert(bims[i]);
	}
	return !mapV.empty();
}


bool setSectionContent(LPCTSTR szPath, LPCTSTR szSection, const std::map<CString, CString> &mapV)
{
	if (!szSection) return false;
	//if (_taccess(szPath, 0x0) != 0x0) return false;

	// 拼字符串
	std::map<CString, CString>::const_iterator it = mapV.begin();
	std::wstring ss;
	for (; it != mapV.end(); ++it)
	{
		ss += it->first;
		ss += _T("=");
		ss += it->second;
		ss.push_back(_T('\0'));
	}
	ss.push_back(_T('\0'));

	return ::WritePrivateProfileSection(szSection, ss.c_str(), szPath) == FALSE ? false : true;
}

namespace
{
	CString GetArxDir()
	{
		TCHAR szPath[MAX_PATH];
		::GetModuleFileName(_hdllInstance, szPath, MAX_PATH);
		CString sPath(szPath);
		sPath = sPath.Left(sPath.ReverseFind(_T('\\')));
		return sPath;
	}

	bool getMeterUnitDraw()
	{
#ifndef ZWCAD
		CString dllPath(GetArxDir() + _T("\\Dimension.arx"));
#else
		CString dllPath(GetArxDir() + _T("\\Dimension.zrx"));
#endif
		typedef int(_cdecl *getUnitOfDraw)();

		HMODULE hmod = ::LoadLibrary(dllPath);
		if (!hmod) return false;

		getUnitOfDraw func_getUnitOfDraw = (getUnitOfDraw)::GetProcAddress(hmod, "getUnitOfDraw");

		if (!func_getUnitOfDraw)
		{
			::FreeLibrary(hmod);
			return false;
		}
		
		int nRet = func_getUnitOfDraw();
		return nRet == 1 ? true : false;
	}

	bool setMeterUnitDraw(const BOOL &bMeter)
	{
	#ifndef ZWCAD
		CString dllPath(GetArxDir() + _T("\\Dimension.arx"));
	#else
		CString dllPath(GetArxDir() + _T("\\Dimension.zrx"));
	#endif
		typedef void(_cdecl *setUnitOfDraw)(const bool &);

		HMODULE hmod = ::LoadLibrary(dllPath);
		if (!hmod) return false;

		setUnitOfDraw func_setUnitOfDraw = (setUnitOfDraw)::GetProcAddress(hmod, "setUnitOfDraw");

		if (!func_setUnitOfDraw)
		{
			::FreeLibrary(hmod);
			return false;
		}

		func_setUnitOfDraw(bMeter);
		return true;
	}
}

bool _docGetPScale(double &dRet)
{
	dRet = (g_nDefaultScale*_UNIT_SCALE);
	int nTileMode = 0, cvport = 0;
	if (TGGetVar(_T("TILEMODE"), &nTileMode) == RTNORM && nTileMode == 0
		&& TGGetVar(_T("CVPORT"), &cvport) == RTNORM && cvport == 1)
	{
		dRet = 1.;
		return true; //PAPERSPACE
	}

	XString sIni;
	if (FindFile(_T("ZT_config.ini"), sIni))
	{
		std::map<CString, CString> data;
		getSectionContent(sIni, _T("zt_setting"), data);
		std::map<CString, CString>::const_iterator it(data.find(_T("PScale")));
		if (it != data.end())
		{
			dRet = _ttof(it->second);
			return true;
		}
	}

	return false;
}

bool _docSetPScale(const double &d)
{
	XString sIni;
	double dRet(g_nDefaultScale*_UNIT_SCALE);
	if (FindFile(_T("ZT_config.ini"), sIni))
	{
		std::map<CString, CString> data;
		getSectionContent(sIni, _T("zt_setting"), data);
		std::map<CString, CString>::iterator it(data.find(_T("PScale")));
		if (it != data.end())
		{
			it->second.Format(_T("%g"), d);
			setSectionContent(sIni, _T("zt_setting"), data);
			g_nDefaultScale = d;
			return true;
		}
	}
	return false;
}

bool _docGetMeterUnitDraw(BOOL &bMeter)
{
	bMeter = getMeterUnitDraw();
	return true;

	XString sIni;
	if (FindFile(_T("ZT_config.ini"), sIni))
	{
		std::map<CString, CString> data;
		getSectionContent(sIni, _T("zt_setting"), data);
		std::map<CString, CString>::const_iterator it(data.find(_T("MeterUnitDraw")));
		if (it != data.end())
		{
			bMeter = _ttoi(it->second) == 0 ? FALSE : TRUE;
			return true;
		}
	}

	return false;
}

bool _docSetMeterUnitDraw(const BOOL &bMeter)
{
	return setMeterUnitDraw(bMeter);

	XString sIni;
	if (FindFile(_T("ZT_config.ini"), sIni))
	{
		std::map<CString, CString> data;
		getSectionContent(sIni, _T("zt_setting"), data);
		std::map<CString, CString>::iterator it(data.find(_T("MeterUnitDraw")));
		if (it != data.end())
		{
			it->second.Format(_T("%d"), bMeter == FALSE ? 0 : 1);
			setSectionContent(sIni, _T("zt_setting"), data);
			return true;
		}
	}
	return false;
}

double DocGetPScale()
{
	
	double dRet(g_nDefaultScale*_UNIT_SCALE);
	if (_docGetPScale(dRet))
	{
		return dRet;
	}

	int nTileMode = 0, cvport = 0;
	if (TGGetVar(_T("TILEMODE"), &nTileMode) == RTNORM && nTileMode == 0 
		&& TGGetVar(_T("CVPORT"), &cvport) == RTNORM && cvport == 1)
	{
		return 1.0; //PAPERSPACE
	}

	TDbConfig *p = GetDwgGlobal(AcDb::kForRead, g_pCurrentDb);

	dRet = (p ? p->GetPScale() : g_nDefaultScale*_UNIT_SCALE);

	if (p)
	{
		p->close();
	}
}

TPickEntSet & DocGetPickFirst()
{
	TArchPerDocData *p = GetCurDocData();
	ASSERT(p);
	if (p != NULL)
	{
		return p->m_ssPickFirst;
	}
	else
	{
		static TPickEntSet ssInvalid;
		return ssInvalid;
	}
}

TEntitySet& DocGetEntMouseOn()
{
	TArchPerDocData *p = GetCurDocData();
	ASSERT(p);
	if (p != NULL)
	{
		return p->m_entMouseOn;
	}
	else
	{
		static TEntitySet entInvalid;
		return entInvalid;
	}
}

TPickEntSet & DocGetPickGrip()
{
	TArchPerDocData *p = GetCurDocData();
	ASSERT(p); 
	if (p != NULL)
	{
		return p->m_ssPickGrip;
	}
	else
	{
		static TPickEntSet ssInvalid;
		return ssInvalid;
	}
}

void ClearKeyboardBuffer()
{
	TArchPerDocData * pDocDat = GetCurDocData();
	if (pDocDat != NULL)
	{
		pDocDat->m_szCommandStr[0] = EOS;
		pDocDat->m_nPos = 0;
	}
}

bool IsLispExpress()
{
	TArchPerDocData * pDocDat = GetCurDocData();
	if (pDocDat != NULL)
	{
		return pDocDat->m_szCommandStr[0] == _T('(');
	}
	return false;
}

TArchPerDocData * GetCurDocData()
{
	if (!TArchDocReactor::g_pTArchAppDocGlobals)
	{
		return NULL;
	}

	TArchPerDocData *pData = TArchDocReactor::g_pTArchAppDocGlobals->FindNode(curDoc(), TArchPerDocData::CompareForFind);
	return pData;
}


int SelectUpFace(AcGePlane &plane)
{
	TEntitySet ent;
	TADSGePoint3d pt;
	if (ent.FilterSelect1(GetApertureWcs(), _T("\n请选择三维坡屋顶坡面<退出>:"), TRBList(), pt) != RTNORM)
	{
        return RTERROR;
	}
	BOOL bUp = TRUE;
	if (ent.Is(_T("3DFACE")) || ent.Is(_T("POLYLINE")))
	{
		bUp = FALSE;
	}
    pt = Ucs2Wcs(pt);
    AcDbVoidPtrArray entSet;
	int nDrawMode = DocGetDrawMode();
	DocSetDrawMode(DRAW_3D);
    OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
    InitModel(TMasterProperties(), pEnt, NULL, entSet);
    OPENOBJ_END();
	DocSetDrawMode(nDrawMode);
    
    int num = entSet.length();
    for (int i = 0; i<num; i++)  
	{
        AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
        ASSERT(pEnt);
        if (pEnt->isA() == AcDbFace::desc())  
		{
            AcDbFace *pFace = AcDbFace::cast(pEnt);
            int nHitFlag = HitTestOnEdge(pFace, pt, TRUE);
            if (nHitFlag >= 0) 
			{
                TGGe3DFace faceUcs, faceWcs;
                for (int n = 0; n<4; n++) 
				{
                    pFace->getVertexAt(n, faceWcs.GetVertex(n));
                }
				TVector3D vtNorm = faceWcs.GetNormal();
				if (vtNorm.z < 1.0E-9 && bUp)
				{
					continue; //法向不正确
				}
				for (n = 0; n<4; n++)
				{
					faceUcs.SetVertex(n, Wcs2Ucs(faceWcs.GetVertex(n)));
				}

                if (faceUcs.IsLinear() || faceUcs.IsPoint())
				{
                    continue;
				}
                TGGiScreenDrawStream dc(7, 1);
                dc << faceUcs;
                int nCode = YesNoQuestion(_T("\n是否为加亮的坡面"));
                ads_redraw(NULL,0);
                if (nCode == RTCAN)
				{
                    return nCode;
				}
                else if (nCode == Q_YES)
				{
					if (vtNorm.z<1.0E-9)
					{
						plane.set((AcGePoint3d &)faceWcs.GetVertex(2), 
								  (AcGePoint3d &)faceWcs.GetVertex(1), 
								  (AcGePoint3d &)faceWcs.GetVertex(0));
					}
					else
					{
						plane.set((AcGePoint3d &)faceWcs.GetVertex(0), 
								  (AcGePoint3d &)faceWcs.GetVertex(1), 
								  (AcGePoint3d &)faceWcs.GetVertex(2));
					}
                   return RTNORM;
                }
            }
        }
    }
    ReleaseEntSet(entSet);
    ads_retnil();
	return RTNONE;
}

void InitDLRegistry(HMODULE modHandle,   const TCHAR *szAppName0)	//应用程序名(可为任意字符))
{
	// 检查HKEY_LOCAL_MACHINE是否有写操作权限
	HKEY hKey = NULL;
	if (ERROR_SUCCESS !=  RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Autodesk\\AutoCAD"), 0, KEY_WRITE, &hKey))
	{
		return;
	}
	RegCloseKey(hKey);

	if (g_nProductId == kTSUN)
	{
		return;
	}
    TCString sAppName;
    sAppName << _T("T8") << g_nProductId << szAppName0;
    TCHAR szAppName[256] = _T("");
    _tcscpy(szAppName, sAppName);
#if (ADS<16)
	CString strAppInfoLoc,strAppLoc;
	strAppInfoLoc = GetRegLocation();
	strAppInfoLoc = strAppInfoLoc+_T("\\TchApps");

    acrxRegisterApp((AcadApp::LoadReasons)(AcadApp::kOnCommandInvocation| AcadApp::kOnLoadRequest), szAppName, strAppInfoLoc, 2);
	CString strThisAppInfoLoc = strAppInfoLoc+_T("\\")+szAppName;
	//Name...................................................
	{
		TRegProperty regProp(strThisAppInfoLoc,_T("Name"));
		regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
		regProp.SetValue(szAppName,szAppName);
	}
	//Loader.................................................
	{
		TCHAR modulePath[512];
		DWORD pathLength = GetModuleFileName(modHandle, modulePath, 512);
		if (pathLength == 0)
		{
			assert(FALSE);
			return ;
		}
		TRegProperty regProp(strThisAppInfoLoc, _T("Loader"));
		regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
		regProp.SetValue(_T("MODULE"),modulePath);
	}
#else
	// sg modify 120228，自R19平台起，API进行了调整，下面的函数作废了
    //const TCHAR *pszRegAcad=acrxProductKey();
    const TCHAR *pszRegAcad=NULL;
#if (ADS > 18)
	pszRegAcad = acdbHostApplicationServices()->getMachineRegistryProductRootKey();
#else
	pszRegAcad = acrxProductKey();
#endif

	acrxRegisterApp((AcadApp::LoadReasons)(AcadApp::kOnCommandInvocation| AcadApp::kOnLoadRequest), szAppName);
	TCString strThisAppInfoLoc;
	strThisAppInfoLoc << pszRegAcad << _T("\\Applications");
	//Loader.................................................
	{
		TCHAR modulePath[512];
		DWORD pathLength = GetModuleFileName(modHandle, modulePath, 512);
		if (pathLength == 0)
		{
			assert(FALSE);
			return ;
		}
		TRegProperty regProp(strThisAppInfoLoc,  szAppName);
		regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
		regProp.SetValue(_T("Description"), szAppName0);
		regProp.SetValue(_T("Loader"), modulePath);
	}

#endif
    { // Commands
	    HKEY hKey;
        if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, strThisAppInfoLoc, 0L,KEY_ALL_ACCESS,&hKey) == ERROR_SUCCESS) 
		{
	         if (RegDeleteKey(hKey, _T("Commands")) != ERROR_SUCCESS)
			 {
                 ;
			 }

#if (ADS>15)
	         if (RegDeleteKey(hKey, _T("TGroups")) != ERROR_SUCCESS)
			 {
                 ;	
			 }
#endif
             RegCloseKey(hKey);
        }
    }
}

//const TCHAR *pszCustObjInfo)	//自定义实体的应用程序名列表(如果不需要监测到自定义实体时加载,可为NULL)
void UpdateDLRegistry(const TCHAR *szAppName0, const STArxCommandTable cmdTable[], const UINT eleNum)
{
	// 检查HKEY_LOCAL_MACHINE是否有写操作权限
	HKEY hKey = NULL;
	if (ERROR_SUCCESS !=  RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Autodesk\\AutoCAD"), 0, KEY_WRITE, &hKey))
	{
		return;
	}
	RegCloseKey(hKey);

	if (g_nProductId == kTSUN)
	{
		return;
	}

    TCString sAppName;
    sAppName << _T("T8") << g_nProductId << szAppName0;
    TCHAR szAppName[256] = _T("");
    _tcscpy(szAppName, sAppName);

	CString strAppInfoLoc;
#if (ADS>15)
	// sg modify 120228，自R19平台起，API进行了调整，下面的函数作废了
    //const TCHAR *pszRegAcad=acrxProductKey();
    const TCHAR *pszRegAcad=NULL;
#if (ADS > 18)
	pszRegAcad = acdbHostApplicationServices()->getMachineRegistryProductRootKey();
#else
	pszRegAcad = acrxProductKey();
#endif
	strAppInfoLoc += pszRegAcad;
	strAppInfoLoc += _T("\\Applications\\");
	strAppInfoLoc += szAppName;
	CString strThisAppInfoLoc = strAppInfoLoc;
#else
	strAppInfoLoc = GetRegLocation();
	strAppInfoLoc = strAppInfoLoc+_T("\\TchApps");
	CString strThisAppInfoLoc = strAppInfoLoc+_T("\\")+szAppName;
#endif

	//Command................................................
	{
    	TRegProperty regProp(strThisAppInfoLoc, _T("Commands"));
		regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
		for (UINT i = 0; i<eleNum; i++)
		{
            TCString sCmd = GetFullCmdName(cmdTable[i].szCmdGlobal);
			regProp.SetValue((const TCHAR *)sCmd,(const TCHAR *)sCmd);
		}
	}

#if (ADS>15)
	// Group
	{
    	TRegProperty regProp(strThisAppInfoLoc, _T("TGroups"));
		regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
		regProp.SetValue(szAppName0, szAppName0);
	}
#endif

}

void UpdateDLRegistry(const TCHAR *szAppName0, const STExtern_fun cmdTable[],	const UINT eleNum)
{
	// 检查HKEY_LOCAL_MACHINE是否有写操作权限
	HKEY hKey = NULL;
	if (ERROR_SUCCESS !=  RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Autodesk\\AutoCAD"), 0, KEY_WRITE, &hKey))
	{
		return;
	}
	RegCloseKey(hKey);

	if (g_nProductId == kTSUN)
	{
		return;
	}

    TCString sAppName;
    sAppName << _T("T8") << g_nProductId << szAppName0;
    TCHAR szAppName[256] = _T("");
    _tcscpy(szAppName, sAppName);

	CString strAppInfoLoc;
#if (ADS>15)
	// sg modify 120228，自R19平台起，API进行了调整，下面的函数作废了
    //const TCHAR *pszRegAcad=acrxProductKey();
    const TCHAR *pszRegAcad=NULL;
#if (ADS > 18)
	pszRegAcad = acdbHostApplicationServices()->getMachineRegistryProductRootKey();
#else
	pszRegAcad = acrxProductKey();
#endif
	strAppInfoLoc += pszRegAcad;
	strAppInfoLoc += _T("\\Applications\\");
	strAppInfoLoc += szAppName;
	CString strThisAppInfoLoc = strAppInfoLoc;
#else
	strAppInfoLoc = GetRegLocation();
	strAppInfoLoc = strAppInfoLoc+_T("\\TchApps");
	CString strThisAppInfoLoc = strAppInfoLoc+_T("\\")+szAppName;
#endif
	//Command................................................
	{
		TRegProperty regProp(strThisAppInfoLoc, _T("Commands"));
		regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
		for (UINT i = 0; i<eleNum; i++) 
		{
            TCString sCommand;
            sCommand = cmdTable[i].cmdname;
            if (sCommand[1] == _T(':'))
			{
				TCString sCmd = GetFullCmdName(&sCommand[2]);
			    regProp.SetValue(sCmd, (const TCHAR *)sCmd);
			}
		}
	}
#if (ADS>15)
	// Group
	{
    	TRegProperty regProp(strThisAppInfoLoc, _T("TGroups"));
		regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
		regProp.SetValue(szAppName0, szAppName0);
	}
#endif
}

void DocStatus()
{
	Refresh_DIST_SNAP();
	
	int nFlag = GetCustomFlag();
	if (!(nFlag&CUSTOM_NO_STATUS)) 
	{
		if (!g_nRunMode) 
		{
			TCString sStatus;
			sStatus << _T("比例 1:") << DocGetPScale();
			
			TPickEntSet ss(SS_FREE); //本次加亮的全部对象
			if (ss.Get(_T("I"),NULL,NULL,TRBList(RTDXF0,_T("TCH_*"),NULL)) == RTNORM) 
			{
				double nScale = -1;
				long len = ss.Length();
				for (long i = 0;i<len;i++)
				{
					TEntitySet ent = ss[i];
					OPENOBJ_BEGIN(ent,AcDb::kForRead,AcDbEntity,pEnt)
					if (pEnt != NULL)
					{
						TEntityBase *pEntBase = TEntityBase::Cast(pEnt);
						if (pEntBase != NULL)
						{
							double nScale1 = pEntBase->GetPScale();
							if (nScale<0)
							{
								nScale = nScale1;
							}
							else if (fabs(nScale-nScale1)>0.001)
							{
								break;
							}
						}
					}
					OPENOBJ_END()
				}
				TCString sTemp;
				if (i == len&&nScale>0)
				{
					sTemp << _T("比例 1:") << nScale;
					sStatus = sTemp;
				}
				else if (i<len)
				{
					sTemp << _T("比例 1:***");
					sStatus = sTemp;
				}
			}
			
#if ADS<16
			TGSetVar(_T("MODEMACRO"), sStatus);
#else 
			AcApStatusBar *pBar = acedGetApplicationStatusBar();
			if (pBar) 
			{
				AcPane *pPane = pBar->GetPane(0);
				if (pPane != NULL)
				{
					pPane->SetVisible(TRUE);
					pPane->SetText((const TCHAR*)sStatus);
					pBar->Update();
				}
			}
#endif 
		} 
		else 
		{
#if ADS<16
			TGSetVar(_T("MODEMACRO"), _T(""));
#else 
			AcApStatusBar *pBar = acedGetApplicationStatusBar();
			if (pBar) 
			{
				AcPane *pPane = pBar->GetPane(0);
				if (pPane != NULL)
				{
					pPane->SetVisible(FALSE);
					pPane->SetText(_T(""));
					pBar->Update();
				}
			}
#endif 
		}
	}
}


int GetBlockBoundary(AcDbObjectId idBlock, TGGePoly2D &poly, BOOL bAddIfNone)
{
	int nRet = RTNONE;
	OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	if (!pBlock)
	{
		return RTERROR;
	}
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = pBlock->newIterator(pBlockIterator);
	ASSERT(es == Acad::eOk && !!pBlockIterator);
	for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step()) 
	{
		AcDbEntity *pEntity;
		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
		ASSERT(es == Acad::eOk);
		TAcDbObjectPtr obj(pEntity);
				
		if (!pEntity->isKindOf(AcDbPolyline::desc()))
		{
			continue;
		}
		
		AcDbPolyline *pline = AcDbPolyline::cast(pEntity);
		ASSERT(pline);
		TCHAR *pszLayer = pEntity->layer();
		ASSERT(pszLayer);
		TCString szPattern(256);
		szPattern << LAY_BOUNDARY << _T(",*|") << LAY_BOUNDARY;
		if (pline->isClosed() && ads_wcmatch(pszLayer, szPattern) == RTNORM) 
		{
			PolyConvert(*pline, poly);
			delete [] pszLayer;
			delete pBlockIterator;
			return RTNORM;
		}
		delete [] pszLayer;
	}
	delete pBlockIterator;
	
	if (bAddIfNone) 
	{
		TDPtrList<TGGeCurveSegment> lstSegs;
		ads_matrix matIdent;
		TGGePoly2D polyOutline(1);
		AsAdsMatrix(AcGeMatrix3d::kIdentity, matIdent);
		Get2DCurveFromBlock(*pBlock, matIdent, lstSegs);
		if (GetExternalBoundaryFromCurves(lstSegs, polyOutline) == RTNORM) 
		{
			if (pBlock->upgradeOpen() == Acad::eOk) 
			{
				AcDbPolyline *pBound = new AcDbPolyline;
				PolyConvert(polyOutline, *pBound);
				AcDbObjectId idLay = InitLayer(LAY_BOUNDARY, FALSE);
				arxAssureLayer(LAY_BOUNDARY, LAYSTAT_FREEZE);
				pBound->setLayer(idLay);
				VERIFY(pBlock->appendAcDbEntity(pBound) == Acad::eOk);
				pBound->close();
				pBlock->downgradeOpen();
				poly = polyOutline;
				nRet = RTNORM;
			}
		}
	}
	OPENOBJ_END();
	
	return nRet;
}

// 取得点ptCen附近并在ptLow,ptUp内部的轴线交点
BOOL GetAxisInter(const TADSGePoint3d& ptLow, const TADSGePoint3d& ptUp, TADSGePointDir2d& ptRes)
{
	TADSGePoint3d ptCen;
	Midpoint(ptLow, ptUp, ptCen);
	TPickEntSet ssAxis(SS_FREE), ss1(SS_FREE), ss2(SS_FREE);
	BOOL bNearAxis1 = (GetSafeSelection(ss1, FALSE, ptLow, ptUp, AcDbLine::desc()) == Acad::eOk);
	BOOL bNearAxis2 = (GetSafeSelection(ss2, FALSE, ptLow, ptUp, AcDbArc::desc()) == Acad::eOk);
	BOOL bNearAxis = (bNearAxis1 || bNearAxis2);
	ssAxis += ss1;
	ssAxis += ss2;
	if (bNearAxis) 
	{
		ssAxis.BaseFilter(TRBList(8, LAY_AXIS, NULL));
		bNearAxis = (ssAxis.Length() == 2);
	}
	if (!bNearAxis)
	{
		return FALSE;
	}
	
	BOOL bRes = FALSE;
	TEntitySet eAxis1 = ssAxis[0L];
	TEntitySet eAxis2 = ssAxis[1L];
	TGGeCurveSegment cv1(eAxis1, LS_FINITE), cv2(eAxis2, LS_FINITE);
	TADSGePoint3d ptInt[2];
	int nIntNum = cv1.Intersection(cv2, ptInt[0], ptInt[1]);
	if (!nIntNum)
	{
		return FALSE;
	}
	if (nIntNum == 1)
	{
		(TADSGePoint3d &)ptRes = ptInt[0];
	}
	else
	{
		(TADSGePoint3d &)ptRes = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ptCen);
	}
	
	ptRes.nDirection = GetXDirection(cv1, cv2,ptRes);
	return TRUE;
}


// 选择墙的一侧
// loc(OUT) -- 墙面上的位置
// drt(OUT) -- 墙面的切向(法向+PI/2.0)
int SelectWallSide(TEntitySet &entWall, TADSGePoint3d & loc, double *drt)
{
	int nOldOsnap = g_nOsnapType;
	DocSetWallOsnapType(1);
	TEntitySet ent;
	TRBList mask(RTDXF0, _T("ATS_WALL,ATS_CURTAIN_WALL"), NULL);
	TADSGePoint3d ptPick;
	int nRetCode = RTNORM;
	if ((nRetCode = SelectEntity1(_T("\n请点取墙体一侧<退出>: "), ent, ptPick, mask)) != RTNORM) 
	{
		DocSetWallOsnapType(nOldOsnap);
		return nRetCode;
	}
	DocSetWallOsnapType(nOldOsnap);
	ptPick = Ucs2Wcs(ptPick);
	
	TAcDbObjectPtr obj(ent, AcDb::kForWrite);
	if (!obj)
	{
		return RTERROR;
	}
	TDbWall *pWall = TDbWall::cast(obj.m_pObject);
	if (!pWall)
	{
		return RTERROR;
	}
	
	TDbWall &wall = *pWall;
	
	TGGeCurveSegment lCurve, rCurve, selCurve;
	wall.GetSideCurve(lCurve, rCurve);
	TADSGePoint3d ptLeft, ptRight; //在左右两侧的投影
	if (lCurve.ProjectToMe(ptPick, ptLeft) != RTNORM ||
		rCurve.ProjectToMe(ptPick, ptRight) != RTNORM)
	{
		return RTERROR;
	}
	
	if (ptPick.Distance(ptLeft) < ptPick.Distance(ptRight))
		
	{
		selCurve = lCurve;
	}
	else
	{
		selCurve = rCurve;
	}
	
	TGGeCurveSegment segCen = wall.OffsetGeomCenter();
	TADSGePoint3d ptOnCen, ptOnSide;
	if (segCen.ProjectToMe(ptPick, ptOnCen) != RTNORM ||
		selCurve.ProjectToMe(ptPick, ptOnSide) != RTNORM) 
	{
		TchGeLib::adsout << _T("\n请正确点取!");
		return RTERROR;
	}
	double nOrthDrt = ads_angle(ptOnCen, ptOnSide);
	*drt = AngleRangeTo2PI(nOrthDrt+PI/2.0);
	loc = ptOnSide;
	entWall = ent;
	return RTNORM;
}

int EditWallPathc0(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWallPatch, pPatch);
	if (!pPatch)
	{
		return RTERROR;
	}
	double nElev = pPatch->GetElevation();
	double nHeight = pPatch->GetHeight();
	TchGeLib::adsout << _T("\n请输入墙体造型的高度或 [底标高(E)]<") << Dist2Str(nHeight) << _T(">:");
	int nRet;
	INITGET_BEG(RSG_NONEG, _T("E"));
	nRet = ads_getreal(_T(""), &nHeight);
	INITGET_END();
	if (nRet == RTNORM) 
	{
		if (pPatch->upgradeOpen() == Acad::eOk) 
		{
			pPatch->SetHeight(nHeight);
			pPatch->downgradeOpen();
		}
	} 
	else if (nRet == RTKWORD) 
	{
		if (GetReal(_T("\n墙体造型底标高"), nElev) == RTNORM) 
		{
			if (pPatch->upgradeOpen() == Acad::eOk)
			{
				pPatch->SetElevation(nElev);
				pPatch->downgradeOpen();
			}
		}			
	}
	OPENOBJ_END();
	return RTNORM;
}

// 产生内轮廓线
int GenSpacePoly(const TADSGePoint3d &ptPick, TGGePoly2D &poly)
{
   return GenSpaceOutline(ptPick, poly, 0);
}


//选单个实体,优先从全局选择集中筛选
int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, const TRBList &rbBaseMask)
{
    if (!g_ssPickFirst || g_ssPickFirst.Length() != 1L) 
	{
        TEntitySet ent;
        int nRet = RTERROR;
        nRet = ent.FilterSelect(szPrompt, rbBaseMask);
        if (nRet == RTNORM)
		{
            entResult = ent;
		}
        return nRet;
    }
	else
	{
        ads_sssetfirst(NULL, NULL);

        TEntitySet ent = g_ssPickFirst[0L];
        ent.GetGroups(0);
        if (ent.MatchBase(rbBaseMask)) 
		{
            entResult = ent;
            g_ssPickFirst.Free();
            return RTNORM;
        }
		else
		{
            int nRet = ent.FilterSelect(szPrompt, rbBaseMask);
            if (nRet == RTNORM)
			{
                entResult = ent;
			}
            return nRet;
        }
    }
    return RTERROR;
}

//  选单个实体,优先从全局选择集中筛选, ptPick--UCS
int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask)
{
    g_ssPickFirst.Free();
    TEntitySet ent;
    int nRet = RTERROR;
    nRet = ent.FilterSelect(szPrompt, rbBaseMask, ptPick);
    if (nRet == RTNORM) 
	{
        entResult = ent;
    }
    return nRet;
}

//  选单个实体,优先从全局选择集中筛选
int SelectEntity1(const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask)
{
    g_ssPickFirst.Free();
    TEntitySet ent;
    int nRet = RTERROR;
    nRet = ent.FilterSelect1(GetPickBoxWcs()/2, szPrompt, rbBaseMask, ptPick);
    if (nRet == RTNORM)
	{
        entResult = ent;
	}
    return nRet;
}

//  选单个实体,优先从全局选择集中筛选
int SelectEntity1(double nPrec, const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask)
{
    g_ssPickFirst.Free();
    TEntitySet ent;
    int nRet = RTERROR;
    nRet = ent.FilterSelect1(nPrec, szPrompt, rbBaseMask, ptPick);
    if (nRet == RTNORM)
	{
        entResult = ent;
	}
    return nRet;
}

//选多个实体，优先从全局选择集中筛选
int SelectEntities(const TCHAR *szPrompt, TPickEntSet &ssResult, const TRBList &rbBaseMask)
{
    TPickEntSet ssPickFirst(SS_FREE|SS_CREATE);
    if (!!g_ssPickFirst)
	{
		ssPickFirst += g_ssPickFirst;
	}
    ssPickFirst.BaseFilter(rbBaseMask);

   int nRetCode = RTNORM;
   int nCount = ssPickFirst.Length();
   if (!ssPickFirst || !ssPickFirst.Length()) 
   {
       const TCHAR *szPrompts[2] = { szPrompt, _T("移除物体") };
       ads_sssetfirst(NULL, NULL);
       nRetCode = ssResult.Get(_T(":$"), szPrompts,NULL,rbBaseMask);
   }
   else 
   {
       ads_sssetfirst(NULL, NULL);
	   g_ssPickFirst.Free();
       ssResult += ssPickFirst;
   }
   return nRetCode;
}


int SelectEntities(const TCHAR *szPrompt, TPickEntSet &ssResult, const TRBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
{
	int nRet;
	INITGET_BEG(-2,szKeyword)
	nRet = SelectEntities(szPrompt, ssResult, rbBaseMask);
	INITGET_END();
	if (g_cKeyword != 0)
	{
		cRet = g_cKeyword;
		ssResult.Free();
		return RTKWORD;
	}
	return nRet;
}

int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
{
	int nRet;
	INITGET_BEG(-2,szKeyword)
	nRet = SelectEntity(szPrompt, entResult,ptPick, rbBaseMask);
	INITGET_END();
	if (g_cKeyword != 0)
	{
		cRet = g_cKeyword;
		return RTKWORD;
	}
	return nRet;
}

int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, const TRBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
{
	int nRet;
	INITGET_BEG(-2,szKeyword)
	nRet = SelectEntity(szPrompt, entResult,rbBaseMask);
	INITGET_END();
	if (g_cKeyword != 0)
	{
		cRet = g_cKeyword;
		return RTKWORD;
	}
	return nRet;
}

int GetPrepickEntity(TEntitySet &entResult, const TRBList &rbBaseMask)
{
    if (!!g_ssPickFirst) 
	{
        TPickEntSet ss(SS_FREE|SS_CREATE);
        ss += g_ssPickFirst;
        ss.BaseFilter(rbBaseMask);
        if (ss.Length() == 1) 
		{
            entResult = g_ssPickFirst[0L];
            return RTNORM;
        }
    }
    return RTERROR;
}

AcDbObjectId GetPrepickEntity(const TRBList &rbBaseMask)
{
	AcDbObjectId idRet;
	TEntitySet ent;
	if (GetPrepickEntity(ent, rbBaseMask) == RTNORM)
	{
		acdbGetObjectId(idRet, ent);
	}
	return idRet;
}


TCString GetFullCmdName(const TCHAR *szName)
{
    TCString szCmd;
	//2012-12-12 LH 根据上华公司沈睿副总经理要求去除上华命令前缀功能 即TXX_Name 去除前缀TXX_
	//if (TRUE)
	if(FALSE)
	{
		szCmd << _T("T9") << g_nProductId << _T("_") << szName;
	} 
	else 
	{
		szCmd = szName;
	}
    return szCmd;
}

void TchAddCommand(const TCHAR *szAppName0,const STArxCommandTable cmdTable[], const UINT eleNum, BOOL bLispCmd)
{
	if (TchGeLib::g_nProtectCode == 0)//表面加密：不加载命令
	{
		return;
	}
    int num = (int)eleNum;
    for (int i = 0; i<num; i++) 
	{
        TCString szCmd = GetFullCmdName(cmdTable[i].szCmdGlobal);
        Acad::ErrorStatus es = acedRegCmds->addCommand(szAppName0, szCmd, szCmd, cmdTable[i].nCmdFlag,
			cmdTable[i].pFun, NULL, (bLispCmd ? i :-1));
        ASSERT(es == Acad::eOk);
    }
}

// 得一个面的参数
int GetFace()
{
	TEntitySet	ent;
	TADSGePoint3d pt;
	if(ent.FilterSelect1(GetApertureWcs(), _T("\n请选择三维坡屋顶坡面<退出>:"), 
        TRBList(), pt)!=RTNORM)
	{
		return RTERROR;
	}
    pt = Ucs2Wcs(pt);
	
    AcDbVoidPtrArray entSet;
	int nDrawMode = DocGetDrawMode();
	DocSetDrawMode(DRAW_3D);
    OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
    InitModel(TMasterProperties(), pEnt, NULL, entSet);
    OPENOBJ_END();
	DocSetDrawMode(nDrawMode);
    
    int num = entSet.length();
    for (int i = 0; i < num; i++)  
	{
        AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
        ASSERT(pEnt);
        if (pEnt->isA() == AcDbFace::desc())
		{
            AcDbFace *pFace = AcDbFace::cast(pEnt);
            int nHitFlag = HitTestOnEdge(pFace, pt, TRUE);
            if (nHitFlag >= 0)
			{
                TGGe3DFace faceUcs, faceWcs;
				AcGePoint3d ptVert;
                for (int n = 0; n < 4; n++) 
				{
                    pFace->getVertexAt(n, ptVert);
                    faceUcs.SetVertex(n, Wcs2Ucs(ptVert));
                }
				
				TVector3D vtNorm = faceWcs.GetNormal();
				if (vtNorm.z < 1.0E-9)
				{
					continue; //法向不正确
				}
                
				if (faceUcs.IsLinear() || faceUcs.IsPoint())
                {
					continue;
				}
				
                TGGiScreenDrawStream dc(7, 1);
                dc << faceUcs;
                
				int nCode = YesNoQuestion(_T("\n是否为加亮的坡面"));
                ads_redraw(NULL,0);
                
				if (nCode == RTCAN) 
				{
					ReleaseEntSet(entSet);
                    return nCode;
				}
                else if (nCode == Q_YES) 
				{
					TADSGePoint3d ptIns;
					if (GetPickPoint(NULL, _T("\n位置点"), ptIns) != RTNORM) 
					{
						ReleaseEntSet(entSet);
						return RTCAN;
					}
					
					for (int n = 0; n < 4; n++) 
					{
						faceUcs.SetVertex(n, Ucs2Wcs(faceUcs.GetVertex(n)));
					}
                    
					for (n = 0; n < 4; n++) 
					{
						int nNext = DePeriod(4, n+1);
						TGGeLine aLine(faceUcs.GetVertex(n), faceUcs.GetVertex(nNext));
						if (aLine.GetLength() < _DIST_SNAP)
						{
							switch(nNext)
							{
							case 0:
								break; // Just ignore vertex[3]
							case 1:
                                faceUcs.SetVertex(1, faceUcs.GetVertex(2));
                                faceUcs.SetVertex(2, faceUcs.GetVertex(3));
                                break;
							case 2:
                                faceUcs.SetVertex(2, faceUcs.GetVertex(3));
                                break;
							}
							break;
						}
					}
					TADSGePoint3d ptInsert = ptIns;
					TADSGePoint3d ptUp = ptInsert + TADSGePoint3d(0,0,100);
					AcGeLine3d ln((AcGePoint3d &)ptInsert, (AcGePoint3d &)ptUp);
					AcGePlane plane;
					plane.set((AcGePoint3d &)faceUcs.GetVertex(0), 
						(AcGePoint3d &)faceUcs.GetVertex(1), 
						(AcGePoint3d &)faceUcs.GetVertex(2));
					
					if (!plane.intersectWith(ln, ptInsert)) 
					{
						ReleaseEntSet(entSet);
						return RTERROR;
					}
					
					TRBList rbRet = ads_buildlist(RT3DPOINT, &ptInsert, RTLB, RT3DPOINT, &faceUcs.GetVertex(0),
						RT3DPOINT, &faceUcs.GetVertex(1),
						RT3DPOINT, &faceUcs.GetVertex(2),
						RT3DPOINT, &faceUcs.GetVertex(0),
						RTLE, NULL);
					ads_retlist(rbRet);
					ReleaseEntSet(entSet);
					return RTNORM;
                }
            }
        }
    }
	
    ReleaseEntSet(entSet);
    ads_retnil();
	return RTNONE;
}

int TGRegApp(LPCTSTR pszAppName, AcDbDatabase* pDb)
{
	ASSERT(NULL != pszAppName && 0 < _tcslen(pszAppName));
	
	if (NULL == pDb)
	{
		return acdbRegApp(pszAppName);
	}
	
	AcDbRegAppTable* pTable = NULL;
	pDb->getRegAppTable(pTable, AcDb::kForWrite);
	if (NULL == pTable)
		return RTERROR;
	
	AcDbRegAppTableRecord* pRecord = new AcDbRegAppTableRecord;
	if (NULL == pRecord)
	{
		pTable->close();
		return RTERROR;
	}
	
	pRecord->setName(pszAppName);
	Acad::ErrorStatus es = pTable->add(pRecord);
	pTable->close();
	if (Acad::eOk != es)
	{
		delete pRecord;
		return RTERROR;
	}
	
	pRecord->close();
	
	return RTNORM;
}

void GetOffsetPoly2D(const TGGePoly2D& polySrc, TGGePoly2D& polyOut, double dOffset, bool bZoomOut/* = ture*/ )
{
	polyOut = polySrc;

	AcDbCurve *pCurve = NULL;
	pCurve = polySrc.AsAcDbCurve();

	if (!bZoomOut)
	{
		dOffset *= -1.0;
	}

	double dOldLen = 0.0;
	double dEndT = 0.0;
	pCurve->getEndParam(dEndT);
	pCurve->getDistAtParam(dEndT,dOldLen);

	AcDbVoidPtrArray offsetCurves;
	pCurve->getOffsetCurves(dOffset,offsetCurves);
	if (offsetCurves.length() > 0)
	{
		AcDbPolyline *pPline = (AcDbPolyline*)offsetCurves[0];
		if (pPline != NULL)
		{
			double dNewLen = 0.0;
			pPline->getEndParam(dEndT);
			pPline->getDistAtParam(dEndT,dNewLen);

			if ((bZoomOut && dNewLen < dOldLen) || (!bZoomOut && dNewLen > dOldLen))
			{//如果放大，却得到了缩小的poly或者如果缩小却得到放大的poly
				offsetCurves.removeAt(0);
				pCurve->getOffsetCurves(-dOffset,offsetCurves);
				if (offsetCurves.length() > 0)
				{
					pPline = (AcDbPolyline*)offsetCurves[0];
				}
			}

			polyOut.SetAcDbCurve(pPline);
			delete pPline;
		}
	}
	delete pCurve;
}
void DrawEntInsulate(const TDPtrList<TGGeCurveSegment> &lstInsulateCurves)
{
	//单独绘制保温层标识 wlw 11.03.17
	int nSysInsutlate = 0;
	TGGetVar(_T("USERI5"), &nSysInsutlate);
	AcGePoint3d pts,pte;
	AcDbObjectId idLayer = InitLayer(LAY_SURFACE,FALSE);
	if (nSysInsutlate == 999)
	{
		AcDbLine *pline = NULL;
		for (int l = 0; l < lstInsulateCurves.Length(); l++)
		{
			pts = (lstInsulateCurves[l]).StartPoint().AsAcGePoint3d();
			pte = (lstInsulateCurves[l]).EndPoint().AsAcGePoint3d();
			pline = new AcDbLine(pts,pte);

			pline->setLayer(idLayer);
			AddToCurrentSpace(pline,Adesk::kTrue);
		}
	}
}

AcDbFace* GetFaceFromSegment(const TGGeCurveSegment& segment, double dHeight)
{
	AcDbFace* pface = NULL;
	AcGePoint3d ptArray[4];
	ptArray[0] = ptArray[1] = segment.StartPoint();
	ptArray[2] = ptArray[3] = segment.EndPoint();
	ptArray[1][2] += dHeight;
	ptArray[2][2] += dHeight;
	pface = new AcDbFace(ptArray[0],ptArray[1],ptArray[2],ptArray[3]);
	return pface;
}
#ifdef TASD
//结构用
TARCH_IMPEXP int g_nColuForce = TDbColumn::eNormal;	//底层墙柱显示工况
TARCH_IMPEXP int g_nLoadDrawMode = 0;		// 荷载显示控制
TARCH_IMPEXP int g_nLoadViewMode = 7;		// 荷载显示控制
TARCH_IMPEXP BOOL g_bDetailMode = TRUE;	// 特殊梁柱是否简图模式
TARCH_IMPEXP double g_dCLTextHeight;		//单元编号文字字高
TARCH_IMPEXP int g_nCLTextColorBeam;		//梁单元编号文字颜色
TARCH_IMPEXP int g_nCLTextColorColu;		//柱单元编号文字颜色
TARCH_IMPEXP int g_nCLTextColorWall;		//剪力墙单元编号文字颜色
TARCH_IMPEXP int g_nCLTextColorSlab;		//板单元编号文字颜色
TARCH_IMPEXP int g_nCLTextColorNode;		//节点编号文字颜色
TARCH_IMPEXP double g_dBHTextHeight;		//截面尺寸文字字高
TARCH_IMPEXP int g_nBHTextColorBeam;		//梁截面尺寸文字颜色
TARCH_IMPEXP int g_nBHTextColorColu;		//柱截面尺寸文字颜色
TARCH_IMPEXP int g_nBHTextColorWall;		//剪力墙截面尺寸文字颜色
TARCH_IMPEXP int g_nBHTextColorSlab;		//板截面尺寸文字颜色
TARCH_IMPEXP int g_nBHTextColorSlabHole;	//板洞截面尺寸文字颜色
TARCH_IMPEXP double g_dRGTextHeight;		//刚域文字字高
TARCH_IMPEXP int g_nRGTextColorBeam;		//梁刚域文字颜色
TARCH_IMPEXP int g_nRGTextColorColu;		//柱刚域文字颜色
TARCH_IMPEXP int g_nGraph = FORCE_NORMAL;// 显示的力图的种类
TARCH_IMPEXP double g_dMGrapTextH = 5;		// 弯矩包络图文字高
TARCH_IMPEXP double g_dMGrapScal = 10;		// 弯矩包络图比例
TARCH_IMPEXP double g_dNGrapTextH = 3;		// 轴力文字高度
TARCH_IMPEXP double g_dReinbarWidth = 30.0f;//钢筋线宽
TARCH_IMPEXP double g_dReinbarLenS = 100.0f;//钢筋直钩平直长度
TARCH_IMPEXP double g_dReinbarLenO = 100.0f;//钢筋斜钩平直长度
TARCH_IMPEXP double g_dReinbarLenB = 100.0f;//钢筋弯钩平直长度
TARCH_IMPEXP double g_dReinbarDiaB = 45.0f;   //钢筋弯钩直径
TARCH_IMPEXP double g_dReinbarDotWidth = 50.0f;//点钢筋直径
TARCH_IMPEXP double g_dStirrupsLen = 100.0f;//箍筋平直长度

TARCH_IMPEXP int g_nDrawModeSlab = 0;		//楼板显示控制
TARCH_IMPEXP int g_nDrawModeSlabBorder = 0;//楼板边界显示控制
TARCH_IMPEXP double g_dCrackGraphTextH = 3.5;	// 字高
TARCH_IMPEXP double g_dCrackLimit      = 0.3;    // 裂缝限制值
TARCH_IMPEXP double g_dDeflectGraphTextH = 3.5;	// 字高
TARCH_IMPEXP double g_dDeflectGraphScale = 10;	// 幅度
TARCH_IMPEXP BOOL g_bShowCrack = FALSE;			// 显示裂缝图
TARCH_IMPEXP BOOL g_bShowDef = FALSE;			// 显示挠度图
TARCH_IMPEXP double g_dSGrapTextH = 5;		// 剪力包络图文字高
TARCH_IMPEXP double g_dSGrapScal = 10;		// 剪力包络图幅值
TARCH_IMPEXP BOOL g_bAutoBreak = TRUE;					//梁柱自动打断控制参数
TARCH_IMPEXP BOOL g_bAutoUpdate = TRUE;				// 自动更新图形控制参数
TARCH_IMPEXP double g_dNodeDiameter = 0.8;			// 节点直径
TARCH_IMPEXP Adesk::UInt16 g_iSolidNodeColor = 0;	// 实节点颜色
TARCH_IMPEXP Adesk::UInt16 g_iVirtualNodeColor = 0;	// 虚节点颜色
TARCH_IMPEXP int g_nReinAreaMode = eNorm;				//配筋面积显示方式
TARCH_IMPEXP int g_nReinAreaModeColu = eNorm;				//柱配筋面积显示方式
TARCH_IMPEXP int g_nReinAreaModeWall = 0;				//墙配筋面积显示方式
TARCH_IMPEXP BOOL g_bSplitFloor = TRUE;


#define WALL_BODY_CAL 0x001
#define WALL_COLU_CAL 0x002
#define WALL_BEAM_CAL 0x004
#define WALL_BODY_REAL 0x010
#define WALL_COLU_REAL 0x020
#define WALL_BEAM_REAL 0x040

BOOL GetViewStyle(int nStyle)
{
	switch(nStyle)
	{
	case BYGRAPHIC:
		return ((g_nLoadViewMode & GRAPHIC) != 0);
		break;
	case BYUNVARYING:
		return ((g_nLoadViewMode & UNVARYINGLOAD) != 0);
		break;
	case BYVARYING:
		return ((g_nLoadViewMode & VARYINGLOAD) != 0);
		break;
	}
	return FALSE;
}

void SetViewStyle(int nStyle, BOOL bTrue)
{
	if(bTrue)
	{
		switch(nStyle)
		{
		case BYGRAPHIC:
			g_nLoadViewMode |= GRAPHIC;
			break;
		case BYUNVARYING:
			g_nLoadViewMode |= UNVARYINGLOAD;
			break;
		case BYVARYING:
			g_nLoadViewMode |= VARYINGLOAD;
			break;
		}
	}
	else
	{
		switch(nStyle)
		{
		case BYGRAPHIC:
			g_nLoadViewMode &= ~GRAPHIC;
			break;
		case BYUNVARYING:
			g_nLoadViewMode &= ~UNVARYINGLOAD;
			break;
		case BYVARYING:
			g_nLoadViewMode &= ~VARYINGLOAD;
			break;
		}
	}
}
// add by wjx on 120325
// 去除小数末尾的零
// in: dDara:数据
// in: nNum:保留的小数位 -1:只去除末尾的0, 否则就是小数位(如果是整数精度没用)
CString TrimDoubleZero(double dData, int nNum)
{
	CString str;
	str.Format(_T("%f"), dData);
	str.TrimRight(_T("0"));  // 去除末尾的0
	CString strDot =  str.Right(1);
	if(_T(".") == strDot)	 // 如果末尾是小数点去除小数点
	{
		str.TrimRight(_T("."));
		return str;
	}

	if(-1 == nNum)			
	{
		return str;
	}
	else if(0 == nNum)		 // 保留整数部分
	{
		str.Format(_T("%.f"), dData);
	}
	else					// 精确到小数
	{
		int nDotPos = str.Find(_T("."));
		if(-1 == nDotPos)
		{
			return str;		// 如果小数部分都是0精确位数没用
		}
		else
		{
			int nLen = str.GetLength();
			if(nLen > (nDotPos + nNum + 1))
			{
				nLen = nDotPos + nNum + 1;
			}
			CString strDot = str.Left(nLen);
			str = strDot;
		}
	}

	return str;
}

void SetWallBodyCal(BOOL bTrue) 
{
	if (bTrue)
	{
		g_nReinAreaModeWall |=  WALL_BODY_CAL;
	}
	else
	{
		g_nReinAreaModeWall &=  ~WALL_BODY_CAL;
	}
}

BOOL IsWallBodyCal() 
{
	return ((g_nReinAreaModeWall & WALL_BODY_CAL) != 0);	
}


void SetWallBeamCal(BOOL bTrue) 
{
	if (bTrue)
	{
		g_nReinAreaModeWall |=  WALL_BEAM_CAL;
	}
	else
	{
		g_nReinAreaModeWall &=  ~WALL_BEAM_CAL;
	}
}

BOOL IsWallBeamCal() 
{
	return ((g_nReinAreaModeWall & WALL_BEAM_CAL) != 0);	
}


void SetWallColuCal(BOOL bTrue) 
{
	if (bTrue)
	{
		g_nReinAreaModeWall |=  WALL_COLU_CAL;
	}
	else
	{
		g_nReinAreaModeWall &=  ~WALL_COLU_CAL;
	}
}

BOOL IsWallColuCal() 
{
	return ((g_nReinAreaModeWall & WALL_COLU_CAL) != 0);	
}


void SetWallBodyReal(BOOL bTrue) 
{
	if (bTrue)
	{
		g_nReinAreaModeWall |=  WALL_BODY_REAL;
	}
	else
	{
		g_nReinAreaModeWall &=  ~WALL_BODY_REAL;
	}
}

BOOL IsWallBodyReal() 
{
	return ((g_nReinAreaModeWall & WALL_BODY_REAL) != 0);	
}


void SetWallBeamReal(BOOL bTrue) 
{
	if (bTrue)
	{
		g_nReinAreaModeWall |=  WALL_BEAM_REAL;
	}
	else
	{
		g_nReinAreaModeWall &=  ~WALL_BEAM_REAL;
	}
}

BOOL IsWallBeamReal() 
{
	return ((g_nReinAreaModeWall & WALL_BEAM_REAL) != 0);	
}


void SetWallColuReal(BOOL bTrue) 
{
	if (bTrue)
	{
		g_nReinAreaModeWall |=  WALL_COLU_REAL;
	}
	else
	{
		g_nReinAreaModeWall &=  ~WALL_COLU_REAL;
	}
}

BOOL IsWallColuReal() 
{
	return ((g_nReinAreaModeWall & WALL_COLU_REAL) != 0);	
}
#endif