//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName	:   TDbWall类
// = Version	:   ver1.0
// = Author		:   cet
// = CreateDate	:   2011-05-09
// = Description:   剪力墙类实现
// = Maintainers: 
//                  
//------------------------------------------------------------------------+

#include "StdAfx.h"
#ifdef TASD
#include "TDbWall.h"
#include "TAsdKeyDefine.h"

/*
Acad::ErrorStatus TDbWall::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbBaseWall::dwgInFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer > g_nVersion)			// Version is too new
	{
		return Acad::eMakeMeProxy;
	}

	pFiler->readItem(&m_idLayerLoad);
	pFiler->readItem(&m_idLayerLoadL);
	pFiler->readItem(&m_idLayerLoadC);
	pFiler->readItem(&m_idTextStyle);
	pFiler->readItem(&m_idTextStyleRB);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbWall::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbBaseWall::dwgOutFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	pFiler->writeItem(g_nVersion);

	pFiler->writeItem(m_idLayerLoad);
	pFiler->writeItem(m_idLayerLoadL);
	pFiler->writeItem(m_idLayerLoadC);
	pFiler->writeItem(m_idTextStyle);
	pFiler->writeItem(m_idTextStyleRB);

	return pFiler->filerStatus();
}
*/
Acad::ErrorStatus TDbWall::StruExplodeOrDraw3d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();
	
	//modify by xlc on 120112荷载显示控制
 	if((DocGetWallShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == WALLLOAD)
 	{
		DrawWallLoad3D(dc);
 	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbWall::StruExplodeOrDraw2d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();

	// 墙尺寸
	if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0)
	{
		AcGiCommonDraw *dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
		if (!dcCommon->context()->isPlotGeneration())
		{
			if(DocGetShowBH() && DocGetWallShowBH())
			{
				DrawBH(dc);
			}
		}
	}

	// 墙编号
	if(DocGetShowNo() && DocGetWallShowCL())
	{
		DrawCLab(dc);
	}

	//modify by xlc on 120112荷载显示控制
	//if (DocGetShowLoadPara())
 	if((DocGetWallShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == WALLLOAD)
 	{
		DrawWallLoad(dc);
 	}

	//if (!g_bDetailMode)			//简图
	//{

	//	TGGeCurveSegment seg;
	//	GetBaseLine(seg);
	//	seg.SetElevation(0.0);

	//	dc << seg;
	//	return Acad::eOk;
	//}

	// 绘制线
	// 双线绘制样式
/*	TBaseWallLine bwlThis;
	GetThisBaseWallLine(bwlThis);

	// 融合剪力墙
	TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
	GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);

	// 起点融合
	TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);

	// 终点融合
	TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);

	// 墙内融合
	for (int i = 0; i < arBaseWallLinesM.Length(); i++)
	{
		TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
	}

	// 融合柱子
	TDbStruColumn *pStruColumn = NULL;
	for (i = 0; i < m_arColumnIds.length(); i++) 
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();

			poly2d.SetElevation(0.0);

			TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
		}
	}

	// 融合洞并绘制增加的墙线
	IntegrateWallHole(bwlThis);
	DrawHoleSideLine2d(dc);

	TGGeVisibilityPoly2D left, right;
	left = bwlThis.GetLeftLine();
	right = bwlThis.GetRightLine();
	AcDbObjectIdArray idArr;
	GetCoverSlab(idArr);
	if (idArr.length() > 0) // 有板
	{
		DrawWallLine2dForCoverSlab(dc, left);
		DrawWallLine2dForCoverSlab(dc, right);
	}
	else
	{
		DrawBaseWall2d(dc, left, true);
		DrawBaseWall2d(dc, right, false);
	}

	// 封闭墙体端点出封口
	int nLen = arBaseWallLinesS.Length();
	bool bHasColumn = IsLinkColumn(true);
	if (nLen == 0 && !bHasColumn) // 起点封口
	{
		if (!(left.GetVisibleAt(0) == AcDb::kInvisible && right.GetVisibleAt(0) == AcDb::kInvisible))
		{
			dc << TGGeLine(*left[0], *right[0]);
		}
	}
	else if (nLen == 1 && !bHasColumn) // 处理起点处有一个融合墙体时，墙体端点两点连线平行的情况
	{
		AcDbObjectId idWall;
		GetWallId(true, idWall);
		DrawSideLine2d(true, idWall, bwlThis, dc);
	}
	else if (nLen == 0 && bHasColumn) // 起点关联柱子
	{
		DrawSideLine2d(true, dc);
	}
      
	nLen = arBaseWallLinesE.Length();
	bHasColumn = IsLinkColumn(false);
	if (arBaseWallLinesE.Length() == 0 && !bHasColumn) // 终点封口
	{
		if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible && right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
		{
			dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);	
		}		
	}
	else if (nLen == 1 && !bHasColumn) // 处理终点处有一个融合墙体时，墙体端点两点连线平行的情况
	{
		AcDbObjectId idWall;
		GetWallId(false, idWall);
		DrawSideLine2d(false, idWall, bwlThis, dc);
	}
	else if (nLen == 0 && bHasColumn) // 终点关联柱子
	{
		DrawSideLine2d(false, dc);
	}
*/
	return Acad::eOk;
}

// 几何形心上的曲线, 端点位置不能作为准确的依据
TGGeCurveSegment TDbWall::GetCenterLine() const
{
	double lWidth = m_lWidth, rWidth = m_rWidth;

	double nGeomCenterLeftOffset = (lWidth - rWidth) / 2.0;
	TGGeCurveSegment cv = TGGeCurveSegment::Offset(OFFSET_LEFT, nGeomCenterLeftOffset, LS_FINITE);

	return cv;
}

/*
Acad::ErrorStatus TDbWall::GetExtents2d( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	TGGePoly2D poly2d;
	GetPoly2D(poly2d);
	poly2d.GetExtend(ptLow, ptUp);
	ptLow.z = 0.0;
	ptUp.z = 0.0;
	return Acad::eOk;
}

Acad::ErrorStatus TDbWall::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	GetExtents2d(ptLow, ptUp);
	
	double dH = 0.0;
	GetAt(KEY_H, dH);
	
	AcGePoint3d ptS;
	GetAt(KEY_START, ptS);

	double dTopE1(0),dTopE2(0);
	GetAt(KEY_TOPE1, dTopE1);
	GetAt(KEY_TOPE2, dTopE2);

	ptLow.z = ptS.z - dH;
	ptUp.z = ptS.z + (dTopE1 > dTopE2 ? dTopE1 : dTopE2);
	return Acad::eOk;
}

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

}

const TCHAR * TDbWall::GetDefaultLayer() const
{
	return LAY_S_WALL_PLAN_LINE;
}

BOOL TDbWall::IsValid() const
{
	assertReadEnabled();
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	double dWidth = 0.0;
	GetAt(KEY_W, dWidth);

	if (fabs(ptS.z - ptE.z) < _DIST_SNAP && dWidth > 0)
	{
		return true;
	}

	return false;
}
*/
/*int TDbWall::GetCtrlToggleIndex() const
{
	return 10;
}*/
/*
void TDbWall::CopyPropertiesFrom( AcDbEntity *pSrcEntity, unsigned gMatchFlag )
{
	assertReadEnabled();
	TDbBaseWall::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	TDbWall *pEnt = TDbWall::cast(pSrcEntity);
	if(pEnt != NULL)
	{
		double dWidth = 0.0, dHeight = 0.0;
		GetAt(KEY_W, dWidth);
		GetAt(KEY_H, dHeight);
		int nWeight = 0;
		GetAt(KEY_WEIGHT, nWeight);

		GetSpecialtyData()->Empty();
		m_mapXData = pEnt->m_mapXData;
		
		SetAt(KEY_W, dWidth); 
		SetAt(KEY_H, dHeight);
		SetAt(KEY_WEIGHT, nWeight);

		if(database() == NULL ||
			pSrcEntity->database() == NULL ||
			database() == pSrcEntity->database())
		{
			m_idLayerLoad = pEnt->m_idLayerLoad;
			m_idLayerLoadL = pEnt->m_idLayerLoadL;
			m_idLayerLoadC = pEnt->m_idLayerLoadC;
			m_idTextStyle = pEnt->m_idTextStyle;
			m_idTextStyleRB	= pEnt->m_idTextStyleRB;
		}
	}
}


void TDbWall::MakeAssocRelation( AcDbObjectIdArray& ids )
{
	assertWriteEnabled();

	if(ids.length() < 1)
	{
		return;
	}

	TPickEntSet ss(SS_FREE);
	ads_name eName;
	for (int i = 0; i < ids.length(); i++)
	{
		if (acdbGetAdsName(eName, ids[i]) == Acad::eOk)
		{
			ss += ids[i];
		}
	}
	
	TEntitySet ent;
#ifdef TESTCASE
	//简单方式手动建立关联
	for (long j = 0; j < ss.Length(); j++)
	{
		ent = ss[j];
		if (ent.Is(_T("ATS_WALL"))) // 剪力墙
		{
			if (!m_arAssocBWallIds.contains(ids[j])) // 剪力墙标高相同
			{
				m_arAssocBWallIds.append(ids[j]);
			}
		}
		else if (ent.Is(_T("ATS_COLUMN"))) // 柱子
		{
			if (!m_arColumnIds.contains(ids[j])) // 标高相同
			{
				m_arColumnIds.append(ids[j]);
			}
		}
		else if (ent.Is(_T("TCH_STRU_HOLE"))) // 墙洞
		{	
			if (!m_arHoleIds.contains(ids[j]))
			{
				m_arHoleIds.append(ids[j]);
			}
		}
		else if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
		{
			if (!m_arSlabIds.contains(ids[j]))
			{
				m_arSlabIds.append(ids[j]);
			}
		}
	}
	return;
#endif
	
	TGGePoly2D poly;					//墙闭合平面
	GetPoly2D(poly);

	double dWidth = 0;					//墙平面宽
	GetTotalWidth(dWidth);

	TGGeCurveSegment cvCL = GetCenterLine();
	cvCL.SetLineFlag(LS_INFINITE);

	double dElevS = cvCL.StartPoint().z;
	double dElevE = cvCL.EndPoint().z;
	bool bModFlg = false;				//记录墙的中心线是否调整
	double dGap(0);
	AcDbObjectId idObj;

	for (long j = 0; j < ss.Length(); j++)
	{
		ent = ss[j];
		if (ent.Is(_T("ATS_WALL"))) //剪力墙
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;
			pEnt->GetPoly2D(polyDest);

			double dWidthDest(0);
			pEnt->GetTotalWidth(dWidthDest);

			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly, polyDest, dGap);
			//间隙小于墙宽一半时，当作关联处理
			if(bRet && (dGap < dWidth*0.5 || dGap < dWidthDest*0.5))
			{
				if (cvCL.Is(CURVE_LINE))
				{
					idObj = pEnt->objectId();
					//建立关联时对墙的中心线进行校验，相交
					TGGeCurveSegment cvCLDest = pEnt->GetCenterLine();
					cvCLDest.SetLineFlag(LS_INFINITE);

					TADSGePoint3d ptInter1,ptInter2;
					int nNum = cvCL.Intersection(cvCLDest,ptInter1,ptInter2);
					if (nNum == 0)				//没有交点，返回
					{
						
					}
					else
					{
						//两个交点时取离cvCL中点近的
						if (nNum == 2)
						{
							TADSGePoint3d ptMid = cvCL.MidPoint();
							ptInter1 = TGGeLine(ptInter1, ptInter2).NearPoint(ptMid);
						}

						bool bModBreak = false;
						int nHitFlag = cvCL.HitTest2d(ptInter1);
						if (nHitFlag == 6)			//起始侧延长线
						{
							bModFlg = true;
							bModBreak = true;
							cvCL.SetStartPoint(ptInter1);
						}
						else if (nHitFlag == 7)		//终止侧延长线
						{
							bModFlg = true;
							bModBreak = true;
							cvCL.SetEndPoint(ptInter1);
						}

						//add by xlc on 120417 墙自动打断
						if (g_bAutoBreak)
						{
							if (bModBreak)
							{
								Acad::ErrorStatus es = upgradeOpen();
								if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
								{
									AcGePoint3d pt = cvCL.StartPoint();
									pt.z = dElevS;
									SetAt(KEY_START, pt);

									pt = cvCL.EndPoint();
									pt.z = dElevE;
									SetAt(KEY_END, pt);
								}
							}

							bool bBreak = false;
							if(nHitFlag == 5)			//交点在线内时对自己进行打断
							{
								if(BreakAt(ptInter1,NULL))
								{
									bModFlg = false;
									bBreak = true;
								}
							}

							bool bModifyOld = g_bModifyAgain;
							pEnt->BreakAt(ptInter1, NULL);
							g_bModifyAgain = bModifyOld;

							if (bBreak)
							{
								break;
							}
						}

					}
				}
			}
			else
			{
				continue;
			}
			OPENOBJ_END();	

			if (!m_arAssocBWallIds.contains(idObj)) 
			{
				m_arAssocBWallIds.append(idObj);
			}

		}
		else if (ent.Is(_T("ATS_COLUMN"))) // 柱子
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruColumn, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;
			pEnt->GetOutline(polyDest);
			polyDest.SetElevation(0);

			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly,polyDest,dGap);
			//间隙小于墙宽一半时，当作关联处理
			if (bRet && dGap < dWidth*0.5)
			{
				if (g_bAutoBreak)
				{
					AcGePoint3d pt;
					pEnt->GetAt(KEY_INSPTI, pt);

					BreakAt(TADSGePoint3d(pt), &polyDest);
				}
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();

			if (!m_arColumnIds.contains(idObj))
			{
				m_arColumnIds.append(idObj);
			}
		}
		else if (ent.Is(_T("TCH_STRU_HOLE"))) // 墙洞
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWallHole, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;
			TGGeCurveSegment cv;
			pEnt->GetOutlinePoly2D(0, polyDest, cv);
			polyDest.SetElevation(0);

			// 判断间隙
			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly,polyDest,dGap);
			if (bRet && dGap < _DIST_SNAP)
			{
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();

			if (!m_arHoleIds.contains(idObj))
			{
				m_arHoleIds.append(idObj);
			}
		}
		else if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruFloorSlab, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;
			pEnt->GetOutline(polyDest);
			polyDest.SetElevation(0);

			// 判断间隙
			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly,polyDest,dGap);
			if (bRet && dGap < _DIST_SNAP)
			{
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();

			if (!m_arSlabIds.contains(idObj))
			{
				m_arSlabIds.append(idObj);
			}
		}
	}

	// 修改墙的端点
	if (bModFlg)
	{
		Acad::ErrorStatus es = upgradeOpen();
		if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
		{
			AcGePoint3d pt = cvCL.StartPoint();
			pt.z = dElevS;
			SetAt(KEY_START, pt);

			pt = cvCL.EndPoint();
			pt.z = dElevE;
			SetAt(KEY_END, pt);
		}
	}
}

void TDbWall::RemoveAssocRelation( AcDbObjectId& id )
{
	m_arAssocBWallIds.remove(id);
	m_arColumnIds.remove(id);
	m_arHoleIds.remove(id);
	m_arSlabIds.remove(id);
}

Acad::ErrorStatus TDbWall::DrawSideLine2d(bool bStart, const AcDbObjectId &idWall, const TBaseWallLine &wallLine, TGGiExplodeDrawBase &dc) const
{
	TDbWall *pWall = NULL;
	acdbOpenObject(pWall, idWall, AcDb::kForRead);
	if (pWall != NULL)
	{
		TBaseWallLine bwlThat;
		pWall->GetThisBaseWallLine(bwlThat);
		int nThatWeight = 0;
		pWall->GetAt(KEY_WEIGHT, nThatWeight);
		pWall->close();

		// 判断墙线融合方式
		TADSGePoint3d ptThat1,ptThat2;
		TBaseWallLine bwlThis;
		GetThisBaseWallLine(bwlThis);
		int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
		if (nType == 1) // 起始端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[0];
			ptThat2 = *rightThat[0];
		}
		else if (nType == 2) // 终止端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[leftThat.Length() - 1];
			ptThat2 = *rightThat[leftThat.Length() - 1];
    	}
		else
		{
			return Acad::eOk;
		}

		if (!!ptThat1 && !!ptThat2)
		{
			TADSGePoint3d ptThis1,ptThis2;
			TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
			TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
			if (bStart) 
			{
				ptThis1 = *leftThis[0];
				ptThis2 = *rightThis[0];
			}
			else
			{
				ptThis1 = *leftThis[leftThis.Length() - 1];
				ptThis2 = *rightThis[rightThis.Length() - 1];
			}

			AcGeVector3d vtThat = ptThat1 - ptThat2;
			AcGeVector3d vtThis = ptThis1 - ptThis2;
			int nThisWeight = 0;
			GetAt(KEY_WEIGHT, nThisWeight);
			if (vtThis.isParallelTo(vtThat)) // 端点连线平行
			{
				if (nThisWeight < nThatWeight) // 比较优先级
				{
					dc << TGGeLine(ptThis1, ptThis2);
				} 
				else
				{
					bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP) 
										  || (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
					if (!bSuperposition)
					{
						// 将that的融合端点投影到this融合端点连线的直线上
						std::vector<TADSGePoint3d> vecPt;
						vecPt.push_back(ptThis1);
						vecPt.push_back(ptThis2);
						TADSGePoint3d pt;
						TGGeLine line(ptThis1, ptThis2);
						ptThat1.Project(&line, pt);
						vecPt.push_back(pt);
						ptThat2.Project(&line, pt);
						vecPt.push_back(pt);

						// 求两点间的距离
						std::map<double, std::vector<TADSGePoint3d> > mapData;
						std::vector<TADSGePoint3d> vecTemp;
						std::vector<TADSGePoint3d>::iterator it1, it2;
						for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
						{
							it2 = it1;
							++it2;
							for (; it2 != vecPt.end(); it2++)
							{
								vecTemp.clear();
								vecTemp.push_back(*it1);
								vecTemp.push_back(*it2);
								mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
							}
						}

						// 获取距离最远的点
						std::map<double, std::vector<TADSGePoint3d> >::iterator it;
						it = mapData.end();
						--it;
						vecTemp.clear();
						vecTemp.push_back((*it).second[0]);
						vecTemp.push_back((*it).second[1]);

						// 从vecPt中删除最远的两点
						for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
						{
							for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
							{
								if ((*it1).Distance(*it2) < _DIST_SNAP)
								{
									vecPt.erase(it2);
									break;;
								}
							}
						}
						
						// this的融合端点是否与最远点重合
						if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis1.Distance(vecPt[0]);
							double dDist2 = ptThis1.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								dc << TGGeLine(ptThis1, vecPt[0]);
							} 
							else
							{
								dc << TGGeLine(ptThis1, vecPt[1]);
							}
						}

						if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis2.Distance(vecPt[0]);
							double dDist2 = ptThis2.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								dc << TGGeLine(ptThis2, vecPt[0]);
							} 
							else
							{
								dc << TGGeLine(ptThis2, vecPt[1]);
							}
						}
					}
				}
			}
			else if (nThatWeight != nThisWeight) // 优先级不同 
			{
				TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
				TGGeVisibilityPoly2D right = wallLine.GetRightLine();
				if (bStart)
				{
					dc << TGGeLine(*left[0], *right[0]);
				} 
				else
				{
					dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);
				}
			}
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbWall::DrawSideLine2d(bool bStart, TGGiExplodeDrawBase &dc) const
{
	// 查看端点与柱子是否发生融合
	TBaseWallLine bwLine;
	GetThisBaseWallLine(bwLine);
	TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
	TGGeVisibilityPoly2D right = bwLine.GetRightLine();
	TADSGePoint3d pt1, pt2; // 端点
	if (bStart) // 起点
	{
		pt1 = *left[0];
		pt2 = *right[0];
	}
	else // 终点
	{
		pt1 = *left[left.Length() - 1];
		pt2 = *right[right.Length() - 1];
	}

	AcDbLine line(pt1, pt2);
	TDbStruColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			bool bLink1 = (pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE;
			bool bLink2 = (pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE;
			// 端点只要一点与柱子相连时，墙体部分封口
			if ((bLink1 && !bLink2) || (!bLink1 && bLink2))
			{
				TADSGePoint3d pt;   
				if (bLink1 && !bLink2)
				{
					pt = pt2;
				} 
				else
				{
					pt = pt1;
				}

				AcDbLine  line(pt1,pt2);
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				AcGePoint3dArray arrPt;
				line.intersectWith(pCurve, AcDb::kOnBothOperands, arrPt);
				if (arrPt.length() == 1)
				{
					pt1 = arrPt[0]; // 将AcGePoint3d转化为TADSGePoint3d
					dc << TGGeLine(pt, pt1);
				}
				else if (arrPt.length() > 1)
				{
					std::map<double, TADSGePoint3d> data;
					for (int i = 0; i < arrPt.length(); i++)
					{
						data.insert(std::make_pair(pt.Distance(arrPt[i]), arrPt[i]));
					}

					//获得最近的交点
					pt1 = (*data.begin()).second;
					dc << TGGeLine(pt1, pt);
				}

				break;
			}
			else if (!bLink1 && !bLink2) // 两点都与poly2d不相连
			{
				AcGePoint3dArray ptArr;
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				if (pCurve != NULL)
				{
					pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr);
					if (ptArr.length() == 1)
					{
						dc << TGGeLine(pt1, pt2);
						break;
					}
					else if (ptArr.length() == 2)
					{
						double dDist1 = 0.0, dDist2 = 0.0;
						dDist1 = pt1.Distance(ptArr[0]);
						dDist2 = pt1.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							dc << TGGeLine(pt1, asDblArray(ptArr[0]));
						}
						else
						{
							dc << TGGeLine(pt1, asDblArray(ptArr[1]));
						}
						
						dDist1 = pt2.Distance(ptArr[0]);
						dDist2 = pt2.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							dc << TGGeLine(pt2, asDblArray(ptArr[0]));
						}
						else
						{
							dc << TGGeLine(pt2, asDblArray(ptArr[1]));
						}
						break;
					}
				}
			}
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbWall::DrawHoleSideLine2d(TGGiExplodeDrawBase &dc) const
{
	TBaseWallLine wallLine;
	GetThisBaseWallLine(wallLine);
	TGGeVisibilityPoly2D &left = wallLine.GetLeftLine();
	TGGeVisibilityPoly2D &right = wallLine.GetRightLine();
	double dWallWidth = 0.0;
	GetAt(KEY_W, dWallWidth);

	for(int i = 0; i < m_arHoleIds.length(); i++)
	{
		TDbWallHole *pHole = NULL;
		acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
		if (pHole == NULL)
		{
			continue;
		}

		int nShapeType = -1;
		pHole->GetAt(KEY_SECTYP, nShapeType);
		double dHoleR = 0.0;
		pHole->GetAt(KEY_R, dHoleR);
		if (fabs(dHoleR) > _DIST_SNAP && nShapeType != ST_RECT) // 弧墙只处理矩形洞
		{
			pHole->close();
			continue;
		}

		TGGePoly2D poly;
		TGGeCurveSegment seg;
		pHole->GetOutlinePoly2D(0.0, poly, seg);
		int nHoleStyle = 0;
		pHole->GetAt(KEY_BORE, nHoleStyle);
		double dHoleWidth = 0.0;
		pHole->GetAt(KEY_W, dHoleWidth);
		pHole->close();

		if (poly.Length() != 4)
		{
			continue;
		}
		
		bool bBore = true;
		if (nHoleStyle == 0) // 不贯穿洞
		{	
			bBore = false;
		}

		TGGeCurveSegment seg1, seg2;
		poly.Nth(1, seg1);
		poly.Nth(3, seg2);
		TADSGePoint3d pt1, pt2, pt3, pt4;
		seg1.GetStartPoint(pt1);
		seg1.GetEndPoint(pt2);
		seg2.GetStartPoint(pt3);
		seg2.GetEndPoint(pt4);
		
		if (!(PtIsOnPoly2d(pt1, left) && PtIsOnPoly2d(pt2, left) || PtIsOnPoly2d(pt3, right) && PtIsOnPoly2d(pt4, right)
			|| PtIsOnPoly2d(pt3, left) && PtIsOnPoly2d(pt4, left) || PtIsOnPoly2d(pt1, right) && PtIsOnPoly2d(pt2, right)))
		{
			continue;
		}		

		if (bBore)//贯穿洞
		{
			TGGeCurveSegment seg1, seg2;
			poly.Nth(0, seg1);
			poly.Nth(2, seg2);
			dc << seg1;
			dc << seg2;
		}
		else//不贯穿洞
		{
			TGGeCurveSegment seg1, seg2, seg3;
			poly.Nth(0, seg1);
			poly.Nth(2, seg2);
			poly.Nth(3, seg3);
			dc << seg1;
			dc << seg2;
			dc << seg3;
		}

	}

	return Acad::eOk;
}

void TDbWall::GetPoly2dBehindIntegrate(TGGePoly2D &poly2d) const
{	
	assertReadEnabled();
	TBaseWallLine bwlThis;
	GetThisBaseWallLine(bwlThis);

	// 通过融合剪切墙体
	TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
	GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);

	// 起点融合
	TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);

	// 终点融合
	TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);

	// 端点融合后新生成的墙线
	TGGeVisibilityPoly2D left, right;
	left = bwlThis.GetLeftLine();
	right = bwlThis.GetRightLine();

	// 删除端点出不可见的墙线
	DeleteInVisiblePt(true, left);
	DeleteInVisiblePt(false,left);
	DeleteInVisiblePt(true, right);
	DeleteInVisiblePt(false, right);

	// 有left,right生成闭合poly2d
	AcDbPolyline* pLwPoly = new AcDbPolyline();
	double dBuge = 0.0;
	int nIndex = 0;
	for (int i = 0; i < left.Length(); i++) 
	{
		dBuge = tan(*(left.m_ardbulges[i]) / 4.0);
		pLwPoly->addVertexAt(nIndex, (*left[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}

	for (i = right.Length() - 1; i >= 0; i--) 
	{
		if (i > 0)
		{
			dBuge = tan(*(right.m_ardbulges[i-1]) / 4.0) * (-1);
		} 
		else
		{
			dBuge = 0.0;
		}
		pLwPoly->addVertexAt(nIndex, (*right[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}

	pLwPoly->setClosed(Adesk::kTrue);
	poly2d.SetAcDbCurve(pLwPoly);
	delete pLwPoly;
}

void TDbWall::DeleteInVisiblePt(bool bStart, TGGeVisibilityPoly2D &poly) const
{
	if (bStart) // 删除起点处不可见的点
	{
		for (int i = 0; i < poly.Length(); i++)
		{
			if (poly.GetVisibleAt(i) == AcDb::kInvisible)
			{
				poly.RemoveNode(i);
				continue;
			}
			break;
		}
	} 
	else // 删除终点处不可见的点
	{
		for (int i = poly.Length() - 1; i >= 0 ; i--)
		{
			if (poly.GetVisibleAt(i) == AcDb::kInvisible && i > 0 && poly.GetVisibleAt(i - 1) == AcDb::kInvisible)
			{
				poly.RemoveNode(i);
				continue;
			}
			break;
		}
	}
}

Acad::ErrorStatus TDbWall::DrawLineWall3d( TGGiExplodeDrawBase &dc ) const
{
	TGGePoly2D poly;
	GetPoly2dBehindIntegrate(poly);
	if (poly.Length() != 4)
	{
		return Acad::eOk;
	}

	double dH = 0.0; // 墙高
	GetAt(KEY_H, dH);
	AcGePoint3d pt;
	GetAt(KEY_START, pt);
	poly.SetElevation(pt.z);
	//顶高
	double dTop1 = 0.0, dTop2 = 0.0;
	GetAt(KEY_TOPE1, dTop1);
	GetAt(KEY_TOPE2, dTop2);
	poly[0]->z += dTop1;
	poly[1]->z += dTop2;
	poly[2]->z += dTop2;
	poly[3]->z += dTop1;

	// 绘制左侧面
	TADSGePoint3d ptS = *poly[0], ptE = *poly[1]; // 左墙起点终点
	TGGePoly2D polyBotLeft(1);
	polyBotLeft.AppendNode(ptS);
	polyBotLeft.AppendNode(ptE);
	TADSGePoint3d pt1=ptS,pt2=ptE;
	pt2.z -=dH + dTop2;
	pt1.z -=dH + dTop1;
	polyBotLeft.AppendNode(pt2);
	polyBotLeft.AppendNode(pt1);

	TGGeCurveSegment seg; // 剪力墙型心线
	GetBaseLine(seg);
	seg.StartPoint().z = 0.0;
	seg.EndPoint().z = 0.0;

	// 左墙面洞
	TDPtrList<TGGePoly2D> lstHoleLeft;
	AcGeVector3d vt = ptE - ptS;
	vt.z = 0.0;
	vt.normalize();
	vt.rotateBy(PI / 2, AcGeVector3d::kZAxis);
	AcGeMatrix3d mat;
	double dWidth = 0.0;
	GetAt(KEY_W, dWidth);
	TGGePoly2D poly2d;
	AcGePoint3d ptIns; // 墙洞插入点
	TADSGePoint3d ptTemp;
 	TDbWallHole *pHole = NULL;
	for (int i = 0; i < m_arHoleIds.length(); i++)
	{
		if (!IsHoleInWall(m_arHoleIds[i]))
		{
			continue;
		}

		acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
		if (pHole != NULL)
		{
			poly2d.Reset();
			pHole->GetOutline(poly2d);
			double dHoleThick = 0.0;
			pHole->GetAt(KEY_THICK, dHoleThick);
			int nBore = 0;
			pHole->GetAt(KEY_BORE, nBore);
			pHole->Close();

			if (nBore == 1) // 贯穿
			{
				mat.setToTranslation(vt * dWidth * 0.5);
			} 
			else // 非贯穿
			{
				mat.setToTranslation(vt * dHoleThick * 0.5);
			}
			
			poly2d.TransformBy(mat);
			TGGePoly2D *pPolyIn=new TGGePoly2D(poly2d);
			lstHoleLeft.Append(pPolyIn);
		}
	}

	dc.DrawShell(polyBotLeft, lstHoleLeft);

	// 绘制右侧面
	ptS = *poly[3], ptE = *poly[2]; // 右墙起点终点
	TGGePoly2D polyBotRight(1);
	polyBotRight.AppendNode(ptS);
	polyBotRight.AppendNode(ptE);
    pt1=ptS,pt2=ptE;
	pt2.z -=dH + dTop2;
	pt1.z -=dH + dTop1;
	polyBotRight.AppendNode(pt2);
	polyBotRight.AppendNode(pt1);

 	// 右墙面洞;
	TDPtrList<TGGePoly2D> lstHoleRight;
	pHole = NULL;
	for (i = 0; i < m_arHoleIds.length(); i++)
	{
		if (!IsHoleInWall(m_arHoleIds[i]))
		{
			continue;
		}

		acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
		if (pHole != NULL)
		{
			poly2d.Reset();
			pHole->GetOutline(poly2d);
			double dHoleThick = 0.0;
			pHole->GetAt(KEY_THICK, dHoleThick);
			int nBore = 0;
			pHole->GetAt(KEY_BORE, nBore);
			pHole->Close();

			if (nBore == 1) // 贯穿
			{
				mat.setToTranslation(vt * dWidth * 0.5);
			} 
			else // 非贯穿
			{
				mat.setToTranslation(vt * dHoleThick * 0.5);
			}
			poly2d.TransformBy(mat);
			TGGePoly2D *pPolyIn=new TGGePoly2D(poly2d);
			lstHoleRight.Append(pPolyIn);
		}
	}

	dc.DrawShell(polyBotRight, lstHoleRight);

	AcGeVector3d vtDir = AcGeVector3d::kZAxis;
	// 两起点侧面
	TGGePoly2D polyTemp;
	polyTemp.AppendNode(*poly[0]);
	polyTemp.AppendNode(*poly[3]);
	polyTemp.AppendNode(*poly[3] - vtDir * (dH + dTop1));
	polyTemp.AppendNode(*poly[0] - vtDir * (dH + dTop1));
	dc.DrawShell(polyTemp);

	// 两终点侧面
	polyTemp.Reset();
	polyTemp.AppendNode(*poly[1]);
	polyTemp.AppendNode(*poly[2]);
	polyTemp.AppendNode(*poly[2] - vtDir * (dH + dTop2));
	polyTemp.AppendNode(*poly[1] - vtDir * (dH + dTop2));
	dc.DrawShell(polyTemp);

	// 绘制上下底面
	dc.DrawShell(poly); // 上底面
	for (i = 0; i < poly.Length(); i++)
	{
		poly[i]->z = pt.z;
		*poly[i] -= vtDir * dH;
	}
	dc.DrawShell(poly); // 下底面

	return Acad::eOk;
}

Acad::ErrorStatus TDbWall::DrawArcWall3d( TGGiExplodeDrawBase &dc ) const
{
	TGGePoly2D poly;
	GetPoly2dBehindIntegrate(poly);
	if (poly.Length() != 4)
	{
		return Acad::eOk;
	}
	
	double dH = 0.0, dWidth = 0.0,dBugle = 0.0;
	GetAt(KEY_H, dH);

	//poly.SetElevation(poly[0]->z-dH);
	AcGePoint3d pt;
	GetAt(KEY_START, pt);
	poly.SetElevation(pt.z-dH);

	TGGeArc arcLeft, arcRight; // 左右弧线
	TGGeLine line1,line2;
	if (poly.Nth(0, line1, arcLeft) != ARC_SEGMENT ||  poly.Nth(2, line2, arcRight) != ARC_SEGMENT)
	{
		return Acad::eOk;
	}

	GetAt(KEY_W, dWidth);
	GetAt(KEY_BULGE, dBugle);
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	ptS.z -= dH;  
	ptE.z -= dH;
	TGGeArc arcMid(ptS, ptE, dBugle);
	
	TArc3DWall left(arcMid, dH , dWidth * 0.5, dWidth * 0.5);

	// 洞, 需排序后操作
	TDPtrList<TArcSection> holes;
	TDbWallHole *pHole = NULL;
	std::map<double, TArcSection*> mapHoles;
	AcGePoint3d ptIns;
	TGGeCurveSegment baseLine;
	GetBaseLine(baseLine);
	for (int i = 0; i < m_arHoleIds.length(); i++)
	{
		if (!IsHoleInWall(m_arHoleIds[i]))
		{
			continue;
		}

		acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
		if (pHole != NULL)
		{
			TGGeCurveSegment seg;
			TGGePoly2D poly;
			pHole->GetOutlinePoly2D(pHole->GetBottomElev(), poly, seg);
			TGGePoly2D poly2d;
			pHole->GetOutline(poly2d);
			pHole->GetAt(KEY_POS, ptIns);

			double dHoleHeight = 0.0; // 洞高
			pHole->GetAt(KEY_SUMH, dHoleHeight);
			int nBore = 0;
			pHole->GetAt(KEY_BORE, nBore);
			pHole->Close();
			if (poly2d.Length() != 4) // 弧墙时只处理矩形洞情况
			{
				continue;
			}
  
			double dH2 = fabs(seg.StartPoint().z - ptS.z); // 洞距墙体高度
			seg.SetElevation(ptS.z);

			if (seg.Is(CURVE_ARC))
			{
				TGGeArc arc(seg.StartPoint(),seg.EndPoint(), seg.GetBulge());
				if (nBore == 0) // 当洞不贯穿时，以贯穿方式显示
				{
					// 调整洞的中心线使其在墙的中心线上
					baseLine.SetElevation(seg.StartPoint().z);
					TADSGePoint3d pt1, pt2, pt3;					
					baseLine.ProjectToMe(seg.GetStartPoint(), pt1);
					baseLine.ProjectToMe(seg.GetEndPoint(), pt2);
					baseLine.ProjectToMe(seg.MidPoint(), pt3);
					arc.Set(pt1, pt3, pt2);
				}
				
				TArcSection *pSection = new TArcSection(arc, dH2, dHoleHeight, TRUE);
				baseLine.SetElevation(ptIns.z);
				double dDist = baseLine.PathDistance(ptIns);
				mapHoles.insert(std::make_pair(dDist, pSection));
			}
		}
	}

	std::map<double, TArcSection*>::iterator it;
	for (it = mapHoles.begin(); it != mapHoles.end(); it++)
	{
		holes.Append((*it).second);
	}
	left.MakeWall(dc, arcLeft, arcRight, holes);

	AcGeVector3d vtDir = AcGeVector3d::kZAxis;
	// 两起点侧面
	TGGePoly2D polyTemp;
	polyTemp.AppendNode(*poly[0]);
	polyTemp.AppendNode(*poly[3]);
	polyTemp.AppendNode(*poly[3] + vtDir * dH);
	polyTemp.AppendNode(*poly[0] + vtDir * dH);
	dc.DrawShell(polyTemp);

	// 两终点侧面
	polyTemp.Reset();
	polyTemp.AppendNode(*poly[1]);
	polyTemp.AppendNode(*poly[2]);
	polyTemp.AppendNode(*poly[2] + vtDir * dH);
	polyTemp.AppendNode(*poly[1] + vtDir * dH);
	dc.DrawShell(polyTemp);

	// 绘制上下底面
	TGGePoly2D polyNew;
	poly.Disperse1(polyNew, _AS_SYS_UNIT(g_nCirDeviation));
	dc.DrawShell(polyNew); // 下底面

	for (i = 0; i < polyNew.Length(); i++)
	{
		*polyNew[i] += vtDir * dH;
	}
	dc.DrawShell(polyNew); // 上底面
	
	return Acad::eOk;
}

bool TDbWall::IsLinkColumn(bool bStart) const 
{
	// 查看端点是否发生融合
	TBaseWallLine bwLine;
	GetThisBaseWallLine(bwLine);
	TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
	TGGeVisibilityPoly2D right = bwLine.GetRightLine();
	TADSGePoint3d pt1, pt2; // 端点
	if (bStart) // 起点
	{
		pt1 = *left[0];
		pt2 = *right[0];
	}
	else // 终点
	{
		pt1 = *left[left.Length() - 1];
		pt2 = *right[right.Length() - 1];
	}
	
	AcDbLine line(pt1, pt2);
	AcGePoint3dArray ptArr;
	TDbStruColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			if (((pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE)
				||((pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE))
			{
				return true;
			}

			AcDbCurve *pCurve = poly2d.AsAcDbCurve();
			if (pCurve != NULL && pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr) == Acad::eOk
				&& ptArr.length() > 0)
			{
				return true;
			}
		}
	}
	return false;
}

void TDbWall::GetPoly2D(TGGePoly2D &poly2d) const
{
	TBaseWallLine wallLine;
	GetThisBaseWallLine(wallLine);
	TGGeVisibilityPoly2D left, right;
	left = wallLine.GetLeftLine();
	right = wallLine.GetRightLine();

	AcDbPolyline* pLwPoly = new AcDbPolyline();
	double dBuge = 0.0;
	int nIndex = 0;
	for (int i = 0; i < left.Length(); i++) 
	{
		dBuge = tan(*(left.m_ardbulges[i]) / 4.0);
		pLwPoly->addVertexAt(nIndex, (*left[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}

	for (i = left.Length() - 1; i >= 0; i--) 
	{
		if (i > 0)
		{
			dBuge = tan(*(right.m_ardbulges[i-1]) / 4.0) * (-1);
		} 
		else
		{
			dBuge = 0.0;
		}
		pLwPoly->addVertexAt(nIndex, (*right[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}

	pLwPoly->setClosed(Adesk::kTrue);
	poly2d.SetAcDbCurve(pLwPoly);
	delete pLwPoly;
}

void TDbWall::GetBaseLine(TGGeCurveSegment &seg) const
{
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	double dBulge = 0.0;
	GetAt(KEY_BULGE,dBulge);
	TGGeCurveSegment segTemp(ptS, ptE, dBulge);
	seg = segTemp;
}
*/
void TDbWall::GetTotalWidth(double &dWidth)const
{
	dWidth = GetWidth(0) + GetWidth(1);
}

// 获得总高度
void TDbWall::GetTotalHeight(double &dHeight)const
{
	dHeight = GetHeight();
}

Acad::ErrorStatus TDbWall::SetStruWidth(double dLeftWidth , double dRightWidth)
{
	assertWriteEnabled();

	m_lWidth = dLeftWidth;
	m_rWidth = dRightWidth;
/*	double dOldLW = 0.0, dOldLeft = 0.0, dOldRight = 0.0;
	GetAt(KEY_W, dOldLW);

	dOldLeft = dOldLW*0.5;
	GetAt(KEY_LWIDTH, dOldLeft);
	
	dOldRight = dOldLW - dOldLeft;
	if (fabs(dLeftWidth - dOldLeft) < _DIST_SNAP && fabs(dRightWidth - dOldRight) < _DIST_SNAP)
	{
		return Acad::eOk;
	}

	double dDist = (dLeftWidth - dRightWidth) - (dOldLeft - dOldRight);
	dDist *= 0.5;

	// 调整型心线位置即起点终点位置
	double dBugle = 0.0;
	GetAt(KEY_BULGE, dBugle);
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	if (fabs(dBugle) < g_angleZero) // 直线
	{
		AcGeVector3d vt = ptS - ptE;
		vt.normalize();
		vt.rotateBy(-PI/2, AcGeVector3d::kZAxis);
		ptS += vt * dDist;
		ptE += vt * dDist;
	}
	else  // 弧线
	{
		TGGeArc arc(ptS, ptE, dBugle);
		AcGePoint3d ptCenter;
		ptCenter = arc.GetCenterPt();
		AcGeVector3d vt = ptCenter - ptS;
		vt.normalize();
		ptS += vt * dDist;
		vt = ptCenter - ptE;
		vt.normalize();
		ptE += vt * dDist;
	}
	SetAt(KEY_START, ptS); 
	SetAt(KEY_END, ptE);*/
	return Acad::eOk;
}
/*
Acad::ErrorStatus TDbWall::DrawWeightLine2d(TGGiExplodeDrawBase &dc) const
{
	// 获取融合后的poly2d
	TGGeVisibilityPoly2D poly;
	GetIntegratedPoly2d(poly);
	poly.Compress();
	
	DrawWeightLine2d(dc, poly, true);

	// 额外绘制融合洞增加的墙线
	DrawWeightHoleSideLine2d(dc);

	return Acad::eOk;
}

Acad::ErrorStatus TDbWall::DrawWeightLine2d(TGGiExplodeDrawBase &dc, TGGeVisibilityPoly2D &poly, bool bVal) const
{
	int nNum = 1;
	if (!bVal)
	{
		nNum = -1;
	}

	double dLineWidth = DocGetConWallLWeight()*GetPScale();
	TGGePoly2D polyDest;
	if (poly.PathArea() > 0) // 顺时针
	{
		poly.Offset(dLineWidth * nNum, polyDest);
	}
	else
	{
		poly.Offset(dLineWidth * (-1) * nNum, polyDest);
	}
	
	if (poly.Length() != polyDest.Length())
	{
		return Acad::eInvalidInput;
	}
	
	TGGePoly2D poly2dNew;
	for (int i = 0; i < poly.Length() - 1; i++)
	{
		if (poly.GetVisibleAt(i) == AcDb::kInvisible)
		{
			continue;
		}
		
		poly2dNew.Reset();
		poly2dNew.AppendNode(*poly[i], *(poly.m_ardbulges[i]));
		poly2dNew.AppendNode(*poly[i+1]);
		poly2dNew.AppendNode(*polyDest[i+1], *(polyDest.m_ardbulges[i]) * (-1));
		poly2dNew.AppendNode(*polyDest[i]);
		poly2dNew.SetClosed();
		dc << TGGeSolid(poly2dNew);
	}
	 
	if (poly.GetVisibleAt(poly.Length() - 1) == AcDb::kVisible)
	{
		poly2dNew.Reset();
		poly2dNew.AppendNode(*poly[poly.Length() - 1], *(poly.m_ardbulges[poly.Length() - 1]));
		poly2dNew.AppendNode(*poly[0]);
		poly2dNew.AppendNode(*polyDest[0], *(polyDest.m_ardbulges[polyDest.Length() - 1]) * (-1));
		poly2dNew.AppendNode(*polyDest[polyDest.Length() - 1]);
		poly2dNew.SetClosed();
		dc << TGGeSolid(poly2dNew);
	}

	return Acad::eOk;
}



void TDbWall::GetIntegratedPoly2d(TGGeVisibilityPoly2D &poly) const
{
	// 双线绘制样式
	TBaseWallLine bwlThis;
	GetThisBaseWallLine(bwlThis);
	
	// 融合剪力墙
	TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
	GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
	// 起点融合
	TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
	// 终点融合
	TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
	// 墙内融合
	for (int i = 0; i < arBaseWallLinesM.Length(); i++)
	{
		TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
	}
	
	// 融合柱子
	TDbStruColumn *pStruColumn = NULL;
	for (i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
		}
	}
	
	// 融合洞
	IntegrateWallHole(bwlThis);
	
	// 生成poly2d
	// 添加左线
	TGGeVisibilityPoly2D left, right;
	left = bwlThis.GetLeftLine();
	right = bwlThis.GetRightLine();
	for (i = 0; i < left.Length(); i++)
	{
		poly.AppendNode(*left[i], *(left.m_ardbulges[i]), left.GetVisibleAt(i));
	}

	// 添加终点封口线
 	int nLen = arBaseWallLinesE.Length();
	bool bHasColumn = IsLinkColumn(false);
	if (arBaseWallLinesE.Length() == 0 && !bHasColumn) // 终点封口
	{
		if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible && right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
		{
			poly.AppendNode(*left[left.Length() - 1]);	
			poly.AppendNode(*right[right.Length() - 1]);
		}		
	}
	else if (nLen == 1 && !bHasColumn) // 处理终点处有一个融合墙体时，墙体端点两点连线平行的情况
	{
		AcDbObjectId id;
		GetWallId(false, id);
		TGGeVisibilityPoly2D polyNew;
		GetSideLine2d(false, id, bwlThis, polyNew);
		polyNew.Compress();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}

		if (polyNew.Length() == 0)
		{
			poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
		}
	}
	else if (nLen == 0 && bHasColumn) // 终点关联柱子
	{
		TGGeVisibilityPoly2D polyNew;
		GetIntegratedPoly2dForColumn(false, polyNew);
		polyNew.Compress();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}
	}
	else
	{
		poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
	}

	// 添加右线
	right.Reverse();
	for (i = 0; i < right.Length(); i++)
	{
		poly.AppendNode(*right[i], *(right.m_ardbulges[i]), right.GetVisibleAt(i));
	}

	//  添加起点封口线
	nLen = arBaseWallLinesS.Length();
	bHasColumn = IsLinkColumn(true);
	if (nLen == 0 && !bHasColumn) // 起点封口
	{
		if (!(left.GetVisibleAt(0) == AcDb::kInvisible && right.GetVisibleAt(0) == AcDb::kInvisible))
		{
			poly.AppendNode(*right[right.Length() - 1]);	// right 已逆转方向
			poly.AppendNode(*left[0]);	
		}
	}
	else if (nLen == 1 && !bHasColumn) // 处理起点处有一个融合墙体时，墙体端点两点连线平行的情况
	{
		AcDbObjectId id;
		GetWallId(true, id);	
		TGGeVisibilityPoly2D polyNew;
		GetSideLine2d(true, id, bwlThis, polyNew);
		polyNew.Compress();
		polyNew.Reverse();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}

		if (polyNew.Length() == 0)
		{
			poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
		}
	}
	else if (nLen == 0 && bHasColumn) // 起点关联柱子
	{
		TGGeVisibilityPoly2D polyNew;
		GetIntegratedPoly2dForColumn(true, polyNew);
		polyNew.Compress();
		polyNew.Reverse();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}
	}
	else
	{
		poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
	}

	poly.SetClosed();
}

void TDbWall::GetIntegratedPoly2dForColumn(bool bStart, TGGeVisibilityPoly2D &poly) const
{
	poly.Reset();
	// 查看端点与柱子是否发生融合
	TBaseWallLine bwLine;
	GetThisBaseWallLine(bwLine);
	TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
	TGGeVisibilityPoly2D right = bwLine.GetRightLine();
	TADSGePoint3d pt1, pt2; // 端点
	if (bStart) // 起点
	{
		pt1 = *left[0];
		pt2 = *right[0];
	}
	else // 终点
	{
		pt1 = *left[left.Length() - 1];
		pt2 = *right[right.Length() - 1];
	}

	pt1.z = 0.0;
	pt2.z = 0.0;

	AcDbLine line(pt1, pt2);
	TDbStruColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			poly2d.SetElevation(0.0);
			bool bLink1 = (pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE;
			bool bLink2 = (pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE;
			// 端点只要一点与柱子相连时，墙体部分封口
			if ((bLink1 && !bLink2) || (!bLink1 && bLink2))
			{
				TADSGePoint3d pt;   
				if (bLink1 && !bLink2)
				{
					pt = pt2;
				} 
				else
				{
					pt = pt1;
				}

				AcDbLine  line(pt1,pt2);
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				AcGePoint3dArray arrPt;
				line.intersectWith(pCurve, AcDb::kOnBothOperands, arrPt);
				if (arrPt.length() == 1)
				{
					if (bLink1 && !bLink2)
					{
						poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
						poly.AppendNode(arrPt[0]);
						poly.AppendNode(pt2);
					} 
					else
					{
						poly.AppendNode(pt1);
						poly.AppendNode(arrPt[0], 0.0, AcDb::kInvisible);
						poly.AppendNode(pt2);
					}
				}
				else if (arrPt.length() > 1)
				{
					std::map<double, TADSGePoint3d> data;
					for (int i = 0; i < arrPt.length(); i++)
					{
						data.insert(std::make_pair(pt.Distance(arrPt[i]), arrPt[i]));
					}

					if (bLink1 && !bLink2)
					{
						poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
						poly.AppendNode((*data.begin()).second);
						poly.AppendNode(pt2);
					} 
					else
					{
						poly.AppendNode(pt1);
						poly.AppendNode((*data.begin()).second, 0.0, AcDb::kInvisible);
						poly.AppendNode(pt2);
					}
				}

				break;
			}
			else if (!bLink1 && !bLink2) // 两点都与poly2d不相连
			{
				AcGePoint3dArray ptArr;
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				if (pCurve != NULL)
				{
					pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr);
					if (ptArr.length() == 1)
					{
						poly.AppendNode(pt1);
						poly.AppendNode(pt2);
						break;
					}
					else if (ptArr.length() == 2)
					{
						double dDist1 = 0.0, dDist2 = 0.0;
						dDist1 = pt1.Distance(ptArr[0]);
						dDist2 = pt1.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							poly.AppendNode(pt1);
							poly.AppendNode(asDblArray(ptArr[0]), 0.0, AcDb::kInvisible);
							poly.AppendNode(pt2);
						}
						else
						{
							poly.AppendNode(pt1);
							poly.AppendNode(asDblArray(ptArr[1]), 0.0, AcDb::kInvisible);
							poly.AppendNode(pt2);
						}
						
						dDist1 = pt2.Distance(ptArr[0]);
						dDist2 = pt2.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
							poly.AppendNode(asDblArray(ptArr[0]));
							poly.AppendNode(pt2);
						}
						else
						{
							poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
							poly.AppendNode(asDblArray(ptArr[1]));
							poly.AppendNode(pt2);
						}
						break;
					}
				}
			}

			if (poly.Length() == 0)
			{
				poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
				poly.AppendNode(pt2);
			}
		}
	}
}

void TDbWall::GetSideLine2d(bool bStart, const AcDbObjectId &idWall, const TBaseWallLine &wallLine, TGGeVisibilityPoly2D &poly) const
{
	poly.Reset();
	TDbWall *pWall = NULL;
	acdbOpenObject(pWall, idWall, AcDb::kForRead);
	if (pWall != NULL)
	{
		TBaseWallLine bwlThat;
		pWall->GetThisBaseWallLine(bwlThat);
		int nThatWeight = 0;
		pWall->GetAt(KEY_WEIGHT, nThatWeight);
		pWall->close();

		// 判断墙线融合方式
		TADSGePoint3d ptThat1,ptThat2;
		TBaseWallLine bwlThis;
		GetThisBaseWallLine(bwlThis);
		int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
		if (nType == 1) // 起始端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[0];
			ptThat2 = *rightThat[0];
		}
		else if (nType == 2) // 终止端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[leftThat.Length() - 1];
			ptThat2 = *rightThat[leftThat.Length() - 1];
    	}
		else
		{
			return;
		}

		if (!!ptThat1 && !!ptThat2)
		{
			TADSGePoint3d ptThis1,ptThis2;
			TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
			TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
			if (bStart) 
			{
				ptThis1 = *leftThis[0];
				ptThis2 = *rightThis[0];
			}
			else
			{
				ptThis1 = *leftThis[leftThis.Length() - 1];
				ptThis2 = *rightThis[rightThis.Length() - 1];
			}

			AcGeVector3d vtThat = ptThat1 - ptThat2;
			AcGeVector3d vtThis = ptThis1 - ptThis2;
			int nThisWeight = 0;
			GetAt(KEY_WEIGHT, nThisWeight);
			if (vtThis.isParallelTo(vtThat)) // 端点连线平行
			{
				if (nThisWeight < nThatWeight) // 比较优先级
				{
					poly.AppendNode(ptThis1);
					poly.AppendNode(ptThis2);
				} 
				else
				{
					bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP) 
										  || (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
					if (!bSuperposition)
					{
						// 将that的融合端点投影到this融合端点连线的直线上
						std::vector<TADSGePoint3d> vecPt;
						vecPt.push_back(ptThis1);
						vecPt.push_back(ptThis2);
						TADSGePoint3d pt;
						TGGeLine line(ptThis1, ptThis2);
						ptThat1.Project(&line, pt);
						vecPt.push_back(pt);
						ptThat2.Project(&line, pt);
						vecPt.push_back(pt);

						// 求两点间的距离
						std::map<double, std::vector<TADSGePoint3d> > mapData;
						std::vector<TADSGePoint3d> vecTemp;
						std::vector<TADSGePoint3d>::iterator it1, it2;
						for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
						{
							it2 = it1;
							++it2;
							for (; it2 != vecPt.end(); it2++)
							{
								vecTemp.clear();
								vecTemp.push_back(*it1);
								vecTemp.push_back(*it2);
								mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
							}
						}

						// 获取距离最远的点
						std::map<double, std::vector<TADSGePoint3d> >::iterator it;
						it = mapData.end();
						--it;
						vecTemp.clear();
						vecTemp.push_back((*it).second[0]);
						vecTemp.push_back((*it).second[1]);

						// 从vecPt中删除最远的两点
						for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
						{
							for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
							{
								if ((*it1).Distance(*it2) < _DIST_SNAP)
								{
									vecPt.erase(it2);
									break;;
								}
							}
						}
						
						// this的融合端点是否与最远点重合
						if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis1.Distance(vecPt[0]);
							double dDist2 = ptThis1.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								poly.AppendNode(ptThis1);
								poly.AppendNode(vecPt[0], 0.0, AcDb::kInvisible);
							} 
							else
							{
								poly.AppendNode(ptThis1);
								poly.AppendNode(vecPt[1], 0.0, AcDb::kInvisible);
							}
						}

						if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis2.Distance(vecPt[0]);
							double dDist2 = ptThis2.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								poly.AppendNode(vecPt[0]);
								poly.AppendNode(ptThis2);
							} 
							else
							{
								poly.AppendNode(vecPt[1]);
								poly.AppendNode(ptThis2);
							}
						}

						if (poly.Length() == 0)
						{
							poly.AppendNode(ptThis1, 0.0, AcDb::kInvisible);
							poly.AppendNode(ptThis2, 0.0, AcDb::kInvisible);
						}
					}
				}
			}
			else if (nThatWeight != nThisWeight) // 优先级不同 
			{
				TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
				TGGeVisibilityPoly2D right = wallLine.GetRightLine();
				if (bStart)
				{
					poly.AppendNode(*left[0]);
					poly.AppendNode(*right[0]);
				} 
				else
				{
					poly.AppendNode(*left[left.Length() - 1]);
					poly.AppendNode(*right[right.Length() - 1]);
				}
			}
		}
	}
}

Acad::ErrorStatus TDbWall::DrawWeightHoleSideLine2d( TGGiExplodeDrawBase &dc ) const
{
	TBaseWallLine wallLine;
	GetThisBaseWallLine(wallLine);
	
	TGGeVisibilityPoly2D &left = wallLine.GetLeftLine();
	TGGeVisibilityPoly2D &right = wallLine.GetRightLine();
	
	double dWallWidth = 0.0;
	GetAt(KEY_W, dWallWidth);
	
	TDbWallHole holeNew;
	TGGePoly2D polyNewHole;
	
	double dLineWidth = DocGetConWallLWeight()*GetPScale();
	for(int i = 0; i < m_arHoleIds.length(); i++)
	{
		TDbWallHole *pHole = NULL;
		acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
		if (pHole == NULL)
		{
			continue;
		}
		TGGePoly2D poly;
		TGGeCurveSegment seg;
		pHole->GetOutlinePoly2D(0.0, poly, seg);
		int nHoleStyle = 0;
		pHole->GetAt(KEY_BORE, nHoleStyle);
		double dHoleWidth = 0.0;
		pHole->GetAt(KEY_W, dHoleWidth);
		holeNew.copyFrom(pHole);
		pHole->close();
		
		if (poly.Length() != 4)
		{
			continue;
		}

		// 修改新洞洞宽，洞厚
		double dWidth = 0.0;
		holeNew.GetAt(KEY_SUMB, dWidth);
		dWidth += 2 * dLineWidth;
		holeNew.SetAt(KEY_SUMB, dWidth);
		double dThick = 0.0;
		holeNew.GetAt(KEY_THICK, dThick);
		dThick += dLineWidth;
		holeNew.SetAt(KEY_THICK, dThick);
		holeNew.GetOutlinePoly2D(0.0, polyNewHole, seg);
		if (polyNewHole.Length() != 4)
		{
			continue;
		}
		
		bool bBore = true;
		if (nHoleStyle == 0) // 不贯穿洞
		{	
			bBore = false;
		}
		
		TGGeCurveSegment seg1, seg2;
		poly.Nth(1, seg1);
		poly.Nth(3, seg2);
		TADSGePoint3d pt1, pt2, pt3, pt4;
		seg1.GetStartPoint(pt1);
		seg1.GetEndPoint(pt2);
		seg2.GetStartPoint(pt3);
		seg2.GetEndPoint(pt4);
		
		if (!(PtIsOnPoly2d(pt1, left) && PtIsOnPoly2d(pt2, left) || PtIsOnPoly2d(pt3, right) && PtIsOnPoly2d(pt4, right)
			|| PtIsOnPoly2d(pt3, left) && PtIsOnPoly2d(pt4, left) || PtIsOnPoly2d(pt1, right) && PtIsOnPoly2d(pt2, right)))
		{
			continue;
		}		
		
		TGGeVisibilityPoly2D polyNew;
		AcDbCurve *pCurve = poly.AsAcDbCurve();
		polyNew.SetAcDbCurve(pCurve);
		delete pCurve;
		if (bBore)//贯穿洞
		{
			polyNew.SetVisibleAt(1, AcDb::kInvisible);
			polyNew.SetVisibleAt(3, AcDb::kInvisible);
		}
		else     //不贯穿洞
		{
			polyNew.SetVisibleAt(1, AcDb::kInvisible);
		}

		// 加粗处理
		TGGePoly2D poly2dNew;
		for (int i = 0; i < polyNew.Length() - 1; i++)
		{
			if (polyNew.GetVisibleAt(i) == AcDb::kInvisible)
			{
				continue;
			}

			poly2dNew.Reset();
			poly2dNew.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]));
			poly2dNew.AppendNode(*polyNew[i+1]);

			poly2dNew.AppendNode(*polyNewHole[i+1], *(polyNewHole.m_ardbulges[i]) * (-1));
			poly2dNew.AppendNode(*polyNewHole[i]);
			poly2dNew.SetClosed();
			dc << TGGeSolid(poly2dNew);
		}

		if (polyNew.GetVisibleAt(polyNew.Length() - 1) == AcDb::kVisible)
		{
			poly2dNew.Reset();
			poly2dNew.AppendNode(*polyNew[polyNew.Length() - 1], *(polyNew.m_ardbulges[polyNew.Length() - 1]));
			poly2dNew.AppendNode(*polyNew[0]);

			poly2dNew.AppendNode(*polyNewHole[0], *(polyNewHole.m_ardbulges[polyNewHole.Length() - 1]) * (-1));
			poly2dNew.AppendNode(*polyNewHole[polyNewHole.Length() - 1]);
			poly2dNew.SetClosed();
			dc << TGGeSolid(poly2dNew);
		}
		
	}
	return Acad::eOk;
}

void TDbWall::IntegrateWallHole(TBaseWallLine &wallLine) const
{
	double dWallWidth = 0.0;
	TGGeVisibilityPoly2D &left = wallLine.GetLeftLine();
	TGGeVisibilityPoly2D &right = wallLine.GetRightLine();

	GetAt(KEY_W, dWallWidth);
	for(int i = 0; i < m_arHoleIds.length(); i++)
	{
		TDbWallHole *pHole = NULL;
		acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
		if (pHole == NULL)
		{
			continue;
		}

		int nShapeType = -1;
		pHole->GetAt(KEY_SECTYP, nShapeType);
		double dHoleR = 0.0;
		pHole->GetAt(KEY_R, dHoleR);
		if (fabs(dHoleR) > _DIST_SNAP && nShapeType != ST_RECT) // 弧墙只处理矩形洞
		{
			pHole->close();
			continue;
		}

		TGGePoly2D poly;
		TGGeCurveSegment seg;
		pHole->GetOutlinePoly2D(0.0, poly, seg);
		int nHoleStyle = 0;
		pHole->GetAt(KEY_BORE, nHoleStyle);
		int nSide = -1;
		pHole->GetAt(KEY_HSIDE, nSide); // 不贯通时，位置标记
		pHole->close();
		
		if (poly.Length() != 4)
		{
			continue;
		}
		
		bool bBore = true;
		if (nHoleStyle == 0) // 不贯穿洞
		{	
			bBore = false;
		}
		
		if (bBore)//贯穿洞
		{
			TGGeCurveSegment seg1, seg2;
			poly.Nth(1, seg1);
			poly.Nth(3, seg2);

			// 判断两条线哪条在左线， 哪条在右线 pt1, pt2 保存左线上的点
			TADSGePoint3d pt1, pt2, pt3, pt4;
			seg1.GetStartPoint(pt1);
			seg1.GetEndPoint(pt2);
			seg2.GetStartPoint(pt3);
			seg2.GetEndPoint(pt4);
			
			if (PtIsOnPoly2d(pt1, left) && PtIsOnPoly2d(pt2, left) && PtIsOnPoly2d(pt3, right) && PtIsOnPoly2d(pt4, right))
			{
			}
			else if (PtIsOnPoly2d(pt3, left) && PtIsOnPoly2d(pt4, left) && PtIsOnPoly2d(pt1, right) && PtIsOnPoly2d(pt2, right))
			{
				TADSGePoint3d ptTemp;
				ptTemp = pt1;
				pt1 = pt3;
				pt3 = ptTemp;
				ptTemp = pt2;
				pt2 = pt4;
				pt4 = ptTemp;
			}
			else
			{
				continue;
			}

			// 判断两点中哪点离线的起点近
			double dDist1 = 0.0, dDist2 = 0.0;
			pt1.z = pt2.z = left[0]->z;
			dDist1 = left.PathDistance2d(pt1);
			dDist2 = left.PathDistance2d(pt2);
			if (dDist1 < dDist2)
			{
				left.InsertNodeAt(pt1, AcDb::kInvisible);
				left.InsertNodeAt(pt2);
			}
			else
			{
				left.InsertNodeAt(pt2, AcDb::kInvisible);
				left.InsertNodeAt(pt1);
			}

			pt3.z = pt4.z = right[0]->z;
			dDist1 = right.PathDistance2d(pt3);
			dDist2 = right.PathDistance2d(pt4);
			if (dDist1 < dDist2)
			{
				right.InsertNodeAt(pt3, AcDb::kInvisible);
				right.InsertNodeAt(pt4);
			}
			else
			{
				right.InsertNodeAt(pt4, AcDb::kInvisible);
				right.InsertNodeAt(pt3);
			}

		}
		else//不贯穿洞
		{
			TGGeCurveSegment seg;
			poly.Nth(1, seg);
			TADSGePoint3d pt1, pt2;
			seg.GetStartPoint(pt1);
			seg.GetEndPoint(pt2);

			if (nSide == 1 && PtIsOnPoly2d(pt1, left) && PtIsOnPoly2d(pt2, left)
				|| nSide == 0 && PtIsOnPoly2d(pt1, right) && PtIsOnPoly2d(pt2, right))
			{
				double dDist1 = 0.0, dDist2 = 0.0;
				pt1.z = pt2.z = left[0]->z;
				if (nSide == 1)
				{
					dDist1 = left.PathDistance2d(pt1);
					dDist2 = left.PathDistance2d(pt2);
				} 
				else if (nSide == 0)
				{
					dDist1 = right.PathDistance2d(pt1);
					dDist2 = right.PathDistance2d(pt2);
				}

				if (dDist1 < dDist2)
				{
					if (nSide == 1) 
					{ 
						left.InsertNodeAt(pt1, AcDb::kInvisible);
						left.InsertNodeAt(pt2);
					} 
					else if (nSide == 0)
					{
						right.InsertNodeAt(pt1, AcDb::kInvisible);
						right.InsertNodeAt(pt2);
					}
				}
				else
				{
					if (nSide == 1) 
					{ 
						left.InsertNodeAt(pt2, AcDb::kInvisible);
						left.InsertNodeAt(pt1);
					} 
					else if (nSide == 0)
					{
						right.InsertNodeAt(pt2, AcDb::kInvisible);
						right.InsertNodeAt(pt1);
					}
				}
			}
		}
		
	}
}

bool TDbWall::PtIsOnPoly2d(const TADSGePoint3d &pt, const TGGePoly2D &poly) const
{
	AcDbPolyline *pCurve = static_cast<AcDbPolyline *>(poly.AsAcDbCurve());
	if (pCurve == NULL)
	{
		return false;
	}

	TADSGePoint3d ptTemp;
	pCurve->getClosestPointTo(pt, ptTemp);
	delete pCurve;
	if (pt.Distance2d(ptTemp) < _DIST_SNAP)
	{
		return true;
	}

	return false;
}

bool TDbWall::IsHoleInWall(const AcDbObjectId &idWall) const
{
	bool bRet = false;
	TDbWallHole *pHole = NULL;
	Acad::ErrorStatus st =acdbOpenObject(pHole, idWall, AcDb::kForRead);
	if (pHole != NULL)
	{
		AcGePoint3d ptIns;
		pHole->GetAt(KEY_POS, ptIns);
		double dHoleHeight = 0.0, dHoleWidth = 0.0;
		pHole->GetAt(KEY_SUMH, dHoleHeight);
		pHole->GetAt(KEY_SUMB, dHoleWidth);
		pHole->close();

		TGGeCurveSegment seg;
		GetBaseLine(seg);
		TADSGePoint3d ptTemp;
		seg.ProjectToMe(ptIns, ptTemp);
		if (ptTemp.Distance2d(ptIns) < _DIST_SNAP) // 插入点在型心线上
		{
			double dDist = ptTemp.Distance(ptIns);
			bool bVal = ptIns.z < ptTemp.z;  //  墙洞插入点在型心线下
			ptIns.z = 0.0;
			seg.StartPoint().z = 0.0;
			seg.EndPoint().z = 0.0;
			double dDist1 = seg.PathDistance(ptIns);
			double dDist2 = seg.PathDistance(ptIns, 0);
			double dWallHeight = 0.0;
			GetAt(KEY_H, dWallHeight);
			if (fabs(dDist1) >= dHoleWidth * 0.5 && fabs(dDist2) > dHoleWidth * 0.5
				&& bVal && dDist >= dHoleHeight && dDist <= dWallHeight)
			{
				bRet = true;
			}
		}
	}
	return bRet;
}

void TDbWall::GetCoverSlab(AcDbObjectIdArray& idArr) const
{
	//modify by cet	111206 多边形时部分遮挡有问题
	//TBaseWallLine baseWallLine;
	//GetThisBaseWallLine(baseWallLine);
	//TGGeVisibilityPoly2D left = baseWallLine.GetLeftLine();
	//TGGeVisibilityPoly2D right = baseWallLine.GetRightLine();
	//left.SetElevation(0.0);
	//right.SetElevation(0.0);
	//AcDbPolyline *pLeft = static_cast<AcDbPolyline*>(left.AsAcDbCurve());
	//if (pLeft == NULL)
	//{
	//	return;
	//}

	//AcDbPolyline *pRight = static_cast<AcDbPolyline*>(right.AsAcDbCurve());
	//if (pRight == NULL)
	//{
	//	delete pLeft;
	//	return;
	//}

	//AcGePoint3dArray ptArrLeft, ptArrRight;
	//AcGePoint3d pt;
	//GetAt(KEY_START, pt);
	//double dWallEle = pt.z;
	//for (int i = 0; i < m_arSlabIds.length(); i++)
	//{
	//	TDbStruFloorSlab *pSlab = NULL;
	//	acdbOpenObject(pSlab, m_arSlabIds[i], AcDb::kForRead);
	//	if (pSlab != NULL)
	//	{
	//		if (pSlab->GetTopElev() > dWallEle - _DIST_SNAP)
	//		{
	//			TGGePoly2D poly;
	//			pSlab->GetOutline(poly);
	//			poly.SetElevation(0.0);
	//			AcDbPolyline *pLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
	//			if (pLine != NULL)
	//			{
	//				ptArrLeft.setLogicalLength(0);
	//				ptArrRight.setLogicalLength(0);
	//				pLine->intersectWith(pLeft, AcDb::kOnBothOperands, ptArrLeft);
	//				pLine->intersectWith(pRight,AcDb::kOnBothOperands, ptArrRight);

	//				if (ptArrLeft.length() > 0 || ptArrRight.length() > 0)
	//				{
	//					idArr.append(m_arSlabIds[i]);
	//				}
	//				delete pLine;
	//			}
	//		}
	//		pSlab->close();
	//	}
	//}

	//delete pLeft;
	//delete pRight;
	TGGePoly2D poly;
	GetPoly2D(poly);
	poly.SetElevation(0.0);
	AcDbPolyline *pWallLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
	if (pWallLine == NULL)
	{
		return;
	}

	AcGePoint3dArray ptArr;
	AcGePoint3d pt;
	GetAt(KEY_START, pt);
	double dWallEle = pt.z;
	for (int i = 0; i < m_arSlabIds.length(); i++)
	{
		TDbStruFloorSlab *pSlab = NULL;
		acdbOpenObject(pSlab, m_arSlabIds[i], AcDb::kForRead);
		if (pSlab != NULL)
		{
			if (pSlab->GetTopElev() > dWallEle - _DIST_SNAP)
			{
				TGGePoly2D poly;
				pSlab->GetOutline(poly);
				poly.SetElevation(0.0);
				AcDbPolyline *pLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
				if (pLine != NULL)
				{
					ptArr.setLogicalLength(0);
					pLine->intersectWith(pWallLine, AcDb::kOnBothOperands, ptArr);

					if (ptArr.length() > 0)
					{
						idArr.append(m_arSlabIds[i]);
					}
					delete pLine;
				}
			}
			pSlab->close();
		}
	}
	delete pWallLine;
}

Acad::ErrorStatus TDbWall::DrawWallLine2dForCoverSlab(TGGiExplodeDrawBase &dc, const TGGeVisibilityPoly2D &poly) const
{
	AcDbObjectIdArray idArr;
	GetCoverSlab(idArr);
	TGGeCurveSegment seg;
	AcDb::Visibility eVal;
	TDbStruFloorSlab *pSlab = NULL;
	TGGePoly2D polySlab;
	std::vector<TGGeCurveSegment> vecSeg1, vecSeg2; // 保存生成的实线虚线
	for (int i = 0; i < poly.TotalSegments(); i++)
	{
		poly.Nth(i, seg, &eVal);
		if (eVal == AcDb::kVisible)
		{
			for (int j = 0; j < idArr.length(); j++)
			{
				acdbOpenObject(pSlab, idArr[j], AcDb::kForRead);
				if (pSlab != NULL)
				{
					polySlab.Reset();
					pSlab->GetOutline(polySlab);
					pSlab->close();
					polySlab.SetElevation(0.0);
					GetSegmentForSlab2d(polySlab, seg, vecSeg1, vecSeg2);
				}
			}
		}
	}

	// 过滤，剪切实线虚线 
	FiltrateSegment(vecSeg1, vecSeg2);

	std::vector<TGGeCurveSegment>::iterator it;
	for (it = vecSeg1.begin(); it < vecSeg1.end(); it++)
	{
		dc << *it;
	}
	
	//Adesk::UInt16 nColor = dc.GetColor();
	//dc.SetColor(1);

	AcDbObjectId idOldLine = dc.GetLineTypeId();
	dc.SetLineType(InitLineType(_T("DASHED"),database()));
	
	for (it = vecSeg2.begin(); it < vecSeg2.end(); it++)
	{
		dc << *it;
	}
	dc.SetLineType(idOldLine);
	//dc.SetColor(nColor);

	return Acad::eOk;
}

void TDbWall::GetClipedPoly2d(std::vector<TGGePoly2D> &vecPoly) const
{
	TGGePoly2D poly2d;
	TDbStruColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++) 
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			poly2d.Reset();
			pStruColumn->GetOutline(poly2d);
			vecPoly.push_back(poly2d);
			pStruColumn->Close();
		}
	}

	TDbWallHole *pHole = NULL;
	for (i = 0; i < m_arHoleIds.length(); i++)
	{
		acdbOpenObject(pHole, m_arHoleIds[i], AcDb::kForRead);
		if (pHole != NULL)
		{
			poly2d.Reset();
			pHole->GetOutlinePoly2D(pHole->GetBottomElev(), poly2d, TGGeCurveSegment());
			vecPoly.push_back(poly2d);
			pHole->close();
		}
	}
}

//将剪力墙的变换传递给墙洞
void TDbWall::ApplyTransformToHoles(const AcGeMatrix3d &xform)
{
	AcDbObjectIdArray idArray;
	if (acdbGetCurrentSelectionSet(idArray) != Acad::eOk)
	{
		return;
	}

	//整体移动，不作出额外判断
	if (idArray.length() > 1000)		
	{
		return;
	}

	for (int i = 0; i < m_arHoleIds.length(); i++) 
	{
		AcDbObjectId id = m_arHoleIds[i];
		if (idArray.contains(id))
		{
			continue;
		}

		TAcDbObjectPtr obj(id, AcDb::kForWrite);
		if (!obj) 
		{
			;
		}
		else 
		{
			TDbWallHole *pWallHole = TDbWallHole::cast(obj.m_pObject);
			if (pWallHole)
			{
				pWallHole->transformBy(xform);
			}
		}
	}
}
*/

// 墙宽标注
void TDbWall::DrawBH(TGGiExplodeDrawBase &dc) const
{
	TDbText text;

	// 设置文字样式
	AcDbObjectId idWallBHStyl = DocGetWallBHStyle();
	if(idWallBHStyl.isNull())
	{
		idWallBHStyl = InitTextStyle(TS_STANDARD);
	}
	text.SetStyleId(idWallBHStyl);	

	text.SetHeight(DocGetWallBHHigh());			// 设置文字高度			

	text.setColorIndex(DocGetWallBHColor());	// 设置文字颜色

	text.SetAlignment(XExplodeDraw::kCenter);	// 设置文字对齐方式

	double dWallWidth = GetWidth(0) + GetWidth(1);// 得到墙宽

	CString strText;
	strText = Dist2Str(dWallWidth);
	text.SetText(strText);						// 设置文字内容

	// 得到墙的起始点和结束点
	TADSGePoint3d ptStart = m_startPoint, ptEnd = m_endPoint;

	double dBulge = GetBulge();					// 得到墙的凸度, 根据凸度判断该墙是否是弧墙

	double dDis = (DocGetWallBHDist() * GetPScale());// 得到文字到墙的距离(考虑图层比例)
	double dTextDis = dWallWidth/2+dDis;

	// 计算文字旋转角度
	ads_real angle = ads_angle(ptStart, ptEnd);// 与x轴的夹角
	if (angle - PI < g_angleZero)
	{
		if(angle - PI/2 > g_angleZero)					// 90-180度文字的旋转角度
		{
			angle = ads_angle(ptEnd, ptStart);

			if(fabs(dBulge) > g_angleZero)				// 弧墙
			{
				dTextDis = -dTextDis;
			}
		}
	}
	else			
	{
		if(angle - 3*PI/2 < g_angleZero)				// 180-270度时文字的旋转角度
		{
			angle = ads_angle(ptEnd, ptStart);

			if(fabs(dBulge) > g_angleZero)				// 弧墙
			{
				dTextDis = -dTextDis;
			}
		}
	}
	text.SetRotation(angle);					// 设置文字的旋转角度

	TADSGePoint3d ptTextAlign;
	if(fabs(dBulge) > g_angleZero)				// 弧墙
	{
		TGGeCurveSegment cvCenter = GetCenterLine();		// 得到墙的中心线
		TADSGePoint3d ptCenter = cvCenter.GetArc().GetCenterPt();// 得到弧墙的圆心
		TADSGePoint3d ptMid = cvCenter.MidPoint();				// 得到中心线的中心点
		double dWallAngle = ads_angle(ptMid, ptCenter);		// 得到中心墙线的中点与弧墙圆心的连线角度
		ptTextAlign = TADSGePoint3d(ptMid, dWallAngle, dTextDis);	// 得到文字的位置点
	}
	else
	{
		Midpoint(ptStart, ptEnd, ptTextAlign);				// 得到墙的中点
		ptTextAlign = TADSGePoint3d(ptTextAlign, angle+PI/2, dTextDis);// 与墙垂直方向
	}

	text.SetLocation(ptTextAlign);							// 设置文字显示位置
	text.ExplodeOrDraw2d(dc);
}

// 墙体构件编号标注
void TDbWall::DrawCLab(TGGiExplodeDrawBase &dc) const
{
	CString strCLab = _T("Q1");
	if(!GetSpecialtyDataReadOnly()->GetAt(KEY_CLAB, strCLab))
	{
		return;
	}

	TDbText text;

	// 设置文字样式
	AcDbObjectId idWallCLStyl = DocGetWallCLStyle();
	if(idWallCLStyl.isNull())
	{
		idWallCLStyl = InitTextStyle(TS_STANDARD);
	}
	text.SetStyleId(idWallCLStyl);

	text.SetHeight(DocGetWallBHHigh());		// 设置文字高度			

	text.setColorIndex(DocGetWallBHColor());// 设置文字颜色

	text.SetAlignment(XExplodeDraw::kMiddle);// 设置文字对齐方式

	text.SetText(strCLab);					// 设置文字内容

	// 得到墙体的起始位置和结束位置
	AcGePoint3d  ptStart = m_startPoint, ptEnd = m_endPoint;

	double dBulge = GetBulge();				// 得到墙的凸度,根据凸度判断是否是弧墙

	double dWallWidth = GetWidth(0) + GetWidth(1);	// 得到墙宽

	// 计算文字的旋转角度
	ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));	// 与x轴的夹角
	if (angle - PI < g_angleZero)			// 0-180度
	{
		if(angle - PI/2 > g_angleZero)		// 180-90度时文字旋转角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > g_angleZero)	// 弧墙
			{
				dWallWidth = -dWallWidth;
			}
		}
	}
	else									// 180-360度
	{
		if(angle - 3*PI/2 < g_angleZero)	// 180-270度时文字的旋转角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > g_angleZero)	// 弧墙
			{
				dWallWidth = -dWallWidth;
			}
		}
	}
	text.SetRotation(angle);				// 设置文字的旋转角度

	TADSGePoint3d ptTextAlign;				// 文字的对齐点

	if(fabs(dBulge) > g_angleZero)
	{
		TGGeCurveSegment cvsegCenter = GetCenterLine();		 // 得到墙的中心线
		TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧墙的圆心
		TADSGePoint3d ptMid = cvsegCenter.MidPoint();				 // 得到中心线的中心点
		double dWallAngle = ads_angle(ptMid, ptCenter);		 // 得到中心线的中心点和圆心的角度
		ptTextAlign = TADSGePoint3d(ptMid, dWallAngle, -dWallWidth);	 // 得到文字的位置点
	}
	else
	{
		Midpoint(ptStart, ptEnd, ptTextAlign);					  // 得到墙的中点
		ptTextAlign = TADSGePoint3d(ptTextAlign, angle+PI/2, -dWallWidth); // 与墙垂直方向
	}

	text.SetLocation(ptTextAlign);				// 设置文字的插入位置


	text.setLayer(DocGetWallCLLayer());		// 设置文字图层

	text.ExplodeOrDraw2d(dc);
}

// add by wjx on 111228
// 功能:得到中心线的中心点和圆心得连线的角度和距离
// [in]:dDis: 到墙边的距离
// return: 中心线的中点和圆心连线的角度
double TDbWall::GetCenetrAngle(double &dDis) const
{
	double dBulge = GetBulge();					// 得到墙的凸度,根据凸度判断是否是弧墙

	AcGePoint3d  ptStart = m_startPoint, ptEnd = m_endPoint;

	// 计算文字的旋转角度
	ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));// 与x轴的夹角
	if (angle - PI < g_angleZero)
	{
		if(angle - PI/2 > g_angleZero)			// 90-180度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > g_angleZero)		// 弧墙	
			{
				dDis = -dDis;
			}
		}
	}
	else
	{
		if(angle - 3*PI/2 < g_angleZero)		// 180-270度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > _DIST_SNAP)		// 弧墙	
			{
				dDis = -dDis;
			}
		}
	}

	double dBeamAngle = 0;
	if(fabs(dBulge) > _DIST_SNAP)				// 弧墙	
	{
		TGGeCurveSegment cvsegCenter = GetCenterLine();				// 得到墙的中心线
		TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧墙的圆心
		TADSGePoint3d ptMid = cvsegCenter.MidPoint();				// 得到弧墙中心线的中心点
		dBeamAngle = ads_angle(ptMid, ptCenter);				// 得到中心线的中心点和圆心得连线的角度
	}
	else
	{
		dBeamAngle = angle+PI/2;
	}

	return dBeamAngle;
}

// add by wjx on 1112228
// 确定左右端点,以x方向和y方向确定
// [in]: ptStart:墙的起始点
// [in]: ptEnd:墙的终止点
// return: 是否交换墙的起始点和终止点
BOOL TDbWall::GetLRPoint(XPoint &ptStart, XPoint &ptEnd)const
{
	bool bSEFlag = true;						// 取起始点的标志
	if (fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)	// 竖向
	{
		if(ptStart.y - ptEnd.y > _DIST_SNAP)
		{
			XPoint ptTemp = ptStart;
			ptStart = ptEnd;
			ptEnd = ptTemp;
			bSEFlag = false;
		}
	}
	else if(ptStart.x - ptEnd.x > _DIST_SNAP)	// 横向
	{
		XPoint ptTemp = ptStart;
		ptStart = ptEnd;
		ptEnd = ptTemp;
		bSEFlag = false;
	}
	return bSEFlag;
}

// add by wjx on 111228
// 功能: 显示墙的荷载信息
void TDbWall::DrawWallLoad(TGGiExplodeDrawBase &dc) const
{
	//if(NULL == g_pStruSubProject)
	//{
	//	return;
	//}

	//add by xlc on 120112荷载显示控制
	BOOL bShowGraphic = false;		//显示图形
	BOOL bShowLive = false;			//显示活荷
	BOOL bShowUnLive = false;		//显示恒荷

	if(g_nLoadDrawMode == BYOBJLOAD)
	{
		bShowGraphic = true;
		bShowLive = bShowUnLive = DocGetShowLoadPara();
	}
	else
	{
		bShowGraphic = GetViewStyle(BYGRAPHIC);
		bShowLive = GetViewStyle(BYVARYING);
		bShowUnLive = GetViewStyle(BYUNVARYING);
	}

	//都不显示时直接返回
	if (!(bShowGraphic||bShowLive||bShowUnLive))
	{
		return;
	}

	std::vector<TStruLoad> vecLoad;
	GetLoadsArray(vecLoad);
	int nSize = vecLoad.size();
	if(nSize < 1)
	{
		return;
	}

	TStruLoad loadData;

	// 画荷载图形
	TGGeCurveSegment segCenter = GetCenterLine();
	segCenter.SetElevation(0.0);
	XPoint ptStart = segCenter.StartPoint();
	XPoint ptEnd = segCenter.EndPoint();
	BOOL bSwtchSEFlag = GetLRPoint(ptStart, ptEnd);

	TPushProperty vProp(this, dc);
	if (m_idLayerLoad.isValid())
	{
		dc.SetLayer(m_idLayerLoad);
	}

	// 计算移动方向
	double dLoadDis = 0.0;	  // 荷载到墙的距离
	double dAugle = 0.0;
	TADSGePoint3d ptMid = segCenter.MidPoint();	// 得到墙中心线的中心点
	XPoint ptInsert;
	ads_matrix mat;
	double dLoadLen = segCenter.GetLength();
	double dTextDis = 300.0;					// 文字到线的距离

	// modify by wjx on 120314修改荷载位置
	for(int i = 0; i < nSize; i++)
	{
		loadData = vecLoad[i];
		if(bShowGraphic)
		{
			TGGeCurveSegment segSub, segTemp;
			XPoint ptSToCenter, ptEtoCenter;	// 映射到中心线上的点
			switch (loadData.GetLoadType())
			{
			case TStruLoad::LT_ALL_H:
				dLoadDis = 100.0;				// 荷载到墙的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);

				segTemp = segCenter;
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);
				break;
			case TStruLoad::LT_LEFT:
				dLoadDis = 150.0;				// 荷载到墙的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);

				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*1000, segTemp);
				segCenter.GetSubSegment((bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(), 
					loadData.GetPara1()*1000, segSub);

				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segTemp = segSub;

				ptSToCenter = segTemp.GetStartPoint();
				segCenter.ProjectToMe(ptSToCenter, ptSToCenter);
				segSub = TGGeCurveSegment(ptSToCenter, segTemp.GetStartPoint(), 0);
				dc.DrawCurve(segSub);

				ptEtoCenter = segTemp.GetEndPoint();
				segCenter.ProjectToMe(ptEtoCenter, ptEtoCenter);
				segSub = TGGeCurveSegment(ptEtoCenter, segTemp.GetEndPoint(), 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_RIGHT:
				dLoadDis = 150.0;				// 荷载到墙的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);

				segCenter.GetSubSegment(ptEnd, loadData.GetPara1()*1000, segTemp);
				segCenter.GetSubSegment((!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(), 
					loadData.GetPara1()*1000, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segTemp = segSub;

				ptSToCenter = segTemp.GetStartPoint();
				segCenter.ProjectToMe(ptSToCenter, ptSToCenter);
				segSub = TGGeCurveSegment(ptSToCenter, segTemp.GetStartPoint(), 0);
				dc.DrawCurve(segSub);

				ptEtoCenter = segTemp.GetEndPoint();
				segCenter.ProjectToMe(ptEtoCenter, ptEtoCenter);
				segSub = TGGeCurveSegment(ptEtoCenter, segTemp.GetEndPoint(), 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_FOCUS:
				dAugle = ads_angle(ptStart, ptEnd);
				ptMid.GetRotationMatrix(dAugle, mat);

				dLoadDis = 200.0;
				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*1000*2, segTemp);

				ptEtoCenter = (bSwtchSEFlag)? segTemp.EndPoint(): segTemp.GetStartPoint();
				ptSToCenter = XPoint(ptEtoCenter.x, ptEtoCenter.y+dLoadDis,0);
				segTemp = TGGeCurveSegment(ptSToCenter, ptEtoCenter, 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x-100, ptEtoCenter.y+100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y+100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);
				break;
			case TStruLoad::LT_TRAPE:
				dLoadDis = 200.0;				// 荷载到墙的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);

				segCenter.GetSubSegment(ptMid, dLoadLen-loadData.GetPara1()*2*1000, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segTemp = segSub;

				ptSToCenter = (!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
				segSub = TGGeCurveSegment(ptStart, ptSToCenter, 0);
				dc.DrawCurve(segSub);

				ptEtoCenter = (bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
				segSub = TGGeCurveSegment(ptEnd, ptEtoCenter, 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_TRIGON:
				dLoadDis = 200.0;				
				dAugle = GetCenetrAngle(dLoadDis);

				segCenter.GetSubSegment(ptStart, (loadData.GetPara1() + loadData.GetPara2())*2*1000, segTemp);

				ptSToCenter = (bSwtchSEFlag)? segTemp.GetEndPoint(): segTemp.StartPoint();
				ptInsert = TADSGePoint3d(ptSToCenter, dAugle, dLoadDis);

				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segTemp);
				ptSToCenter = (bSwtchSEFlag)? segTemp.GetEndPoint(): segTemp.StartPoint();
				segSub = TGGeCurveSegment(ptInsert, ptSToCenter, 0);
				dc.DrawCurve(segSub);

// 				ptEtoCenter = segTemp.EndPoint();
				segCenter.GetSubSegment(ptStart, (loadData.GetPara1()+loadData.GetPara2()*2)*2*1000, segTemp);
				ptEtoCenter = (bSwtchSEFlag)? segTemp.GetEndPoint(): segTemp.StartPoint();
				segSub = TGGeCurveSegment(ptInsert, ptEtoCenter, 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_FOLD:
				dLoadDis = 250.0;				
				dAugle = GetCenetrAngle(dLoadDis);

// 				segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
// 				segTemp = segSub;
				segCenter.GetSubSegment(ptStart, loadData.GetPara2()*2*1000, segTemp);

				ptInsert = (bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
				ptSToCenter = TADSGePoint3d(ptInsert, dAugle, dLoadDis-200);
				segSub = TGGeCurveSegment(ptInsert, ptSToCenter, 0);
				dc.DrawCurve(segSub);

				segCenter.GetSubSegment(ptStart, (loadData.GetPara2()+loadData.GetPara3())*2*1000, segTemp);
				ptInsert = (bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
				ptEtoCenter = TADSGePoint3d(ptInsert, dAugle, dLoadDis);
				segSub = TGGeCurveSegment(ptInsert, ptEtoCenter, 0);
				dc.DrawCurve(segSub);

				segSub = TGGeCurveSegment(ptSToCenter, ptEtoCenter, 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_MOMENT:
				dAugle = ads_angle(ptStart, ptEnd);
// 				ptMid.GetRotationMatrix(dAugle, mat);

				dLoadDis = 200;
				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segTemp);
				ptInsert = (bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
				ptEtoCenter = XPoint(ptInsert.x, ptInsert.y-dLoadDis/2,0);
				ptSToCenter = XPoint(ptInsert.x, ptInsert.y+dLoadDis/2,0);
				segTemp = TGGeCurveSegment(ptSToCenter, ptEtoCenter, -PI*5/4);
				ptInsert.GetRotationMatrix(dAugle, mat);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y+100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y-100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				break;
			}
		}

		// 显示文字
		if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive)			//活荷
			||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive)	//恒荷
			)
		{
			dAugle = ads_angle(ptStart, ptEnd);
			DrawWallLoadText2d(loadData, dAugle, dTextDis, dc);
		}
	}

}

// add by wjx on 111228
// 功能: 设置显示荷载的文字
// [in]: loadData: 荷载信息
// [in]: dAugle: 线与x轴的夹角
// [in]: dDis: 荷载信息显示位置到线的距离
void TDbWall::DrawWallLoadText2d(TStruLoad loadData, double dAugle, 
									 double &dDis, TGGiExplodeDrawBase &dc) const
{
	int nKind = loadData.GetLoadKind();       // 荷载种类

	// 设置文字
	AcDbText text;
	text.setHeight(DocGetLoadTextHeight());// 设置文字高度		

	// 得到中心线
	TGGeCurveSegment segCenter = GetCenterLine();
	segCenter.SetElevation(0.0);
	XPoint ptMid = segCenter.MidPoint();

	// 生成要显示的荷载文字
	int nType = loadData.GetLoadType();		  // 荷载类型
	CString strLoadInfo;
	if(nType == TStruLoad::LT_FOLD)
	{
		strLoadInfo.Format(_T("7*%s*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()), 
												TrimDoubleZero(loadData.GetPara1()),
												TrimDoubleZero(loadData.GetPara2()),
												TrimDoubleZero(loadData.GetPara3()));
	}
	else if(nType == TStruLoad::LT_TRIGON)
	{
		strLoadInfo.Format(_T("6*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()), 
											 TrimDoubleZero(loadData.GetPara1()), 
											 TrimDoubleZero(loadData.GetPara2()));
	}
	else if(nType == TStruLoad::LT_ALL_H)
	{
		strLoadInfo.Format(_T("1*%s"), TrimDoubleZero(loadData.GetValue()));
	}
	else
	{
		strLoadInfo.Format(_T("%d*s*%s"), nType, TrimDoubleZero(loadData.GetValue()), 
												 TrimDoubleZero(loadData.GetPara1()));
	}

	text.setTextString(strLoadInfo);
	
	TPushProperty vProp(this, dc);
	if(nKind == TStruLoad::LK_UNVARYING)
	{
		if (m_idLayerLoadC.isValid())
		{
			dc.SetLayer(m_idLayerLoadC);
			text.setLayer(m_idLayerLoadC);
		}
	}
	else if(nKind == TStruLoad::LK_VARYING)
	{
		if (m_idLayerLoadL.isValid())
		{
			dc.SetLayer(m_idLayerLoadL);
			text.setLayer(m_idLayerLoadL);
		}
	}

	double dBugle = GetCenetrAngle(dDis);	// 与墙线垂直方向与x轴夹角

	text.setRotation(dAugle);

	TADSGePoint3d ptInsert = TADSGePoint3d(ptMid, dBugle, dDis);	// 得到墙中心线的中心点
	text.setPosition(ptInsert);
	dc.DrawEntity(text);

	dDis += DocGetLoadTextHeight();
}

// 在线的中点位置画箭头
// [in]: seg:墙线
// [in]: nEdgeFlag: 0:起始点 1:中点 2:终止点
void TDbWall::DrawArrow3D(TGGeCurveSegment seg, TGGiExplodeDrawBase &dc, int nEdgeFalg)const
{
	XPoint ptS;

	if(nEdgeFalg == 1)
	{
		ptS= seg.MidPoint();
	}
	else if(nEdgeFalg == 0)
	{
		ptS = seg.StartPoint();
	}
	else
	{
		ptS = seg.EndPoint();
	}

	XPoint ptPro, ptTemp;

	TGGeCurveSegment segCenter = GetCenterLine();
	segCenter.ProjectToMe(ptS, ptPro);

	TGGeCurveSegment segTemp(ptS, ptPro, 0);
	dc.DrawCurve(segTemp);

	ptTemp = ptPro;
	TGGeCurveSegment  segSub;

	seg.GetSubSegment(ptS, 200, segSub);

	segCenter.ProjectToMe(segSub.StartPoint(), ptPro);
	segTemp = TGGeCurveSegment(XPoint(ptPro.x, ptPro.y, ptPro.z+100), ptTemp, 0);
	dc.DrawCurve(segTemp);

	segCenter.ProjectToMe(segSub.EndPoint(), ptPro);
	segTemp = TGGeCurveSegment(XPoint(ptPro.x, ptPro.y, ptPro.z+100), ptTemp, 0);
	dc.DrawCurve(segTemp);
}

// add by wjx 0n 111221
// 绘制3d荷载信息
void TDbWall::DrawWallLoad3D(TGGiExplodeDrawBase &dc)const
{
	//if(NULL == g_pStruSubProject)
	//{
	//	return;
	//}

	//add by xlc on 120112荷载显示控制
	BOOL bShowGraphic = false;		//显示图形
	BOOL bShowLive = false;			//显示活荷
	BOOL bShowUnLive = false;		//显示恒荷

	if(g_nLoadDrawMode == BYOBJLOAD)
	{
		bShowGraphic = true;
		bShowLive = bShowUnLive = DocGetShowLoadPara();
	}
	else
	{
		bShowGraphic = GetViewStyle(BYGRAPHIC);
		bShowLive = GetViewStyle(BYVARYING);
		bShowUnLive = GetViewStyle(BYUNVARYING);
	}

	//都不显示时直接返回
	if (!(bShowGraphic||bShowLive||bShowUnLive))
	{
		return;
	}

	std::vector<TStruLoad> vecLoad;
	GetLoadsArray(vecLoad);
	int nSize = vecLoad.size();
	if(nSize < 1)
	{
		return;
	}

	TStruLoad loadData;
	int nColorOld = dc.GetColor();
	dc.SetColor(1);

	TGGeCurveSegment segCenter = GetCenterLine();// 墙的中心线
	TGGeCurveSegment segSub, segCenterBak;
	XPoint ptMid = segCenter.MidPoint();
	XPoint ptStart = segCenter.GetStartPoint();
	XPoint ptEnd = segCenter.GetEndPoint();
	BOOL bSwitchSE = GetLRPoint(ptStart, ptEnd);// 确定起始点和终止点那个点在左侧或右侧
	XPoint ptS, ptE, ptM;						// 荷载图像上的起始,结束,中点
	ads_matrix mat;
	double dLoadLen = segCenter.GetLength();
	double dZ = 500;
	double dAugle = ads_angle(ptStart, ptEnd);
	AcDbArc arcLine;
	AcGeVector3d vecNormal = AcGeVector3d(0, 0, 1);

	for(int k = 0; k < nSize; k++)
	{
		loadData = vecLoad[k];
		if(bShowGraphic)
		{
			// modify by wjx on 120314 修改荷载位置
			switch (loadData.GetLoadType())
			{
			case TStruLoad::LT_ALL_H:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+300);
				ptMid.GetMoveMatrix(ptM, mat);
				segCenterBak = segCenter;
				segCenterBak.TransformBy(mat);
				dc.DrawCurve(segCenterBak);

				DrawArrow3D(segCenterBak, dc);
				segCenterBak.GetSubSegment(ptM, dLoadLen/2, segSub);
				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 2);
				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 2);
				break;
			case TStruLoad::LT_LEFT:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
				ptMid.GetMoveMatrix(ptM, mat);
				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*1000, segCenterBak);
				segCenter.GetSubSegment((bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint(), 
					loadData.GetPara1()*1000, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segCenterBak = segSub;

				ptM = segCenterBak.MidPoint();

				DrawArrow3D(segCenterBak, dc);
				segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 2);
				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 2);
				break;
			case TStruLoad::LT_RIGHT:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
				ptMid.GetMoveMatrix(ptM, mat);
				segCenter.GetSubSegment(ptEnd, loadData.GetPara1()*1000, segCenterBak);
				segCenter.GetSubSegment((bSwitchSE)? segCenterBak.StartPoint(): segCenterBak.EndPoint(), 
					loadData.GetPara1()*1000, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segCenterBak = segSub;

				ptM = segCenterBak.MidPoint();

				DrawArrow3D(segCenterBak, dc);
				segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 2);
				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 2);
				break;
			case TStruLoad::LT_FOCUS:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
				ptMid.GetMoveMatrix(ptM, mat);
				/*segCenterBak = segCenter;*/
				segCenter.GetSubSegment(ptStart, loadData.GetPara1() * 1000 * 2, segCenterBak);
				segCenterBak.TransformBy(mat);

				DrawArrow3D(segCenterBak, dc);
				break;
			case TStruLoad::LT_TRAPE:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
				ptMid.GetMoveMatrix(ptM, mat);
// 				segCenter.GetSubSegment(ptMid, dLoadLen/3, segCenterBak);
				segCenter.GetSubSegment(ptMid, dLoadLen - 2 * loadData.GetPara1()*1000, segCenterBak);
				segCenterBak.TransformBy(mat);
				dc.DrawCurve(segCenterBak);

				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 1);
				DrawArrow3D(segCenterBak, dc, 2);

				ptS = (!bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptStart, ptS, 0);
				dc.DrawCurve(segSub);
				DrawArrow3D(segSub, dc);

				ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptEnd, ptE, 0);
				dc.DrawCurve(segSub);
				DrawArrow3D(segSub, dc);
				break;
			case TStruLoad::LT_TRIGON:
				segCenter.GetSubSegment(ptStart, (loadData.GetPara1() + loadData.GetPara2())*2*1000, segSub);
				ptS = (bSwitchSE)? segSub.GetEndPoint(): segSub.GetStartPoint();
				ptM = XPoint(ptS.x, ptS.y, ptS.z+400);
				ptS.GetMoveMatrix(ptM, mat);

// 				segCenterBak = segCenter;
				segCenter.GetSubSegment(ptS, loadData.GetPara2()*2*1000, segCenterBak);
				segCenterBak.TransformBy(mat);
				DrawArrow3D(segCenterBak, dc);

// 				segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
// 				segCenterBak = segSub;
				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segCenterBak);
				ptS = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptM, ptS, 0);
				dc.DrawCurve(segSub);

				DrawArrow3D(segSub, dc);

				segCenter.GetSubSegment(ptStart, (loadData.GetPara1() + loadData.GetPara2()*2)*2*1000, segCenterBak);
				ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptM, ptE, 0);
				dc.DrawCurve(segSub);

				DrawArrow3D(segSub, dc);
				break;
			case TStruLoad::LT_FOLD:
// 				segCenter.GetSubSegment(ptMid, dLoadLen/4, segSub);
// 				segCenterBak = segSub;
				segCenter.GetSubSegment(ptStart, loadData.GetPara2()*2*1000, segCenterBak);

				ptS = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				ptS = XPoint(ptS.x, ptS.y, ptS.z+100);

				ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				ptE = XPoint(ptE.x, ptE.y, ptE.z+400);

				segSub = TGGeCurveSegment(ptS, ptE, 0);
				dc.DrawCurve(segSub);

				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 1);
				DrawArrow3D(segSub, dc, 2);
				break;
			case TStruLoad::LT_MOMENT:
// 				arcLine.setCenter(ptMid);
				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segCenterBak);
				ptM = (bSwitchSE)? segCenterBak.GetEndPoint(): segCenterBak.GetStartPoint();
				arcLine.setCenter(ptM);
				arcLine.setStartAngle(0);
				arcLine.setEndAngle(PI*3/2);
				arcLine.setRadius(200);
				arcLine.setNormal(AcGeVector3d::kZAxis);
				arcLine.setColorIndex(1);
				dc.DrawEntity(arcLine);

				arcLine.getEndPoint(ptE);
				segSub = TGGeCurveSegment(ptE, ptMid, 0);
				dc.DrawCurve(segSub);
				segSub = TGGeCurveSegment(ptE, XPoint(ptM.x, ptM.y, ptM.z-200), 0);
				dc.DrawCurve(segSub);

				break;
			}
		}
		
		if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive)			//活荷
			||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive)	//恒荷
			)
		{
			DrawLoadText3D(loadData, dAugle, dZ, dc);
		}
	}

	dc.SetColor(nColorOld);
}

void TDbWall::DrawLoadText3D(TStruLoad loadData, double dAugle, double &dZ, TGGiExplodeDrawBase &dc)const
{
	int nKind = loadData.GetLoadKind();       // 荷载种类

	//del by xlc on 120112显示控制移到外边了
	//if(!GetViewStyle(nKind))
	//{
	//	return;
	//}

	// 设置文字
	AcDbText text;
	text.setHeight(DocGetLoadTextHeight());// 设置文字高度		

	// 得到墙的中心线
	TGGeCurveSegment segCenter = GetCenterLine();
	XPoint ptMid = segCenter.MidPoint();

	// 生成要显示的荷载文字
	int nType = loadData.GetLoadType();		  // 荷载类型
	CString strLoadInfo;
	if(nType == TStruLoad::LT_FOLD)
	{
		strLoadInfo.Format(_T("7*%s*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()),TrimDoubleZero(loadData.GetPara2()),
			TrimDoubleZero(loadData.GetPara3()));
	}
	else if(nType == TStruLoad::LT_TRIGON)
	{
		strLoadInfo.Format(_T("6*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()), 
			TrimDoubleZero(loadData.GetPara1()), TrimDoubleZero(loadData.GetPara2()));
	}
	else if(nType == TStruLoad::LT_ALL_H)
	{
		strLoadInfo.Format(_T("1*%s"), TrimDoubleZero(loadData.GetValue()));
	}
	else
	{
		strLoadInfo.Format(_T("%d*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
												  TrimDoubleZero(loadData.GetPara1()));
	}

	text.setTextString(strLoadInfo);

	TPushProperty vProp(this, dc);
	if(nKind == TStruLoad::LK_UNVARYING)
	{
		//text.setColorIndex(7);
		if (m_idLayerLoadC.isValid())
		{
			dc.SetLayer(m_idLayerLoadC);
			text.setLayer(m_idLayerLoadC);
		}
	}
	else if(nKind == TStruLoad::LK_VARYING)
	{
		//text.setColorIndex(2);
		if (m_idLayerLoadL.isValid())
		{
			dc.SetLayer(m_idLayerLoadL);
			text.setLayer(m_idLayerLoadL);
		}
	}

	text.setRotation(dAugle);

	// 设置文字法向
	if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
	{
		AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();

		AcGePoint3d ptCamera, ptTarget;
		vp.getCameraTarget(ptTarget);
		vp.getCameraLocation(ptCamera);

		AcGeVector3d vtViewDrt = ptCamera-ptTarget;
		AcGeVector3d vtViewDir1= vp.viewDir();

		AcGeVector3d vtCamera;
		vp.getCameraUpVector(vtCamera);

		vtViewDrt.normalize();

		text.setNormal(vtViewDrt);
	}

	text.setPosition(XPoint(ptMid.x, ptMid.y, ptMid.z+dZ));
	dc.DrawEntity(text);

	dZ += DocGetLoadTextHeight();
}
/*
//墙可以合并的属性条件判断
BOOL TDbWall::CanMerge(AcDbObjectId idWall)
{
	int nMatTyp, nMatTypOther;
	GetAt(KEY_MATTYP, nMatTyp);

	int nKind(0),nKindOther(0);
	GetAt(KEY_KIND,nKind);

	OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbWall, pEnt);
	if (pEnt)
	{
		pEnt->GetAt(KEY_MATTYP, nMatTypOther);
		if (nMatTyp - nMatTypOther != 0)
		{
			//材料不同
			return FALSE;
		}

		pEnt->GetAt(KEY_KIND, nKindOther);
		if(nKind != nKindOther)
		{
			//类别不同
			return FALSE;
		}
	}
	else
	{
		return FALSE;
	}
	OPENOBJ_END();

	return TRUE;
}*/
//add by xlc on 120118
//设置荷载数组
bool TDbWall::SetLoadsArray(const std::vector<TStruLoad>& vectLoads)
{
	assertWriteEnabled();
	ClearLoadsArray();
	return SetAt(KEY_WALL, vectLoads);
}
//获得荷载数组
bool TDbWall::GetLoadsArray(std::vector<TStruLoad>& vectLoads)const
{
	assertReadEnabled();
	return GetAt(KEY_WALL, vectLoads);
}
//清除荷载数组
void TDbWall::ClearLoadsArray()
{
	assertWriteEnabled();
	RemoveLoadsKey(KEY_WALL);
}

bool TDbWall::SetAt(LPCTSTR pszKey,const std::vector<TStruLoad>& vectLoads)
{
	assertWriteEnabled();
	if (pszKey != NULL)
	{
		int nLength = vectLoads.size();
		GetSpecialtyData()->SetAt(pszKey, nLength);

		CString sSubKey;
		for (int i = 0;i < nLength; i++)
		{
			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_ENTTYPE, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetEntType());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADTYPE, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetLoadType());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADKIND, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetLoadKind());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADVAL, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetValue());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA1, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetPara1());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA2, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetPara2());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA3, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetPara3());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADFORCEX, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetForceX());

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADFORCEY, i);
			GetSpecialtyData()->SetAt(sSubKey, vectLoads[i].GetForceY());
		}

		return true;
	}

	return false;
}

bool TDbWall::GetAt(LPCTSTR pszKey,std::vector<TStruLoad>& vectLoads)const
{
	assertReadEnabled();

	vectLoads.clear();
	if (pszKey != NULL)
	{
		int nLength = 0;
		GetSpecialtyDataReadOnly()->GetAt(pszKey, nLength);

		CString sSubKey;
		double dVal = 0;
		int nVal = 0;

		int i = 0;
		while(nLength > 0)
		{
			TStruLoad struLoad;
			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_ENTTYPE, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, nVal))
			{
				struLoad.SetEntType(nVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADTYPE, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, nVal))
			{
				struLoad.SetLoadType(nVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADKIND, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, nVal))
			{
				struLoad.SetLoadKind(nVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADVAL, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				struLoad.SetValue(dVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA1, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				struLoad.SetPara1(dVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA2, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				struLoad.SetPara2(dVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA3, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				struLoad.SetPara3(dVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADFORCEX, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				struLoad.SetForceX(dVal);
			}

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADFORCEY, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				struLoad.SetForceY(dVal);
			}

			vectLoads.push_back(struLoad);
			i++;
			nLength--;
		}
	}

	return (vectLoads.size() > 0);
}

void TDbWall::RemoveLoadsKey(LPCTSTR pszKey)
{
	assertWriteEnabled();
	if (pszKey != NULL)
	{
		int nLength = 0;
		GetSpecialtyData()->GetAt(pszKey, nLength);
		GetSpecialtyData()->RemoveAt(pszKey);

		CString sSubKey;
		for (int i = 0;i < nLength; i++)
		{
			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_ENTTYPE, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADTYPE, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADKIND, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADVAL, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA1, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA2, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADPARA3, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADFORCEX, i);
			GetSpecialtyData()->RemoveAt(sSubKey);

			sSubKey.Format(_T("%s%s%d"),pszKey, KEY_LOADFORCEY, i);
			GetSpecialtyData()->RemoveAt(sSubKey);
		}
	}
}

//荷载
AcDbObjectId TDbWall::GetLayerLoad() const
{
	return m_idLayerLoad;
}
void TDbWall::SetLayerLoad(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoad = idLayer;
}

//活荷值
AcDbObjectId TDbWall::GetLayerLoadL() const
{
	return m_idLayerLoadL;
}
void TDbWall::SetLayerLoadL(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoadL = idLayer;
}

//恒荷值
AcDbObjectId TDbWall::GetLayerLoadC() const
{
	return m_idLayerLoadC;
}
void TDbWall::SetLayerLoadC(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoadC = idLayer;
}

//文字样式
AcDbObjectId TDbWall::GetTextStyle() const
{
	return m_idTextStyle;
}
void TDbWall::SetTextStyle(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idTextStyle = idLayer;
}

//文字样式
AcDbObjectId TDbWall::GetTextStyleRB() const
{
	return m_idTextStyleRB;
}
void TDbWall::SetTextStyleRB(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idTextStyleRB = idLayer;
}
void TDbWall::GetAssocRelation( int nType, AcDbObjectIdArray& ar ) const
{
	assertReadEnabled();
	switch(nType)
	{
	case ASSOC_XY: // XY平面关联 
		{			
			break;
		}
	case ASSOC_Z: // Z平面关联
		{
			break;
		}
	case ASSOC_HOLE: // 关联洞
		{
			//ar = m_arHoleIds;
			ar.setLogicalLength(0);
			for (int i = 0; i < m_lstOpeningId.Length(); i++) 
			{
				ar.append(m_lstOpeningId[i]);
			}
			break;
		}
	case ASSOC_SLAB:// 关联楼板
		{
			ar = m_arSlabIds;
			break;
		}
	case ASSOC_COLU: // 关联柱
		{
			ar.setLogicalLength(0);
			if (!!m_idColuStart)
			{
				ar.append(m_idColuStart);
			}

			if (!!m_idColuEnd)
			{
				ar.append(m_idColuEnd);
			}
			break;
		}
	case ASSOC_ALL:	//所有关联
		{
			ar.setLogicalLength(0);
			
			if (!!m_idColuStart)
			{
				ar.append(m_idColuStart);
			}

			if (!!m_idColuEnd)
			{
				ar.append(m_idColuEnd);
			}

			if (m_arSlabIds.length() > 0)
			{
				ar.append(m_arSlabIds);
			}

			for (int i = 0; i < m_lstOpeningId.Length(); i++) 
			{
				ar.append(m_lstOpeningId[i]);
			}
			break;
		}
	}
}
// 墙的榀数
void TDbWall::GetWallSplit(std::vector<CWallSplitInfo> &vecWallSplit)const
{
	assertReadEnabled();
	int iSize;
	if( !GetSpecialtyDataReadOnly()->GetAt(KEY_WSPLIT, iSize) ) // 获取墙榀数
	{
		return ;
	}

	CString sIndex;
	CWallSplitInfo wallSplit;
	for( int i=0; i<iSize; i++ )
	{
		wallSplit.Reset();
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_HEIGHT, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dHeight);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_WIDTH, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWidth);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_SECTSPAN, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dSectSpan);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_AXISPRESS, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dAxisPress);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_NORMSECT, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallNormSect);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_SLOPSECT, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallSlopSect);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BODYREINH, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallBodyReinH);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BODYREINV, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallBodyReinV);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_COUPBEAM, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_bCoupBeam);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BEAMREINU, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallBeamReinU);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BEAMREIND, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallBeamReinD);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BEAMREINS, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallBeamStrrup);
		sIndex.Format(_T("%sHP%d"), KEY_WSPLIT, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallBodyReinHP);
		sIndex.Format(_T("%sVP%d"), KEY_WSPLIT, i+1);
		GetSpecialtyDataReadOnly()->GetAt(sIndex, wallSplit.m_dWallBodyReinVP);

		vecWallSplit.push_back(wallSplit);
	}

}

// 墙的榀数
void TDbWall::SetWallSplit(const std::vector<CWallSplitInfo> &vecWallSplit)
{
	assertWriteEnabled();
	int iSize = vecWallSplit.size();
	if( !GetSpecialtyData()->SetAt(KEY_WSPLIT, iSize) ) // 获取墙榀数
	{
		return ;
	}

	CString sIndex;
	CWallSplitInfo wallSplit;
	for( int i=0; i<iSize; i++ )
	{
		wallSplit.Reset();
		wallSplit = vecWallSplit[i];
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_HEIGHT, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dHeight);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_WIDTH, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWidth);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_SECTSPAN, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dSectSpan);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_AXISPRESS, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dAxisPress);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_NORMSECT, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallNormSect);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_SLOPSECT, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallSlopSect);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BODYREINH, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallBodyReinH);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BODYREINV, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallBodyReinV);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_COUPBEAM, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_bCoupBeam);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BEAMREINU, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallBeamReinU);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BEAMREIND, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallBeamReinD);
		sIndex.Format(_T("%s%d"), KEY_WSPLIT_BEAMREINS, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallBeamStrrup);
		sIndex.Format(_T("%sHP%d"), KEY_WSPLIT, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallBodyReinHP);
		sIndex.Format(_T("%sVP%d"), KEY_WSPLIT, i+1);
		GetSpecialtyData()->SetAt(sIndex, wallSplit.m_dWallBodyReinVP);
	}
}

void TDbWall::IsFloorCover(TGGeCurveSegment cvLeft, TGGeCurveSegment cvRight, BOOL& bLeft, BOOL& bRight)const
{
	bLeft = bRight = FALSE;

	if (DocGetSpaceDispMode() != 1)  //1为俯视法
	{
		return;
	}

	TADSGePoint3d ptLeft = cvLeft.MidPoint(), ptRight = cvRight.MidPoint();

	ptLeft.z = 0;
	ptRight.z = 0;

	for (int i = 0; i < m_arSlabIds.length(); i++)
	{
		OPENOBJ_BEGIN(m_arSlabIds[i],AcDb::kForRead, TDbStruFloorSlab, pEnt);
		if (pEnt)
		{
			TGGePoly2D poly;
			pEnt->GetOutline(poly);

			poly.SetElevation(0);
			if (!bLeft)
			{
				if ((ptLeft & poly) != PR_OUTSIDE)
				{
					bLeft = TRUE;
				}
			}

			if (!bRight)
			{
				if ((ptRight & poly) != PR_OUTSIDE)
				{
					bRight = TRUE;
				}
			}

			if (bLeft && bRight)
			{
				break;
			}
		}
		OPENOBJ_END();
	}

}

void TDbWall::MakeAssocRelation( AcDbObjectIdArray& ids )
{
	assertWriteEnabled();
	TPickEntSet ss(SS_FREE);
	ads_name eName;
	for (int i = 0; i < ids.length(); i++)
	{
		if (acdbGetAdsName(eName, ids[i]) == Acad::eOk)
		{
			ss += ids[i];
		}
	}

	long nLenth = ss.Length();
	if (nLenth < 1)
	{
		return;
	}

	TEntitySet ent;

	TGGeCurveSegment cvLeft, cvRight;
	GetSideCurve(cvLeft, cvRight);	

	TADSGePoint3d ptLeft,ptRight;
	ptLeft = cvLeft.MidPoint();
	ptRight = cvRight.MidPoint();
	ptLeft.z = 0;
	ptRight.z = 0;

	bool bModFlg = false;				//记录梁的中心线是否调整
	double dGap(0);
	AcDbObjectId idObj = AcDbObjectId::kNull;

	for (long j = 0; j < nLenth; j++)
	{
		ent = ss[j];
		
		if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruFloorSlab, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;
			pEnt->GetOutline(polyDest);
			polyDest.SetElevation(0);

			if ((ptLeft & polyDest) == PR_OUTSIDE && (ptRight & polyDest) == PR_OUTSIDE)
			{
				continue;
			}
			else
			{
				idObj = pEnt->objectId();
			}
			OPENOBJ_END();

			if (!m_arSlabIds.contains(idObj))
			{
				m_arSlabIds.append(idObj);
			}
		}
	}
}

void TDbWall::RemoveAssocRelation( AcDbObjectId& id )
{
	m_arSlabIds.remove(id);
}
#endif