#include "stdafx.h"
#include "DbPipeValve.h"
#include "DbPipe.h"
#include "DbDoubleLinePipe.h"

extern void Matrix3D2String( const AcGeMatrix3d &mat, CString &str );
ACRX_DXF_DEFINE_MEMBERS(ATSPipeValve, ATSPipeAttachment, AcDb::kDHL_CURRENT,
						AcDb::kMReleaseCurrent,1, ATS_PIPEVALVE,
						"ATS_PIPEVALVE图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbPipeValve);

const Adesk::UInt8 TDbPipeValve::g_nVersion = 2;

TDbPipeValve::TDbPipeValve() :
m_dWidth(0.0),m_dScale(1.0),m_dYScale(1.0),m_dFlangeDn(0),m_dFlangeWidth(0),m_nQuadrant(0),m_bHorizontal(FALSE),m_bFlange(FALSE),m_dSpare(0)
{
}

void TDbPipeValve::CopyPropertiesFrom(AcDbEntity *pSrc,unsigned gMatchFlag)
{
	assertWriteEnabled();
	TDbPipeAttachment::CopyPropertiesFrom(pSrc, gMatchFlag);
	TDbPipeValve *pValve = TDbPipeValve::cast(pSrc);
	if(pValve) {
		//m_idBlock2d = pValve->m_idBlock2d;
		//m_idBlock3d = pValve->m_idBlock3d;
		//m_sSysBlock = pValve->m_sSysBlock;
		m_bHorizontal = pValve->m_bHorizontal;
        m_bFlange = pValve->m_bFlange;
        m_dFlangeDn = pValve->m_dFlangeDn;   
        m_dFlangeWidth = pValve->m_dFlangeWidth;   
        
		//m_dWidth = pValve->m_dWidth;
		//m_dScale = pValve->m_dScale;
	}
}

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

// 从DWG读入数据:
Acad::ErrorStatus 
TDbPipeValve::dwgInFields(AcDbDwgFiler* pFiler)
{
    assertWriteEnabled();

    Acad::ErrorStatus es = TDbPipeAttachment::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_idBlock2d);
	pFiler->readItem(&m_idBlock3d);
	ReadString(pFiler, m_sSysBlock);
	pFiler->readItem(&m_dScale);
	pFiler->readItem(&m_dWidth);
	//pFiler->readItem(&m_bHorizontal);
	FilerRead(pFiler, m_bHorizontal);
	pFiler->readItem(&m_nQuadrant);
    if(nVer > 1){
        pFiler->readItem(&m_dYScale);
        pFiler->readItem(&m_dZScale);
        pFiler->readItem(&m_dFlangeWidth);
        pFiler->readItem(&m_dFlangeDn);
        //pFiler->readItem(&m_bFlange);
		FilerRead(pFiler, m_bFlange);
      //  pFiler->readItem(&m_dFlangeWidth);
   }
    else{
        BOOL IsDoublePipeValve = FALSE;
        if(m_dYScale == 1 && m_dZScale == 0){
            m_dYScale = m_dScale;
            m_dZScale = m_dScale;
        }
        OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, TDbDoubleLinePipe, pPipe);
        if(pPipe){
            if(m_dScale > 10 && m_dYScale < 2){
                m_dYScale = m_dScale;
                m_dZScale = m_dScale;
            }
        }
        OPENOBJ_END();
    }
    return pFiler->filerStatus();
}

Acad::ErrorStatus 
TDbPipeValve::dwgOutFields(AcDbDwgFiler* pFiler) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = TDbPipeAttachment::dwgOutFields(pFiler);
    if(es != Acad::eOk) return es;
    if(g_nSaveTArchVer==6)
        pFiler->writeItem((Adesk::UInt8)1);
    else
        pFiler->writeItem(g_nVersion);

    pFiler->writeItem(m_idBlock2d);
	pFiler->writeItem(m_idBlock3d);
	pFiler->writeItem((const TCHAR *)m_sSysBlock);
	pFiler->writeItem(m_dScale);
	pFiler->writeItem(m_dWidth);
	//pFiler->writeItem(m_bHorizontal);
	FilerWrite(pFiler, m_bHorizontal);
	pFiler->writeItem(m_nQuadrant);
    if(g_nSaveTArchVer>6){
        pFiler->writeItem(m_dYScale);
        pFiler->writeItem(m_dZScale);
        pFiler->writeItem(m_dFlangeWidth);
        pFiler->writeItem(m_dFlangeDn);
        //pFiler->writeItem(m_bFlange);
		FilerWrite(pFiler, m_bFlange);
 //       pFiler->writeItem(m_dFlangeWidth);
    }

    return pFiler->filerStatus();
}

Acad::ErrorStatus 
TDbPipeValve::dxfInFields(AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();
	Acad::ErrorStatus es=Acad::eOk;
    es = TDbPipeAttachment::dxfInFields(pFiler);
    if(es!=Acad::eOk) return es;

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

	resbuf rb;
	while((es==Acad::eOk) && ((es=pFiler->readResBuf(&rb))==Acad::eOk)) {
		switch (rb.restype) {
		case AcDb::kDxfXReal:
			m_dWidth=rb.resval.rreal;
			break;
		case AcDb::kDxfXReal+1:
			m_dScale=rb.resval.rreal;
			break;
		case AcDb::kDxfBlockName:
			break;
		default:
			pFiler->pushBackItem();
			es = Acad::eEndOfFile;
			break;
		}
	}
	if(es!=Acad::eEndOfFile)
		return Acad::eInvalidResBuf;

    return pFiler->filerStatus();
}

Acad::ErrorStatus 
TDbPipeValve::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    Acad::ErrorStatus es=Acad::eOk;
    es = TDbPipeAttachment::dxfOutFields(pFiler);
    assert(es == Acad::eOk);
    es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPipeValve"));
    assert(es == Acad::eOk);

	pFiler->writeDouble(AcDb::kDxfXReal,m_dWidth);
	pFiler->writeDouble(AcDb::kDxfXReal+1,m_dScale);
	CString sBlkName,sDesName;
	GetBlkNameById(m_idBlock2d,sBlkName,sDesName);
	pFiler->writeString(AcDb::kDxfBlockName,(const TCHAR*)sBlkName);

	return es;
}

Acad::ErrorStatus 
TDbPipeValve::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
	assertReadEnabled();
	Acad::ErrorStatus es=Acad::eOk;
	es = TDbPipeAttachment::subGetStretchPoints(stretchPoints);
	if(es!=Acad::eOk) return es;

	return Acad::eOk;
}

// 取得所有的夹点
Acad::ErrorStatus 
TDbPipeValve::subGetGripPoints(AcGePoint3dArray&  gripPoints,
								 AcDbIntArray&  osnapModes,
								 AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	Acad::ErrorStatus es=Acad::eOk;
	es = TDbPipeAttachment::subGetGripPoints(gripPoints,osnapModes,geomIds);
	if(es!=Acad::eOk) return es;

	XPoint ptQuadrant = GetQuadrantGrip();
	gripPoints.append((AcGePoint3d)ptQuadrant);
	return Acad::eOk;
}

extern BOOL Is2DView();
Acad::ErrorStatus 
TDbPipeValve::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
//  移动、赋值、黏贴时阀门所在管线进行了特殊处理，故阀门作相应调整处理 cet 2012.11.12 modify
//	TDbPipeAttachment::subTransformBy(xform);
	XString &sCmd=GetCurDocData()->m_sCurCommand;
	if((_tcsicmp(sCmd,_T("MOVE"))==0 || _tcsicmp(sCmd,_T("copy"))==0 || _tcsicmp(sCmd,_T("pasteclip"))==0)
		&& (Is2DView()))
	{ 
		AcGeVector3d vtNoneZ = xform.translation();
		AcGeMatrix3d mat(xform);
		if(fabs(vtNoneZ.x) > 0.0001 || fabs(vtNoneZ.y) > 0.0001)//2012-9-2 SR 修正：z轴位移除外
		{
			vtNoneZ.x = 0.0;
			vtNoneZ.y = 0.0;
			vtNoneZ.z *= -1;
			AcGeMatrix3d mat1;
			mat1.setToTranslation(vtNoneZ);
			mat *= mat1;
		}
		TDbPipeAttachment::subTransformBy(mat);
	} 
	else
	{
		TDbPipeAttachment::subTransformBy(xform);
	}

	ScaleTransform(xform,m_dScale);
    ScaleTransform(xform,m_dYScale);
    ScaleTransform(xform,m_dZScale);
	if(IsMirrorMatrix(xform)) { //阀门镜像 sr add 2005/6/7
        int q = GetQuadrant();
		if(q == 0)
			q = 3;
		else if(q == 1)
			q = 2;
		else if(q == 2)
			q = 1;
		else if(q == 3)
			q = 0;
        //q = (q + 2) % 4;
        SetQuadrant(q);
		return Acad::eOk;
	}		
	
	return Acad::eOk;
}

// 取得夹点说明
Acad::ErrorStatus TDbPipeValve::GetGripText(int idx, CString &cs) const
{
	Acad::ErrorStatus es = Acad::eOk;
	es = TDbPipeAttachment::GetGripText(idx,cs);
	if(es!=Acad::eOk) return es;

	switch(idx)	{
		case 1:	cs=_T("改变开启方向");	break;
		default: /*es=Acad::eInvalidInput*/;
	}
	return es;
}

Acad::ErrorStatus 
TDbPipeValve::MoveGSPointsAt(const AcDbIntArray& indices,
							 const AcGeVector3d& offset)
{
    XPoint vtOffset=*(XPoint *)&offset;
	for (int i = 0; i < indices.length(); i++) {
		int idx = indices[i];
		switch(idx) {
		case 1:{//quadrant point
			vtOffset.z=0;
			XPoint ptQuadrant(GetQuadrantGrip());
			ptQuadrant += vtOffset;
			double dAngle = 0;
			if(!IsHorizontal())
				dAngle = ads_angle(XPoint(),m_vtLocation);
			dAngle = CT_std_angle(ads_angle(m_ptLocation, ptQuadrant)-dAngle);
			if(dAngle>=0.0 && dAngle<PI/2.0) m_nQuadrant=0;
			else if(dAngle>=PI/2.0 && dAngle<PI) m_nQuadrant=1;
			else if(dAngle>=PI && dAngle<1.5*PI) m_nQuadrant=2;
			else m_nQuadrant=3;
			   }
			   break;
		default:	break;
		}				
	}
	return Acad::eOk;
}

Acad::ErrorStatus 
TDbPipeValve::subMoveGripPointsAt(const AcDbIntArray& indices,
							   const AcGeVector3d& offset)
{
	assertWriteEnabled();

	Acad::ErrorStatus es=Acad::eOk;
	es = TDbPipeAttachment::subMoveGripPointsAt(indices,offset);
	if(es!=Acad::eOk) return es;

	es = MoveGSPointsAt(indices,offset);

	return es;
}

Acad::ErrorStatus 
TDbPipeValve::subMoveStretchPointsAt(const AcDbIntArray& indices,
							   const AcGeVector3d& offset)
{
	assertWriteEnabled();

	Acad::ErrorStatus es=Acad::eOk;
	es = TDbPipeAttachment::subMoveStretchPointsAt(indices,offset);
	//if(es!=Acad::eOk) return es;

	//es = MoveGSPointsAt(indices,offset);

	return es;
}

// 象限点
XPoint TDbPipeValve::GetQuadrantGrip() const
{
	XPoint ptQuadrant;
    double dGripDist = 1;
	double dAngle = 0;
	if(!IsHorizontal())
		dAngle = ads_angle(XPoint(),m_vtLocation);
	dAngle += m_nQuadrant*PI/2+PI/4;
	double dWidth=GetWidth()>1.0E-3 ? GetWidth()/2 : 100;
//    if(GetScale() > 50)
    //        dGripDist = dWidth;
    //    else
    
	    dGripDist = dWidth*GetScale();
	ads_polar(m_ptLocation,dAngle,dGripDist,ptQuadrant);
	return ptQuadrant;
}

double TDbPipeValve::GetWidth() const 
{ 
    BOOL IsDoublePipeValve = FALSE;
    OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, TDbDoubleLinePipe, pPipe);
    if(pPipe){
        IsDoublePipeValve = TRUE;
    }
    OPENOBJ_END();
 	if(!IsDoublePipeValve)
 		return m_dWidth*GetPScale()/100; 
 	else 
	{
		// cet 2018.6.22 add 支持米单位
		if (DocGetCurMeterUnitDraw())
		{
			return m_dWidth * 0.001;
		}
 		return m_dWidth;
	}
}

//	图块插入比例
AcGeScale3d TDbPipeValve::GetInsertScale() const
{
	assertReadEnabled();
    BOOL IsDoublePipeValve = FALSE;
 
    
    OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, TDbDoubleLinePipe, pPipe);
    if(pPipe){
        IsDoublePipeValve = TRUE;
    }
    OPENOBJ_END();
    
	double dScale(1), dScaleY(1);
    if(!IsDoublePipeValve)
        dScale=GetScale()*GetPScale()/100;
    else
	{
        dScale = m_dScale;
		// cet 2018.6.22 add 支持米单位
		if (DocGetCurMeterUnitDraw())
		{
			dScale *= 0.001;
		}
	}

    if(!IsDoublePipeValve)
        dScaleY=m_dYScale*GetPScale()/100;
    else
	{
        dScaleY = m_dYScale;
	    // cet 2018.6.22 add 支持米单位
		if (DocGetCurMeterUnitDraw())
		{
			dScaleY *= 0.001;
		}
	}
	if(fabs(dScaleY) < 0.001)
        dScaleY = dScale;
	AcGeScale3d scale(dScale,dScaleY,fabs(dScale));

	if(m_nQuadrant==1){
		scale.sx *= -1;
	} else if(m_nQuadrant==2) {
		scale.sx *= -1;
		scale.sy *= -1;
	} else if(m_nQuadrant==3) {
		scale.sy *= -1;
	}

	return scale;
}

Acad::ErrorStatus TDbPipeValve::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
	return _ExplodeOrDraw2d(dc);
}


extern BOOL IsSystemValve(AcDbObjectId id);

Acad::ErrorStatus TDbPipeValve::
_ExplodeOrDraw2d(XExplodeDraw &dc,BOOL bZEqual0) const
{
	if(!m_idBlock2d.isValid())
		return Acad::eInvalidInput;

	if(fabs(m_vtLocation.x)<1.0E-6 && fabs(m_vtLocation.y)<1.0E-6)
		return Acad::eOk; //垂直阀件

	OPENOBJ_BEGIN(m_idBlock2d, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	if(pBlock) {
		XPoint ptInsert=m_ptLocation;
		if(bZEqual0) ptInsert.z=0;
		double dAngle=0;
		if(!m_bHorizontal)
			dAngle=ads_angle(XPoint(),m_vtLocation);

		//delete by dyw 2014-5-8 在端点处的阀门水平放置时与管线平行
		/*************************************************************************
		else // cet 2011.11.10 add 水平放置时角度
		{
			dAngle = Ucs2Wcs(0.0);
		}
		*************************************************************************/
		//delete end

		//add by dyw 2014-5-9 如果在水管的端点进行水平放置的时候 则阀门的方向跟水管的方向一致
		//============================================================================================
		else
		{
			//获取关联水管的起始和终止点
			XPoint ptSPipe, ptEPipe;						
			OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, TDbPipe, pPipe);
			if(NULL != pPipe)
			{
				ptSPipe = pPipe->StartPoint();
				ptEPipe = pPipe->EndPoint();

				//拾取水管端点时，计算水管的方向
				if(acutDistance(m_ptLocation, ptSPipe) <= 1e-5
					|| acutDistance(m_ptLocation, ptEPipe) <= 1e-5)
				{
					AcGeVector3d vecTemp(m_vtLocation);
					vecTemp.rotateBy(PI / 2, AcGeVector3d::kZAxis);
					dAngle = ads_angle(XPoint(), XPoint(vecTemp.x, vecTemp.y, vecTemp.z));

					//水管方向与X轴夹角大于九十度的时候 根据拾取点的位置(以Y轴为基准),若点在上方则反向绘制阀门
					if(dAngle > PI / 2)
					{
						dAngle = (((m_ptLocation == ptSPipe) && (m_ptLocation.y > ptEPipe.y))||
							((m_ptLocation == ptEPipe) && (m_ptLocation.y > ptSPipe.y))) ? dAngle - PI : dAngle;
					}
					//水管方向与X轴平行的时候 根据拾取点的位置(以X轴为基准),若点在右方则反向绘制阀门
					else if((dAngle - PI / 2) <= 1e-5)
					{
						dAngle = (((m_ptLocation == ptSPipe) && (m_ptLocation.x > ptEPipe.x))||
							((m_ptLocation == ptEPipe) && (m_ptLocation.x > ptSPipe.x))) ? dAngle - PI : dAngle;
					}
					//水管方向与X轴夹角小于九十度的时候 根据拾取点的位置(以Y轴为基准),若点在上方则反向绘制阀门
					else
					{				
						dAngle = (((m_ptLocation == ptSPipe) && (m_ptLocation.y > ptEPipe.y))||
							((m_ptLocation == ptEPipe) && (m_ptLocation.y > ptSPipe.y))) ? dAngle - PI : dAngle;
					}
				}
				//拾取水管上的点时 
				else
					dAngle = Ucs2Wcs(0.0);
			}
			else
				dAngle = Ucs2Wcs(0.0);
			OPENOBJ_END();
		}
		//============================================================================================
		//add end

		double dScaleX=1,dScaleY=1;
	//	BOOL bNewMethod=(g_nAcadVer>15.0001 && g_bMakeBlock);
		// sg add 091105，强制打印时，不使用新方法
	//	if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0 && dc.IsPlotGeneration())
	//		bNewMethod = FALSE;
	
		//2011-9-30 沈睿dc.DrawBlock(*pBlock,ptInsert,GetInsertScale(),dAngle,TRUE); 采用旧方法，从8.0版本开始，TRUE参数对于打印不起作用。关闭图层，仍然打印		
		//dc.DrawBlock(*pBlock,ptInsert,GetInsertScale(),dAngle,bNewMethod);
		
		dc.DrawBlock(*pBlock,ptInsert,GetInsertScale(),dAngle,TRUE);
	}
	OPENOBJ_END();


	BOOL bIsDouble = FALSE;
    BOOL bIsSys = IsSystemValve(m_idBlock2d);

    OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, TDbDoubleLinePipe, pPipe);
    if(pPipe){
		bIsDouble = TRUE;
        if(bIsSys)
            bIsSys = FALSE;
    }
    OPENOBJ_END();
    
    if(m_bFlange){
        
        double nWidth = GetWidth()*m_dScale+m_dFlangeWidth*m_dScale*GetPScale()/100;
	 
        double dFlangeDn=m_dFlangeDn*GetPScale()/100;
		if(bIsDouble)
			dFlangeDn = m_dFlangeDn; //如果是双线水管的阀门，按真实尺寸，不按比例 2008－11－3

        double dAng = ads_angle(XPoint(),m_vtLocation);
        if(bIsSys){
            if(m_nQuadrant == 0 || m_nQuadrant == 2)
                dAng = dAng - PI/4;
            else
                dAng = dAng + PI/4;
        }

        XPoint pt1, pt2, pt3, pt4;
//      cet 2011.11.10 modify
//      ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), nWidth/2, pt1);
//      ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), -nWidth/2, pt2);
		if (m_bHorizontal)
		{
			dAng = Ucs2Wcs(0.0);
			ads_polar(m_ptLocation, dAng, nWidth/2, pt1);
		    ads_polar(m_ptLocation, dAng, -nWidth/2, pt2);
		} 
		else
		{
			 ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), nWidth/2, pt1);
			 ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), -nWidth/2, pt2);
		}
        ads_polar(pt1, dAng+PI/2, dFlangeDn/2, pt3);
        ads_polar(pt1, dAng-PI/2, dFlangeDn/2, pt4);
        dc << XLine(pt3, pt4);
        ads_polar(pt2, dAng+PI/2, dFlangeDn/2, pt3);
        ads_polar(pt2, dAng-PI/2, dFlangeDn/2, pt4);
        dc << XLine(pt3, pt4);

        nWidth = GetWidth()*m_dScale;
//      cet 2011.11.10 modify
//      ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), nWidth/2, pt1);
//      ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), -nWidth/2, pt2);
		if (m_bHorizontal)
		{
			ads_polar(m_ptLocation, dAng, nWidth/2, pt1);
			ads_polar(m_ptLocation, dAng, -nWidth/2, pt2);
		} 
		else
		{
			ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), nWidth/2, pt1);
			ads_polar(m_ptLocation, ads_angle(XPoint(),m_vtLocation), -nWidth/2, pt2);
		}
        ads_polar(pt1, dAng+PI/2, dFlangeDn/2, pt3);
        ads_polar(pt1, dAng-PI/2, dFlangeDn/2, pt4);
        dc << XLine(pt3, pt4);
        ads_polar(pt2, dAng+PI/2, dFlangeDn/2, pt3);
        ads_polar(pt2, dAng-PI/2, dFlangeDn/2, pt4);
        dc << XLine(pt3, pt4);
    }
	return Acad::eOk;
}


 
Acad::ErrorStatus TDbPipeValve::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	if(!m_idBlock3d.isValid())
		return _ExplodeOrDraw2d(dc,FALSE);

	OPENOBJ_BEGIN(m_idBlock3d, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	if(pBlock) {
		XVector3D vtNormal(0,0,1);
		if(fabs(m_vtLocation.z)>1.0E-6) { //非水平面，计算法向
			vtNormal = XVector3D(1,0,0)*m_vtLocation;
			vtNormal.Normalize();
		}
		XPoint ptLoc=Wcs2Ecs(m_ptLocation, vtNormal);
		double nRotEcs = ads_angle(XPoint(),m_vtLocation); //计算ECS下的转角
        if(fabs(m_vtLocation.z)>1.0E-6) { //非水平面，计算插入角度，ads_angle只能计算平面角度
            AcGeVector3d v1 = m_vtLocation.AsAcGeVector3d();
            AcGeVector3d v2 = AcGeVector3d::kXAxis;
            nRotEcs = v2.angleTo(v1);
        }
        
		AcDbBlockReference insert(ptLoc, m_idBlock3d);
		insert.setRotation(nRotEcs);
        insert.setNormal(vtNormal);
      //  sr modify 2005-6-14 阀门的比例随管径走，不管平面中的插入比例
        OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            double dn = pPipe->GetDnDiameter()*0.5;
			// cet 2017.3.3 add 支持米单位
			if (DocGetCurMeterUnitDraw())
			{
				dn *= 0.001;
			}
            if(pPipe->GetModelType() == TPipeSys::kSystem)//系统图不画3d
                return _ExplodeOrDraw2d(dc,FALSE);
            insert.setScaleFactors(dn);
        }
        OPENOBJ_END();
	
        if(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) {
			AcGeMatrix3d mat=insert.blockTransform();
			AcGiGeometry *geom=((XAcGiViewDraw &)dc).GetCommonDraw()->rawGeometry();
			geom->pushModelTransform(mat);
			//if(geom != NULL)
			//	geom->draw(&insert);
			geom->draw(pBlock);
			geom->popModelTransform();
			//insert.worldDraw(viewDraw.m_pWd);
		} else if(_tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0) {
			((XExplodeStream &)dc).Append((AcDbEntity *)insert.clone());
		}
	} else {
		return Acad::eInvalidInput;
	}
	OPENOBJ_END();
	return Acad::eOk;
}


void TDbPipeValve::GetTips(DList<TObjInfoUnit> &info) const
{
	TDbPipeAttachment::GetTips(info);

	info.Append(new TObjInfoUnit(_T("对象类型"), _T("管道附件")));
	CString sBlkName,sDesName;
	if(GetBlkNameById(m_idBlock2d,sBlkName,sDesName) && !sDesName.IsEmpty()) {
		info.Append(new TObjInfoUnit(_T("对象名称"), (const TCHAR*)sDesName));
	}
}

void InitDbPipeValve(BOOL bTrue)
{
    if(bTrue) {
        TDbPipeValve::rxInit();
		TDbPipeValve::InitMatchProtocol(TRUE);
    } else {
		TDbPipeValve::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbPipeValve::desc());
    }
}

bool TDbPipeValve::GetSection(const AcDbFace &face, const AcGeVector3d& vtPlaneSecDir, 
								std::vector<TObjSectionRecord> &sectionRecords, 
								AcDbVoidPtrArray& arFillPtrs) const
{
	AcDbObjectId idPipe = GetPipeId(); // 所在管线
	if (!idPipe.isValid())
	{
		return false;
	}

	AcGePoint3d ptS, ptE;
	BOOL bVertical = FALSE;
    TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		ptS = pPipe->StartPoint();
		ptE = pPipe->EndPoint();
		bVertical = pPipe->IsVertical();
		pPipe->close();
	}

	TGGeSectionPlane section_pln(face, vtPlaneSecDir);
	AcGeLineSeg3d line(ptS, ptE);

	AcGeLineSeg3d seg;
	AcGePoint3d pt;
	short iRet = SectionUtility::Projection_line2plane(section_pln, line, seg, pt);
	if (iRet == 0) // 不垂直
	{	
		AcGePlane plane = section_pln.AsAcGePlane();
		pt = m_ptLocation.AsAcGePoint3d();
		AcGePoint3d ptTemp  = pt.orthoProject(plane);
		if (section_pln.IsOn(ptTemp,true))
		{
			// 距投影面的距离
			double dDist = ptTemp.distanceTo(pt);

			// 图块外包框
 			AcGePoint3d ptMin, ptMax;
			XPoint pt1, pt2;
			GetExtents(pt1, pt2);
			ptMin = pt1;
			ptMax = pt2;

			ptMax = ptMax.orthoProject(plane);
			ptMin = ptMin.orthoProject(plane);

			if (bVertical) // 附件在立管上
			{
				CString strBlockName, strDesName;
				GetBlkNameById(m_idBlock2d, strBlockName, strDesName);
				int nIndex = -1;
				nIndex = strBlockName.Find(_T("$"), 1);
				if (nIndex != -1)
				{
					strBlockName = strBlockName.Right(strBlockName.GetLength() - nIndex - 1);
				}

				strBlockName += _T("-1");
				AcDbBlockTable *pBlkTbl = NULL;
				acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlkTbl, AcDb::kForWrite);
				if (pBlkTbl != NULL)
				{
					AcDbObjectId idBlock;
					if (pBlkTbl->has(strBlockName)) // 块存在
					{
						pBlkTbl->getAt(strBlockName, idBlock);
					}
					else
					{
						AcDbBlockTableRecord *pNewRec = new AcDbBlockTableRecord;
						pNewRec->setName(strBlockName);
						pBlkTbl->add(idBlock, pNewRec);
						AcDbBlockReference *pRef = new AcDbBlockReference(AcGePoint3d::kOrigin, m_idBlock2d);
						AcGeMatrix3d mat;
						mat.setToRotation(PI * 0.5, AcGeVector3d::kZAxis, AcGePoint3d::kOrigin);
						pRef->transformBy(mat);
						AcDbVoidPtrArray ptrArr;
						pRef->explode(ptrArr);
						for (int i = 0; i < ptrArr.length(); i++)
						{
							AcDbEntity *pEnt = (AcDbEntity*)ptrArr[i];
							AcDbEntity *pNewEnt = (AcDbEntity*)pEnt->clone();
							if(pNewEnt != NULL)
							{
								pNewRec->appendAcDbEntity(pNewEnt);
								pNewEnt->close();
							}
						}
						delete pRef; 
						pNewRec->close();
					}

					pBlkTbl->close();

					if (idBlock.isValid())
					{
						BlockRefInfo info(idBlock, AcGeScale3d(m_dScale), ptTemp, dDist * (-1), ptMax, ptMin);
						TSectionFill *pFill = new TSectionFill(info, layerId());
						arFillPtrs.append(pFill);
					}
				}
			}      
			else
			{
				BlockRefInfo info(m_idBlock2d, AcGeScale3d(m_dScale), ptTemp, dDist * (-1), ptMax, ptMin);
				TSectionFill *pFill = new TSectionFill(info, layerId());
				arFillPtrs.append(pFill);
			}
		}
	}
	return true;
}

CString TDbPipeValve::GetXml(const AcGeMatrix3d& mat) const
{	
	// cet 2013.5.14 add 三维图块id不存在时，不进行导出
	if (!m_idBlock3d.isValid() && !m_idBlock2d.isValid())
	{
		return CString();
	}

	AcDbObjectId idBlock3d = m_idBlock3d;
	if (!m_idBlock3d.isValid())
	{
		idBlock3d = m_idBlock2d;
	}

	TPipeSys::ModelType modelType = TPipeSys::kModel;
	AcDbObjectId idPipe = GetPipeId(); // 所在管线
    TDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		modelType = pPipe->GetModelType();
		pPipe->close();
	}

	if (modelType == TPipeSys::kSystem) // 系统图
	{
		return CString();
	}


	TXmlTree xmlTree;
	CString csText;
	AcGePoint3d pt;
	CString csX, csY, csZ;
	int nPreci = 3; // 精度

	POSITION posRoot = xmlTree.Insert(_T("ATS_PIPEVALVE"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("水管阀门"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	POSITION posItemName = xmlTree.Insert(_T("Equip_name"),posRoot, NULL);
	{ 
		xmlTree.SetAttribute(posItemName, _T("name"), _T("设备名称"));
		xmlTree.SetAttribute(posItemName, _T("comment"), _T("对应图库中的阀门名称"));
		CString csBlkName, csDesName;
		GetBlkNameById(m_idBlock2d,csBlkName,csDesName);
		xmlTree.SetItemText(posItemName, csDesName);		
	}

	POSITION posItemCenterPt = xmlTree.Insert(_T("Center_point"), posRoot, posItemName);
	{ 
		xmlTree.SetAttribute(posItemCenterPt, _T("name"), _T("中心点"));
		xmlTree.SetAttribute(posItemCenterPt, _T("comment"), _T("插入点位置"));
		XPoint ptLoc = m_ptLocation;
		ptLoc.TransformBy(mat);
		csX = DoubleToString(ptLoc.x, nPreci);
		csY = DoubleToString(ptLoc.y, nPreci);
		csZ = DoubleToString(ptLoc.z, nPreci);	
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemCenterPt, csText);
	}
	
	POSITION posItemBlk = xmlTree.Insert(_T("Block"), posRoot, posItemCenterPt);
	{
		xmlTree.SetAttribute(posItemBlk, _T("name"), _T("对应图块"));
	}

	POSITION posItemBlk2d = xmlTree.Insert(_T("Block_2D"), posItemBlk, NULL);
	{
		xmlTree.SetAttribute(posItemBlk2d, _T("name"), _T("2D块图块名"));
		xmlTree.SetAttribute(posItemBlk2d, _T("comment"), _T("平面图块"));
		CString csBlkName, csDesName;
		GetBlkNameById(m_idBlock2d, csBlkName, csDesName);
		xmlTree.SetItemText(posItemBlk2d, csBlkName);
	}

	POSITION posItemBlk3d = xmlTree.Insert(_T("Block_3D"), posItemBlk, posItemBlk2d);
	{
		xmlTree.SetAttribute(posItemBlk3d, _T("name"), _T("3D块图块名"));
		xmlTree.SetAttribute(posItemBlk3d, _T("comment"), _T("三维图块"));
		CString csBlkName, csDesName;
		GetBlkNameById(idBlock3d, csBlkName, csDesName); 
		xmlTree.SetItemText(posItemBlk3d, csBlkName);
	}
	

	POSITION posItemScale = xmlTree.Insert(_T("Ratio"), posRoot, posItemBlk3d);
	{ 
		xmlTree.SetAttribute(posItemScale, _T("name"), _T("图块比例"));
		xmlTree.SetAttribute(posItemScale, _T("comment"), _T("图块x,y,z方向比例"));
		AcGeScale3d scale = GetInsertScale();
		csX = DoubleToString(scale[X], nPreci);
		csY = DoubleToString(scale[Y], nPreci);
		csZ = DoubleToString(scale[Z], nPreci);	
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemScale, csText);
	}

	POSITION posItemVector = xmlTree.Insert(_T("Vector"), posRoot, posItemCenterPt);
	{
		xmlTree.SetAttribute(posItemVector, _T("name"), _T("向量"));
		xmlTree.SetAttribute(posItemVector, _T("comment"), _T("向量"));	
		XVector3D vector3d = GetDirection();
		csX = DoubleToString(vector3d.x, nPreci);
		csY = DoubleToString(vector3d.y, nPreci);
		csZ = DoubleToString(vector3d.z, nPreci);	
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemVector, csText);
	}

	POSITION posItemId = xmlTree.Insert(_T("Object_ID"), posRoot, posItemBlk);
	{
		xmlTree.SetAttribute(posItemId, _T("name"), _T("ID"));
		xmlTree.SetAttribute(posItemId, _T("comment"), _T("阀门ID"));
		csText.Format(_T("%ld"), objectId().asOldId());
		xmlTree.SetItemText(posItemId, csText);
	}

	// 三维图块转换矩阵
	XVector3D vtNormal(0,0,1);
	if(fabs(m_vtLocation.z)>1.0E-6) //非水平面，计算法向
	{ 
		vtNormal = XVector3D(1,0,0)*m_vtLocation;
		vtNormal.Normalize();
	}
	XPoint ptLoc=Wcs2Ecs(m_ptLocation, vtNormal);
	double nRotEcs = ads_angle(XPoint(),m_vtLocation); //计算ECS下的转角
	if(fabs(m_vtLocation.z)>1.0E-6) //非水平面，计算插入角度，ads_angle只能计算平面角度
	{ 
		AcGeVector3d v1 = m_vtLocation.AsAcGeVector3d();
		AcGeVector3d v2 = AcGeVector3d::kXAxis;
		nRotEcs = v2.angleTo(v1);
	}
	
	AcDbBlockReference insert(ptLoc, idBlock3d);
	insert.setRotation(nRotEcs);
	insert.setNormal(vtNormal);
	if (idBlock3d != m_idBlock2d)
	{
		//  sr modify 2005-6-14 阀门的比例随管径走，不管平面中的插入比例
		OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe)
		{
			double dn = pPipe->GetDnDiameter()*0.5;	
			// 将阀门阀件放大一些，以便包裹住管道，增强显示效果
			insert.setScaleFactors(dn * 1.4);
		}
		OPENOBJ_END();
	}
	else
	{
		insert.setScaleFactors(GetInsertScale());
	}

	AcGeMatrix3d mat1 = insert.blockTransform();
	mat1 = mat * mat1;
	CString sMat;
	Matrix3D2String(mat1, sMat);

	POSITION posItemMat= xmlTree.Insert(_T("Matrix3d"), posRoot, posItemId);
	{
		xmlTree.SetAttribute(posItemMat, _T("name"), _T("矩阵"));
		xmlTree.SetAttribute(posItemMat, _T("comment"), _T("图块转换矩阵"));
		xmlTree.SetItemText(posItemMat, sMat);
	}

	CString csXml = xmlTree.GetXml();
	int nIndex = -1;
	nIndex = csXml.Find(_T("</ATS_PIPEVALVE>"));
	if (nIndex != -1)
	{
		CString sTemp = TDbPipeAttachment::GetXml(mat); 
		csXml.Insert(nIndex, sTemp);
	}
	return csXml;
}