//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName	:   TDbBaseWall类
// = Version	:   ver1.0
// = Author		:   ywb
// = CreateDate	:   2011-05-03
// = Description:   结构柱子类实现
// = Maintainers: 
//                  
//------------------------------------------------------------------------+
#include "StdAfx.h"
#ifdef TASD
#include "TDbColumn.h"
#include "TAsdKeyDefine.h"

double g_dCoordinateLen = 300;	 // 坐标线的长度

#define COLUCOLOR 2
#define TBCOLUCOLOR 4
#define TCOLUCOLOR 7
#define BCOLUCOLOR 8
#define CORCOLUCOLOR 6

extern TARCH_EXP int g_nColuForce;	//底层墙柱显示工况

Acad::ErrorStatus TDbColumn::StruExplodeOrDraw3d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();

	if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0)
	{
		AcGiCommonDraw *dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
		if (!dcCommon->context()->isPlotGeneration())
		{
			//单元编号
			if(DocGetShowNo() && DocGetColuShowNo())
			{
				DrawCellNo(dc);
			}

			//刚域
			if(DocGetShowRG() && DocGetColuShowRG())
			{
				DrawRG(dc);
			}
		}
	}

	// add by xlc on 120112荷载显示控制
	if((DocGetColuShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == COLULOAD)
	{
		DrawColuLoad(dc, 3);
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbColumn::StruExplodeOrDraw2d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();
	AcDbObjectId idLineType = AcDbObjectId::kNull, idOldLineType = AcDbObjectId::kNull;
	GetSpecialtyDataReadOnly()->GetAt(KEY_LTID, idLineType);
	idOldLineType = dc.GetLineTypeId();
	if (idLineType.isValid())
	{
		dc.SetLineType(idLineType);
	}

	TGGePoly2D plBot(m_polyOutline);
	plBot.SetElevation(0); 

	// modify by wjx on 111230
	// 柱坐标和特殊柱填充
	int nColor = dc.GetColor();
	int nType = GetHinge();
	if(!g_bDetailMode)						//简图
	{
		//仅布置和修改柱荷时显示柱坐标
		if (g_nLoadDrawMode == COLULOAD)
		{
			DrawCoordinate(dc);
		}
		SepColuHach(dc);

		if(nType == 0)						// 普通柱
		{
			dc.SetColor(COLUCOLOR);		// 黄色
			dc.DrawXPoly(plBot);
		}
		else
		{
			if(nType == 1)					// 上端铰柱
			{
				dc.SetColor(TCOLUCOLOR);	// 白色
			}
			else if(nType == 2)				// 下端铰柱
			{	
				dc.SetColor(BCOLUCOLOR);	// 灰色	
			}
			else if(nType == 3)				// 两端铰柱
			{
				dc.SetColor(TBCOLUCOLOR);	// 青色
			}
		}
	}
	else									// 详图
	{
		// 绘制线
		dc << plBot;
		dc.SetLineType(idOldLineType);
	}

	// 填充
	int nHatchType = 0;
	GetSpecialtyDataReadOnly()->GetAt(KEY_HATCH, nHatchType);

	TColumnData::TColumnMaterial nMatTyp = kConcrete;

	BOOL bHatch = FALSE;					//是否填充
	BOOL bThick = FALSE;					//是否加粗
	double dLineWidth = 0;					//加粗线宽
	CString sHatchType = _T("SOLID");
	switch (nMatTyp)
	{
	case kConcrete:						//混凝土柱
		bHatch = DocGetConColuHatch();
		bThick = DocGetConColuThick();
		dLineWidth = DocGetConColuLWeight();
		sHatchType = DocGetConColuHPatte();
		break;
	case kSteel:							//钢柱
		bHatch = DocGetStlColuHatch();
		bThick = DocGetStlColuThick();
		dLineWidth = DocGetStlColuLWeight();
		sHatchType = DocGetStlColuHPatte();
		break;
	}
	dLineWidth *= GetPScale();

	if(nHatchType == 0 && DocGetIsSolidFill() && bHatch|| nHatchType == 1 || nType > 0)
	{
		TPushProperty vProp(this, dc);
		if (m_idLayerHatch.isValid())
		{
			dc.SetLayer(m_idLayerHatch);
		}

		if (plBot.HasArcSegment())
		{
			TGGePoly2D poly;
			plBot.Disperse(poly);
			plBot.Reset();
			plBot = poly;
		}

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

	dc.SetColor(nColor);

	// 加粗
	if(!g_bDetailMode)						//简图
	{
		int nLineWeight = 0;
		GetSpecialtyDataReadOnly()->GetAt(KEY_LNWEIGHT, nLineWeight);
		if((nLineWeight == 0 && DocGetIsLineWeight() && bThick)|| nLineWeight == 1)
		{
			TGGePoly2D polyDest;
			if (plBot.PathArea() > 0) // 顺时针
			{
				plBot.Offset(dLineWidth, polyDest);
			}
			else
			{
				plBot.Offset(dLineWidth * (-1), polyDest);
			}

			TGGePoly2D poly2dNew;
			for (int i = 0; i < plBot.Length() - 1; i++)
			{
				poly2dNew.Reset();
				poly2dNew.AppendNode(*plBot[i], *(plBot.m_ardbulges[i]));
				poly2dNew.AppendNode(*plBot[i+1]);
				poly2dNew.AppendNode(*polyDest[i+1], *(polyDest.m_ardbulges[i]) * (-1));
				poly2dNew.AppendNode(*polyDest[i]);
				poly2dNew.SetClosed();
				dc << TGGeSolid(poly2dNew);
			}

			poly2dNew.Reset();
			poly2dNew.AppendNode(*plBot[plBot.Length() - 1], *(plBot.m_ardbulges[plBot.Length() - 1]));
			poly2dNew.AppendNode(*plBot[0]);
			poly2dNew.AppendNode(*polyDest[0], *(polyDest.m_ardbulges[polyDest.Length() - 1]) * (-1));
			poly2dNew.AppendNode(*polyDest[polyDest.Length() - 1]);
			poly2dNew.SetClosed();
			dc << TGGeSolid(poly2dNew);
		}
	}

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

	// 显示构件编号
	if(DocGetColuShowCL())
	{
		DrawClab(dc);			
	}

	// 绘制荷载信息
	if((DocGetColuShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == COLULOAD)

	{
		DrawColuLoad(dc, 2);
	}

	// add by wjx on 120329
	// 绘制轴力图
	if(g_nGraph == FORCE_N)
	{
		DrawNGraph(dc);
	}

	//绘制底层墙柱内力
	DrawWallColu(dc);

	//绘制配筋面积
	if(g_nReinAreaModeColu != eNorm)
	{
		DrawColuRein(dc);
	}
	return Acad::eOk;
}
/*
double TDbColumn::GetBottomElev() const
{
assertReadEnabled();
AcGePoint3d ptPos = AcGePoint3d::kOrigin;
GetSpecialtyDataReadOnly()->GetAt(KEY_INSPTI, ptPos);
return ptPos.z;
}

void TDbColumn::SetBottomElev( double dElev )
{
assertWriteEnabled();
AcGePoint3d ptPos = AcGePoint3d::kOrigin;
GetSpecialtyData()->GetAt(KEY_INSPTI, ptPos);
ptPos.z = dElev;
GetSpecialtyData()->SetAt(KEY_INSPTI, ptPos);
}

double TDbColumn::GetTopElev() const
{
assertReadEnabled();
AcGePoint3d ptPos = AcGePoint3d::kOrigin;
GetSpecialtyDataReadOnly()->GetAt(KEY_INSPTJ, ptPos);
return ptPos.z;
}

void TDbColumn::SetTopEleve(double dElev)
{
assertWriteEnabled();
AcGePoint3d ptPos = AcGePoint3d::kOrigin;
GetSpecialtyData()->GetAt(KEY_INSPTJ, ptPos);
ptPos.z = dElev;
GetSpecialtyData()->SetAt(KEY_INSPTJ, ptPos);
}

TADSGePoint3d TDbColumn::GetParameters() const
{
assertReadEnabled();
TADSGePoint3d pt, ptUp, ptLow;
m_polyOutline.GetExtend(ptLow, ptUp);
pt.x = fabs(ptLow.x - ptUp.x);
pt.y = fabs(ptLow.y - ptUp.y);

double dAngle = 0.0;
GetSpecialtyDataReadOnly()->GetAt(KEY_AXANG, dAngle);
pt.z = dAngle;

return pt;
}

double TDbColumn::GetColumnHeight() const
{
AcGePoint3d pt1, pt2;
GetSpecialtyDataReadOnly()->GetAt(KEY_INSPTJ, pt1);
GetSpecialtyDataReadOnly()->GetAt(KEY_INSPTI, pt2);
return fabs(pt1.z - pt2.z);
}

*/
// 尺寸标注
void TDbColumn::DrawBH(TGGiExplodeDrawBase &dc) const
{
	TDbText text;
	text.setPropertiesFrom(this);
	if (m_idLayerDim.isValid())
	{
		text.setLayer(m_idLayerDim);
	}

	AcDbObjectId idColuBHStyl = DocGetColuBHStyle();
	if(idColuBHStyl.isNull())
	{
		idColuBHStyl = InitTextStyle(TS_STANDARD);
	}
	text.SetStyleId(idColuBHStyl);			// 设置尺寸文字样式

	text.SetHeight(DocGetColuBHHigh());		// 设置尺寸文字高度			

	text.setColorIndex(DocGetColuBHColor());// 设置尺寸文字颜色

	text.SetAlignment(XExplodeDraw::kCenter);

	TADSGePoint3d ptPara = GetParameters();
	TADSGePoint3d ptLow, ptUp;
	//	GetExtents2d(ptLow, ptUp);				// 获得柱子轮廓的最高点和最底点
	m_polyOutline.GetExtend(ptLow, ptUp);
	ptLow.z = 0.0;
	ptUp.z = 0.0;

	// 求柱子外围轮廓的宽和高
	double dHeight, dWidth;
	dHeight = fabs(ptUp.y - ptLow.y);		
//	dWidth = fabs(ptUp.x - ptLow.x);

	// 设置文字内容
	CString strText;

	// 获得插入点
	AcGePoint3d  ptInsert = GetLocation();

	TSectionShape nShape = GetSectionShape();

	double dColuWidth = 0.0;

	double dDis = DocGetColuBHDist() * GetPScale();
	CString strWidth;
	if(nShape != kCircle)						 // 非圆形
	{		
		strText.Format(_T("%.fX%.f"), ptPara.x, ptPara.y);
		text.SetText(strText);

		//TGGePoly2D poly = GetOutlinePoly();		 // 得到柱子的外围框
		//TGGeCurveSegment seg;
		//poly.Nth(0, seg);

		//TADSGePoint3d ptStart = seg.GetStartPoint();
		//TADSGePoint3d ptEnd = seg.GetEndPoint();

		//double angle = ptPara.z;//ads_angle(ptStart, ptEnd);// 得到柱子的旋转角度
		//AngleRangeToPI(angle);					 // 180-360度时的处理

		//if(fabs(cos(angle)) <= g_angleZero)			// 0-90度时得到文字需要移动的距离
		//{
		//	dColuWidth = ptPara.x;
		//}
		//else									// 90-180
		//{
		//	dColuWidth = ptPara.y/cos(angle);
		//}


		dDis += dHeight/2;
		ptInsert.y += dDis;// 得到插入点(在垂直方向移动dDis距离后的点)
	}
	else										// 圆形
	{
		//GetSpecialtyDataReadOnly()->GetAt(KEY_B, dColuWidth);

		strText.Format(_T("%.f"), ptPara.x);	// 直径
		text.SetText(strText);

		dDis += ptPara.x/2;
		ptInsert.y += dDis;
	}

	text.SetLocation(ptInsert);					// 设置文字位置

	TPushProperty vProp(&text, dc);
	if (dc.IsFullExplode())
	{
		text.ExplodeOrDraw2d(dc);
	}
	else
	{
		dc.DrawEntity(text);
	}
}

// 构件编号
void TDbColumn::DrawClab(TGGiExplodeDrawBase &dc) const
{
	TPushProperty vProp(this, dc);
	if (m_idLayerNum.isValid())
	{
		dc.SetLayer(m_idLayerNum);
	}

	// modify by wjx on 120105 没有编号时需要显示斜线和横线
	double dLineLen = 200;					// 线长
	AcGePoint3d  ptInsert = GetLocation();	// 得到柱子的插入点

	// 画文字的斜线部分
	TADSGePoint3d ptLow, ptUp;
	//	GetExtents2d(ptLow, ptUp);				// 得到柱子的最高点和最低点
	m_polyOutline.GetExtend(ptLow, ptUp);
	ptLow.z = 0.0;
	ptUp.z = 0.0;

	double dHeight, dWidth;
	dHeight = fabs(ptUp.y - ptLow.y);
	dWidth = fabs(ptUp.x - ptLow.x);

	// 设置斜线部分的起始点和终止点
	TADSGePoint3d ptEnd(ptInsert.x + dWidth/2 + dLineLen, ptInsert.y + dHeight/2 + dLineLen, ptInsert.z);
	TADSGePoint3d ptStart(ptInsert);

	TGGeCurveSegment seg(ptStart, ptEnd, 0);

	TGGeLine line(seg);
	dc.DrawLine(line);

	// 画文字宽和高
	double dTextWidth = dLineLen, dTextHeight = 0;

	CString strCLab;
	GetSpecialtyDataReadOnly()->GetAt(KEY_CLAB, strCLab);

	if(!strCLab.IsEmpty())
	{
		TDbText text;
		text.setPropertiesFrom(this);

		AcDbObjectId idColuCLStyl = DocGetColuCLStyle();
		if(idColuCLStyl.isNull())
		{
			idColuCLStyl = InitTextStyle(TS_STANDARD);
		}
		text.SetStyleId(idColuCLStyl);			// 设置文字样式
		text.SetHeight(DocGetColuCLHigh());		// 设置文字高度			
		text.setColorIndex(DocGetColuCLColor());// 设置文字颜色
		text.SetAlignment(XExplodeDraw::kCenter);// 设置文字对齐方式
		text.SetText(strCLab);					// 设置文字内容
		text.GetExtents(&dTextWidth, &dTextHeight);					// 得到文字的宽和高

		ptInsert = AcGePoint3d(ptEnd.x + dTextWidth/2, ptEnd.y, 0);	// 计算文字的插入点

		text.SetLocation(ptInsert);									// 设置文字的插入点

		//text.setLayer(DocGetColuCLLayer());						// 设置文字图层
		if (m_idLayerNum.isValid())
		{
			text.setLayer(m_idLayerNum);
		}

		TPushProperty vProp(&text, dc);
		if (dc.IsFullExplode())
		{
			text.ExplodeOrDraw2d(dc);
		}
		else
		{
			dc.DrawEntity(text);
		}
	}

	ptStart = TADSGePoint3d(ptEnd);
	ptEnd.x += dTextWidth * 1.2;									// *1.2是因为文字下方的线要比文字的宽度长一些

	seg = TGGeCurveSegment(ptStart, ptEnd, 0);

	line = TGGeLine(seg);
	dc.DrawLine(line);
}

// 单元编号
void TDbColumn::DrawCellNo(TGGiExplodeDrawBase &dc) const
{
	CString strCellNo;
	GetSpecialtyDataReadOnly()->GetAt(KEY_CELLNO, strCellNo);
	if (strCellNo.IsEmpty())
	{
		return;
	}

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

	AcDbText text;
	text.setTextString(strCellNo);						// 设置文字的显示内容

	// 设置文字样式
	AcDbObjectId idColuNOStyl = DocGetColuNoStyle();
	if(!idColuNOStyl.isNull())
	{
		text.setTextStyle(idColuNOStyl);			
	}
	else
	{
		text.setTextStyle(InitTextStyle(TS_STANDARD));
	}

	text.setHeight(DocGetColuNoHigh() * GetPScale());	// 设置文字字高	

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

	// 设置文字法向
	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);
	}

	AcGePoint3d  ptInsertJ = GetLocation();
	ptInsertJ.z = GetLocation().z + GetHeight()/2;

	TADSGePoint3d ptLow, ptUp;
	//	GetExtents2d(ptLow, ptUp);						// 获得柱子轮廓的最高点和最底点
	m_polyOutline.GetExtend(ptLow, ptUp);
	ptLow.z = 0.0;
	ptUp.z = 0.0;

	// 求柱子外围轮廓的宽和高
	double dWidth;
	dWidth = fabs(ptUp.x - ptLow.x);

	double dDis = (DocGetColuNoDist() * GetPScale()) + dWidth/2;// 得到文字到柱子的距离(考虑图纸比例)
	ptInsertJ.x += dDis;

	text.setPosition(ptInsertJ);						// 设置文字的插入位置
	text.setHorizontalMode(AcDb::kTextMid);			// 设置文字的对齐方式

	dc.DrawEntity(text);
}

// 刚域
void TDbColumn::DrawRG(TGGiExplodeDrawBase &dc) const
{
	double dRGI, dRGJ;
	bool bI = GetSpecialtyDataReadOnly()->GetAt(KEY_RIGIDI, dRGI);
	double bJ = GetSpecialtyDataReadOnly()->GetAt(KEY_RIGIDJ, dRGJ);
	if(!bI && !bJ)
	{
		return;
	}

	CString strRGI, strRGJ;
	AcDbText text;

	// 设置文字样式
	AcDbObjectId idColuRGStyl = DocGetColuRGStyle();
	if(!idColuRGStyl.isNull())
	{
		text.setTextStyle(idColuRGStyl);	
	}
	else
	{
		text.setTextStyle(InitTextStyle(TS_STANDARD));
	}

	text.setHeight(DocGetColuRGHigh() * GetPScale());// 设置文字高度

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

	// 设置文字法向
	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);
	}

	double dDis = (DocGetColuRGDist() * GetPScale());	// 得到文字到柱子的距离(考虑图层比例)
	AcGePoint3d  ptInsert;

	text.setHorizontalMode(AcDb::kTextMid);				// 设置文字的对齐方式

	if(bI)
	{
		strRGI = TrimDoubleZero(dRGI);
		ptInsert = GetLocation();						// 得到柱子的插入点
		text.setTextString(strRGI);						// 设置文字内容
		ptInsert.z -= dDis;
		ptInsert.z -= text.height();

		text.setPosition(ptInsert);							// 设置文字的插入位置
		dc.DrawEntity(text);								// 画文字对象
	}

	if(bJ)
	{
		strRGJ = TrimDoubleZero(dRGJ);
		text.setTextString(strRGJ);							// 设置文字内容

		ptInsert = GetLocation();							// 得到柱高
		ptInsert.z += dDis + GetHeight();

		text.setPosition(ptInsert);							// 设置文字位置

		dc.DrawEntity(text);		
	}

}

// 柱坐标
void TDbColumn::DrawCoordinate(TGGiExplodeDrawBase &dc)const
{
	// 坐标文字设置
	TDbText textX, textY;

	AcDbObjectId idColuBHStyl = DocGetColuBHStyle();
	if(idColuBHStyl.isNull())
	{
		idColuBHStyl = InitTextStyle(TS_STANDARD);
	}
	textX.SetStyleId(idColuBHStyl);				// 设置尺寸文字样式
	textX.SetHeight(3);							// 设置尺寸文字高度			
	textX.setColorIndex(DocGetColuBHColor());	// 设置尺寸文字颜色
	textX.SetAlignment(XExplodeDraw::kMiddleLeft);
	textX.SetText(_T("X"));

	textY.SetStyleId(idColuBHStyl);				// 设置尺寸文字样式
	textY.SetHeight(3);							// 设置尺寸文字高度			
	textY.setColorIndex(DocGetColuBHColor());	// 设置尺寸文字颜色
	textY.SetAlignment(XExplodeDraw::kBottomCenter);
	textY.SetText(_T("Y"));

	// 获得柱子的插入点
	AcGePoint3d ptInsert;
	ptInsert = GetLocation();
	XPoint ptInsertCopy(ptInsert);

	// 得到柱子截面形状
	TSectionShape nShape = GetSectionShape();

	// 画坐标
	TADSGePoint3d ptXEnd(ptInsert.x + g_dCoordinateLen, ptInsert.y, 0.0);// X轴
	TADSGePoint3d ptStart(ptInsert);
	TADSGePoint3d ptYEnd(ptInsert.x, ptInsert.y + g_dCoordinateLen, 0.0);// Y轴

	TGGeCurveSegment segX(ptStart, ptXEnd, 0);
	TGGeCurveSegment segY(ptStart, ptYEnd, 0);

	TGGeLine lineX(segX);
	TGGeLine lineY(segY);

	AcDbPolyline polyX;
	ptStart = ptXEnd;
	ptXEnd = TADSGePoint3d(ptStart.x + g_dCoordinateLen/5, ptStart.y, 0.0);
	polyX.addVertexAt(0, ptXEnd.AsAcGePoint2d());

	textX.SetLocation(ptXEnd);

	ptXEnd = TADSGePoint3d(ptStart.x, ptStart.y + g_dCoordinateLen/10, 0.0);
	polyX.addVertexAt(1, ptXEnd.AsAcGePoint2d());

	ptXEnd = TADSGePoint3d(ptStart.x, ptStart.y - g_dCoordinateLen/10, 0.0);
	polyX.addVertexAt(2, ptXEnd.AsAcGePoint2d());
	polyX.setClosed(Adesk::kTrue);


	AcDbPolyline polyY;
	ptStart = ptYEnd;
	ptYEnd = TADSGePoint3d(ptStart.x, ptStart.y + g_dCoordinateLen/5, 0.0);
	polyY.addVertexAt(0, ptYEnd.AsAcGePoint2d());

	textY.SetLocation(ptYEnd);

	ptYEnd = TADSGePoint3d(ptStart.x + g_dCoordinateLen/10, ptStart.y, 0.0);
	polyY.addVertexAt(1, ptYEnd.AsAcGePoint2d());

	ptYEnd = TADSGePoint3d(ptStart.x - g_dCoordinateLen/10, ptStart.y, 0.0);
	polyY.addVertexAt(2, ptYEnd.AsAcGePoint2d());
	polyY.setClosed(Adesk::kTrue);

	if(nShape != kCircle)
	{
		// 得到柱子的转角
		double dAngle;
		GetSpecialtyDataReadOnly()->GetAt(KEY_AXANG, dAngle);

		ads_matrix matRot;
		ptInsertCopy.GetRotationMatrix(dAngle, matRot);

		// 矩阵转化
		lineX.TransformBy(matRot);
		lineY.TransformBy(matRot);
		polyX.transformBy(AsAcGeMatrix3d(matRot));
		polyY.transformBy(AsAcGeMatrix3d(matRot));
		textX.transformBy(AsAcGeMatrix3d(matRot));
		textY.transformBy(AsAcGeMatrix3d(matRot));
	}	

	lineX.SetElevation(0.0);
	lineY.SetElevation(0.0);

	dc.DrawLine(lineX);
	dc.DrawLine(lineY);
	dc.Polyline(polyX);
	dc.Polyline(polyY);

	textX.ExplodeOrDraw2d(dc);
	textY.ExplodeOrDraw2d(dc);
}

// add by wjx on 111222
// 功能:绘制柱子荷载
// [in]:nFlag2d3d:绘制2d3d标志2:2d 3:3d
void TDbColumn::DrawColuLoad(TGGiExplodeDrawBase &dc, int nFlag2d3d)const
{
	//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;
	}

	// modify by wjx on 120130 修改柱子荷载信息的读取方式
	std::vector<TStruLoad> vecLoad;
	GetLoadsArray(vecLoad);

	int nSize = vecLoad.size();
	if(nSize < 1)
	{
		return;
	}

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

	TStruLoad loadData;
	double dTextDisL,dTextDisR, dTextDisT, dTextDisB, dTextDis;// 四个方向文字距离
	dTextDisL = dTextDisT = (-250+DocGetLoadTextHeight());
	dTextDisR = dTextDisB = (250-DocGetLoadTextHeight());
	dTextDis = 300;

	for(int i = 0; i < nSize; i++)
	{
		loadData = vecLoad[i];
		if(nFlag2d3d == 2)
		{
			// 获得柱子的插入点
			AcGePoint3d ptInsert;
			ptInsert = GetLocation();
			XPoint ptLoadS, ptLoadE;				// 荷载图像的起始和终止点
			double dLoadLen = 200;					// 荷载图像长度
			double dWidth, dHeight;					// 柱子截面宽和高

			TSectionShape nShape = GetSectionShape();
			if(nShape == kRect)						// 矩形
			{
				GetSpecialtyDataReadOnly()->GetAt(KEY_B, dWidth);
				GetSpecialtyDataReadOnly()->GetAt(KEY_H, dHeight);
			}
			else if(nShape == kIBeam)
			{
				double dU = 0.0, dB = 0.0, dD = 0.0, dF = 0.0;
				GetSpecialtyDataReadOnly()->GetAt(KEY_H,dHeight);
				GetSpecialtyDataReadOnly()->GetAt(KEY_B,dB);
				GetSpecialtyDataReadOnly()->GetAt(KEY_U,dU);
				GetSpecialtyDataReadOnly()->GetAt(KEY_D,dD);

				if(dB - dU > _DIST_SNAP)
				{
					if(dB - dD > _DIST_SNAP)
					{
						dWidth = dB;
					}
					else
					{
						dWidth = dD;
					}
				}
				else
				{
					if(dU - dD > _DIST_SNAP)
					{
						dWidth = dU;
					}
					else
					{
						dWidth = dD;
					}
				}
			}
			else if(nShape == kCircle)
			{
				GetSpecialtyDataReadOnly()->GetAt(KEY_B, dWidth);
				dHeight = dWidth;
			}

			int nKind = loadData.GetLoadKind();
			double dLoadValue = loadData.GetValue();
			double dArrow;			// 箭头方向,文字距离
			if(nKind == TStruLoad::LK_UNVARYING || nKind == TStruLoad::LK_VARYING)// x向作用
			{
				if(dLoadValue > _DIST_SNAP)
				{
					ptLoadS = XPoint(ptInsert.x - dWidth/2 - dLoadLen, ptInsert.y, 0.0);
					ptLoadE = XPoint(ptInsert.x - dWidth/2, ptInsert.y, 0.0);
					dArrow = -30;
					dTextDisL -= DocGetLoadTextHeight();
					dTextDis = dTextDisL;
				}
				else
				{
					ptLoadS = XPoint(ptInsert.x + dWidth/2 + dLoadLen, ptInsert.y, 0.0);
					ptLoadE = XPoint(ptInsert.x + dWidth/2, ptInsert.y, 0.0);
					dArrow = 30;
					dTextDisR += DocGetLoadTextHeight();
					dTextDis = dTextDisR;
				}
			}
			else																  // y向作用
			{
				if(dLoadValue > _DIST_SNAP)
				{
					ptLoadS = XPoint(ptInsert.x, ptInsert.y - dHeight/2 - dLoadLen, 0.0);
					ptLoadE = XPoint(ptInsert.x, ptInsert.y - dHeight/2, 0.0);
					dArrow = -30;
					dTextDisB -= DocGetLoadTextHeight();
					dTextDis = dTextDisB;
				}
				else
				{
					ptLoadS = XPoint(ptInsert.x, ptInsert.y + dHeight/2 + dLoadLen, 0.0);
					ptLoadE = XPoint(ptInsert.x, ptInsert.y + dHeight/2, 0.0);
					dArrow = +30;
					dTextDisT += DocGetLoadTextHeight();
					dTextDis = dTextDisT;
				}
			}

			if(bShowGraphic)
			{
				DrawColuLoad2d(dc, loadData, ptLoadS, ptLoadE, dArrow);
			}

			if (((loadData.GetLoadKind() == TStruLoad::LK_VARYING
				||loadData.GetLoadKind() == TStruLoad::LK_VARYINGY) && bShowLive)		//活荷
				||((loadData.GetLoadKind() == TStruLoad::LK_UNVARYING
				||loadData.GetLoadKind() == TStruLoad::LK_UNVARYINGY) && bShowUnLive)	//恒荷
				)
			{
				DrawLoadText2d(dc, loadData, ptLoadS, dTextDis);
			}
		}
		else
		{
			if(bShowGraphic)
			{
				DrawColuLoad3d(dc, loadData);
			}

			if (((loadData.GetLoadKind() == TStruLoad::LK_VARYING
				||loadData.GetLoadKind() == TStruLoad::LK_VARYINGY)&&bShowLive)		//活荷
				||((loadData.GetLoadKind() == TStruLoad::LK_UNVARYING
				||loadData.GetLoadKind() == TStruLoad::LK_UNVARYINGY)&&bShowUnLive)	//恒荷
				)
			{
				DrawLoadText3d(dc, loadData, dTextDis);
			}
		}
	}
}

// add by wjx on 111222
// 功能:绘制2d荷载
// [in]:loadData:荷载信息
void TDbColumn::DrawColuLoad2d(TGGiExplodeDrawBase &dc, TStruLoad loadData, 
							   XPoint ptLoadS, XPoint ptLoadE, double dArrow)const
{
	// 获得柱子的插入点
	AcGePoint3d ptInsert = GetLocation();

	TSectionShape nShape = GetSectionShape();

	int nKind = loadData.GetLoadKind();

	double dLineWidth = 100;// 线粗
	ads_matrix matRot;
	if(nShape != kCircle)
	{
		// 得到柱子的转角
		double dAngle;
		GetSpecialtyDataReadOnly()->GetAt(KEY_AXANG, dAngle);
		XPoint(ptInsert).GetRotationMatrix(dAngle, matRot);
	}

	int nType = loadData.GetLoadType();
	AcDbPolyline polyLine, line;
	polyLine.setColorIndex(1);
	line.setColorIndex(1);

	// 	nType += 9;
	switch (nType)
	{
	case TStruLoad::LT_FOCUS_V:
		if(nShape != kCircle)
		{
			ptLoadS.TransformBy(matRot);
			ptLoadE.TransformBy(matRot);
		}

		polyLine.addVertexAt(0, XPoint(ptLoadS.x, ptLoadS.y+10, 0), PI, dLineWidth, dLineWidth);
		polyLine.addVertexAt(1, XPoint(ptLoadS.x, ptLoadS.y-10, 0), 0.3, dLineWidth, dLineWidth);
		polyLine.setClosed(Adesk::kTrue);
		dc.DrawEntity(polyLine);

		dLineWidth = 10;
		line.addVertexAt(0, ptLoadS, 0, dLineWidth, dLineWidth);
		line.addVertexAt(1, ptLoadE, 0, dLineWidth, dLineWidth);
		dc.DrawEntity(line);
		break;
	case TStruLoad::LT_ALL_V:
		if(nShape != kCircle)
		{
			ptLoadS.TransformBy(matRot);
			ptLoadE.TransformBy(matRot);
		}

		dLineWidth = 20;
		polyLine.addVertexAt(0, ptLoadS, 0, dLineWidth, dLineWidth);
		polyLine.addVertexAt(1, ptLoadE, 0, dLineWidth, dLineWidth);
		dc.DrawEntity(polyLine);
		break;
	case TStruLoad::LT_FOLD_V:
		dLineWidth = 20;
		if(nKind == TStruLoad::LK_UNVARYING || nKind == TStruLoad::LK_VARYING)
		{
			polyLine.addVertexAt(0, XPoint(ptLoadS.x, ptLoadS.y+50, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(1, XPoint(ptLoadS.x, ptLoadS.y-50, 0), 0, dLineWidth, dLineWidth);
		}
		else
		{
			polyLine.addVertexAt(0, XPoint(ptLoadS.x+50, ptLoadS.y, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(1, XPoint(ptLoadS.x-50, ptLoadS.y, 0), 0, dLineWidth, dLineWidth);
		}

		polyLine.addVertexAt(2, ptLoadS, 0, dLineWidth, dLineWidth);
		polyLine.addVertexAt(3, ptLoadE, 0, dLineWidth, dLineWidth);
		polyLine.transformBy(AsAcGeMatrix3d(matRot));
		dc.DrawEntity(polyLine);
		break;
	case TStruLoad::LT_FOCUS_H:
		dLineWidth = 10;
		if(nKind == TStruLoad::LK_UNVARYING || nKind == TStruLoad::LK_VARYING)
		{
			polyLine.addVertexAt(0, XPoint(ptLoadE.x+dArrow, ptLoadE.y+50, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(1, ptLoadE, 0, 10, 10);
			polyLine.addVertexAt(2, XPoint(ptLoadE.x+dArrow, ptLoadE.y-50, 0), 0, dLineWidth, dLineWidth);
		}
		else
		{
			polyLine.addVertexAt(0, XPoint(ptLoadE.x+50, ptLoadE.y+dArrow, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(1, ptLoadE, 0, 10, 10);
			polyLine.addVertexAt(2, XPoint(ptLoadE.x-50, ptLoadE.y+dArrow, 0), 0, dLineWidth, dLineWidth);
		}
		polyLine.addVertexAt(3, ptLoadE, 0, dLineWidth, dLineWidth);
		polyLine.addVertexAt(4, ptLoadS, 0, dLineWidth, dLineWidth);
		polyLine.transformBy(AsAcGeMatrix3d(matRot));
		dc.DrawEntity(polyLine);
		break;
	case TStruLoad::LT_MOMENT_V:
		dLineWidth= 20;
		if(nKind == TStruLoad::LK_UNVARYING || nKind == TStruLoad::LK_VARYING)
		{
			polyLine.addVertexAt(0, XPoint(ptLoadE.x+dArrow, ptLoadE.y, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(1, XPoint(ptLoadE.x+dArrow, ptLoadE.y+40, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(2, ptLoadE, 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(3, XPoint(ptLoadE.x+dArrow, ptLoadE.y-40, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(4, XPoint(ptLoadE.x+dArrow, ptLoadE.y, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(5, XPoint(ptLoadE.x+dArrow*2, ptLoadE.y, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(6, XPoint(ptLoadE.x+dArrow*3, ptLoadE.y+40, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(7, XPoint(ptLoadE.x+dArrow*3, ptLoadE.y-40, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(8, XPoint(ptLoadE.x+dArrow*2, ptLoadE.y, 0), 0, 10, 10);
		}
		else
		{
			polyLine.addVertexAt(0, XPoint(ptLoadE.x, ptLoadE.y+dArrow, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(1, XPoint(ptLoadE.x+40, ptLoadE.y+dArrow, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(2, ptLoadE, 0, 30, 30);
			polyLine.addVertexAt(3, XPoint(ptLoadE.x-40, ptLoadE.y+dArrow, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(4, XPoint(ptLoadE.x, ptLoadE.y+dArrow, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(5, XPoint(ptLoadE.x, ptLoadE.y+dArrow*2, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(6, XPoint(ptLoadE.x+40, ptLoadE.y+dArrow*3, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(7, XPoint(ptLoadE.x-40, ptLoadE.y+dArrow*3, 0), 0, dLineWidth, dLineWidth);
			polyLine.addVertexAt(8, XPoint(ptLoadE.x, ptLoadE.y+dArrow*2, 0), 0, 10, 10);
		}
		polyLine.addVertexAt(9, ptLoadS, 0, 10, 10);
		polyLine.transformBy(AsAcGeMatrix3d(matRot));
		dc.DrawEntity(polyLine);
		break;
	}
}

// 绘制2d荷载文字
void TDbColumn::DrawLoadText2d(TGGiExplodeDrawBase &dc, TStruLoad loadData, 
							   XPoint ptInsert, double dTextDis)const
{
	int nKind = loadData.GetLoadKind();       // 荷载种类

	TSectionShape nShape = GetSectionShape();

	ads_matrix matRot;
	// 得到柱子的转角
	double dAngle = 0;
	if(nShape != kCircle)
	{
		GetSpecialtyDataReadOnly()->GetAt(KEY_AXANG, dAngle);

		TADSGePoint3d ptInsertColu = GetLocation();
		ptInsertColu.GetRotationMatrix(dAngle, matRot);
	}

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

	// 生成要显示的荷载文字
	int nType = loadData.GetLoadType();		  // 荷载类型

	CString strLoadInfo;
	switch (nType)
	{
	case TStruLoad::LT_FOCUS_V:
		strLoadInfo.Format(_T("%d*%s*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()), TrimDoubleZero(loadData.GetPara2()));
		break;
	case TStruLoad::LT_ALL_V:
		strLoadInfo.Format(_T("%d*%s"), nType,TrimDoubleZero(loadData.GetValue()));
		break;
	case TStruLoad::LT_FOLD_V:
		strLoadInfo.Format(_T("%d*%s*%s*%s*%s"), nType,TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()), TrimDoubleZero(loadData.GetPara2()),
			TrimDoubleZero(loadData.GetPara3()));
		break;
	case TStruLoad::LT_FOCUS_H:
	case TStruLoad::LT_MOMENT_V:
		strLoadInfo.Format(_T("%d*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()));
		break;
	}

	text.setTextString(strLoadInfo);

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

	if(nKind == TStruLoad::LK_UNVARYING || nKind == TStruLoad::LK_VARYING)
	{
		dAngle += PI/2;
		ptInsert.x += dTextDis;
	}
	else
	{
		ptInsert.y += dTextDis;
	}

	if(nShape != kCircle)
	{
		ptInsert.TransformBy(matRot);
	}

	text.setPosition(ptInsert);
	text.setRotation(dAngle);
	text.setHorizontalMode(AcDb::kTextCenter);			// 设置文字的对齐方式
	text.setAlignmentPoint(ptInsert);

	dc.DrawEntity(text);
}

// add by wjx on 111222
// 功能:绘制3d荷载
// [in]:loadData:荷载信息
void TDbColumn::DrawColuLoad3d(TGGiExplodeDrawBase &dc, TStruLoad loadData)const
{
	AcGePoint3d ptI = GetLocation(), ptJ = GetLocation();
	ptJ.z = ptI.z + GetHeight();

	double dZ = GetHeight();
	XPoint ptMid = XPoint(ptI.x, ptI.y, ptI.z + dZ/2);
	XPoint ptH = XPoint(ptI.x, ptI.y, ptI.z + loadData.GetPara1()*1000);
	TGGeCurveSegment seg, segCenter;

	// 生成要显示的荷载文字
	int nType = loadData.GetLoadType();		  // 荷载类型
	// 	nType += 9;

	double dDis = 300, dDisZ;
	CString strLoadInfo;

	double dLenTemp = 100;
	int nColor = dc.GetColor();
	dc.SetColor(1);

	int i = 0;
	switch (nType)
	{
	case TStruLoad::LT_FOCUS_V:
		seg = TGGeCurveSegment(ptMid, XPoint(ptMid.x+dDis, ptMid.y, ptMid.z), 0);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(XPoint(ptMid.x+dDis, ptMid.y, ptMid.z), XPoint(ptMid.x+dDis, ptMid.y, ptH.z), 0);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(XPoint(ptJ.x+dDis, ptJ.y, ptJ.z), XPoint(ptMid.x+dDis, ptMid.y, ptH.z+dLenTemp), 0);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(XPoint(ptMid.x+dDis, ptMid.y, ptH.z+dLenTemp), XPoint(ptMid.x+dDis+dLenTemp, ptMid.y+dLenTemp, ptH.z+dLenTemp*2), 0);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(XPoint(ptMid.x+dDis, ptMid.y, ptH.z+dLenTemp), XPoint(ptMid.x+dDis-dLenTemp, ptMid.y-dLenTemp, ptH.z+dLenTemp*2), 0);
		dc.DrawCurve(seg);		

		break;
	case TStruLoad::LT_ALL_V:
		segCenter = TGGeCurveSegment(ptI, ptJ, 0);
		seg = TGGeCurveSegment(XPoint(ptI.x+dDis, ptMid.y, ptI.z), XPoint(ptJ.x+dDis, ptJ.y, ptJ.z), 0);
		dc.DrawCurve(seg);

		dDisZ = seg.GetLength()/5;
		for (; i <= 5; i++)
		{
			segCenter.ProjectToMe(XPoint(ptI.x+dDis, ptI.y, ptI.z+i*dDisZ), ptMid);
			seg = TGGeCurveSegment(XPoint(ptI.x+dDis, ptI.y, ptI.z+i*dDisZ), ptMid, 0);
			dc.DrawCurve(seg);
		}
		break;
	case TStruLoad::LT_FOLD_V:
		segCenter = TGGeCurveSegment(XPoint(ptI.x+dDis/2, ptI.y, ptI.z+loadData.GetPara2()*1000), XPoint(ptJ.x+dDis, ptJ.y, ptI.z+(loadData.GetPara2()+loadData.GetPara3())*1000), 0);
		// 		seg = TGGeCurveSegment(XPoint(ptI.x+dDis/2, ptI.y, ptI.z+dZ/4), XPoint(ptJ.x+dDis, ptJ.y, ptJ.z-dZ/4), 0);
		dc.DrawCurve(segCenter);

		dDisZ = segCenter.GetLength()/5;
		for (; i <= 5; i++)
		{
			segCenter.ProjectToMe(XPoint(ptI.x, ptI.y, ptI.z+loadData.GetPara2()*1000+i*dDisZ), ptMid);
			seg = TGGeCurveSegment(XPoint(ptI.x, ptI.y, ptI.z+loadData.GetPara2()*1000+i*dDisZ), ptMid, 0);
			dc.DrawCurve(seg);
		}
		break;
	case TStruLoad::LT_FOCUS_H:
		seg = TGGeCurveSegment(ptH, XPoint(ptH.x, ptH.y+dDis,ptH.z), 0);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(ptH, XPoint(ptH.x+dLenTemp, ptH.y+dDis/2-dLenTemp,ptH.z), 0);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(ptH, XPoint(ptH.x-dLenTemp, ptH.y+dDis/2-dLenTemp,ptH.z), 0);
		dc.DrawCurve(seg);

		break;
	case TStruLoad::LT_MOMENT_V:
		seg = TGGeCurveSegment(XPoint(ptH.x, ptH.y-dDis/2,ptH.z), XPoint(ptH.x, ptH.y+dDis/2,ptH.z), -PI*5/4);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(XPoint(ptH.x, ptH.y+dDis/2,ptH.z), XPoint(ptH.x-dLenTemp, ptH.y+dDis/2+dLenTemp,ptH.z), 0);
		dc.DrawCurve(seg);

		seg = TGGeCurveSegment(XPoint(ptH.x, ptH.y+dDis/2,ptH.z), XPoint(ptH.x-dLenTemp, ptH.y+dDis/2-dLenTemp,ptH.z), 0);
		dc.DrawCurve(seg);

		break;
	}

	dc.SetColor(nColor);
}

// 绘制3d荷载文字
void TDbColumn::DrawLoadText3d(TGGiExplodeDrawBase &dc, TStruLoad loadData, double &dDis)const
{
	int nKind = loadData.GetLoadKind();       // 荷载种类

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

	// 得到柱子的中心点
	AcGePoint3d ptI = GetLocation();
	double dZ = GetHeight()/2;
	XPoint ptMid(ptI.x, ptI.y, ptI.z+dZ);

	// 生成要显示的荷载文字
	int nType = loadData.GetLoadType();		  // 荷载类型
	// 	nType += 9;

	CString strLoadInfo;
	switch (nType)
	{
	case TStruLoad::LT_FOCUS_V:
		strLoadInfo.Format(_T("%d*%s*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()), TrimDoubleZero(loadData.GetPara2()));
		break;
	case TStruLoad::LT_ALL_V:
		strLoadInfo.Format(_T("%d*%s"), nType,TrimDoubleZero(loadData.GetValue()));
		break;
	case TStruLoad::LT_FOLD_V:
		strLoadInfo.Format(_T("%d*%s*%s*%s*%s"), nType,TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()), TrimDoubleZero(loadData.GetPara2()),
			TrimDoubleZero(loadData.GetPara3()));
		break;
	case TStruLoad::LT_FOCUS_H:
	case TStruLoad::LT_MOMENT_V:
		strLoadInfo.Format(_T("%d*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()));
		break;
	}

	text.setTextString(strLoadInfo);

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

	text.setRotation(PI/2);

	// 设置文字法向
	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+dDis, ptMid.z));
	dc.DrawEntity(text);

	dDis += DocGetLoadTextHeight();	
}

//铰接属性
//返回值 0：普通柱，1:上端铰柱,2:下端铰柱，3：两端铰柱
int TDbColumn::GetHinge()const
{
	assertReadEnabled();

	int	nHinge(0);
	if(GetSpecialtyDataReadOnly()->GetAt(KEY_HINGE, nHinge))
	{
		BOOL bTop = ((nHinge & HINGE_START) != 0);
		BOOL bDown = ((nHinge & HINGE_END) != 0);

		if (bTop && bDown)
		{
			return 3;		//两端铰柱
		}
		else if (bTop)
		{
			return 1;		//上端铰柱
		}
		else if(bDown)
		{
			return 2;		//下端铰柱
		}
	}
	return 0;				//普通柱
}

// add by wjx 0n 111230
// 特殊柱填充
void TDbColumn::SepColuHach(TGGiExplodeDrawBase &dc)const
{
	// 设置文字
	double dTextHeight = 200;
	AcDbText text;
	text.setHeight(dTextHeight);// 设置文字高度	

	TADSGePoint3d ptLow, ptUp;
	//GetExtents2d(ptLow, ptUp);				// 获得柱子轮廓的最高点和最底点
	m_polyOutline.GetExtend(ptLow, ptUp);
	ptLow.z = 0.0;
	ptUp.z = 0.0;

	// 求柱子外围轮廓的宽和高
	double dHeight, dWidth;
	dHeight = fabs(ptUp.y - ptLow.y);		
	dWidth = fabs(ptUp.x - ptLow.x);

	AcGePoint3d ptIns = GetLocation();

	int nKind = kColu;
	GetSpecialtyDataReadOnly()->GetAt(KEY_KIND, nKind);
	text.setPosition(XPoint(ptIns.x+dWidth/2, ptIns.y-dHeight/2, 0));

	if(nKind == kConerColu)				// 角柱
	{
		text.setTextString(_T("JZ"));
		text.setColorIndex(CORCOLUCOLOR);//紫色
		dc.DrawEntity(text);
	}
	else if(nKind == kTransColu)		// 转换柱
	{
		text.setTextString(_T("ZHZ"));
		text.setColorIndex(TCOLUCOLOR);	//白色
		dc.DrawEntity(text);
	}
	else if(nKind == kTransConColu)		// 角柱和转换柱
	{
		text.setTextString(_T("JZ"));
		text.setColorIndex(CORCOLUCOLOR);//紫色
		dc.DrawEntity(text);

		text.setTextString(_T("ZHZ"));
		text.setColorIndex(TCOLUCOLOR);	//白色
		text.setPosition(XPoint(ptIns.x+dWidth/2, ptIns.y-dHeight/2+dTextHeight, 0));
		dc.DrawEntity(text);
	}
}

void TDbColumn::SetHinge(BOOL bTop, BOOL bTrue)
{
	assertReadEnabled();
	int nHingeNum(0);			
	int	nHinge(0);

	GetSpecialtyDataReadOnly()->GetAt(KEY_HINGE, nHinge);
	if(bTop)
	{
		if(bTrue)
		{
			nHinge |= HINGE_START;
		}
		else
		{
			nHinge &= ~HINGE_START;
		}
	}
	else
	{
		if(bTrue)
		{
			nHinge |= HINGE_END;
		}
		else
		{
			nHinge &= ~HINGE_END;
		}
	}
	GetSpecialtyData()->SetAt(KEY_HINGE, nHinge);
}

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

// add by wjx on 120329 轴力包络图
// 数组中的顺序是工况, 轴力, 弯距x, 弯矩y, 剪力x, 剪力y
bool TDbColumn::SetNGraArray(const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	ClearNGraArray();
	return SetAt(KEY_NGRA, vecData);
}

//获得轴力包络图数组
bool TDbColumn::GetNGraArray(std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();
	return GetAt(KEY_NGRA, vecData);
}

//清除轴力包络图数组
void TDbColumn::ClearNGraArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_NGRA);	
}

// add by wjx on 120329 绘制轴力图
void TDbColumn::DrawNGraph(TGGiExplodeDrawBase &dc)const
{
	std::vector<TCombForceData> vecData;

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

	if(GetNGraArray(vecData))			// 得到轴力数据
	{
		AcGePoint3d ptInsert, ptText;
		ptInsert = GetLocation();		// 得到柱子的插入位置

		double dPaperScale = GetPScale();
		// 得到轴力文字总的高度
		double dTotalHeight = g_dNGrapTextH * dPaperScale * 5;

		// 计算文字的起始位置
		ptText = ptInsert;
		ptText.y = ptInsert.y + dTotalHeight/3;

		// 计算文字与柱子的距离
		double dTextWidth = 10*dPaperScale;
		XPoint ptUp, ptLow;
		//		GetExtents2d(ptLow, ptUp);
		m_polyOutline.GetExtend(ptLow, ptUp);
		ptLow.z = 0.0;
		ptUp.z = 0.0;

		double dDis = fabs(ptUp.x - ptLow.x);
		dDis = dDis/2 + dTextWidth;
		ptText.x = ptInsert.x - dDis;

		AcDbText text;
		text.setTextStyle(InitTextStyle(TS_STANDARD));
		text.setHeight(g_dNGrapTextH*dPaperScale);// 设置文字高度
		int nColor = 2;
		text.setColorIndex(nColor);

		CString strText;
		int nSize = vecData.size();
		for(int i = 1; i < nSize; i++)
		{
			strText.Format(_T("%.3f"), vecData[i].m_dForce);
			text.setTextString(strText);
			text.setPosition(XPoint(ptText.x, ptText.y-g_dNGrapTextH*(i-1) * dPaperScale, 0));
			dc.DrawEntity(text);
		}
	}
}

//底层墙柱内力图
void TDbColumn::DrawWallColu(TGGiExplodeDrawBase &dc)const
{
	TPushProperty vProp(this, dc);
	if (m_idLayerForce.isValid())
	{
		dc.SetLayer(m_idLayerForce);
	}

	std::vector<TCombForceData> vecData;
	switch (g_nColuForce)
	{
	case eVXMax:			//X向最大剪力
		GetVXMaxArray(vecData);
		break;
	case eVYMax:			//Y向最大剪力
		GetVYMaxArray(vecData);
		break;
	case eNMax:				//最大轴力
		GetNMaxArray(vecData);
		break;
	case eNMin:				//最小轴力
		GetNMinArray(vecData);
		break;
	case eMXMax:			//X向最大弯矩
		GetMXMaxArray(vecData);
		break;
	case eMYMax:			//Y向最大弯矩
		GetMYMaxArray(vecData);
		break;
	default :
		break;
	}
	if(vecData.size() > 0)				// 得到内力数据
	{
		AcGePoint3d ptInsert, ptText;
		ptInsert = GetLocation();	// 得到柱子的插入位置

		double dPaperScale = GetPScale();
		// 得到内力文字总的高度
		double dTotalHeight = g_dNGrapTextH * dPaperScale * 5;

		// 计算文字的起始位置
		ptText = ptInsert;
		ptText.y = ptInsert.y + dTotalHeight/3;

		// 计算文字与柱子的距离
		double dTextWidth = 10*dPaperScale;
		XPoint ptUp, ptLow;
		//		GetExtents2d(ptLow, ptUp);
		m_polyOutline.GetExtend(ptLow, ptUp);
		ptLow.z = 0.0;
		ptUp.z = 0.0;

		double dDis = fabs(ptUp.x - ptLow.x);
		dDis = dDis/2 + dTextWidth;
		ptText.x = ptInsert.x - dDis;

		AcDbText text;
		text.setTextStyle(InitTextStyle(TS_STANDARD));
		text.setHeight(g_dNGrapTextH*dPaperScale);// 设置文字高度
		int nColor = 2;
		text.setColorIndex(nColor);

		CString strText;
		int nSize = vecData.size();
		for(int i = 1; i < nSize; i++)
		{
			strText.Format(_T("%.3f"), vecData[i].m_dForce);
			text.setTextString(strText);
			text.setPosition(XPoint(ptText.x, ptText.y-g_dNGrapTextH*(i-1) * dPaperScale, 0));
			dc.DrawEntity(text);
		}
	}
}

//柱填充图层
AcDbObjectId TDbColumn::GetLayerHatch() const
{
	return m_idLayerHatch;
}
void TDbColumn::SetLayerHatch(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerHatch = idLayer;
}

//柱尺寸图层
AcDbObjectId TDbColumn::GetLayerDim() const
{
	return m_idLayerDim;
}
void TDbColumn::SetLayerDim(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerDim = idLayer;
}

//柱编号图层
AcDbObjectId TDbColumn::GetLayerNum() const
{
	return m_idLayerNum;
}
void TDbColumn::SetLayerNum(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerNum = idLayer;
}

//柱标注图层
AcDbObjectId TDbColumn::GetLayerMark() const
{
	return m_idLayerMark;
}
void TDbColumn::SetLayerMark(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerMark = idLayer;
}

//柱截面注写图层
AcDbObjectId TDbColumn::GetLayerSect() const
{
	return m_idLayerSect;
}
void TDbColumn::SetLayerSect(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerSect = idLayer;
}

//柱表注写图层
AcDbObjectId TDbColumn::GetLayerTbl() const
{
	return m_idLayerTbl;
}
void TDbColumn::SetLayerTbl(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerTbl = idLayer;
}

//柱平法纵筋图层
AcDbObjectId TDbColumn::GetLayerRBarV() const
{
	return m_idLayerRBarV;
}
void TDbColumn::SetLayerRBarV(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerRBarV = idLayer;
}

//柱平法箍筋图层
AcDbObjectId TDbColumn::GetLayerRBarR() const
{
	return m_idLayerRBarR;
}
void TDbColumn::SetLayerRBarR(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerRBarR = idLayer;
}

//柱实配面积图层
AcDbObjectId TDbColumn::GetLayerRealArea() const
{
	return m_idLayerRealArea;
}
void TDbColumn::SetLayerRealArea(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerRealArea = idLayer;
}

//柱双偏压图层
AcDbObjectId TDbColumn::GetLayerChkBias() const
{
	return m_idLayerChkBias;
}
void TDbColumn::SetLayerChkBias(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerChkBias = idLayer;
}

//柱轴压比图层
AcDbObjectId TDbColumn::GetLayerChkRati() const
{
	return m_idLayerChkRati;
}
void TDbColumn::SetLayerChkRati(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerChkRati = idLayer;
}
//柱内力结果图层
AcDbObjectId TDbColumn::GetLayerForce() const
{
	return m_idLayerForce;
}
void TDbColumn::SetLayerForce(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerForce = idLayer;
}

//柱计算配筋图层
AcDbObjectId TDbColumn::GetLayerCalcArea() const
{
	return m_idLayerCalcArea;
}
void TDbColumn::SetLayerCalcArea(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerCalcArea = idLayer;
}

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

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

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

//文字样式
AcDbObjectId TDbColumn::GetTextStyleRB() const
{
	return m_idTextStyleRB;
}
void TDbColumn::SetTextStyleRB(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idTextStyleRB = idLayer;
}

//X向最大剪力
bool TDbColumn::SetVXMaxArray(const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	ClearVXMaxArray();
	return SetAt(KEY_VXMAX, vecData);
}
bool TDbColumn::GetVXMaxArray(std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();
	return GetAt(KEY_VXMAX, vecData);
}
void TDbColumn::ClearVXMaxArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_VXMAX);
}
//Y向最大剪力
bool TDbColumn::SetVYMaxArray(const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	ClearVYMaxArray();
	return SetAt(KEY_VYMAX, vecData);
}
bool TDbColumn::GetVYMaxArray(std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();
	return GetAt(KEY_VYMAX, vecData);
}
void TDbColumn::ClearVYMaxArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_VYMAX);
}
//最大轴力
bool TDbColumn::SetNMaxArray(const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	ClearNMaxArray();
	return SetAt(KEY_NMAX, vecData);
}
bool TDbColumn::GetNMaxArray(std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();
	return GetAt(KEY_NMAX, vecData);
}
void TDbColumn::ClearNMaxArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_NMAX);
}
//最小轴力
bool TDbColumn::SetNMinArray(const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	ClearNMinArray();
	return SetAt(KEY_NMIN, vecData);
}
bool TDbColumn::GetNMinArray(std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();
	return GetAt(KEY_NMIN, vecData);
}
void TDbColumn::ClearNMinArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_NMIN);
}
//X向最大弯矩
bool TDbColumn::SetMXMaxArray(const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	ClearMXMaxArray();
	return SetAt(KEY_MXMAX, vecData);
}
bool TDbColumn::GetMXMaxArray(std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();
	return GetAt(KEY_MXMAX, vecData);
}
void TDbColumn::ClearMXMaxArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_MXMAX);
}
bool TDbColumn::SetAt(LPCTSTR pszKey,const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	if (pszKey != NULL)
	{
		CString sSubKey;
		int nLength = vecData.size();
		GetSpecialtyData()->SetAt(pszKey, nLength);

		for (int i = 0;i < nLength; i++)
		{
			sSubKey.Format(_T("%sG%d"),pszKey, i);
			GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_iGroup);
			sSubKey.Format(_T("%sV%d"),pszKey, i);
			GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_dForce);
		}

		return true;
	}

	return false;
}

bool TDbColumn::GetAt(LPCTSTR pszKey,std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();

	vecData.clear();

	if (pszKey != NULL)
	{
		CString sSubKey;
		int nLength = 0;
		GetSpecialtyDataReadOnly()->GetAt(pszKey, nLength);

		double dVal = 0;
		int i = 0,nCombNo;
		while(nLength > 0)
		{
			TCombForceData fcData;
			sSubKey.Format(_T("%sG%d"),pszKey, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, nCombNo))
			{
				fcData.m_iGroup = nCombNo;
			}
			sSubKey.Format(_T("%sV%d"),pszKey, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				fcData.m_dForce = dVal;
			}
			vecData.push_back(fcData);

			i++;
			nLength--;
		}
	}

	return ((int)vecData.size() > 0);
}
void TDbColumn::RemoveNGraKey(LPCTSTR pszKey)
{
	assertWriteEnabled();
	if (pszKey != NULL)
	{
		CString sSubKey;
		int nLength = 0;
		GetSpecialtyDataReadOnly()->GetAt(sSubKey, nLength);
		GetSpecialtyData()->RemoveAt(pszKey);

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

bool TDbColumn::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 TDbColumn::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 TDbColumn::RemoveLoadsKey(LPCTSTR pszKey)
{
	assertWriteEnabled();
	if (pszKey != NULL)
	{
		int nLength = 0;
		GetSpecialtyDataReadOnly()->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);
		}
	}
}
//Y向最大弯矩
bool TDbColumn::SetMYMaxArray(const std::vector<TCombForceData>& vecData)
{
	assertWriteEnabled();
	ClearMYMaxArray();
	return SetAt(KEY_MYMAX, vecData);
}
bool TDbColumn::GetMYMaxArray(std::vector<TCombForceData>& vecData)const
{
	assertReadEnabled();
	return GetAt(KEY_MYMAX, vecData);
}
void TDbColumn::ClearMYMaxArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_MYMAX);
}

bool TDbColumn::SetForceArray(LPCTSTR pszKey, const std::vector<TCombSectForceData>& vecData)
{
	int nLength = vecData.size();
	GetSpecialtyData()->SetAt(pszKey, nLength);

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

		sSubKey.Format(_T("%sS%d"),pszKey, i);
		GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_secForce.m_nSectID);

		sSubKey.Format(_T("%sA%d"),pszKey, i);
		GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_secForce.m_force.m_dAxisForce);

		sSubKey.Format(_T("%sSX%d"),pszKey, i);
		GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_secForce.m_force.m_dShear12);

		sSubKey.Format(_T("%sSY%d"),pszKey, i);
		GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_secForce.m_force.m_dShear13);

		sSubKey.Format(_T("%sMX%d"),pszKey, i);
		GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_secForce.m_force.m_dMoment12);

		sSubKey.Format(_T("%sMY%d"),pszKey, i);
		GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_secForce.m_force.m_dMoment13);

		sSubKey.Format(_T("%sN%d"),pszKey, i);
		GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_secForce.m_force.m_dTorque);
	}
	return true;
}
bool TDbColumn::GetForceArray(LPCTSTR pszKey, std::vector<TCombSectForceData>& vecData)const
{
	vecData.clear();

	int nLength = 0;
	GetSpecialtyDataReadOnly()->GetAt(pszKey, nLength);

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

	int i = 0;
	while(nLength > 0)
	{
		TCombSectForceData forceData;
		sSubKey.Format(_T("%sC%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, nVal))
		{
			forceData.m_iGroup = nVal;
		}

		sSubKey.Format(_T("%sS%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, nVal))
		{
			forceData.m_secForce.m_nSectID = nVal;
		}

		sSubKey.Format(_T("%sA%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
		{
			forceData.m_secForce.m_force.m_dAxisForce = dVal;
		}

		sSubKey.Format(_T("%sSX%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
		{
			forceData.m_secForce.m_force.m_dShear12 = dVal;
		}

		sSubKey.Format(_T("%sSY%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
		{
			forceData.m_secForce.m_force.m_dShear13 = dVal;
		}

		sSubKey.Format(_T("%sMX%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
		{
			forceData.m_secForce.m_force.m_dMoment12 = dVal;
		}

		sSubKey.Format(_T("%sMY%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
		{
			forceData.m_secForce.m_force.m_dMoment13 = dVal;
		}

		sSubKey.Format(_T("%sN%d"),pszKey, i);
		if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
		{
			forceData.m_secForce.m_force.m_dTorque = dVal;
		}

		vecData.push_back(forceData);
		i++;
		nLength--;
	}
	return true;
}
void TDbColumn::ClearForceArray(LPCTSTR pszKey)
{
	int nLength = 0;
	GetSpecialtyDataReadOnly()->GetAt(pszKey, nLength);
	GetSpecialtyData()->RemoveAt(pszKey);

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

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

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

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

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

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

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

		sSubKey.Format(_T("%sN%d"),pszKey, i);
		GetSpecialtyData()->RemoveAt(sSubKey);
	}
}
// 活载标准内力数据
bool TDbColumn::SetVSForceArray(const std::vector<TCombSectForceData>& vecData)
{
	assertWriteEnabled();
	return SetForceArray(KEY_VSFORC, vecData);
}
bool TDbColumn::GetVSForceArray(std::vector<TCombSectForceData>& vecData)const
{
	assertReadEnabled();
	return GetForceArray(KEY_VSFORC, vecData);
}
void TDbColumn::ClearVSForceArray()
{
	assertWriteEnabled();
	ClearForceArray(KEY_VSFORC);
}
// 恒载标准内力数据
bool TDbColumn::SetSForceArray(const std::vector<TCombSectForceData>& vecData)
{
	assertWriteEnabled();
	return SetForceArray(KEY_SFORC, vecData);
}
bool TDbColumn::GetSForceArray(std::vector<TCombSectForceData>& vecData)const
{
	assertReadEnabled();
	return GetForceArray(KEY_SFORC, vecData);
}
void TDbColumn::ClearSForceArray()
{
	assertWriteEnabled();
	ClearForceArray(KEY_SFORC);
}
//内力数据
bool TDbColumn::SetForceArray(const std::vector<TCombSectForceData>& vecData)
{
	assertWriteEnabled();
	return SetForceArray(KEY_FORC, vecData);
}
bool TDbColumn::GetForceArray(std::vector<TCombSectForceData>& vecData)const
{
	assertReadEnabled();
	return GetForceArray(KEY_FORC, vecData);
}
void TDbColumn::ClearForceArray()
{
	assertWriteEnabled();
	ClearForceArray(KEY_FORC);
}

//柱正截面配筋面积数据
bool TDbColumn::SetRSArray(const std::vector<TReinSectData>& vecRSData)
{
	assertWriteEnabled();
	ClearRSArray();
	return SetAt(KEY_RSA, vecRSData);
}
bool TDbColumn::GetRSArray(std::vector<TReinSectData>& vecRSData)const
{
	assertReadEnabled();	
	return GetAt(KEY_RSA, vecRSData);
}
void TDbColumn::ClearRSArray()
{
	assertWriteEnabled();
	RemoveRSDataKey(KEY_RSA);
}
//柱斜截面配筋面积数据
bool TDbColumn::SetRSSArray(const std::vector<TReinSectData>& vecRSData)
{
	assertWriteEnabled();
	ClearRSSArray();
	return SetAt(KEY_RSSA, vecRSData);
}
bool TDbColumn::GetRSSArray(std::vector<TReinSectData>& vecRSData)const
{
	assertReadEnabled();	
	return GetAt(KEY_RSSA, vecRSData);
}
void TDbColumn::ClearRSSArray()
{
	assertWriteEnabled();
	RemoveRSDataKey(KEY_RSSA);
}

//截面配筋面积数据
bool TDbColumn::SetAt(LPCTSTR pszKey,const std::vector<TReinSectData>& vecData)
{
	assertWriteEnabled();
	if (pszKey != NULL)
	{
		CString sSubKey;
		int nLength = vecData.size();
		GetSpecialtyData()->SetAt(pszKey, nLength);

		for (int i = 0;i < nLength; i++)
		{
			sSubKey.Format(_T("%sL%d"),pszKey, i);
			GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_nSectNo);
			sSubKey.Format(_T("%sV%d"),pszKey, i);
			GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_dArea);
			sSubKey.Format(_T("%sP%d"),pszKey, i);
			GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_dAreaS);	
			sSubKey.Format(_T("%sY%d"),pszKey, i);
			GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_dAreaY);
			sSubKey.Format(_T("%sF%d"),pszKey, i);
			GetSpecialtyData()->SetAt(sSubKey, vecData[i].m_nFlag);
		}

		return true;
	}

	return false;
}
bool TDbColumn::GetAt(LPCTSTR pszKey,std::vector<TReinSectData>& vecData)const
{
	assertReadEnabled();

	vecData.clear();

	if (pszKey != NULL)
	{
		CString sSubKey;
		int nLength = 0;
		GetSpecialtyDataReadOnly()->GetAt(pszKey, nLength);

		double dVal = 0;
		int i = 0,nSectNo;
		while(nLength > 0)
		{
			TReinSectData rsData;
			sSubKey.Format(_T("%sL%d"),pszKey, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, nSectNo))
			{
				rsData.m_nSectNo = nSectNo;		
			}
			sSubKey.Format(_T("%sV%d"),pszKey, i);
			if (GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				rsData.m_dArea = dVal;
			}

			sSubKey.Format(_T("%sP%d"),pszKey, i);			
			if(GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				rsData.m_dAreaS = dVal;
			}
			sSubKey.Format(_T("%sY%d"),pszKey, i);			
			if(GetSpecialtyDataReadOnly()->GetAt(sSubKey, dVal))
			{
				rsData.m_dAreaY = dVal;
			}
			sSubKey.Format(_T("%sF%d"),pszKey, i);
			if(GetSpecialtyDataReadOnly()->GetAt(sSubKey, nSectNo))
			{
				rsData.m_nFlag = nSectNo;
			}

			vecData.push_back(rsData);

			i++;
			nLength--;
		}
	}

	return ((int)vecData.size() > 0);
}
void TDbColumn::RemoveRSDataKey(LPCTSTR pszKey)
{
	assertWriteEnabled();
	if (pszKey != NULL)
	{
		CString sSubKey;
		int nLength = 0;
		GetSpecialtyDataReadOnly()->GetAt(sSubKey, nLength);
		GetSpecialtyData()->RemoveAt(pszKey);

		for (int i = 0;i < nLength; i++)
		{
			sSubKey.Format(_T("%sL%d"),pszKey, i);
			GetSpecialtyData()->RemoveAt(sSubKey);
			sSubKey.Format(_T("%sV%d"),pszKey, i);
			GetSpecialtyData()->RemoveAt(sSubKey);
			sSubKey.Format(_T("%sP%d"),pszKey, i);
			GetSpecialtyData()->RemoveAt(sSubKey);
			sSubKey.Format(_T("%sY%d"),pszKey, i);
			GetSpecialtyData()->RemoveAt(sSubKey);
			sSubKey.Format(_T("%sF%d"),pszKey, i);
			GetSpecialtyData()->RemoveAt(sSubKey);
		}
	}
}

bool TDbColumn::ConstructShape(const TADSGePoint3d &pt, TGGePoly2D &poly) const
{
	poly.Reset();

	TSectionShape nShape = GetSectionShape();
	bool bRet = false;
	switch(nShape)
	{
	case kRect:
		{
			bRet = ConstructRectShape(pt, poly);
			break;
		}
	case kIBeam:
		{
			bRet = ConstructIShape(pt, poly);
			break;
		}
	case kCircle:
		{
			bRet = ConstructCircleShape(pt, poly);
			break;
		}
	default:
		{
			return false;
		}
	}

	if (!bRet)
	{
		return false;
	}

	if (poly.PathArea() > 0) // 顺时针时调整为逆时针
	{
		poly.Reverse();
	}

	double dAngle = 0.0;
	GetSpecialtyDataReadOnly()->GetAt(KEY_AXANG, dAngle);
	ads_matrix xform;
	pt.GetRotationMatrix(dAngle, xform);
	AcGeMatrix3d mat;
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			mat(i, j) = xform[i][j];
		}
	}
	poly.TransformBy(mat);

	return true;	
}
//以左下点为起点，逆时针
bool TDbColumn::ConstructRectShape(const TADSGePoint3d &pt, TGGePoly2D &poly) const
{
	double dWidth = 0.0, dHeight = 0.0, dAng = 0.0;
	GetSpecialtyDataReadOnly()->GetAt(KEY_B, dWidth);
	GetSpecialtyDataReadOnly()->GetAt(KEY_H, dHeight);
	AcGePoint3d ptOrigin = pt;
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	AcGeVector3d vtY = vtX;
	vtY = vtY.rotateBy(PI / 2, AcGeVector3d::kZAxis);
	AcGePoint3d ptLT = ptOrigin - vtX * dWidth * 0.5 + vtY * dHeight * 0.5;
	AcGePoint3d ptRT = ptLT + vtX * dWidth;
	AcGePoint3d ptLB = ptLT - vtY * dHeight;
	AcGePoint3d ptRB = ptRT - vtY * dHeight;
	poly.AppendNode(ptLB);
	poly.AppendNode(ptRB);
	poly.AppendNode(ptRT);
	poly.AppendNode(ptLT);
	poly.SetFlag(1);

	return true;
}

//以左下点为起点，逆时针
bool TDbColumn::ConstructIShape(const TADSGePoint3d &pt, TGGePoly2D &poly) const
{
	double dB = 0.0, dH = 0.0, dU = 0.0, dT = 0.0, dD = 0.0, dF = 0.0, dAngle = 0.0;
	GetSpecialtyDataReadOnly()->GetAt(KEY_B,dB);
	GetSpecialtyDataReadOnly()->GetAt(KEY_H,dH);
	GetSpecialtyDataReadOnly()->GetAt(KEY_U,dU);
	GetSpecialtyDataReadOnly()->GetAt(KEY_T,dT);
	GetSpecialtyDataReadOnly()->GetAt(KEY_D,dD);
	GetSpecialtyDataReadOnly()->GetAt(KEY_F,dF);
	GetSpecialtyDataReadOnly()->GetAt(KEY_AXANG, dAngle);
	AcGePoint3d ptOrigin = pt;
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	AcGeVector3d vtY = vtX;
	vtY = vtY.rotateBy(PI / 2, AcGeVector3d::kZAxis);
	AcGePoint3d pt1 = ptOrigin - vtX * dU * 0.5 + vtY * dH * 0.5;
	AcGePoint3d pt2 = pt1 + vtX * dU;
	AcGePoint3d pt3 = pt2 - vtY * dT;
	AcGePoint3d pt4 = pt3 - vtX * (dU - dB) * 0.5;
	AcGePoint3d pt5 = pt4 - vtY * (dH - dF - dT);
	AcGePoint3d pt6 = pt5 + vtX * (dD - dB) * 0.5;
	AcGePoint3d pt7 = pt6 - vtY * dF;
	AcGePoint3d pt8 = pt7 - vtX * dD;
	AcGePoint3d pt9 = pt8 + vtY * dF;
	AcGePoint3d pt10 = pt9 + vtX * (dD - dB) * 0.5;
	AcGePoint3d pt11 = pt10 + vtY * (dH - dT - dF);
	AcGePoint3d pt12 = pt11 - vtX * (dU - dB) * 0.5;

	poly.AppendNode(pt8);
	poly.AppendNode(pt7);
	poly.AppendNode(pt6);
	poly.AppendNode(pt5);
	poly.AppendNode(pt4);
	poly.AppendNode(pt3);
	poly.AppendNode(pt2);
	poly.AppendNode(pt1);
	poly.AppendNode(pt12);
	poly.AppendNode(pt11);
	poly.AppendNode(pt10);
	poly.AppendNode(pt9);
	poly.SetFlag(1);
	return true;
}

bool TDbColumn::ConstructCircleShape(const TADSGePoint3d &pt, TGGePoly2D &poly) const
{
	double dRadius = 0.0;
	GetSpecialtyDataReadOnly()->GetAt(KEY_B, dRadius);
	dRadius *= 0.5;
	TGGeCircle cir(pt, dRadius);
	TGGeCurveSegment seg;
	seg = cir;
	seg.AsPoly2D(poly);
	return true;
}

double TDbColumn::GetCalcAngle() const
{
	if(m_polyOutline.Length() < 2)
	{
		return 0;
	}

	AcGeVector3d vt = m_polyOutline[1] - m_polyOutline[0];
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	vtX.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // 考虑ucs
	double dAngle = vtX.angleTo(vt, AcGeVector3d::kZAxis);
	return dAngle;
}


//柱实际配筋面积数据
bool TDbColumn::SetRAreaArray(const TReinData& raData)
{
	assertWriteEnabled();
	CString pszKey = KEY_RAREA;

	CString sSubKey;
	sSubKey.Format(_T("%sX"),pszKey);
	GetSpecialtyData()->SetAt(sSubKey, raData.m_dAreaX);
	sSubKey.Format(_T("%sY"),pszKey);
	GetSpecialtyData()->SetAt(sSubKey, raData.m_dAreaY);
	sSubKey.Format(_T("%sGX"),pszKey);
	GetSpecialtyData()->SetAt(sSubKey, raData.m_dAreaGX);
	sSubKey.Format(_T("%sFX"),pszKey);
	GetSpecialtyData()->SetAt(sSubKey, raData.m_dAreaFX);
	sSubKey.Format(_T("%sGY"),pszKey);
	GetSpecialtyData()->SetAt(sSubKey, raData.m_dAreaGY);
	sSubKey.Format(_T("%sFY"),pszKey);
	GetSpecialtyData()->SetAt(sSubKey, raData.m_dAreaFY);

	return true;
}
bool TDbColumn::GetRAreaArray(TReinData& raData)const
{
	assertReadEnabled();
	CString pszKey = KEY_RAREA;

	CString sSubKey;
	sSubKey.Format(_T("%sX"),pszKey);
	if(!GetSpecialtyDataReadOnly()->GetAt(sSubKey, raData.m_dAreaX))
	{
		return false;
	}
	sSubKey.Format(_T("%sY"),pszKey);
	if(!GetSpecialtyDataReadOnly()->GetAt(sSubKey, raData.m_dAreaY))
	{
		return false;
	}
	sSubKey.Format(_T("%sGX"),pszKey);
	if(!GetSpecialtyDataReadOnly()->GetAt(sSubKey, raData.m_dAreaGX))
	{
		return false;
	}
	sSubKey.Format(_T("%sFX"),pszKey);
	if(!GetSpecialtyDataReadOnly()->GetAt(sSubKey, raData.m_dAreaFX))
	{
		return false;
	}
	sSubKey.Format(_T("%sGY"),pszKey);
	if(!GetSpecialtyDataReadOnly()->GetAt(sSubKey, raData.m_dAreaGY))
	{
		return false;
	}
	sSubKey.Format(_T("%sFY"),pszKey);
	if(!GetSpecialtyDataReadOnly()->GetAt(sSubKey, raData.m_dAreaFY))
	{
		return false;
	}
	return true;

}
void TDbColumn::ClearRAreaArray()
{
	CString pszKey = KEY_RAREA;

	{
		CString sSubKey;
		sSubKey.Format(_T("%sX"),pszKey);
		GetSpecialtyData()->RemoveAt(sSubKey);
		sSubKey.Format(_T("%sY"),pszKey);
		GetSpecialtyData()->RemoveAt(sSubKey);
		sSubKey.Format(_T("%sGX"),pszKey);
		GetSpecialtyData()->RemoveAt(sSubKey);
		sSubKey.Format(_T("%sFX"),pszKey);
		GetSpecialtyData()->RemoveAt(sSubKey);
		sSubKey.Format(_T("%sGY"),pszKey);
		GetSpecialtyData()->RemoveAt(sSubKey);
		sSubKey.Format(_T("%sFY"),pszKey);
		GetSpecialtyData()->RemoveAt(sSubKey);
	}
}

//配筋面积图
void TDbColumn::DrawColuRein(TGGiExplodeDrawBase &dc)const
{
	int nPrec = 0;
	bool bShow = false;
	double dTop = 0, dBottom = 0, dMidUp = 0, dMidDown = 0;
	double dAngle = 0;
	TADSGePoint3d ptMin, ptMax, ptLoc;
	CString strText;
	TPushProperty vPorp(this, dc);
	switch (g_nReinAreaModeColu)
	{
	case eCalArea:				//计算配筋面积
		{
			m_polyOutline.GetExtend(ptMin, ptMax);
			ptMin -= TADSGePoint3d(10,10,0);
			ptMax += TADSGePoint3d(10,10,0);

			TDbText text;

			AcDbObjectId id = GetTextStyleId(_T("STANDARD"));
			text.setPropertiesFrom(this);
			double dTextHeight = 3.5;		//文字字高
			text.SetHeight(dTextHeight);
			text.SetStyleId(id);

			std::vector<TReinSectData> vecData;
			if( GetRSArray(vecData))
			{
				dc.SetLayer(m_idLayerCalcArea);
				int nSize = vecData.size();
				if(nSize > 1)
				{
					TReinSectData reinDataB = vecData[0],reinDataT = vecData[nSize - 1];
					dBottom = reinDataB.m_dArea;
					dTop = reinDataT.m_dArea;
	
					ptLoc = TADSGePoint3d(ptMin.x, ptMax.y, 0);
					text.SetLocation(ptLoc);
					dAngle = 0;
					text.SetRotation(dAngle);		//设置文字角度
					text.SetAlignment(XExplodeDraw::kBottomLeft);	//文字左侧底部对齐
					strText.Format(_T("B: %.1f"), dBottom);
					text.SetText(strText);
					dc.DrawEntity(text);

					ptLoc = TADSGePoint3d(ptMin.x, ptMax.y+dTextHeight*GetPScale(), 0);
					text.SetLocation(ptLoc);
					strText.Format(_T("T: %.1f"), dTop);
					text.SetText(strText);
					dc.DrawEntity(text);

					if (GetSectionShape() == kRect)			//矩形柱标注Y向
					{
						dBottom = reinDataB.m_dAreaY;
						dTop = reinDataT.m_dAreaY;

						ptLoc = TADSGePoint3d(ptMin.x, ptMin.y, 0);
						text.SetLocation(ptLoc);
						dAngle = 0;
						text.SetRotation(dAngle+PI/2);		//设置文字角度，
						text.SetAlignment(XExplodeDraw::kBottomLeft);	//文字左侧底部对齐
						strText.Format(_T("B: %.1f"), dBottom);
						text.SetText(strText);
						dc.DrawEntity(text);

						ptLoc = TADSGePoint3d(ptMin.x-dTextHeight*GetPScale(), ptMin.y, 0);
						text.SetLocation(ptLoc);
						strText.Format(_T("T: %.1f"), dTop);
						text.SetText(strText);
						dc.DrawEntity(text);
					}
				}
			}

			if(GetRSArray(vecData) && vecData.size() > 1)
			{
				ptLoc = TADSGePoint3d(ptMax.x, ptMin.y, 0);
				text.SetLocation(ptLoc);
				dAngle = 0;
				text.SetRotation(dAngle);		//设置文字角度
				text.SetAlignment(XExplodeDraw::kTopLeft);	//文字左侧底部对齐
				strText.Format(_T("G: %.1f-%.1f"), vecData[0].m_dArea, vecData[0].m_dAreaY);
				text.SetText(strText);
				dc.DrawEntity(text);			
			}
		}
		break;
	case eRealArea:				//实配面积
		{
			TReinData rData;
			if (GetRAreaArray(rData))
			{
				m_polyOutline.GetExtend(ptMin, ptMax);
				ptMin -= TADSGePoint3d(10,10,0);
				ptMax += TADSGePoint3d(10,10,0);

				TDbText text;

				AcDbObjectId id = GetTextStyleId(_T("STANDARD"));
				text.setPropertiesFrom(this);
				double dTextHeight = 3.5;		//文字字高
				text.SetHeight(dTextHeight);
				text.SetStyleId(id);
				dAngle = 0;
				text.SetRotation(dAngle);		//设置文字角度，
				text.SetAlignment(XExplodeDraw::kTopLeft);	//文字对齐

				ptLoc = TADSGePoint3d(ptMax.x, ptMin.y, 0);
				if (GetSectionShape() == kRect)
				{
					ptLoc = TADSGePoint3d(ptMax.x, ptMin.y, 0);
					text.SetLocation(ptLoc);
					strText.Format(_T("Asx: %.1f"), rData.m_dAreaX);
					text.SetText(strText);
					dc.DrawEntity(text);
					
					ptLoc = TADSGePoint3d(ptMax.x, ptMin.y-dTextHeight*GetPScale(), 0);
					text.SetLocation(ptLoc);
					strText.Format(_T("Asy: %.1f"), rData.m_dAreaY);
					text.SetText(strText);
					dc.DrawEntity(text);

					ptLoc = TADSGePoint3d(ptMax.x, ptMin.y-dTextHeight*2*GetPScale(), 0);
					text.SetLocation(ptLoc);
					strText.Format(_T("GX: %.1f-%.1f"), rData.m_dAreaGX, rData.m_dAreaFX);
					text.SetText(strText);
					dc.DrawEntity(text);

					ptLoc = TADSGePoint3d(ptMax.x, ptMin.y-dTextHeight*3*GetPScale(), 0);
					text.SetLocation(ptLoc);
					strText.Format(_T("GY: %.1f-%.1f"), rData.m_dAreaGX, rData.m_dAreaFX);
					text.SetText(strText);
					dc.DrawEntity(text);
				}
				else
				{
					ptLoc = TADSGePoint3d(ptMax.x, ptMin.y, 0);
					text.SetLocation(ptLoc);
					strText.Format(_T("As: %.1f"), rData.m_dAreaX);
					text.SetText(strText);
					dc.DrawEntity(text);

					ptLoc = TADSGePoint3d(ptMax.x, ptMin.y-dTextHeight*GetPScale(), 0);
					text.SetLocation(ptLoc);
					strText.Format(_T("G: %.1f-%.1f"), rData.m_dAreaGX, rData.m_dAreaFX);
					text.SetText(strText);
					dc.DrawEntity(text);
				}
			}

		}
		break;
	default:
		break;
	}
}
#endif