//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TDbWallPatch.cpp
// = Version	:   ver2.0
// = Author		:   xlc
// = CreateDate	:   2002-09-09
// = Description:   墙体造型类的定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TDbWallPatch.h"
#include "TDbWall.h"
#include "TDbColumn.h"
#include "Symdef.h"
#include "TSearchRegionFromCurve.h"
#include "TGGeRegion.h"
#include "DbConfig.h"
#include "TDPtrList.h"
#include "TPushMemVar.h"
#include "wall_xdata_key.h"

// ver：1－TArch5；2－TArch6;3-TArch7;4-TArch8
const Adesk::UInt8 TDbWallPatch::g_nVersion = 4;

ACRX_DXF_DEFINE_MEMBERS(ATSWallPatch, ATSEntity, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, ATS_WALL_PATCH, "ATS_WALL_PATCH,图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");

IMPLEMENT_TENTBASE(TDbWallPatch);

extern double g_nInsulateThick;

//TDbWallPatch::TDbWallPatch(): TGGiCurveStream(), m_nUsageFlag(kUnknown), m_nElevation(0.0), m_nHeight(0.0),m_nFlag(0),m_nInsulateThick(80)
TDbWallPatch::TDbWallPatch(): TGGiCurveStream(), m_nUsageFlag(kUnknown), m_nElevation(0.0), m_nHeight(0.0),m_nFlag(0),m_nInsulateThick((int)g_nInsulateThick)
{

}

Acad::ErrorStatus TDbWallPatch::subGetClassID(CLSID* pClsid) const
{
	return Acad::eOk;
}

BOOL TDbWallPatch::IsValid() const
{
	BOOL bRet = TDbEntity::IsValid();
	if (!bRet)
	{
		return bRet;
	}

	bRet = (m_polyOutline.Length() > 1 && m_polyOutline.IsClosed() &&
			m_nHeight > -1.0E-6);

	return bRet;
}

Acad::ErrorStatus TDbWallPatch::SetPathPoly(const TGGePoly2D &polyPath,const AcGeVector3d&normal)
{
	assertWriteEnabled();
	m_polyOutline = polyPath;

	if (m_polyOutline.PathArea() > 0)
	{
		m_polyOutline.Reverse();
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbWallPatch::GetPathPoly(TGGePoly2D &polyPath,AcGeVector3d&normal) const 
{
	assertReadEnabled();
	
	polyPath = m_polyOutline;
	normal = AcGeVector3d::kZAxis;
	
	return Acad::eOk;
}

// 提供对格式刷的支持
void TDbWallPatch::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
	assertWriteEnabled();
	
	TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	
	TDbWallPatch *pSrc = TDbWallPatch::cast(pSrcEntity);
	if (pSrc) 
	{
		m_nUsageFlag = pSrc->m_nUsageFlag; 
		m_nFlag = pSrc->m_nFlag;
		m_nInsulateThick = pSrc->m_nInsulateThick;

		if (database() == NULL
			|| pSrcEntity->database() == NULL
			|| database() == pSrcEntity->database())	//add by W on 060317
		{
			m_idLayerHatch2d = pSrc->m_idLayerHatch2d;
			m_idLayerInsulate = pSrc->m_idLayerInsulate;
		}
	}
}

// 从DWG读入数据:
// 注意: 有待加入版本控制
Acad::ErrorStatus TDbWallPatch::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();

	Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	
	if (nVer > g_nVersion)
	{
		return Acad::eMakeMeProxy;
	}

	m_lstCurves.Reset();
	ReadCurveList(pFiler, m_lstCurves);

	pFiler->readItem(&m_nElevation);

	m_polyOutline.Reset();
	ReadPoly2D(pFiler, m_polyOutline);
	pFiler->readItem(&m_nHeight);  

	m_lstIdsForPatch.Reset();
	Adesk::UInt8 nPatchCount = 0;			// max 255
	pFiler->readItem(&nPatchCount);
	for (Adesk::UInt8 n = 0; n < nPatchCount; n++) 
	{
		AcDbSoftPointerId id; 
		pFiler->readItem(&id);
		m_lstIdsForPatch.Append(new AcDbSoftPointerId(id));
	}

	Adesk::UInt8 nUsage;
	pFiler->readItem(&nUsage);
	m_nUsageFlag = (UsageFlag)nUsage;
	if (nVer > 1)
	{
		pFiler->readItem(&m_idLayerHatch2d);
	}
	else 
	{
		if (database() == acdbCurDwg())
		{
			m_idLayerHatch2d = InitLayer(LAY_HATCH, FALSE);
		}
		else
		{
			m_idLayerHatch2d = GetLayerIdFromString(LAY_HATCH, database());
		}
	}

	m_lstNeighbourId.Reset();
	if (nVer > 2)						//TArch7
	{
		Adesk::UInt8 nCount = 0;		// max 255
		pFiler->readItem(&nCount);
		for (Adesk::UInt8 n = 0; n < nCount; n++) 
		{
			AcDbSoftPointerId id; 
			pFiler->readItem(&id);
			m_lstNeighbourId.Append(new AcDbSoftPointerId(id));
		}

		Adesk::UInt8 nStyle;
		pFiler->readItem(&nStyle);
		m_nStyle = (TWallPatchStyle)nStyle;

	}

	if (nVer > 3)						//TArch8
	{
		pFiler->readItem(&m_nFlag);
		pFiler->readItem(&m_nInsulateThick);
		pFiler->readItem(&m_idLayerInsulate);
	}

	return pFiler->filerStatus();
}

// 写出数据到dwg:
Acad::ErrorStatus TDbWallPatch::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	
	Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	if (g_nSaveTArchVer == 5)
	{
		pFiler->writeItem((Adesk::UInt8)1);
	}
	else if (g_nSaveTArchVer == 6)
	{
		pFiler->writeItem((Adesk::UInt8)2);
	}
	else if (g_nSaveTArchVer == 7)
	{
		pFiler->writeItem((Adesk::UInt8)3);
	}
	else
	{
		pFiler->writeItem(g_nVersion);
	}

	TchPrivate::WriteCurveList(pFiler, m_lstCurves);

	pFiler->writeItem(m_nElevation);
	WritePoly2D(pFiler, m_polyOutline);
	pFiler->writeItem(m_nHeight); 

	Adesk::UInt8 nPatchCount = (Adesk::UInt8)m_lstIdsForPatch.Length(); // max 255
	pFiler->writeItem(nPatchCount);

	for (Adesk::UInt8 n = 0; n < nPatchCount; n++) 
	{
		const AcDbSoftPointerId &id = m_lstIdsForPatch[(int)n]; 
		pFiler->writeItem(id);
	}

	pFiler->writeItem((Adesk::UInt8)m_nUsageFlag);

	if (g_nSaveTArchVer > 5)
	{
		pFiler->writeItem(m_idLayerHatch2d);
	}

	if (g_nSaveTArchVer > 6)
	{
		Adesk::UInt8 nCount = (Adesk::UInt8)m_lstNeighbourId.Length();
		pFiler->writeItem(nCount);
	
		for (long i = 0; i < m_lstNeighbourId.Length(); i++) 
		{
			const AcDbSoftPointerId &id = m_lstNeighbourId[i]; 
			pFiler->writeItem(id);
		}

		pFiler->writeItem((Adesk::UInt8)m_nStyle);
	}

	if (g_nSaveTArchVer > 7)						//TArch8
	{
		pFiler->writeItem(m_nFlag);
		pFiler->writeItem(m_nInsulateThick);
		pFiler->writeItem(m_idLayerInsulate);
	}

	return es;
}

Acad::ErrorStatus TDbWallPatch::dxfInFields (AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();

	Acad::ErrorStatus es = TDbEntity::dxfInFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	if (!pFiler->atSubclassData(_T("TDbWallPatch"))) 
	{
		return Acad::eBadDxfSequence;
	}

	double r1, r2, r3;
	TCString sHatchLayer;
	TADSGePoint3d pt;
	Adesk::UInt32 fieldsFlags = 0;
	resbuf rb;
	TDPtrList<AcDbSoftPointerId> lstIds;
	AcDbObjectId id;
	TDPtrList<TADSGePoint3d> pts;
	TDPtrList<double> bulges;
	while ((es  ==  Acad::eOk)
		&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    
	{
		switch (rb.restype) 
		{
		case AcDb::kDxfReal:
			r1 = rb.resval.rreal;
			fieldsFlags |= 0x01;
			break;
		case AcDb::kDxfReal + 1:
			fieldsFlags |= 0x02;
			r2 = rb.resval.rreal;
			break;    
		case AcDb::kDxfSoftPointerId:
			fieldsFlags |= 0x04; 
			acdbGetObjectId(id, rb.resval.rlname);
			lstIds.Append(new AcDbSoftPointerId(id));
			break;    
		case AcDb::kDxfXCoord:
			pt = rb.resval.rpoint;
			pts.Append(new TADSGePoint3d(pt));
			break;    
		case AcDb::kDxfAngle:
			r3 = rb.resval.rreal;
			bulges.Append(new double(r3));
			break;
		case 411:
			sHatchLayer = rb.resval.rstring;
			fieldsFlags |= 0x08;
			free(rb.resval.rstring);
			break;
		default:
			pFiler->pushBackItem();
			es = Acad::eEndOfFile;
			break;
		}
	}

	if (es != Acad::eEndOfFile)
	{
		return Acad::eInvalidResBuf;
	}

	if (!(fieldsFlags & 0x04)) 
	{
		pFiler->setError(Acad::eMissingDxfField,
			_T("\nMissing DXF group code: %d"), AcDb::kDxfSoftPointerId);
		return Acad::eMissingDxfField;
	}

	if (pts.Length() < 2 || pts.Length() != bulges.Length()) 
	{
		pFiler->setError(Acad::eMissingDxfField,
			_T("\nError DXF group code: 10, 50"));
		return Acad::eMissingDxfField;
	}
	
	if (fieldsFlags & 0x01)
	{
		m_nHeight = r1;
	}

	if (fieldsFlags & 0x02)
	{
		m_nElevation = r2;
	}

	m_lstIdsForPatch.Reset();
	lstIds.SetDelFlag(FALSE);
	for (int i = 0; i < lstIds.Length(); i++)
	{
		m_lstIdsForPatch.Append(lstIds[i]);
	}

	m_polyOutline.Reset();
	for (i = 0; i < pts.Length(); i++) 
	{
		m_polyOutline.AppendNode(*pts[i], *bulges[i]);
	}

	if (fieldsFlags & 0x08) 
	{
		m_idLayerHatch2d = GetLayerIdFromString(sHatchLayer, database());
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbWallPatch::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled();
	
	Acad::ErrorStatus es =  TDbEntity::dxfOutFields(pFiler);
	assert(es == Acad::eOk);

	es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbWallPatch"));
	assert(es == Acad::eOk);

	pFiler->writeDouble(AcDb::kDxfReal, m_nHeight);
	pFiler->writeDouble(AcDb::kDxfReal + 1, m_nElevation);
	
	for (int i = 0; i < m_lstIdsForPatch.Length(); i++) 
	{
		const AcDbSoftPointerId &id = m_lstIdsForPatch[i];
		pFiler->writeItem(AcDb::kDxfSoftPointerId,id);
	}

	for (i = 0; i < m_polyOutline.Length(); i++) 
	{
		pFiler->writePoint2d(AcDb::kDxfXCoord, m_polyOutline[i].AsAcGePoint2d());
		pFiler->writeDouble(AcDb::kDxfAngle, m_polyOutline.GetBulge(i));
	}
	
	pFiler->writeString(411, (const TCHAR*)LayerId2String(m_idLayerHatch2d));
	
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbWallPatch::subGetGripPoints(AcGePoint3dArray&  gripPoints,
												 AcDbIntArray&  osnapModes,
												 AcDbIntArray&  geomIds) const
{
	assertReadEnabled();

	TchExport2::GetGripPoints(m_polyOutline,gripPoints);
	
	return Acad::eOk;
}

Acad::ErrorStatus  TDbWallPatch::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
	assertReadEnabled();

	AcDbPolyline pline;
	PolyConvert(m_polyOutline, pline);
	
	return pline.getStretchPoints(stretchPoints);
}

Acad::ErrorStatus TDbWallPatch::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();

	TDbEntity::subTransformBy(xform);

	//modified by W on 070413
	//ads_matrix mat;
	//memcpy(mat, &xform, sizeof(ads_matrix));
	//for (int i = 0; i<m_polyOutline.Length(); i++) {
	//    TADSGePoint3d &pt = *m_polyOutline[i];
	//    pt.z = m_nElevation;
	//    pt.TransformBy(mat);
	//    //以第一个顶点的z坐标为基准
	//    if (i == 0) {
	//        m_nElevation = pt.z;
	//    } 
	//    pt.z=0.0; // 2D Only
	//}
	//for (i=0; i<m_lstCurves.Length(); i++) {
	//    TGGeCurveSegment *pCurve=m_lstCurves[i];
	//    // 圆弧的变换不能使用下列方法
	//    pCurve->startPoint.TransformBy(mat);
	//    pCurve->endPoint.TransformBy(mat);
	//}
	if (m_polyOutline.Length() < 1)
	{
		return Acad::eOk;
	}

	m_polyOutline.SetElevation(m_nElevation);
	m_polyOutline.TransformBy(xform);
	m_nElevation = m_polyOutline[0]->z;
	m_polyOutline.SetElevation(0);
	
	if (m_polyOutline.PathArea() > 0) 
	{
		m_polyOutline.Reverse();
	}

	return Acad::eOk;
}

// 功能: 夹点操作
Acad::ErrorStatus TDbWallPatch::subMoveGripPointsAt(
										const AcDbIntArray& indices,
										const AcGeVector3d& offset)
{
	assertWriteEnabled();

	Acad::ErrorStatus es = TchExport2::MoveGripPointsAt(m_polyOutline, indices, offset);
	m_polyOutline.SetElevation(0.0);
	
	return es;
}

// 功能: 夹点操作
Acad::ErrorStatus TDbWallPatch::subMoveStretchPointsAt(
										const AcDbIntArray& indices,
										const AcGeVector3d& offset)
{
	assertWriteEnabled();

	AcDbPolyline pline;
	PolyConvert(m_polyOutline, pline);
	
	Acad::ErrorStatus es = pline.moveGripPointsAt(indices, offset);
	PolyConvert(pline, m_polyOutline);
	m_polyOutline.SetElevation(0.0);
	
	return es;
}

// 取得夹点说明
Acad::ErrorStatus TDbWallPatch::GetGripText(int i, CString &cs) const
{
	assertReadEnabled();

	TchExport2::GetGripText(m_polyOutline,i,cs);
	
	return Acad::eOk;
}

#if ADS > 15
void TDbWallPatch::CreateGrip()
{
	TDbEntity::CreateGrip();
	TchExport2::CreateGrip(this,m_polyOutline,0);
}

Acad::ErrorStatus TDbWallPatch::EntityToDim(long iGrip,long iDim,const AcDbEntity*pEnt)
{
	TEntityBase *pCurve = TDbWallPatch::cast(pEnt);

	if (pCurve == NULL)
	{
		pCurve = this;
	}

	TGGePoly2D polyPath;
	AcGeVector3d normal;
	pCurve->GetPathPoly(polyPath,normal);
	
	return ::EntityToDim(this,polyPath,iGrip,iDim,0);
}

Acad::ErrorStatus TDbWallPatch::DimToEntity(long iGrip,long iDim,double newValue,const AcGeVector3d& offset)
{
	assertWriteEnabled();

	TDbWallPatch curve;
	curve.CopyPropertiesFrom(this,0);

	Acad::ErrorStatus es = ::DimToEntity(this,m_polyOutline,iGrip,iDim,newValue,offset,0);
	if (es == Acad::eOk&&!IsValid())
	{
		CopyPropertiesFrom(&curve,0);
		return Acad::eInvalidInput;
	}

	return es;
}

#endif

// 如果其他构件优先(强)于本构件, 则用它们的外轮廓, 如果相等用内轮廓
void TDbWallPatch::GetInPatchObjectOutline(TDPtrList<TGGePoly2D> &lstClipPolies) const
{
	double nThick = DocGetIsLineWeight() ? GetLineWeight(FALSE) : 0.0;
	
	for (int i = 0; i < m_lstIdsForPatch.Length(); i++) 
	{
		OPENOBJ_BEGIN(m_lstIdsForPatch[i], AcDb::kForRead, TDbWall, pWall);
		if (pWall) 
		{
			TGGePoly2D polyOut(1);
			pWall->GetOutlinePoly(m_nElevation, polyOut);	//一定是逆时针

			TGGePoly2D polyIn(1);
			if (polyOut.QuickOffset(-nThick, polyIn) == RTNORM) 
			{
				lstClipPolies.Append(new TGGePoly2D(polyIn));
			}
		}
		OPENOBJ_END();
	}

	return;
}

void TDbWallPatch::ClipOutlineByPatchWalls(TDPtrList<TGGeCurveSegment> &lstResult, TDPtrList<TGGeCurveSegment> &lstResultIn) const
{
	TDPtrList<TGGeCurveSegment> lstCurves, lstCurves1, *pSource = NULL, *pDest = NULL;
	TDPtrList<TGGeCurveSegment> lstCurvesIn, lstCurves1In, *pSourceIn = NULL, *pDestIn = NULL;
	double nThick = DocGetIsLineWeight() ? GetLineWeight(FALSE) : 0.0;

	TGGePoly2D polyOut(1), polyIn(1);
	GetOutlinePoly(polyOut);

	ASSERT(polyOut.Length() != 0);
	polyOut.QuickOffset(-nThick, polyIn);
	ExplodePoly2D(polyOut, lstCurves);
	
	if (!lstCurves) 
	{
		return;
	}

	BOOL bThickMode = (IsBoldLine() && nThick > _DIST_SNAP);
	if (bThickMode)
	{
		ExplodePoly2D(polyIn, lstCurvesIn);
	}

	pSource = &lstCurves; 
	pSourceIn = &lstCurvesIn;

	pDest = &lstCurves1; 
	pDestIn = &lstCurves1In;

	AcDbObjectId idOwner = ownerId();
	if (!!idOwner) 
	{											//不是拖动状态
		//找接于柱子的墙
		for (int i = 0; i < m_lstIdsForPatch.Length(); i++)
		{
			OPENOBJ_BEGIN(m_lstIdsForPatch[i], AcDb::kForRead, TDbWall, pWall);
			if (!pWall)
			{
				continue;
			}

			TGGePoly2D polyWall(1);
			pWall->GetOutlinePoly(0.0, polyWall);
			polyWall.SetElevation(GetElevation());

			pDest->Reset();  
			TDPtrList<TGGeCurveSegment> lstTemp, lstEdge;
			PolyClip(*pSource, polyWall, lstTemp, *pDest, lstEdge);
			
			if (!pDest->Length())				//裁剩下空
			{
				return;
			}

			TchPrivate::Exchange(pSource, pDest);
			if (bThickMode) 
			{
				TGGePoly2D polyClip(1);
				TGGeCurveSegment cvLeftIn, cvRightIn; //粗线内侧
				pWall->GetThickLineSideCurve(cvLeftIn, cvRightIn);
			
				polyClip.AppendNode(cvLeftIn.GetStartPoint());
				polyClip.AppendNode(pWall->GetStartPoint());
				polyClip.AppendNode(cvRightIn.GetStartPoint(), cvRightIn.GetBulge());
				polyClip.AppendNode(cvRightIn.GetEndPoint());
				polyClip.AppendNode(pWall->GetEndPoint());
				polyClip.AppendNode(cvLeftIn.GetEndPoint(), -cvLeftIn.GetBulge());
				polyClip.SetElevation(GetElevation());
				
				pDestIn->Reset();				
				PolyClip(*pSourceIn, polyClip, lstTemp, *pDestIn, lstEdge);
				TchPrivate::Exchange(pSourceIn, pDestIn);
				pDestIn->Reset();
			}
			OPENOBJ_END();
		}
	}

	for (int n = 0; n < pSource->Length(); n++) 
	{
		lstResult.Append(new TGGeCurveSegment(*(*pSource)[n]));
	}

	if (bThickMode)
	{
		for (n = 0; n < pSourceIn->Length(); n++)
		{
			lstResultIn.Append(new TGGeCurveSegment(*(*pSourceIn)[n]));
		}
	}
}

static int GetExternalBoundary(const TDPtrList<TGGeCurveSegment> &lstCurves, TGGePoly2D &poly2d, BOOL bHasArc)
{
	TDPtrList<TGGeCurveSegment> lstShadeCurves, lstShadeArcs;
	for (int i = 0; i < lstCurves.Length(); i++) 
	{
		TGGeCurveSegment *seg = new TGGeCurveSegment(lstCurves[i]);
		seg->SetElevation(0.0);

		if (bHasArc && !seg->Is(CURVE_LINE))
		{
			lstShadeArcs.Append(seg);
		}
		else
		{
			lstShadeCurves.Append(seg);
		}
	}

	if (bHasArc) 
	{							//怎么没有考虑弧的重叠呢？
		TdRemoveDupCurves(lstShadeCurves, FALSE, FALSE); 
		lstShadeArcs.SetDelFlag(FALSE);

		for (int n = 0; n < lstShadeArcs.Length(); n++)
		{
			lstShadeCurves.Append(lstShadeArcs[n]);
		}

		IntersectCurves(lstShadeCurves, _DIST_SNAP);
	}
	else 
	{
		TdRemoveDupCurves(lstShadeCurves, FALSE, TRUE);
	}

	for (i = lstShadeCurves.Length() - 1; i >= 0; i--) 
	{
		TGGeCurveSegment *pSeg = lstShadeCurves[i];
		if (pSeg->GetLength() < _DIST_SNAP)
		{
			lstShadeCurves.Remove();
		}
	}

	TSearchRegionFromCurve aSearch;
	try 
	{ 
		aSearch.InitStart(lstShadeCurves); 
	} 
	catch(...) 
	{
		adsout << _T("\n发生例外情况!");
		return RTERROR;
	}

	TGGeRegion *pExt = aSearch.SearchRegions();
	if (pExt) 
	{
		poly2d.Reset();
		pExt->CenterPoly2D(poly2d);
		poly2d.Compress();
	
		return RTNORM;
	}

	return RTERROR;
}

// Modify on 2002/4/26 by Z, 对调填充和绘制边界的顺序，以利于图面美观
Acad::ErrorStatus TDbWallPatch::ExplodeOrDraw2d(TGGiExplodeDrawBase &dc) const
{
	Acad::ErrorStatus es = Acad::eOk;

	AcDbObjectId idMe = objectId();
	if (!idMe)
	{
		dc << m_polyOutline;
		return es;
	}

	double nThick = DocGetIsLineWeight() ? GetLineWeight(FALSE) : 0.0; 
	BOOL bInsulate = HasInsulate();
	//得到所有邻接墙、柱的外轮廓
	TDPtrList<TGGePoly2D> lstWallOut,lstWallOutInsulate;
	TDualPtrList<AcDbObjectId> lstColu;
	for (int i = 0; i<m_lstIdsForPatch.Length(); i++) 
	{
		OPENOBJ_BEGIN(m_lstIdsForPatch[i], AcDb::kForRead, TDbWall, pWall);
		if (pWall) 
		{
			TGGePoly2D polyOut(1);
			pWall->GetOutlinePoly(0, polyOut); 
			lstWallOut.Append(new TGGePoly2D(polyOut));
			//保温层裁剪需要考虑到墙的保温
			pWall->GetOutlinePoly(0, polyOut,1); 
			lstWallOutInsulate.Append(new TGGePoly2D(polyOut));

			if (lstColu.Find(pWall->GetStartColumnId()) == NOT_FOUND)
			{
				OPENOBJ_BEGIN(pWall->GetStartColumnId(),AcDb::kForRead,TDbColumn,pColu)
				if (pColu)
				{
					TGGePoly2D polyOut = pColu->GetOutlinePoly();
					
					// del by xlc on 110406 绘制填充时不需要保温,解决有保温的情况下填充豁口问题
					//if (bInsulate)
					//{
					//	GetOffsetPoly2D(pColu->m_polyOutline,polyOut,pColu->m_nInsulateThick);
					//}
					polyOut.SetElevation(0);
					lstWallOut.Append(new TGGePoly2D(polyOut));			
					dc.PushClip(polyOut);
				}
				OPENOBJ_END()
			
				lstColu.AddTail(pWall->GetStartColumnId());
			}

			if (lstColu.Find(pWall->GetEndColumnId()) == NOT_FOUND)
			{
				OPENOBJ_BEGIN(pWall->GetEndColumnId(),AcDb::kForRead,TDbColumn,pColu)
				if (pColu)
				{
					TGGePoly2D polyOut = pColu->GetOutlinePoly();
					
					// del by xlc on 110406 绘制填充时不需要保温,解决有保温的情况下填充豁口问题
					//if (bInsulate)
					//{
					//	GetOffsetPoly2D(pColu->m_polyOutline,polyOut,pColu->m_nInsulateThick);
					//}
					polyOut.SetElevation(0);
					lstWallOut.Append(new TGGePoly2D(polyOut));
					dc.PushClip(polyOut);
				}
				OPENOBJ_END()
			
				lstColu.AddTail(pWall->GetEndColumnId());
			}
		}
		OPENOBJ_END();
	}

	//计算大融合体外轮廓
	TDPtrList<TGGePoly2D> lstMyPoly,lstUnion;
	TGGePoly2D *pNewPoly = new TGGePoly2D(m_polyOutline);
	pNewPoly->SetElevation(0);
	lstMyPoly.Append(pNewPoly);

	Union(lstMyPoly,lstWallOut,lstUnion);

	TGGePoly2D polyUnion(m_polyOutline);
	if (lstUnion.Length() == 1)
	{
		polyUnion = *lstUnion[0];
	}
	else							//add by W on 080923，解决union出错问题
	{
		TDPtrList<TGGeCurveSegment> lstCurve;
		ExplodePoly2D(m_polyOutline,lstCurve);

		for (long i = 0; i < lstWallOut.Length(); i++)
		{
			ExplodePoly2D(*lstWallOut[i],lstCurve);
		}

		TGGePoly2D polyTemp(1);
		if (GetExternalBoundary(lstCurve,polyTemp,TRUE) == RTNORM)
		{
			polyUnion = polyTemp;
		}
	}

	//wlw修改100629
	TGGePoly2D polyInsulate;
	TGGePoly2D polyUnionInsulate(m_polyOutline);
	bool bzoom = true;
	if (GetUsageFlag() == kConcave)
	{
		bzoom = false;
	}
	if (bInsulate)
	{
		//计算大融合体外轮廓
		lstMyPoly.Reset();
		lstUnion.Reset();
		if (lstWallOut.Length() > 0)
		{
			lstWallOut.Remove(0);
		}
		lstWallOutInsulate << lstWallOut;
		
		GetOffsetPoly2D(m_polyOutline, polyInsulate, m_nInsulateThick,bzoom);
		polyInsulate.SetElevation(0);
		lstMyPoly.Append(new TGGePoly2D(polyInsulate));
		
		Union(lstMyPoly,lstWallOutInsulate,lstUnion);
		
		if (lstUnion.Length() == 1)
		{
			polyUnionInsulate = *lstUnion[0];
		}
		else
		{
			TDPtrList<TGGeCurveSegment> lstCurve;
			ExplodePoly2D(polyInsulate,lstCurve);
			
			for (long i = 0; i < lstWallOutInsulate.Length(); i++)
			{
				ExplodePoly2D(*lstWallOutInsulate[i],lstCurve);
			}
			
			TGGePoly2D polyTemp(1);
			if (GetExternalBoundary(lstCurve,polyTemp,TRUE) == RTNORM)
			{
				polyUnionInsulate = polyTemp;
			}
		}
	}

	if (GetUsageFlag() != kConcave)
	{
		if (!g_bOsnapExpl)
		{
			//绘制填充
			const TCHAR *pszHatch = NULL;
			if ((pszHatch = GetHatchPattern()) != NULL)  
			{ 
				//绘制内部填充
				AcDbObjectId idOldLay = dc.GetLayerId();
				int nColorOld = dc.GetColor();

				dc.SetColorLayer(GetHatchColor(),m_idLayerHatch2d);

				if (_tcsicmp(pszHatch, _T("SOLID")) == 0) 
				{
					dc<<TGGeSolid(m_polyOutline);
				}
				else
				{
					dc<<TGGeHatch(m_polyOutline, pszHatch, GetPScale());
				}

				dc.SetLayer(idOldLay);
				dc.SetColor(nColorOld);
			} 

			//绘制加粗边界
			if (nThick > _DIST_SNAP) 
			{
				bool bFree = true;

				//add by W on 061225
				extern AcDbObjectId g_idPubWall;	//墙柱加粗的图层，为上华3服务
				AcDbObjectId idOldLayer = dc.GetLayerId();
				dc.SetLayer(g_idPubWall);

				if (m_lstIdsForPatch.Length() > 0)
				{
					TGGePoly2D polyUnionHatch = polyUnion;
					TGGePoly2D polyTemp(1);
					double nOffset = -nThick;
					
					if (polyUnionHatch.QuickOffset(nOffset, polyTemp) == RTNORM)
					{
						polyUnionHatch = polyTemp;
					}

					TDPtrList<TGGePoly2D> lstResultPolies;
					if (TchSubExport::Subtract(m_polyOutline,polyUnionHatch,lstResultPolies) == RTNORM
						&& lstResultPolies.Length() > 0)
					{
						bFree = false;
						for (int i = 0; i < lstResultPolies.Length(); i++) 
						{
							dc << TGGeSolid(*lstResultPolies[i]);
						}
					}
				}

				if (bFree)							//独立造型。
				{
					TDPtrList<TGGeCurveSegment> lstSegs, lstSegsIn;
					ClipOutlineByPatchWalls(lstSegs, lstSegsIn);

					if (lstSegsIn.Length() > 0 && lstSegs.Length() == lstSegsIn.Length())
					{
						for (int n = 0; n < lstSegs.Length(); n++) 
						{
							dc << TGGeSolidCurve(*lstSegs[n], *lstSegsIn[n]);
						}
					}
				}

				dc.SetLayer(idOldLayer);
			}
		}

		//绘制边界细线
		TDPtrList<TGGeCurveSegment> lstSegs0,lstSegs,temp;
		ExplodePoly2D(m_polyOutline,lstSegs0);
		PolyClip(lstSegs0,polyUnion,temp,lstSegs);

		for (int n = 0; n < lstSegs.Length(); n++)
		{
			dc << *lstSegs[n];
		}

		// 输出其他曲线
		for (int i = 0; i < m_lstCurves.Length(); i++)
		{
			dc << m_lstCurves[i];
		}
	}
	else											//内凹造型
	{
		//绘制加粗边界
		if (!g_bOsnapExpl && nThick > _DIST_SNAP) 
		{
			TGGePoly2D polyTemp(1);
			if (m_polyOutline.QuickOffset(nThick, polyTemp) == RTNORM)
			{
				TDPtrList<TGGePoly2D> lstResultPolies,lstPolySub,buf;
				TchSubExport::Intersect(polyUnion,polyTemp,buf);
		
				lstPolySub.Append(new TGGePoly2D(m_polyOutline));
				Subtract(buf,lstPolySub,lstResultPolies);

				for (i = 0; i < lstResultPolies.Length(); i++) 
				{
					TGGePoly2D &poly = *lstResultPolies[i];
					if (!g_bOsnapExpl) 
					{
						dc << TGGeSolid(poly);
					}
				}
			}
		}

		//绘制边界细线
		TDPtrList<TGGeCurveSegment> lstSegs0,lstSegs,lstOut,lstEdge;
		ExplodePoly2D(m_polyOutline,lstSegs0);
		PolyClip(lstSegs0,polyUnion,lstSegs,lstOut,lstEdge);

		if (lstSegs.Length() < 1)
		{
			dc << m_polyOutline;
		}
		else
		{
			for (int n = 0; n < lstSegs.Length(); n++)
			{
				dc << *lstSegs[n];
			}
		}
	}

	//wlw修改100629绘制保温
	if (bInsulate && m_nInsulateThick > 1.E-5)
	{
		// add by xlc on 110519 解决阳台遮挡保温层的问题
		long iClipCount = 0;		//阳台裁剪边界数
		for (long i = 0; i < m_lstClippedId.Length(); i++)
		{
			const AcDbObjectId &id = m_lstClippedId[i];
			if (id.isNull() || !id.isValid())
			{
				continue;
			}
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbBalcony, pBalcony);
			if (pBalcony)			
			{
				if(pBalcony->IsBalconyClipInsu())
				{
					TGGePoly2D polyBal = pBalcony->GetOutline(),polyIn;
					if( pBalcony->GetPolyIn(polyIn))
					{							
						polyIn.SetFlag(0);
						polyIn.Reverse();

						for (int j = 0; j < polyIn.Length(); j++)
						{
							polyBal.AppendNode(*polyIn[j], polyIn.GetBulge(j));
						}

						dc.PushClip(polyBal);
						iClipCount++;
					}
				}

			}
			OPENOBJ_END();
		}

		DrawInsulateLine(polyInsulate,polyUnionInsulate,bzoom,dc);

		// add by xlc on 110519 解决阳台遮挡保温层的问题
		while (iClipCount > 0)
		{
			dc.PopClip();
			iClipCount--;
		}
	}
	return es;
}

Acad::ErrorStatus TDbWallPatch::ExplodeOrDraw3d(TGGiExplodeDrawBase &dc) const
{
	extern GEOAPI BOOL g_bExplodeMesh;

	if (m_nHeight < _DIST_SNAP || GetUsageFlag() == TDbWallPatch::kConcave) //高度为0的不绘制
	{
		return Acad::eOk;
	}

	double nElev = GetElevation();
	TGGePoly2D polyOut(m_polyOutline);
	polyOut.SetElevation(nElev);

	double nHeight = m_nHeight;
	BOOL bVisBot = HasBottom(), bVisTop = HasTop();
	if (!DocGetLevelLine()
		&& TchGeLib::g_bExplodeMesh
		&& (!bVisBot || !bVisTop)) 
	{
		TGGePoly2D polyBot;
		polyOut.Disperse1(polyBot, _AS_SYS_UNIT(g_nCirDeviation));
	
		int nColumn = polyBot.Length() + 1;
		int nRow = 2;
		TADSGePoint3d *ptArray = new TADSGePoint3d[nColumn * nRow];
		for (int m = 0; m < nRow; m++) 
		{
			for (int n = 0; n < nColumn; n++) 
			{
				int nBase = m * nColumn;
				int idx = n;
				if (n == nColumn - 1)
				{
					idx = 0;
				}

				ptArray[nBase + n] = *polyBot[idx];
				if (m)
				{
					ptArray[nBase + n].z += nHeight;
				}
			}
		}

		AcGiEdgeData edgeData;
		Adesk::UInt8 *edgeVis = new Adesk::UInt8[(nColumn - 1) * nRow + nColumn * (nRow - 1)];
		for (m = 0; m < (nColumn - 1) * nRow; m++) 
		{
			if (m < nColumn - 1)
			{
				edgeVis[m] = bVisBot;
			}
			else
			{
				edgeVis[m] = bVisTop;
			}
		}

		for (int n = 0; n < nColumn; n++) 
		{
			int idx = n;
			if (n == nColumn - 1)
			{
				idx = 0;
			}

			edgeVis[m + n] = 1;
		}

		edgeData.setVisibility(edgeVis);
		dc.DrawMesh(nRow, nColumn, (AcGePoint3d *)ptArray, &edgeData);

		delete [] ptArray;
		delete [] edgeVis;
		
		if (bVisBot) 
		{
			dc.DrawShell(polyBot);
		} 
		
		if (bVisTop) 
		{
			polyBot.SetElevation(nElev + nHeight);
			dc.DrawShell(polyBot);
		}
	}
	else 
	{
		dc.DrawBody(polyOut, TVector3D(0,0,nHeight));
	}
	
	return Acad::eOk;
}

const TCHAR *TDbWallPatch::GetDefaultLayer() const
{
	const TCHAR *szLay = LAY_WALL;
	if (m_lstIdsForPatch.Length() > 0) 
	{
		const AcDbObjectId id = m_lstIdsForPatch[0];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWall, pWall);
		if (pWall)
		{
			szLay = pWall->GetDefaultLayer();
		}
		OPENOBJ_END();
	}

	return szLay;
}

void TDbWallPatch::UpdateAssocWallGraphics() const
{
	int nLen = m_lstIdsForPatch.Length();
	for (int i = 0; i < nLen; i++) 
	{
		OPENOBJ_BEGIN(m_lstIdsForPatch[i], AcDb::kForRead, TDbWall, pWall);
		if (pWall) 
		{
			pWall->draw();
		}
		OPENOBJ_END();
	}
}

BOOL TDbWallPatch::HasTop() const
{
	int nLen = m_lstIdsForPatch.Length();
	BOOL bHasTop = TRUE;
	if (nLen > 0) 
	{
		AcDbObjectId idWall = m_lstIdsForPatch[0];
		
		OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbWall, pWall);
		if (pWall && !pWall->HasTop()) 
		{
			if (fabs(GetElevation() + GetHeight() - 
				pWall->GetElevation() - pWall->GetHeight()) < _DIST_SNAP)
			{
				bHasTop = FALSE;
			}
		}
		OPENOBJ_END();
	} 
	else 
	{
		bHasTop = (fabs(GetElevation() + GetHeight() - DocGetLHeight()) > _DIST_SNAP);
	}

	return bHasTop;
}

BOOL TDbWallPatch::HasBottom() const
{
	int nLen = m_lstIdsForPatch.Length();
	BOOL bHasBot = TRUE;
	if (nLen > 0) 
	{
		AcDbObjectId idWall = m_lstIdsForPatch[0];
	
		OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbWall, pWall);
		if (pWall && !pWall->HasBottom()) 
		{
			if (fabs(GetElevation() - pWall->GetElevation()) < _DIST_SNAP)
			{
				bHasBot = FALSE;
			}
		}
		OPENOBJ_END();
	}
	else 
	{
		bHasBot = (fabs(GetElevation()) > _DIST_SNAP);
	}
	
	return bHasBot;
}

void TDbWallPatch::GetTips(TDPtrList<TObjInfoUnit> &lstInfo) const
{

	const TCHAR *pszUsage = _T("墙体造型");
	lstInfo.Append(new TObjInfoUnit(_T("对象类型"), pszUsage));
	lstInfo.Append(new TObjInfoUnit(_T("高度"), TchExport::Dist2Str(m_nHeight)));

	lstInfo.Append(new TObjInfoUnit(_T("底标高"),  TchExport::Dist2Str(GetElevation())));

	double nArea = m_polyOutline.Area();
	lstInfo.Append(new TObjInfoUnit(_T("底面积"), TCString(_T("%.2f"), _AS_SQMETER(nArea))));
	lstInfo.Append(new TObjInfoUnit(_T("体积"), TCString(_T("%.3f"), _AS_SQMETER(nArea) * _AS_METER(m_nHeight))));
}

Acad::ErrorStatus TDbWallPatch::AddPatchId(const AcDbObjectId &id)
{
	if (!id || m_lstIdsForPatch.FindNode(&id, CompareObjectId))
	{
		return Acad::eInvalidInput;
	}

	m_lstIdsForPatch.Append(new AcDbSoftPointerId(id));
	return Acad::eOk;
}

Acad::ErrorStatus TDbWallPatch::RemovePatchId(const AcDbObjectId &id)
{
	if (!id || m_lstIdsForPatch.FindNode(&id, CompareObjectId))
	{
		return Acad::eInvalidInput;
	}

	m_lstIdsForPatch.Remove();
	return Acad::eOk;
}

BOOL TDbWallPatch::IsConcrete() const
{
	if (!m_lstIdsForPatch)
	{
		return FALSE;
	}

	const AcDbObjectId id = m_lstIdsForPatch[0];
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWall, pWall);
	if (pWall && pWall->GetStyle() == TWallData::kConcrete)
	{
		return TRUE;
	}
	OPENOBJ_END();

	return FALSE;
}

const TCHAR *TDbWallPatch::GetHatchPattern() const
{
	if (!m_lstIdsForPatch)
	{
		return NULL;
	}

	if (m_lstIdsForPatch.Length() > 0) 
	{
		const AcDbObjectId id = m_lstIdsForPatch[0];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWall, pWall);
		if (pWall)
		{
			return pWall->GetHatchPattern();
		}
		OPENOBJ_END();
	}

	return NULL;
}

Adesk::UInt16 TDbWallPatch::GetHatchColor() const
{
	Adesk::UInt16 color = 256;
	if (m_lstIdsForPatch.Length() > 0) 
	{
		const AcDbObjectId id = m_lstIdsForPatch[0];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWall, pWall);
		if (pWall)
		{
			color = pWall->GetHatchColor();
		}
		OPENOBJ_END();
	}

	return color;
}

//取线粗，不管加粗开关是否开启
double TDbWallPatch::GetLineWeight(BOOL bAsPaperUnit) const
{
	double nWeight = 0.0;
	if (m_lstIdsForPatch.Length() > 0)
	{
		const AcDbObjectId id = m_lstIdsForPatch[0];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWall, pWall);
		if (pWall)
		{
			nWeight = pWall->GetLineWeight(TRUE);
		}
		OPENOBJ_END();
	}

	if (!bAsPaperUnit)
	{
		nWeight *= GetPScale();
	}

	return nWeight;
}

const TCHAR * TDbWallPatch::Descriptor()
{
	return _T("TDbWallPatch");
}

const TCHAR * TDbWallPatch::Desc()
{
	return Descriptor();
}

Acad::ErrorStatus TDbWallPatch::subClose()
{
	Acad::ErrorStatus es = TDbEntity::subClose();

	if (es == Acad::eOk && isModified() && database() == acdbCurDwg())
	{
		static BOOL g_bWallPatchSubClose = FALSE;
		if (!g_bWallPatchSubClose)			//防止与TDbWall::subClose的递归调用
		{
			TPushMemVar<BOOL> vTemp(g_bWallPatchSubClose,TRUE);
			
			//通知附件, 墙体已经发生变化
			for (int i = 0; i < m_lstIdsForPatch.Length(); i++) 
			{
				OPENOBJ_BEGIN(*m_lstIdsForPatch[i], AcDb::kForRead, TDbWall, pWall);
				if (pWall) 
				{
					if (!pWall->isModified())
					{
						if (pWall->upgradeOpen() == Acad::eOk)
						{
							pWall->recordGraphicsModified(Adesk::kTrue);
						}
					}
				}
				OPENOBJ_END();
			}
		}
	}

	return es;
}

Acad::ErrorStatus TDbWallPatch::subErase(Adesk::Boolean bErasing)
{
	extern BOOL SkipSubErase(const TCHAR *szCmd);
	Acad::ErrorStatus es = TDbEntity::subErase(bErasing);

	TCString &cmdStr = GetCurDocData()->m_sCurCommand;

	if (TchPrivate::SkipSubErase(cmdStr))
	{
		return es;
	}

	if (es == Acad::eOk && bErasing == Adesk::kTrue && database() == acdbCurDwg()) 
	{
		//通知墙体, 解除对附件的连接
		for (int i = 0; i < m_lstIdsForPatch.Length(); i++) 
		{
			OPENOBJ_BEGIN(*m_lstIdsForPatch[i], AcDb::kForWrite, TDbWall, pWall);
			if (pWall) 
			{
				pWall->assertWriteEnabled();
				pWall->RemovePatchId(objectId());
			}
			OPENOBJ_END();
		}
	}

	return es;
}

// 移除同墙体的连接关系(双向)
void TDbWallPatch::RemoveAllLinkages()
{
	assertWriteEnabled();

	//通知墙体, 解除对附件的连接
	for (int i = 0; i < m_lstIdsForPatch.Length(); i++) 
	{
		OPENOBJ_BEGIN(*m_lstIdsForPatch[i], AcDb::kForWrite, TDbWall, pWall);
		if (pWall) 
		{
			pWall->assertWriteEnabled();
			pWall->RemovePatchId(objectId());
		}
		OPENOBJ_END();
	}

	m_lstIdsForPatch.Reset();
}

Acad::ErrorStatus
TDbWallPatch::subWblockClone(AcRxObject*    pOwner,
							 AcDbObject*&   pClonedObject,
							 AcDbIdMapping& idMap,
							 Adesk::Boolean isPrimary) const
{
	Acad::ErrorStatus es = TDbEntity::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
	return es;
}

BOOL TDbWallPatch::OnlyPatchMe(AcDbObjectId idWall) const
{
	return (m_lstIdsForPatch.Length() == 1 && m_lstIdsForPatch[0] == idWall);
}

bool TDbWallPatch::IsModelEntity() const
{
	return true;
}

bool TDbWallPatch::IsMeClip()const
{
	return true;
}

AcDbEntity* TDbWallPatch::GetMyEntity()const
{
	return (AcDbEntity*)this;
}

int TDbWallPatch::GetMaterialIndex()const
{
	return GetStyle();
}

TDbWallPatch::Usage TDbWallPatch::GetUsage()const
{
	return kPatch;
}

const TDPtrList<AcDbSoftPointerId> & TDbWallPatch::GetPatchIds() const
{
	return m_lstIdsForPatch;
}

TDbWallPatch::UsageFlag TDbWallPatch::GetUsageFlag() const 
{
	return m_nUsageFlag;
}

void TDbWallPatch::SetUsageFlag(UsageFlag nUsage) 
{
	m_nUsageFlag = nUsage;
}

//用于OPM的属性, 形状被修改后需调用UpdateAssocWallGraphics();
double TDbWallPatch::GetElevation() const 
{
	return m_nElevation;					//底标高
}

void TDbWallPatch::SetElevation(double nElev) 
{
	assertWriteEnabled();
	m_nElevation = nElev;
}

void TDbWallPatch::GetOutlinePoly(TGGePoly2D &poly, bool bInsulate) const
{
	if (HasInsulate())
	{
		if (bInsulate)
		{
			bool bzoom = true;
			if (GetUsageFlag() == kConcave)
			{
				bzoom = false;
			}
			GetOffsetPoly2D(m_polyOutline,poly,m_nInsulateThick,bzoom);
		}
		else
		{
			poly = m_polyOutline;
		}
	}
	else
	{
		poly = m_polyOutline;
	}

}

void TDbWallPatch::SetOutlinePoly(const TGGePoly2D &poly)
{
	assertWriteEnabled();
	m_polyOutline = poly;

	if (m_polyOutline.PathArea() > 0)
	{
		m_polyOutline.Reverse();			//确保按逆时针方向
	}
}

double TDbWallPatch::GetHeight() const 
{
	return  m_nHeight;						//高度, 如果为0则不显示三维
}

void TDbWallPatch::SetHeight(double h) 
{
	assertWriteEnabled();
	m_nHeight = h;
}

AcDbObjectId TDbWallPatch::GetLayerHatch2d() const 
{
	return m_idLayerHatch2d;
}

void TDbWallPatch::SetLayerHatch2d(AcDbObjectId id) 
{
	assertWriteEnabled();
	m_idLayerHatch2d = id;
}

void TDbWallPatch::SetStyle(TWallPatchStyle style)
{
	assertWriteEnabled();
	m_nStyle = style;
}

TDbWallPatch::TWallPatchStyle TDbWallPatch::GetStyle() const
{
	assertReadEnabled();
	return m_nStyle;
}

AcDbObjectId TDbWallPatch::GetLayerInsulateId() const 
{
	return m_idLayerInsulate;
}

void TDbWallPatch::SetLayerInsulateId(AcDbObjectId id) 
{
	assertWriteEnabled();
	m_idLayerInsulate = id;
}

double TDbWallPatch::GetInsulateThick() const 
{
	return m_nInsulateThick;
}

void TDbWallPatch::SetInsulateThick(double dThick) 
{
	assertWriteEnabled();
	m_nInsulateThick = dThick;
}

BOOL TDbWallPatch::HasInsulate() const 
{
	return ((m_nFlag & WF_PATCH_INSULATE) != 0);
}

void TDbWallPatch::SetInsulate(BOOL bTrue) 
{
	if (bTrue)
	{
		m_nFlag |= WF_PATCH_INSULATE;
	}
	else
	{
		m_nFlag &= ~WF_PATCH_INSULATE;
	}
}

int TDbWallPatch::GetWallFlag() const 
{
	return m_nFlag;
}

void TDbWallPatch::SetWallFlag(int nFlag) 
{
	m_nFlag = nFlag;
}

// 通用的函数, 要移到其他模块
Acad::ErrorStatus TDbWallPatch::ReadCurve(AcDbDwgFiler *pFiler, TGGeCurveSegment &seg)
{
	TADSGePoint3d ptStart,ptEnd;
	pFiler->readItem(&(AcGePoint3d &)ptStart);
	pFiler->readItem(&(AcGePoint3d &)ptEnd);
	seg.SetStartPoint(ptStart);
	seg.SetEndPoint(ptEnd);
	
	double bulge = 0;
	pFiler->readItem(&bulge);
	seg.SetBulge(bulge);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbWallPatch::ReadCurveList(AcDbDwgFiler *pFiler, TDPtrList<TGGeCurveSegment> &lstSegs)
{
	Adesk::UInt16 nCount = 0;
	pFiler->readItem(&nCount);
	
	for (Adesk::UInt16 i = 0U; i<nCount; i++) 
	{
		TGGeCurveSegment *seg = new TGGeCurveSegment;
		ReadCurve(pFiler, *seg);
		lstSegs.Append(seg);
	}
	
	return pFiler->filerStatus();
}

void TDbWallPatch::GetInsulateExLine(TDPtrList<TGGeCurveSegment> &lstSegs) const
{
	// 对于内凹式造型添加保温线保证造型保温与墙保温不断开
	lstSegs.Reset();
	TGGeCurveSegment segl,segr;
	TGGeCurveSegment segIs,segTmp;
	ads_point pt1,pt2;
	AcGePoint3dArray arptIns,arptInsInsulate;
	TADSGePoint3d ptInter;
	TGGePoly2D polyPath(1),polyPathIs(1);
	double dThick = DocGetIsLineWeight() ? GetLineWeight(FALSE) : 0.0; 
	AcGeVector3d vt;
	for (int i = 0; i< m_lstIdsForPatch.Length(); i++) 
	{
		OPENOBJ_BEGIN(m_lstIdsForPatch[i], AcDb::kForRead, TDbWall, pWall);
		if (pWall == NULL) 
		{
			continue;
		}

		// 绘制保温线
		TDPtrList<TGGeCurveSegment> lstInsulateCurves;
		for (int nSide = 0; nSide < 2; nSide++) 
		{
			pWall->GetSideCurve(segl,segr,0.0,TRUE);
			// 取得墙保温线分别于造型和造型保温求交，得到交线
			if (pWall->IsInsulateOnSide(nSide))
			{
				segIs = nSide ? segr : segl;
				segIs.SetLineFlag(LS_INFINITE);

				GetOutlinePoly(polyPathIs);
				GetOutlinePoly(polyPath,0);

				polyPath.SetElevation(GetElevation());
				polyPathIs.SetElevation(GetElevation());

				for (int j = 0; j < polyPath.Length(); j++)
				{
					polyPath.Nth(j,segTmp);
					segTmp.SetLineFlag(LS_FINITE);
					if (segIs.Intersection(segTmp,pt1,pt2))
					{
						ptInter = pt1;
						arptIns.append(ptInter);
						//对弧线来说，有两个交点
						if (segTmp.GetBulge() > 0)
						{
							ptInter = pt2;
							arptIns.append(ptInter);
							break;
						}
					}
				}

				for (j = 0; j < polyPathIs.Length(); j++)
				{
					polyPathIs.Nth(j,segTmp);
					segTmp.SetLineFlag(LS_FINITE);
					if (segIs.Intersection(segTmp,pt1,pt2))
					{
						ptInter = pt1;
						arptInsInsulate.append(ptInter);
						//对弧线来说，有两个交点
						if (segTmp.GetBulge() > 0)
						{
							ptInter = pt2;
							arptInsInsulate.append(ptInter);
							break;
						}
					}
				}
				//如果交点多于2个点，暂时不处理。处理方法可将点数组按照墙线方向序列化，取第一个和最后一个wlw
				if (arptInsInsulate.length() == 2 && arptIns.length() == 2)
				{
					segTmp.SetBulge(0.0);
					segTmp.SetStartPoint(arptIns[0]);
					segTmp.SetEndPoint(arptInsInsulate[0]);
					if (arptIns[0].distanceTo(arptInsInsulate[0]) > arptIns[0].distanceTo(arptInsInsulate[1]))
					{
						segTmp.SetEndPoint(arptInsInsulate[1]);
					}
					if (dThick > 0.01)
					{//补加粗的豁口
						vt = segTmp.StartPoint() - segTmp.EndPoint();
						vt.normalize();
						segTmp.StartPoint() += vt * dThick;
					}
					lstSegs.Append(new TGGeCurveSegment(segTmp));
					segTmp.SetStartPoint(arptIns[1]);
					segTmp.SetEndPoint(arptInsInsulate[1]);
					if (arptIns[1].distanceTo(arptInsInsulate[1]) > arptIns[1].distanceTo(arptInsInsulate[0]))
					{
						segTmp.SetEndPoint(arptInsInsulate[1]);
					}
					if (dThick > 0.01)
					{//补加粗的豁口
						vt = segTmp.StartPoint() - segTmp.EndPoint();
						vt.normalize();
						segTmp.StartPoint() += vt * dThick;
					}
					lstSegs.Append(new TGGeCurveSegment(segTmp));
				}

			}
		}
		OPENOBJ_END();
	}
}

void TDbWallPatch::DrawInsulateLine(const TGGePoly2D& polyInsulate,TGGePoly2D& polyUnionInsulate, bool bzoom, TGGiExplodeDrawBase &dc) const
{
	TDPtrList<TGGeCurveSegment> lstSegsTmp,lstSegsOut,lstSegsIn;
	ExplodePoly2D(polyInsulate,lstSegsTmp);
	PolyClip(lstSegsTmp,polyUnionInsulate,lstSegsIn,lstSegsOut);
	AcDbObjectId idOldLay = dc.GetLayerId();

	int nColorOld = dc.GetColor();
	dc.SetColorLayer(colorIndex(), m_idLayerInsulate);
	int n = 0,nSide=0;

	int nSaveFlag = 0;
	m_XDataMap.GetAt(_T("DownGradeSaveFlag"), nSaveFlag);

	// 外凸
	if (bzoom)
	{
		BOOL bFullExplode = FALSE;
		if (_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor()) == 0)
		{
			bFullExplode = TRUE;
		}
		if (_tcscmp(dc.Desc(), TGGiExplodeDraw::Descriptor()) == 0)
		{
			bFullExplode =  ((TGGiExplodeDraw &)dc).m_bFullExplode;
		}
		BOOL bIsWallHatch = FALSE;
		CString sPattern;
		Adesk::UInt16 nColor(256);

		const AcDbObjectId id = m_lstIdsForPatch[0];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWall, pWall);
		AcDbObjectId idLineBlock;
		TDbPolyPathArray linepat;

		TGGePoly2D poly2d;
		TADSGePoint3d ptOnln;
		TGGeCurveSegment seg;
		if (pWall)
		{//wlw add 140220 增加保温花线
			pWall->GetSpecialtyDataReadOnly()->GetAt(idKEY_WALL_WARM_HATCH_PATTERN_ID, idLineBlock);
			pWall->GetSpecialtyDataReadOnly()->GetAt(bKEY_WALL_WARM_HATCH_OP, bIsWallHatch);
			pWall->GetSpecialtyDataReadOnly()->GetAt(nKEY_WALL_WARM_HATCH_COLOR, (int&)nColor);
			if (pWall->GetUsageFlag() == TWallData::kParapet)
			{
				bIsWallHatch = FALSE;
			}
			if (bIsWallHatch && bFullExplode && !g_bOsnapExpl)
			{
				linepat.SetUnitId(idLineBlock);
				for (n = 0; n < lstSegsOut.Length(); n++)
				{	
					seg = *lstSegsOut[n];
					nSide = pWall->OnWhichSide(lstSegsOut[n]->MidPoint());

					if (pWall->IsInsulateOnSide(nSide))
					{
						for (int j = 0; j < m_polyOutline.Length(); j++)
						{
							TADSGePoint3d pt = m_polyOutline[j];
							
							lstSegsOut[n]->ProjectToMe(pt,ptOnln);

							//为了避免墙相交时图案重叠
							if (fabs(m_nInsulateThick - ptOnln.Distance2d(pt)) < 1 && ((ptOnln & seg) == PR_INSIDE))
							{
								if (lstSegsOut[n]->StartPoint().Distance2d(ptOnln) < lstSegsOut[n]->EndPoint().Distance2d(ptOnln))
								{
									seg.SetStartPoint(ptOnln);
								}
								else
								{
									seg.SetEndPoint(ptOnln);
								}
							}
						}
						poly2d.Reset();
						seg.AsPoly2D(poly2d);
						linepat.SetBaseType(1);//0,左，1，右，2，中
						linepat.SetUnitHeight(m_nInsulateThick);
						linepat.SetPathPoly(poly2d,AcGeVector3d::kZAxis);
						linepat.SetRatio(1);

						if (nSaveFlag == 1)
						{
							linepat.setLayer(dc.GetLayerId());
							linepat.setColorIndex(dc.GetColor());
							dc.DrawEntity(linepat);					
						}
						else
						{
							BOOL bWallLinepatClipOld = g_bWallLinepatClip;
							if (_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
							{
								g_bWallLinepatClip = TRUE;
							}
							linepat.ExplodeOrDraw2d(dc);
							g_bWallLinepatClip = bWallLinepatClipOld;
						}
					}
				}
			}

		}
		OPENOBJ_END();

		for (n = 0; n < lstSegsOut.Length(); n++)
		{
			dc << *lstSegsOut[n];
		}
	}
	//内凹
	else
	{
		if (lstSegsIn.Length() < 1)
		{
			dc << polyInsulate;
		}
		else
		{
			for (n = 0; n < lstSegsIn.Length(); n++)
			{
				dc << *lstSegsIn[n];
			}
			
			//添加两根连接小线
			GetInsulateExLine(lstSegsOut);
			
			for (n = 0; n < lstSegsOut.Length(); n++)
			{
				dc << *lstSegsOut[n];
			}
		}
	}
	dc.SetLayer(idOldLay);
	dc.SetColor(nColorOld);
}

// sg add 101115，支持统一标高
bool TDbWallPatch::UnifyElevation(double dElevation)
{
    assertWriteEnabled();
    SetElevation(dElevation);
	return true;
}

// sg add 101118，支持导出XML
CString TDbWallPatch::GetXml(const AcGeMatrix3d& mat) const
{
	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_WALL_PATCH"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("墙体造型"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	CString strText;
	POSITION posItem1 = xmlTree.Insert(_T("Object_ID"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("对象编号"));
		xmlTree.SetAttribute(posItem1, _T("comment"), _T("当前对象的句柄"));
		strText.Format(_T("%ld"), objectId());
		xmlTree.SetItemText(posItem1, strText);		
	}

	POSITION posItem2 = xmlTree.Insert(_T("Link_WALL"), posRoot, posItem1);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("连接墙体"));

		POSITION posItemLinkID = NULL;
		for (int i = 0; i < m_lstIdsForPatch.Length(); i++)
		{
			posItemLinkID = xmlTree.Insert(_T("Link_ID"), posItem2, posItemLinkID);
			xmlTree.SetAttribute(posItemLinkID, _T("name"), _T("墙体句柄"));
			strText.Format(_T("%ld"), m_lstIdsForPatch[i]);
			xmlTree.SetItemText(posItemLinkID, strText);
		}
	}

	POSITION posItem3 = xmlTree.Insert(_T("Property"), posRoot, posItem2);
	{
		xmlTree.SetAttribute(posItem3, _T("name"), _T("外凸特性"));
		xmlTree.SetAttribute(posItem3, _T("comment"), _T("外凸为1，内凹为0"));
		strText.Format(_T("%d"), m_nUsageFlag != kConcave);
		xmlTree.SetItemText(posItem3, strText);
	}

	POSITION posItem4 = xmlTree.Insert(_T("Baseline"), posRoot, posItem3);
	{
		xmlTree.SetAttribute(posItem4, _T("name"), _T("基线参数"));

		POSITION posItemPoint = NULL;
		TADSGePoint3d ptNode;
		for (int i = 0; i < m_polyOutline.Length(); i++)
		{
			ptNode = m_polyOutline[i];
			strText.Format(_T("Point_%d"), i + 1);
			posItemPoint = xmlTree.Insert(strText, posItem4, posItemPoint);
			{
				strText.Format(_T("第%d点"), i + 1);
				xmlTree.SetAttribute(posItemPoint, _T("name"), strText);
				strText.Format(_T("%f,%f,%f"), ptNode.x, ptNode.y, ptNode.z);
				xmlTree.SetItemText(posItemPoint, strText);
			}

			strText.Format(_T("Ang_%d"), i + 1);
			posItemPoint = xmlTree.Insert(strText, posItem4, posItemPoint);
			{
				strText.Format(_T("圆心角%d"), i + 1);
				xmlTree.SetAttribute(posItemPoint, _T("name"), strText);
				strText.Format(_T("%f"), m_polyOutline.GetBulge(i));
				xmlTree.SetItemText(posItemPoint, strText);
			}
		}
	}
 
	POSITION posItem5 = xmlTree.Insert(_T("Height"), posRoot, posItem4);
	{
		xmlTree.SetAttribute(posItem5, _T("name"), _T("墙体造型高度参数"));
		
		POSITION posItemHeight = NULL;
		posItemHeight = xmlTree.Insert(_T("Net_Height"), posItem5, posItemHeight);
		{
			xmlTree.SetAttribute(posItemHeight, _T("name"), _T("墙体造型高"));
			xmlTree.SetAttribute(posItemHeight, _T("comment"), _T("从墙体造型底起算的墙体造型净高"));
			strText.Format(_T("%f"), GetHeight());
			xmlTree.SetItemText(posItemHeight, strText);
		}

		posItemHeight = xmlTree.Insert(_T("Bottom_Height"), posItem5, posItemHeight);
		{
			xmlTree.SetAttribute(posItemHeight, _T("name"), _T("墙体造型底高"));
			xmlTree.SetAttribute(posItemHeight, _T("comment"), _T("从零标高到墙体造型底的相对高度"));
			strText.Format(_T("%f"), GetElevation());
			xmlTree.SetItemText(posItemHeight, strText);
		}
	}

	CString strBase = TEntityBase::GetXml(mat);
	CString strXml = xmlTree.GetXml();
	int nIndex = strXml.Find(_T("<Object_ID"));
	strXml.Insert(nIndex, strBase);

	return strXml;
}

//add by xlc on 110408 抽取保温线
Acad::ErrorStatus TDbWallPatch::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
{
	// sg delete 110907，为了保证图纸导出后的门窗显示正确，恢复到和8.5B2版本一致

	if (g_nSaveTArchVer < 10)
	{
		TGGiExplodeDraw dcSrc(entSet);
		dcSrc.m_bFullExplode = TRUE;
		AcDbVoidPtrArray arpents;
		dcSrc.SetPropertiesFrom(GetMe());
		if (nDrawMode == DRAW_2D)
		{//导出T9时需要T20的保温和填充 wlw add 140219
			int nFlag = 1;
			m_XDataMap.SetAt(_T("DownGradeSaveFlag"), nFlag);
			ExplodeOrDraw2d(dcSrc);
			nFlag = 0;
			m_XDataMap.SetAt(_T("DownGradeSaveFlag"), nFlag);
			for (int i = 0; i < entSet.length(); i++)
			{
				AcDbEntity *pent = (AcDbEntity*)entSet[i];
				if ( (pent->isKindOf(TDbPolyPathArray::desc())) )
				{
					arpents.append(entSet[i]);
				}
				/*导出低版本不支持，否则与全局填充重叠
				else if (pent->isKindOf(AcDbHatch::desc()))
				{
					BOOL bIsWallHatch = FALSE;
					OPENOBJ_BEGIN(*m_lstIdsForPatch[0], AcDb::kForRead, TDbWall, pWall);
					pWall->GetSpecialtyDataReadOnly()->GetAt(bKET_WALL_HATCH_OP, bIsWallHatch);
					OPENOBJ_END()

					if (bIsWallHatch)
					{//只有是自定义的hatch才导出
						if (pent->layerId() == m_idLayerHatch2d)
						{
							arpents.append(entSet[i]);
						}
					}
				}
				*/
			}
			entSet = (arpents);
		}
	}
	return TDbEntity::DownGradeSave(nDrawMode, entSet, bErase);
/*
	Acad::ErrorStatus es = Acad::eOk;

	if (nDrawMode == DRAW_3D)
	{
		if (bErase)
		{
			*bErase = FALSE;
		}
		return es;
	}

	if (g_nSaveTArchVer <= 8)	//TArch8之前版本
	{
		if (GetInsulateThick() < 1.e-5 || !HasInsulate())	//无保温
		{
			if (bErase)
			{
				*bErase = FALSE;
			}
		}
		else
		{
			TDbWallPatch *pNewSet=NULL;
			{
				XPushMemVar<int> vTemp(g_nSaveTArchVer,_TCH_VERSION);
				pNewSet=(TDbWallPatch*)clone();
			}
			pNewSet->SetInsulate(FALSE);
			for (int n = 0; n < m_lstIdsForPatch.Length(); n++)
			{
				pNewSet->AddPatchId(*m_lstIdsForPatch[n]);
			}
			entSet.append(pNewSet);

			TGGiExplodeDraw dc(entSet);
			BOOL bInsulate = HasInsulate();
			//得到所有邻接墙、柱的外轮廓
			TDPtrList<TGGePoly2D> lstWallOut,lstWallOutInsulate;
			TDualPtrList<AcDbObjectId> lstColu;
			for (int i = 0; i<m_lstIdsForPatch.Length(); i++) 
			{
				OPENOBJ_BEGIN(*m_lstIdsForPatch[i], AcDb::kForRead, TDbWall, pWall);
				if (pWall) 
				{
					TGGePoly2D polyOut(1);
					pWall->GetOutlinePoly(0, polyOut); 
					lstWallOut.Append(new TGGePoly2D(polyOut));
					//保温层裁剪需要考虑到墙的保温
					pWall->GetOutlinePoly(0, polyOut,1); 
					lstWallOutInsulate.Append(new TGGePoly2D(polyOut));

					if (lstColu.Find(pWall->GetStartColumnId()) == NOT_FOUND)
					{
						OPENOBJ_BEGIN(pWall->GetStartColumnId(),AcDb::kForRead,TDbColumn,pColu)
						if (pColu)
						{
							TGGePoly2D polyOut = pColu->GetOutlinePoly();
							polyOut.SetElevation(0);
							lstWallOut.Append(new TGGePoly2D(polyOut));			
							dc.PushClip(polyOut);
						}
						OPENOBJ_END()
						lstColu.AddTail(pWall->GetStartColumnId());
					}

					if (lstColu.Find(pWall->GetEndColumnId()) == NOT_FOUND)
					{
						OPENOBJ_BEGIN(pWall->GetEndColumnId(),AcDb::kForRead,TDbColumn,pColu)
							if (pColu)
							{
								TGGePoly2D polyOut = pColu->GetOutlinePoly();
								polyOut.SetElevation(0);
								lstWallOut.Append(new TGGePoly2D(polyOut));
								dc.PushClip(polyOut);
							}
						OPENOBJ_END()

						lstColu.AddTail(pWall->GetEndColumnId());
					}
				}
				OPENOBJ_END();
			}

			//计算大融合体外轮廓
			TDPtrList<TGGePoly2D> lstMyPoly,lstUnion;
			TGGePoly2D polyInsulate;
			TGGePoly2D polyUnionInsulate(m_polyOutline);
			bool bzoom = true;
			if (GetUsageFlag() == kConcave)
			{
				bzoom = false;
			}

			if (bInsulate)
			{
				//计算大融合体外轮廓
				lstMyPoly.Reset();
				lstUnion.Reset();
				if (lstWallOut.Length() > 0)
				{
					lstWallOut.Remove(0);
				}
				lstWallOutInsulate << lstWallOut;

				GetOffsetPoly2D(m_polyOutline, polyInsulate, m_nInsulateThick,bzoom);
				polyInsulate.SetElevation(0);
				lstMyPoly.Append(new TGGePoly2D(polyInsulate));

				Union(lstMyPoly,lstWallOutInsulate,lstUnion);

				if (lstUnion.Length() == 1)
				{
					polyUnionInsulate = *lstUnion[0];
				}
				else
				{
					TDPtrList<TGGeCurveSegment> lstCurve;
					ExplodePoly2D(polyInsulate,lstCurve);

					for (long i = 0; i < lstWallOutInsulate.Length(); i++)
					{
						ExplodePoly2D(*lstWallOutInsulate[i],lstCurve);
					}

					TGGePoly2D polyTemp(1);
					if (GetExternalBoundary(lstCurve,polyTemp,TRUE) == RTNORM)
					{
						polyUnionInsulate = polyTemp;
					}
				}
			}

			DrawInsulateLine(polyInsulate,polyUnionInsulate,bzoom,dc);

			if (bErase)
			{
				*bErase = TRUE;
			}
		}
	}
	else
	{
		if (bErase)
		{
			*bErase = FALSE;
		}
	}

	return es;
*/
}