#include "stdafx.h"
#include "DbPipeValve.h"
#include "DbPipe.h"
#include "AcDbObjectPtr.h"
#include "PickEntSet.h"
//#include "DbDoubleLinePipe.h"

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

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

CDbPipeValve::CDbPipeValve() :
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 CDbPipeValve::CopyPropertiesFrom(AcDbEntity *pSrc,unsigned gMatchFlag)
{
	assertWriteEnabled();
	CDbPipeAttachment::CopyPropertiesFrom(pSrc, gMatchFlag);
	CDbPipeValve *pValve = CDbPipeValve::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 CDbPipeValve::subGetClassID(CLSID* pClsid) const
{
	return Acad::eOk;
}

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

    Acad::ErrorStatus es = CDbPipeAttachment::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);
	GlobalFunc::ReadString(pFiler, m_sSysBlock);
	pFiler->readItem(&m_dScale);
	pFiler->readItem(&m_dWidth);
	//pFiler->readItem(&m_bHorizontal);
	GlobalFunc::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);
		GlobalFunc::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 
CDbPipeValve::dwgOutFields(AcDbDwgFiler* pFiler) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = CDbPipeAttachment::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);
	GlobalFunc::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);
		GlobalFunc::FilerWrite(pFiler, m_bFlange);
 //       pFiler->writeItem(m_dFlangeWidth);
    //}

    return pFiler->filerStatus();
}

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

    if (!pFiler->atSubclassData(_T("CDbPipeValve"))) {
        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 
CDbPipeValve::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    Acad::ErrorStatus es=Acad::eOk;
    es = CDbPipeAttachment::dxfOutFields(pFiler);
    assert(es == Acad::eOk);
    es = pFiler->writeItem(AcDb::kDxfSubclass,_T("CDbPipeValve"));
    assert(es == Acad::eOk);

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

	return es;
}

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

	return Acad::eOk;
}

// 取得所有的夹点
Acad::ErrorStatus 
CDbPipeValve::subGetGripPoints(AcGePoint3dArray&  gripPoints,
								 AcDbIntArray&  osnapModes,
								 AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	Acad::ErrorStatus es=Acad::eOk;
	es = CDbPipeAttachment::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 
CDbPipeValve::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
//  移动、赋值、黏贴时阀门所在管线进行了特殊处理，故阀门作相应调整处理 cet 2012.11.12 modify
//	CDbPipeAttachment::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;
	//	}
	//	CDbPipeAttachment::subTransformBy(mat);
	//} 
	//else
	//{
		CDbPipeAttachment::subTransformBy(xform);
	//}

	GlobalFunc::ScaleTransform(xform,m_dScale);
    GlobalFunc::ScaleTransform(xform,m_dYScale);
    GlobalFunc::ScaleTransform(xform,m_dZScale);
	if(GlobalFunc::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 CDbPipeValve::GetGripText(int idx, CString &cs) const
{
	Acad::ErrorStatus es = Acad::eOk;
	es = CDbPipeAttachment::GetGripText(idx,cs);
	if(es!=Acad::eOk) return es;

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

Acad::ErrorStatus 
CDbPipeValve::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 
CDbPipeValve::subMoveGripPointsAt(const AcDbIntArray& indices,
							   const AcGeVector3d& offset)
{
	assertWriteEnabled();

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

	es = MoveGSPointsAt(indices,offset);

	return es;
}

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

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

	//es = MoveGSPointsAt(indices,offset);

	return es;
}

// 象限点
XPoint CDbPipeValve::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 CDbPipeValve::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 (GlobalFunc::DocGetCurMeterUnitDraw())
		{
			return m_dWidth * 0.001;
		}
 		return m_dWidth;
	}
}

//	图块插入比例
AcGeScale3d CDbPipeValve::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 (GlobalFunc::DocGetCurMeterUnitDraw())
		{
			dScale *= 0.001;
		}
	}

    if(!IsDoublePipeValve)
        dScaleY=m_dYScale*GetPScale()/100;
    else
	{
        dScaleY = m_dYScale;
	    // cet 2018.6.22 add 支持米单位
		if (GlobalFunc::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 CDbPipeValve::Draw2d(AcGiDraw &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);
}

BOOL IsSystemValve(AcDbObjectId id)
{
	const TCHAR *pszBlkName = NULL;
	OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbBlockTableRecord, pRecord);
	if (pRecord)
		pRecord->getName(pszBlkName);
	OPENOBJ_END();
	if (pszBlkName!=NULL) {
		CString sBlkName = pszBlkName;
		CString sTKName, sRocord;
		GlobalFunc::SplitBlkStr(sBlkName, sTKName, sRocord);
		sTKName = g_Option::instance().g_sDwbPath + sTKName + _T(".tk");
		CString sDesName = GlobalFunc::GetBlkDesName((const TCHAR *)sRocord, (const TCHAR *)sTKName);
		if (sDesName.Find(_T("-")) > -1 || sTKName.Find(_T("_U")) > -1)
			return FALSE;
		else
			return TRUE;
	}
	return FALSE;
}

Acad::ErrorStatus CDbPipeValve:: _ExplodeOrDraw2d(AcGiDraw &dc,BOOL bZEqual0) const
{

	if (Has2DBuffer())
	{
		Draw2DBuffers(dc);
		return Acad::eOk;
	}

	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 = GlobalFunc::Ucs2Wcs(0.0);
		}
		*************************************************************************/
		//delete end

		//add by dyw 2014-5-9 如果在水管的端点进行水平放置的时候 则阀门的方向跟水管的方向一致
		//============================================================================================
		else
		{
			//获取关联水管的起始和终止点
			XPoint ptSPipe, ptEPipe;						
			OPENOBJ_BEGIN(m_idPipe, AcDb::kForRead, CDbPipe, 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 = GlobalFunc::Ucs2Wcs(0.0);
			}
			else
				dAngle = GlobalFunc::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 = GlobalFunc::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);
		DrawLine(dc, XLine(pt3, pt4));
        //dc << XLine(pt3, pt4);
        ads_polar(pt2, dAng+PI/2, dFlangeDn/2, pt3);
        ads_polar(pt2, dAng-PI/2, dFlangeDn/2, pt4);
		DrawLine(dc, XLine(pt3, 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);
		DrawLine(dc, XLine(pt3, pt4));
        //dc << XLine(pt3, pt4);
        ads_polar(pt2, dAng+PI/2, dFlangeDn/2, pt3);
        ads_polar(pt2, dAng-PI/2, dFlangeDn/2, pt4);
		DrawLine(dc, XLine(pt3, pt4));
        //dc << XLine(pt3, pt4);
    }
	return Acad::eOk;
}

void CDbPipeValve::GetTips(DList<ObjInfoUnit> &info) const
{
	CDbPipeAttachment::GetTips(info);

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

void IniCDbPipeValve(BOOL bTrue)
{
    if(bTrue) {
        CDbPipeValve::rxInit();
    } else {
		deleteAcRxClass(CDbPipeValve::desc());
    }
}