2152 lines
57 KiB
C++
2152 lines
57 KiB
C++
#include "stdafx.h"
|
||
#include "TDbColumn.h"
|
||
#include "TDbWallPatch.h"
|
||
|
||
#include "imgdef.h" // AcDbRasterImageDef and reactors,
|
||
#include "imgent.h"
|
||
|
||
/////////////////////////////////////////////////////////////
|
||
// 阳台对象类
|
||
/////////////////////////////////////////////////////////////
|
||
extern BOOL g_bBalconyClipInsu;
|
||
// ver：1－TArch5；2－TArch6; 3-TArch7,4-TArch8
|
||
const Adesk::UInt8 TDbBalcony::g_nVersion = 4;
|
||
|
||
ACRX_DXF_DEFINE_MEMBERS(ATSBalcony, ATSPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
||
1, ATS_BALCONY, "ATS_BALCONY图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
||
|
||
IMPLEMENT_TENTBASE(TDbBalcony);
|
||
|
||
TDbBalcony::TDbBalcony()
|
||
:m_polyOutline(1), m_nRailEdge(0)
|
||
{
|
||
m_nRailWidth=m_nRailHeight=0;
|
||
m_nSlabThickness = m_nGirderThickness = 0;
|
||
|
||
m_nFlag=0;
|
||
m_uFrame=_AS_SYS_UNIT(40);
|
||
m_vFrame=_AS_SYS_UNIT(40);
|
||
m_nWinHeight=_AS_SYS_UNIT(1500);
|
||
|
||
//add by xlc on 110218 阳台遮挡保温
|
||
if (g_bBalconyClipInsu)
|
||
{
|
||
SetBalconyClipInsu(TRUE);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
TDbBalcony::~TDbBalcony()
|
||
{
|
||
}
|
||
|
||
BOOL TDbBalcony::IsValid() const
|
||
{
|
||
BOOL bRet=TDbPolyPathEnt::IsValid();
|
||
if(!bRet)
|
||
return bRet;
|
||
bRet=(m_polyOutline.Length()>1 && m_polyOutline.IsClosed() &&
|
||
m_nRailHeight>-1.0E-6 &&
|
||
fabs(m_nRailWidth)>1E-6 &&
|
||
m_nSlabThickness>1E-6 &&
|
||
m_nGirderThickness>1E-6);
|
||
if(bRet) {
|
||
XPoly2D polyIn(1);
|
||
polyIn=m_polyOutline;
|
||
XPoly2D polyOut(1);
|
||
if(!Offset(polyIn, polyOut))
|
||
return FALSE;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbBalcony::audit(AcDbAuditInfo* pAuditInfo)
|
||
{
|
||
Acad::ErrorStatus es = Acad::eOk;
|
||
// sg add 090806，解决高版本下修复02图纸，对象丢失的问题
|
||
es = TDbPolyPathEnt::audit(pAuditInfo);
|
||
if (es != Acad::eOk)
|
||
return es;
|
||
|
||
if (m_polyOutline.PathArea() >= 0.0)
|
||
{
|
||
pAuditInfo->errorsFound(1);
|
||
if (pAuditInfo->fixErrors() == Adesk::kTrue) {
|
||
pAuditInfo->printError(_T("柱子"), _T("轮廓"), _T("必须为逆时针"), _T(""));
|
||
|
||
m_polyOutline.Reverse();
|
||
int nEdgeNum=GetEdgeNum();
|
||
DList<int> lstEdgeFlag;
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
lstEdgeFlag.Append(new int(HasRailAt(n)));
|
||
lstEdgeFlag.Reverse();
|
||
for(n=0; n<nEdgeNum; n++)
|
||
SetRailAt(n, *lstEdgeFlag[n]);
|
||
|
||
pAuditInfo->errorsFixed(1);
|
||
es = Acad::eFixedAllErrors;
|
||
} else
|
||
es = Acad::eLeftErrorsUnfixed;
|
||
}
|
||
return es;
|
||
}
|
||
|
||
|
||
|
||
// 提供对格式刷的支持
|
||
void TDbBalcony::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
||
{
|
||
assertWriteEnabled();
|
||
TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
||
TDbBalcony *pSrc=TDbBalcony::cast(pSrcEntity);
|
||
if(pSrc) {
|
||
m_nRailHeight=pSrc->m_nRailHeight;
|
||
m_nRailWidth=pSrc->m_nRailWidth; //扶手高和扶手宽, 扶手宽<0, 则为内轮廓
|
||
m_nSlabThickness=pSrc->m_nSlabThickness;
|
||
m_nGirderThickness=pSrc->m_nGirderThickness;
|
||
m_nFlag=pSrc->m_nFlag;
|
||
if(database()==NULL||
|
||
pSrcEntity->database()==NULL||
|
||
database()==pSrcEntity->database())//add by whl on 060317
|
||
{
|
||
m_idLayerGround3d=pSrc->m_idLayerGround3d;
|
||
m_idLayerGlass3d=pSrc->m_idLayerGlass3d;
|
||
m_idLayerFrame3d=pSrc->m_idLayerFrame3d;
|
||
}
|
||
m_uFrame=pSrc->m_uFrame;
|
||
m_vFrame=pSrc->m_vFrame;
|
||
m_nWinHeight=pSrc->m_nWinHeight;
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbBalcony::subGetClassID(CLSID* pClsid) const
|
||
{
|
||
return Acad::eOk;
|
||
|
||
}
|
||
|
||
// 从DWG读入数据:
|
||
Acad::ErrorStatus TDbBalcony::dwgInFields (AcDbDwgFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es = TDbPolyPathEnt::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_nRailEdge);
|
||
|
||
double nElev=0.0;
|
||
pFiler->readItem(&nElev);
|
||
ReadPoly2D(pFiler, m_polyOutline);
|
||
m_polyOutline.SetElevation(nElev);
|
||
|
||
pFiler->readItem(&m_nRailWidth);
|
||
pFiler->readItem(&m_nRailHeight);
|
||
|
||
pFiler->readItem(&m_nSlabThickness);
|
||
pFiler->readItem(&m_nGirderThickness);
|
||
|
||
if(nVer>1)
|
||
{
|
||
pFiler->readItem(&m_idLayerGround3d);
|
||
}
|
||
else
|
||
{ // TArch5 update
|
||
if(database()==acdbCurDwg())
|
||
{
|
||
m_idLayerGround3d = InitLayer(LAY_GROUND, FALSE);
|
||
}
|
||
else
|
||
{
|
||
m_idLayerGround3d = GetLayerIdFromString(LAY_GROUND, database());
|
||
}
|
||
}
|
||
|
||
if(nVer>2)
|
||
{
|
||
pFiler->readItem(&m_nFlag);
|
||
pFiler->readItem(&m_idLayerGlass3d);
|
||
pFiler->readItem(&m_idLayerFrame3d);
|
||
pFiler->readItem(&m_uFrame);
|
||
pFiler->readItem(&m_vFrame);
|
||
pFiler->readItem(&m_nWinHeight);
|
||
|
||
int num;
|
||
pFiler->readItem(&num);//无用数据,永远为0
|
||
}
|
||
|
||
if(nVer>3)//TArch8
|
||
{
|
||
//modify by xlc on 100419 添加num变量的初始化
|
||
Adesk::Int32 num = 0;
|
||
|
||
m_lstWallId.Reset();
|
||
pFiler->readItem(&num);
|
||
for(long i=0;i<num;i++)
|
||
{
|
||
AcDbSoftPointerId idWall;
|
||
pFiler->readItem(&idWall);
|
||
m_lstWallId.Append(new AcDbSoftPointerId(idWall));
|
||
}
|
||
|
||
pFiler->readItem(&m_idHouse);
|
||
|
||
m_lstWinId.Reset();
|
||
|
||
num = 0;
|
||
pFiler->readItem(&num);
|
||
for(i=0;i<num;i++)
|
||
{
|
||
AcDbSoftPointerId idWin;
|
||
pFiler->readItem(&idWin);
|
||
m_lstWinId.Append(new AcDbSoftPointerId(idWin));
|
||
}
|
||
}
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TDbBalcony::dwgOutFields(AcDbDwgFiler* pFiler) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es = TDbPolyPathEnt::dwgOutFields(pFiler);
|
||
if(es != Acad::eOk) return es;
|
||
|
||
if(g_nSaveTArchVer==5)
|
||
pFiler->writeItem((Adesk::UInt8)1);
|
||
else if(g_nSaveTArchVer==6)
|
||
pFiler->writeItem((Adesk::UInt8)2);
|
||
else if(g_nSaveTArchVer==7)
|
||
pFiler->writeItem((Adesk::UInt8)3);
|
||
else
|
||
pFiler->writeItem(g_nVersion);
|
||
|
||
pFiler->writeItem(m_nRailEdge);
|
||
|
||
double nElev=0.0;
|
||
if(!!m_polyOutline)
|
||
nElev=m_polyOutline[0].z;
|
||
pFiler->writeItem(nElev);
|
||
WritePoly2D(pFiler, m_polyOutline);
|
||
|
||
pFiler->writeItem(m_nRailWidth);
|
||
pFiler->writeItem(m_nRailHeight);
|
||
|
||
pFiler->writeItem(m_nSlabThickness);
|
||
pFiler->writeItem(m_nGirderThickness);
|
||
|
||
if(g_nSaveTArchVer>5)
|
||
pFiler->writeItem(m_idLayerGround3d);
|
||
|
||
if(g_nSaveTArchVer>6)
|
||
{
|
||
pFiler->writeItem(m_nFlag);
|
||
pFiler->writeItem(m_idLayerGlass3d);
|
||
pFiler->writeItem(m_idLayerFrame3d);
|
||
pFiler->writeItem(m_uFrame);
|
||
pFiler->writeItem(m_vFrame);
|
||
pFiler->writeItem(m_nWinHeight);
|
||
|
||
int num=0;
|
||
pFiler->writeItem(num);//无用数据
|
||
}
|
||
|
||
if(g_nSaveTArchVer>7)
|
||
{
|
||
Adesk::Int32 num;
|
||
|
||
num=m_lstWallId.Length();
|
||
pFiler->writeItem(num);
|
||
for(long i=0;i<num;i++)
|
||
pFiler->writeItem(m_lstWallId[i]);
|
||
|
||
pFiler->writeItem(m_idHouse);
|
||
|
||
num=m_lstWinId.Length();
|
||
pFiler->writeItem(num);
|
||
for(i=0;i<num;i++)
|
||
pFiler->writeItem(m_lstWinId[i]);
|
||
}
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TDbBalcony::dxfInFields (AcDbDxfFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es = TDbPolyPathEnt::dxfInFields(pFiler);
|
||
if(es!=Acad::eOk)
|
||
return es;
|
||
|
||
if (!pFiler->atSubclassData(_T("TDbBalcony"))) {
|
||
return Acad::eBadDxfSequence;
|
||
}
|
||
|
||
int fieldsFlags=0;
|
||
resbuf rb;
|
||
Adesk::UInt32 nFlag;
|
||
double r1, r2, r3, r4, r5;
|
||
DList<XPoint> pts;
|
||
DList<double> bulges;
|
||
while ((es == Acad::eOk)
|
||
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
||
switch (rb.restype) {
|
||
case 148:
|
||
r1=rb.resval.rreal;
|
||
fieldsFlags |= 0x01;
|
||
break;
|
||
case AcDb::kDxfReal:
|
||
r2 = rb.resval.rreal;
|
||
fieldsFlags |= 0x02;
|
||
break;
|
||
case AcDb::kDxfReal+1:
|
||
r3=rb.resval.rreal;
|
||
fieldsFlags |= 0x04;
|
||
break;
|
||
case AcDb::kDxfReal+2:
|
||
r4=rb.resval.rreal;
|
||
fieldsFlags |= 0x08;
|
||
break;
|
||
case AcDb::kDxfReal+3:
|
||
r5=rb.resval.rreal;
|
||
fieldsFlags |= 0x10;
|
||
break;
|
||
case AcDb::kDxfInt32:
|
||
nFlag=rb.resval.rlong;
|
||
fieldsFlags |= 0x20;
|
||
break;
|
||
case AcDb::kDxfXCoord:
|
||
pts.Append(new XPoint(rb.resval.rpoint));
|
||
fieldsFlags |= 0x40;
|
||
break;
|
||
case AcDb::kDxfAngle:
|
||
bulges.Append(new double(rb.resval.rreal));
|
||
fieldsFlags |= 0x80;
|
||
break;
|
||
case 412:
|
||
m_idLayerGround3d=GetLayerIdFromString(rb.resval.rstring, database());
|
||
free(rb.resval.rstring);
|
||
break;
|
||
//fall through intentional
|
||
default:
|
||
// An unrecognized group. Push it back so that
|
||
// the subclass can read it again.
|
||
pFiler->pushBackItem();
|
||
es = Acad::eEndOfFile;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// At this point the es variable must contain eEndOfFile
|
||
// - either from readResBuf() or from pushback. If not,
|
||
// it indicates that an error happened and we should
|
||
// return immediately.
|
||
//
|
||
if (es != Acad::eEndOfFile)
|
||
return Acad::eInvalidResBuf;
|
||
|
||
if (!(fieldsFlags&0x02)) {
|
||
pFiler->setError(Acad::eMissingDxfField,
|
||
_T("\nMissing DXF group code: 40"));
|
||
return Acad::eMissingDxfField;
|
||
}
|
||
if (!(fieldsFlags&0x04)) {
|
||
pFiler->setError(Acad::eMissingDxfField,
|
||
_T("\nMissing DXF group code: 41"));
|
||
return Acad::eMissingDxfField;
|
||
}
|
||
if (!(fieldsFlags&0x08)) {
|
||
pFiler->setError(Acad::eMissingDxfField,
|
||
_T("\nMissing DXF group code: 42"));
|
||
return Acad::eMissingDxfField;
|
||
}
|
||
if (!(fieldsFlags&0x10)) {
|
||
pFiler->setError(Acad::eMissingDxfField,
|
||
_T("\nMissing DXF group code: 43"));
|
||
return Acad::eMissingDxfField;
|
||
}
|
||
if(pts.Length()<2 || pts.Length()!=bulges.Length()) {
|
||
pFiler->setError(_T("\nError DXF group code: 10, 50"));
|
||
return Acad::eMissingDxfField;
|
||
}
|
||
|
||
double nElev=(fieldsFlags&0x01)? r1 : 0.0;
|
||
SetRailHeight(r2);
|
||
SetRailWidth(r3);
|
||
SetSlabThickness(r4);
|
||
SetGirderThickness(r5);
|
||
if(fieldsFlags&0x20)
|
||
m_nRailEdge=nFlag;
|
||
m_polyOutline.Reset();
|
||
for(int i=0; i<pts.Length(); i++) {
|
||
m_polyOutline.AppendNode(*pts[i], *bulges[i]);
|
||
}
|
||
m_polyOutline.SetElevation(nElev);
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TDbBalcony::dxfOutFields(AcDbDxfFiler* pFiler) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es;
|
||
|
||
es = TDbPolyPathEnt::dxfOutFields(pFiler);
|
||
assert(es == Acad::eOk);
|
||
|
||
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbBalcony"));
|
||
assert(es == Acad::eOk);
|
||
pFiler->writeDouble(148, GetElevation());
|
||
pFiler->writeDouble(AcDb::kDxfReal, GetRailHeight());
|
||
pFiler->writeDouble(AcDb::kDxfReal+1, GetRailWidth());
|
||
pFiler->writeDouble(AcDb::kDxfReal+2, GetSlabThickness());
|
||
pFiler->writeDouble(AcDb::kDxfReal+3, GetGirderThickness());
|
||
pFiler->writeInt32(AcDb::kDxfInt32, m_nRailEdge);
|
||
for(int i=0; i<m_polyOutline.Length(); i++) {
|
||
pFiler->writePoint2d(AcDb::kDxfXCoord, m_polyOutline[i]);
|
||
pFiler->writeDouble(AcDb::kDxfAngle, m_polyOutline.GetBulge(i));
|
||
}
|
||
|
||
pFiler->writeString(412, (const TCHAR *)LayerId2String(m_idLayerGround3d));
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
|
||
// -----------------------------------------------------------------------
|
||
// Overriden functions for edit
|
||
// to do:
|
||
// 允许通过夹点改变边界
|
||
Acad::ErrorStatus TDbBalcony::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
||
AcDbIntArray& osnapModes,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
assertReadEnabled();
|
||
int nEdgeNum=GetEdgeNum();
|
||
for(int i=0; i<nEdgeNum; i++) {
|
||
gripPoints.append(m_polyOutline[i]);
|
||
}
|
||
//边上的夹点
|
||
for(i=0; i<nEdgeNum; i++) {
|
||
XCurveSegment edge;
|
||
m_polyOutline.Nth(i, edge);
|
||
XPoint ptMid=edge.MidPoint();
|
||
gripPoints.append(ptMid);
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// stretch points is diffrent from grep points, with no midpoint included
|
||
Acad::ErrorStatus TDbBalcony::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
|
||
{
|
||
assertReadEnabled();
|
||
for(int i=0; i<m_polyOutline.Length(); i++) {
|
||
stretchPoints.append(m_polyOutline[i]);
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
|
||
|
||
// Active when being rotated, scaled, moved, etc.
|
||
Acad::ErrorStatus
|
||
TDbBalcony::subTransformBy(const AcGeMatrix3d& xform)
|
||
{
|
||
assertWriteEnabled();
|
||
TDbEntity::subTransformBy(xform);
|
||
ads_matrix mat;
|
||
memcpy(mat, &xform, sizeof(ads_matrix));
|
||
double nElev=0.0;
|
||
for(int i=0; i<m_polyOutline.Length(); i++) {
|
||
XPoint *pt=m_polyOutline[i];
|
||
pt->TransformBy(mat);
|
||
//以第一个顶点的z坐标为基准
|
||
if(i==0) {
|
||
nElev = pt->z;
|
||
} else {
|
||
pt->z = nElev;
|
||
}
|
||
}
|
||
if(IsMirrorMatrix(mat)) {
|
||
for(int m=0; m<m_polyOutline.Length(); m++)
|
||
m_polyOutline.SetBulge(m, -m_polyOutline.GetBulge(m));
|
||
}
|
||
if(m_polyOutline.PathArea()>0) {
|
||
m_polyOutline.Reverse();
|
||
int nEdgeNum=GetEdgeNum();
|
||
DList<int> lstEdgeFlag;
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
lstEdgeFlag.Append(new int(HasRailAt(n)));
|
||
lstEdgeFlag.Reverse();
|
||
for(n=0; n<nEdgeNum; n++)
|
||
SetRailAt(n, *lstEdgeFlag[n]);
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
void TDbBalcony::UnionScale(double nScale)
|
||
{
|
||
assertWriteEnabled();
|
||
double nOldElev=GetElevation();
|
||
TDbEntity::UnionScale(nScale);
|
||
SetElevation(nOldElev*nScale);
|
||
m_nRailHeight*=nScale;
|
||
m_nRailWidth*=nScale;
|
||
m_nSlabThickness*=nScale;
|
||
m_nGirderThickness*=nScale;
|
||
m_uFrame*=nScale;
|
||
m_vFrame*=nScale;
|
||
m_nWinHeight*=nScale;
|
||
}
|
||
// 功能: 夹点操作
|
||
Acad::ErrorStatus TDbBalcony::subMoveGripPointsAt(
|
||
const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
assertWriteEnabled();
|
||
XPoly2D polyBack(m_polyOutline);
|
||
|
||
XPoint vtOffset=*(XPoint *)&offset;
|
||
vtOffset.z=0;
|
||
int nTotalEdge=GetEdgeNum();
|
||
for (int i = 0; i < indices.length(); i++)
|
||
{
|
||
int idx = indices[i];
|
||
ASSERT(idx<2*nTotalEdge);
|
||
if (idx<nTotalEdge)
|
||
{
|
||
*m_polyOutline[idx] += vtOffset;
|
||
}
|
||
else
|
||
{
|
||
int nEdgeIndex=idx-nTotalEdge;
|
||
ASSERT(nEdgeIndex<nTotalEdge);
|
||
|
||
XDirectionCurve cv;
|
||
m_polyOutline.Nth(nEdgeIndex, cv);
|
||
ASSERT(!!cv);
|
||
if(cv.Is(CURVE_LINE)) { // Move
|
||
XLine ln=cv.GetLine();
|
||
ln.StartPoint() += vtOffset;
|
||
ln.EndPoint() += vtOffset;
|
||
ln.SetLineFlag(LS_INFINITE);
|
||
XDirectionCurve prevSeg, nextSeg;
|
||
int nPrev=nEdgeIndex-1, nNext=nEdgeIndex+1;
|
||
nPrev=DePeriod(nTotalEdge, nPrev);
|
||
nNext=DePeriod(nTotalEdge, nNext);
|
||
|
||
XPoint ptStart, ptEnd;
|
||
BOOL bUpdateIt=TRUE;
|
||
//更新起点
|
||
if(nPrev>=0 && nPrev<nTotalEdge) {
|
||
m_polyOutline.Nth(nPrev, prevSeg);
|
||
prevSeg.SetLineFlag(LS_INFINITE);
|
||
XPoint ptInt[2];
|
||
int nIntNum=prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if(nIntNum==1) ptStart=ptInt[0];
|
||
else if(nIntNum==2) {
|
||
ptStart=XLine(ptInt[0], ptInt[1]).NearPoint(ln.StartPoint());
|
||
} else bUpdateIt=FALSE;
|
||
} else {
|
||
ptStart = *m_polyOutline[nEdgeIndex] + vtOffset;
|
||
}
|
||
|
||
// 更新下一点
|
||
if(nNext>=0 && nNext<nTotalEdge) {
|
||
m_polyOutline.Nth(nNext, nextSeg);
|
||
nextSeg.SetLineFlag(LS_INFINITE);
|
||
XPoint ptInt[2];
|
||
int nIntNum=nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if(nIntNum==1) ptEnd=ptInt[0];
|
||
else if(nIntNum==2) {
|
||
ptEnd=XLine(ptInt[0], ptInt[1]).NearPoint(ln.EndPoint());
|
||
} else bUpdateIt=FALSE;
|
||
} else {
|
||
ptEnd = *m_polyOutline[nEdgeIndex+1] + vtOffset;
|
||
}
|
||
|
||
if(bUpdateIt) {
|
||
double nPrevBulge=0.0, nNextBulge=0.0;
|
||
if(fabs(prevSeg.GetBulge())>1.0E-5) {
|
||
XArc prevArc=prevSeg.GetArc();
|
||
double nAngBeg=ads_angle(prevArc.GetCenterPt(), prevSeg.StartPoint());
|
||
double nAngEnd=ads_angle(prevArc.GetCenterPt(), ptStart);
|
||
if(prevSeg.IsMinusArc()) {
|
||
nPrevBulge=-CT_std_angle(nAngBeg-nAngEnd);
|
||
} else {
|
||
nPrevBulge=CT_std_angle(nAngEnd-nAngBeg);
|
||
}
|
||
}
|
||
if(fabs(nextSeg.GetBulge())>1.0E-5) {
|
||
XArc nextArc=nextSeg.GetArc();
|
||
double nAngBeg=ads_angle(nextArc.GetCenterPt(), ptEnd);
|
||
double nAngEnd=ads_angle(nextArc.GetCenterPt(), nextSeg.EndPoint());
|
||
if(nextSeg.IsMinusArc()) {
|
||
nNextBulge=-CT_std_angle(nAngBeg-nAngEnd);
|
||
} else {
|
||
nNextBulge=CT_std_angle(nAngEnd-nAngBeg);
|
||
}
|
||
}
|
||
|
||
*m_polyOutline[nEdgeIndex] = ptStart;
|
||
if(nNext>=0 && nNext<m_polyOutline.Length())
|
||
{
|
||
*m_polyOutline[nNext] = ptEnd;
|
||
m_polyOutline.SetBulge(nNext, nNextBulge);
|
||
}
|
||
if(nPrev>=0 && nPrev<m_polyOutline.Length())
|
||
m_polyOutline.SetBulge(nPrev, nPrevBulge);
|
||
|
||
}
|
||
|
||
} else { // Change Arc Segment--bulge
|
||
XPoint ptMid=cv.MidPoint();
|
||
XPoint ptMidNew= ptMid + vtOffset;
|
||
XArc arNew(cv.StartPoint(), ptMidNew, cv.EndPoint());
|
||
if(!!arNew) { //新的弧有效
|
||
XCurveSegment cvLine(cv.StartPoint(), cv.EndPoint(), 0.0);
|
||
int nSideOld=cvLine.OnWhichSide(ptMid);
|
||
int nSideNew=cvLine.OnWhichSide(ptMidNew);
|
||
double nSignal=cv.GetBulge()/fabs(cv.GetBulge());
|
||
if(nSideOld==nSideNew) {
|
||
m_polyOutline.SetBulge(nEdgeIndex, nSignal*arNew.Bulge());
|
||
} else {
|
||
m_polyOutline.SetBulge(nEdgeIndex, -nSignal*arNew.Bulge());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Acad::ErrorStatus es = Acad::eOk;
|
||
if(m_polyOutline.IsSelfIntersect()) {
|
||
m_polyOutline=polyBack;
|
||
es = Acad::eInvalidInput;
|
||
}
|
||
|
||
// sg add 110106，解决阳台对象，拖拽夹点后，出现反向的问题
|
||
if (m_polyOutline.PathArea()>0)
|
||
{
|
||
m_polyOutline.Reverse();
|
||
int nEdgeNum=GetEdgeNum();
|
||
DList<int> lstEdgeFlag;
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
lstEdgeFlag.Append(new int(HasRailAt(n)));
|
||
lstEdgeFlag.Reverse();
|
||
for(n=0; n<nEdgeNum; n++)
|
||
SetRailAt(n, *lstEdgeFlag[n]);
|
||
}
|
||
|
||
return es;
|
||
}
|
||
|
||
// 取得夹点说明
|
||
Acad::ErrorStatus TDbBalcony::GetGripText(int i, CString &cs) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
XString sInfo;
|
||
if(i<GetEdgeNum()) {
|
||
sInfo << _T("移动第") << (i+1) << _T("个顶点");
|
||
} else {
|
||
sInfo << _T("移动第") << (i-GetEdgeNum()+1) << _T("条边");
|
||
}
|
||
cs = sInfo;
|
||
return es;
|
||
}
|
||
#if ADS>15
|
||
void TDbBalcony::CreateGrip()
|
||
{
|
||
TDbEntity::CreateGrip();
|
||
TchExport2::CreateGrip(this,m_polyOutline,0);
|
||
}
|
||
Acad::ErrorStatus TDbBalcony::EntityToDim(long iGrip,long iDim,const AcDbEntity*pEnt)
|
||
{
|
||
TEntityBase *pCurve=TDbBalcony::cast(pEnt);
|
||
if(pCurve==NULL)
|
||
pCurve=this;
|
||
XPoly2D polyPath;
|
||
AcGeVector3d normal;
|
||
pCurve->GetPathPoly(polyPath,normal);
|
||
return TchExport2::EntityToDim(this,polyPath,iGrip,iDim,0);
|
||
}
|
||
|
||
Acad::ErrorStatus TDbBalcony::DimToEntity(long iGrip,long iDim,double newValue,const AcGeVector3d& offset)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
TDbBalcony curve;
|
||
curve.CopyPropertiesFrom(this,0);
|
||
|
||
Acad::ErrorStatus es=TchExport2::DimToEntity(this,m_polyOutline,iGrip,iDim,newValue,offset,0);
|
||
if(es==Acad::eOk&&!IsValid())
|
||
{
|
||
CopyPropertiesFrom(&curve,0);
|
||
return Acad::eInvalidInput;
|
||
}
|
||
|
||
// sg add 110106，解决阳台对象，动态输入修改夹点后，出现反向的问题
|
||
if (m_polyOutline.PathArea()>0)
|
||
{
|
||
m_polyOutline.Reverse();
|
||
int nEdgeNum=GetEdgeNum();
|
||
DList<int> lstEdgeFlag;
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
lstEdgeFlag.Append(new int(HasRailAt(n)));
|
||
lstEdgeFlag.Reverse();
|
||
for(n=0; n<nEdgeNum; n++)
|
||
SetRailAt(n, *lstEdgeFlag[n]);
|
||
}
|
||
|
||
|
||
return es;
|
||
}
|
||
#endif
|
||
// 功能: 夹点操作
|
||
// 状态: 有待完成修改相关墙体门窗的操作
|
||
Acad::ErrorStatus TDbBalcony::subMoveStretchPointsAt(
|
||
const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
assertWriteEnabled();
|
||
int nCount=indices.length();
|
||
return subMoveGripPointsAt(indices, offset);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
Acad::ErrorStatus
|
||
TDbBalcony::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
||
{
|
||
assertReadEnabled();
|
||
//TPushProperty vProp(this, dc);
|
||
|
||
XPoly2D polyIn(1);
|
||
polyIn=m_polyOutline;
|
||
|
||
XPoly2D polyOut(1);
|
||
{
|
||
//// sg add 110920，解决日照环境和建筑环境下，由于容忍度不一样，导致日照软件环境下，求不到交点，阳台不能显示的问题
|
||
if (g_nProductId == kTSUN)
|
||
{
|
||
AcGeTol &tmpTol = AcGeContext::gTol;
|
||
double dOldTol = tmpTol.equalPoint(),
|
||
dNewTol = _distSnap*0.1;
|
||
tmpTol.setEqualPoint(dNewTol);
|
||
|
||
if (!Offset(polyIn, polyOut))
|
||
return Acad::eInvalidInput;
|
||
|
||
tmpTol.setEqualPoint(dOldTol);
|
||
}
|
||
else
|
||
{
|
||
if (!Offset(polyIn, polyOut))
|
||
return Acad::eInvalidInput;
|
||
}
|
||
}
|
||
|
||
double nHIn = GetRailHeight();
|
||
double nHOut = GetRailHeight() + GetGirderThickness();
|
||
if(m_nRailWidth>0)
|
||
TchPrivate::Exchange(polyIn, polyOut);
|
||
|
||
DList<XPoly2D> lstPolys;
|
||
// modify on 2002/2/22 by ZJQ 解决标高不为0的时候，区域运算和搜索的问题。
|
||
polyOut.SetElevation(0.0);
|
||
polyIn.SetElevation(0.0);
|
||
TchSubExport::Subtract(polyOut, polyIn, lstPolys); //阳台拦板
|
||
|
||
double nOutElev=GetElevation()-GetGirderThickness();
|
||
XVector3D vt(0,0,GetGirderThickness()-GetSlabThickness());
|
||
polyOut.SetElevation(nOutElev);
|
||
polyIn.SetElevation(GetElevation());
|
||
int nEdge=GetEdgeNum();
|
||
for(int i=0; i<nEdge; i++) {
|
||
if(!HasRailAt(i))
|
||
continue;
|
||
XCurveSegment seg1, seg2;
|
||
polyIn.Nth(i, seg1);
|
||
polyOut.Nth(i, seg2);
|
||
dc.DrawCurve(seg1, nHIn);
|
||
dc.DrawCurve(seg2, nHOut);
|
||
// 封梁侧面
|
||
if(vt.z>_DIST_SNAP) {
|
||
seg1.SetElevation(nOutElev);
|
||
dc.DrawCurve(seg1, vt.z);
|
||
}
|
||
}
|
||
|
||
|
||
for(int ii=0; ii<lstPolys.Length(); ii++) {
|
||
XPoly2D &rPoly=*lstPolys[ii];
|
||
rPoly.SetElevation(GetElevation()+nHIn);
|
||
dc.DrawShell(rPoly, DList<XPoly2D>()); //栏板顶面
|
||
rPoly.SetElevation(GetElevation()-GetGirderThickness());
|
||
if(HasGirder())
|
||
dc.DrawShell(rPoly, DList<XPoly2D>()); //封梁底
|
||
//dc.DrawMesh(rPoly, vt); //封梁侧面
|
||
}
|
||
|
||
|
||
TMasterProperties prop;
|
||
dc.BackUpProperties(prop);
|
||
dc.SetColorLayer(colorIndex(), m_idLayerGround3d);
|
||
dc.DrawShell(polyIn, DList<XPoly2D>()); //阳台地面
|
||
polyIn.SetElevation(GetElevation()-GetSlabThickness());
|
||
dc.DrawShell(HasGirder()? polyIn : polyOut, DList<XPoly2D>()); //阳台底面
|
||
dc.RestoreProperties(prop);
|
||
return Acad::eOk;
|
||
}
|
||
bool TDbBalcony::IsClipMe(const TEntityBase* pEnt)const
|
||
{
|
||
if(TDbEntity::IsClipMe(pEnt))
|
||
return true;
|
||
|
||
// if(pEnt->GetMe()->isKindOf(TDbColumn::desc())||
|
||
// pEnt->GetMe()->isKindOf(TDbWall::desc())) // 8.0支持墙裁剪阳台
|
||
if(pEnt->GetMe()->isKindOf(TDbColumn::desc()) ||
|
||
pEnt->GetMe()->isKindOf(TDbWall::desc()) || // 8.0支持墙裁剪阳台
|
||
pEnt->GetMe()->isKindOf(TDbWallPatch::desc())) // sg add 090527，墙体造型裁剪阳台
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
Acad::ErrorStatus
|
||
TDbBalcony::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
||
{
|
||
//TPushProperty vProp(this, dc);
|
||
assertReadEnabled();
|
||
XPoly2D polyCur(1);
|
||
polyCur=m_polyOutline;
|
||
polyCur.SetElevation(0.0);
|
||
|
||
XPoly2D polyNext(1);
|
||
{
|
||
// sg add 110928，解决日照环境和建筑环境下，由于容忍度不一样，导致日照软件环境下，求不到交点，阳台不能显示的问题
|
||
if (g_nProductId == kTSUN)
|
||
{
|
||
AcGeTol &tmpTol = AcGeContext::gTol;
|
||
double dOldTol = tmpTol.equalPoint(),
|
||
dNewTol = _distSnap*0.1;
|
||
tmpTol.setEqualPoint(dNewTol);
|
||
|
||
if (!Offset(polyCur, polyNext))
|
||
{
|
||
XPoint pt1, pt2;
|
||
int nColorOld=dc.GetColor();
|
||
dc.SetColor(1);
|
||
dc << polyCur;
|
||
polyCur.GetExtend(pt1, pt2);
|
||
XRectAngle box(pt1, pt2);
|
||
dc << XLine(box.GetLowLeft(), box.GetUpRight())
|
||
<< XLine(box.GetUpLeft(), box.GetLowRight());
|
||
dc.SetColor(nColorOld);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
tmpTol.setEqualPoint(dOldTol);
|
||
}
|
||
else
|
||
{
|
||
if (!Offset(polyCur, polyNext))
|
||
{
|
||
XPoint pt1, pt2;
|
||
int nColorOld=dc.GetColor();
|
||
dc.SetColor(1);
|
||
dc << polyCur;
|
||
polyCur.GetExtend(pt1, pt2);
|
||
XRectAngle box(pt1, pt2);
|
||
dc << XLine(box.GetLowLeft(), box.GetUpRight())
|
||
<< XLine(box.GetUpLeft(), box.GetLowRight());
|
||
dc.SetColor(nColorOld);
|
||
return Acad::eOk;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//modify by xlc on 110519 调整阳台遮挡保温算法
|
||
// //add by xlc on 110218 阳台遮挡保温
|
||
// bool bBalconyClipInsu = false;
|
||
// TDPtrList<TGGePoly2D> lstTemp;
|
||
// double dLength = _AS_SYS_UNIT(10);
|
||
// if(IsBalconyClipInsu() && (!(g_bGetExtents || g_bOsnapExpl)))
|
||
// {
|
||
// for (long i = 0; i < m_lstClipId.Length(); i++)
|
||
// {
|
||
// const AcDbObjectId &id = m_lstClipId[i];
|
||
// if (id.isNull() || !id.isValid())
|
||
// {
|
||
// continue;
|
||
// }
|
||
//
|
||
// //modify by xlc on 110314 优化阳台遮挡保温算法
|
||
// //OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWall, pWall);
|
||
// //if (pWall)
|
||
// //{
|
||
// // if ((pWall->GetWallFlag() & WF_LEFT_INSULATE) || (pWall->GetWallFlag() & WF_RIGHT_INSULATE))
|
||
// // {
|
||
// // bBalconyClipInsu = true;
|
||
// // break;
|
||
// // }
|
||
// //}
|
||
// //OPENOBJ_END();
|
||
// AcDbEntity *pEnt = NULL;
|
||
// acdbOpenObject(pEnt,id,AcDb::kForRead);
|
||
//
|
||
// if (pEnt != NULL)
|
||
// {
|
||
// bool bAddPoly = false;
|
||
// double dThick = 0;
|
||
// TGGePoly2D polyOut;
|
||
// if (pEnt->isKindOf(TDbWall::desc()))
|
||
// {
|
||
// bAddPoly = true;
|
||
// ((TDbWall*)pEnt)->GetOutlinePoly(0, polyOut);
|
||
//
|
||
// int nWallFlag = ((TDbWall*)pEnt)->GetWallFlag();
|
||
// if ((nWallFlag & WF_LEFT_INSULATE) || (nWallFlag & WF_RIGHT_INSULATE))
|
||
// {
|
||
// bBalconyClipInsu = true;
|
||
// double dThick0 = ((TDbWall*)pEnt)->GetInsulateThick(0);
|
||
// double dThick1 = ((TDbWall*)pEnt)->GetInsulateThick(1);
|
||
// dThick = dThick0;
|
||
// if (dThick > dThick1)
|
||
// {
|
||
// dThick = dThick1;
|
||
// }
|
||
// }
|
||
// }
|
||
// else if (pEnt->isKindOf(TDbColumn::desc()))
|
||
// {
|
||
// bAddPoly = true;
|
||
// polyOut=((TDbColumn*)pEnt)->GetOutlinePoly();
|
||
//
|
||
// bool bHasInsl = ((TDbColumn*)pEnt)->IsInsulateOnColumn();
|
||
// double dInsThk = ((TDbColumn*)pEnt)->GetInsulateThick();
|
||
// if (bHasInsl && dInsThk >= 1.e-3) //这里精度与柱子绘制精度保持一致
|
||
// {
|
||
// dThick = dInsThk;
|
||
// bBalconyClipInsu = true;
|
||
// }
|
||
//
|
||
// }
|
||
// else if(pEnt->isKindOf(TDbWallPatch::desc()))
|
||
// {
|
||
// bAddPoly = true;
|
||
// ((TDbWallPatch*)pEnt)->GetOutlinePoly(polyOut, false);
|
||
// BOOL bHasInsl = ((TDbWallPatch*)pEnt)->HasInsulate();
|
||
// double dInsThk = ((TDbWallPatch*)pEnt)->GetInsulateThick();
|
||
// if (bHasInsl && dInsThk >= 1.E-5) //这里精度与墙体造型绘制精度保持一致
|
||
// {
|
||
// dThick = dInsThk;
|
||
// bBalconyClipInsu = true;
|
||
// }
|
||
// }
|
||
//
|
||
// if (bAddPoly)
|
||
// {
|
||
// if (dThick > dLength)
|
||
// {
|
||
// dThick = dLength;
|
||
// }
|
||
// else
|
||
// {
|
||
// dThick *= 0.5;
|
||
// }
|
||
//
|
||
// GetOffsetPoly2D(polyOut,polyOut,dThick);
|
||
// lstTemp.Append(new TGGePoly2D(polyOut));
|
||
// }
|
||
// pEnt->close();
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// int nEdge=GetEdgeNum();
|
||
// TGGePoly2D poly(1);
|
||
// TDPtrList<TGGeCurveSegment> lstCurves;
|
||
// bool bFirst = true;
|
||
// TGGePoly2D poly1,poly2;
|
||
// for(int i=0; i<nEdge; i++)
|
||
// {
|
||
// if(!HasRailAt(i))
|
||
// continue;
|
||
// XCurveSegment seg1, seg2;
|
||
// polyCur.Nth(i, seg1);
|
||
// polyNext.Nth(i, seg2);
|
||
//
|
||
// //modify by xlc on 110218 阳台遮挡保温
|
||
// //dc<<seg1<<seg2;
|
||
// if(bBalconyClipInsu)
|
||
// {
|
||
// lstCurves.Append(new TGGeCurveSegment(seg1));
|
||
// lstCurves.Append(new TGGeCurveSegment(seg2));
|
||
//
|
||
// //modify by xlc on 110314 优化阳台遮挡保温算法
|
||
// //XPoint ptS = seg1.StartPoint(), ptE =seg1.EndPoint();
|
||
// //if (bFirst)
|
||
// //{
|
||
// // TADSGePointDir2d ptDir;
|
||
// // seg1.Polar(dLength, ptDir);
|
||
// // poly.InsertNodeAt(0, ptDir);
|
||
// //}
|
||
// //poly.InsertNodeAt(0, ptE);
|
||
// //
|
||
// //ptS = seg2.StartPoint(), ptE = seg2.EndPoint();
|
||
// //if (bFirst)
|
||
// //{
|
||
// // TADSGePointDir2d ptDir;
|
||
// // seg2.Polar(dLength, ptDir);
|
||
// // poly.AppendNode(ptDir);
|
||
// //}
|
||
// //else
|
||
// //{
|
||
// // bFirst = false;
|
||
// //}
|
||
// //poly.AppendNode(ptE);
|
||
// if (bFirst)
|
||
// {
|
||
// poly1.AppendNode(*polyCur[i],polyCur.GetBulge(i));
|
||
// }
|
||
// poly1.AppendNode(*polyCur[i+1],polyCur.GetBulge(i+1));
|
||
//
|
||
// if (bFirst)
|
||
// {
|
||
// poly2.AppendNode(*polyNext[i],polyNext.GetBulge(i));
|
||
// bFirst = false;
|
||
// }
|
||
// poly2.AppendNode(*polyNext[i+1],polyNext.GetBulge(i+1));
|
||
// }
|
||
// else
|
||
// {
|
||
// dc<<seg1<<seg2;
|
||
// }
|
||
// }
|
||
//
|
||
// if (0&&bBalconyClipInsu && _tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0)
|
||
// {
|
||
// for (int i = 0; i < poly1.Length(); i++)
|
||
// {
|
||
// poly.AppendNode(*poly1[i],poly1.GetBulge(i));
|
||
// }
|
||
// poly2.Reverse();
|
||
// for (i = 0; i < poly2.Length(); i++)
|
||
// {
|
||
// poly.AppendNode(*poly2[i],poly2.GetBulge(i));
|
||
// }
|
||
// poly.Compress();
|
||
//
|
||
// TDPtrList<TGGePoly2D> lstBal,lstRes;
|
||
// lstBal.Append(new TGGePoly2D(poly));
|
||
// Subtract(lstBal, lstTemp, lstRes);
|
||
//
|
||
// if (lstRes.Length()>0)
|
||
// {
|
||
// poly = *lstRes[0];
|
||
// }
|
||
// else
|
||
// {
|
||
// poly.Reset();
|
||
// }
|
||
//
|
||
// if(poly.Length() > 3)
|
||
// {
|
||
///* if (lstCurves.Length() >= 2)
|
||
// {
|
||
// TGGeCurveSegment &cvSeg = *lstCurves[lstCurves.Length()-2];
|
||
// TADSGePointDir2d ptDir;
|
||
// cvSeg.Polar(cvSeg.GetLength()-dLength, ptDir, 1);
|
||
// poly.RemoveNode(0);
|
||
// poly.InsertNodeAt(0, ptDir);
|
||
//
|
||
// TGGeCurveSegment &cvSeg1 = *lstCurves[lstCurves.Length()-1];
|
||
// cvSeg1.Polar(cvSeg1.GetLength()-dLength, ptDir, 1);
|
||
// poly.RemoveNode(poly.Length()-1);
|
||
// poly.AppendNode(ptDir);
|
||
// }
|
||
//*/
|
||
//
|
||
// COLORREF colorImage;
|
||
// AcColorSettings setAcadColor;
|
||
// acedGetCurrentColors(&setAcadColor);
|
||
//
|
||
// int tilemode;
|
||
// xg_getvar(_T("TILEMODE"), &tilemode);
|
||
// colorImage = tilemode? setAcadColor.dwGfxModelBkColor : setAcadColor.dwGfxLayoutBkColor;
|
||
// AcCmEntityColor color;
|
||
// if (colorImage == RGB(255,255,255))
|
||
// {
|
||
// color.setColorIndex(255);
|
||
// }
|
||
// else
|
||
// {
|
||
// color.setTrueColor();
|
||
// color.setRGB(GetRValue(colorImage),GetGValue(colorImage),GetBValue(colorImage));
|
||
// }
|
||
//
|
||
// AcGiCommonDraw *dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
|
||
// if (!dcCommon->context()->isPlotGeneration())
|
||
// {
|
||
// AcGiFillType nFillType=dcCommon->subEntityTraits().fillType();
|
||
// AcCmEntityColor cmColor=dcCommon->subEntityTraits().trueColor();
|
||
// dcCommon->subEntityTraits().setFillType(kAcGiFillAlways);
|
||
// dcCommon->subEntityTraits().setTrueColor(color);
|
||
// dc<<XSolid(poly);
|
||
// dcCommon->subEntityTraits().setFillType(nFillType);
|
||
// dcCommon->subEntityTraits().setTrueColor(cmColor);
|
||
// }
|
||
// }
|
||
// }
|
||
// if (bBalconyClipInsu)
|
||
// {
|
||
// dc << lstCurves;
|
||
// }
|
||
int nEdge=GetEdgeNum();
|
||
for(int i=0; i<nEdge; i++)
|
||
{
|
||
if(!HasRailAt(i))
|
||
continue;
|
||
TGGeCurveSegment seg1, seg2;
|
||
polyCur.Nth(i, seg1);
|
||
polyNext.Nth(i, seg2);
|
||
dc<<seg1<<seg2;
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
const TCHAR *TDbBalcony::GetDefaultLayer() const
|
||
{
|
||
assertReadEnabled();
|
||
return LAY_BALCONY;
|
||
}
|
||
|
||
|
||
|
||
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
||
void TDbBalcony::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
||
{
|
||
assertReadEnabled();
|
||
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("阳台")));
|
||
lstInfo.Append(new TObjInfoUnit(_T("拦板宽"), Dist2Str(fabs(GetRailWidth()))));
|
||
lstInfo.Append(new TObjInfoUnit(_T("拦板高"), Dist2Str(GetRailHeight())));
|
||
lstInfo.Append(new TObjInfoUnit(_T("地面高差"), Dist2Str(-GetElevation())));
|
||
lstInfo.Append(new TObjInfoUnit(_T("地板厚"), Dist2Str(GetSlabThickness())));
|
||
if(HasGirder())
|
||
lstInfo.Append(new TObjInfoUnit(_T("梁高"), Dist2Str(GetGirderThickness())));
|
||
XString sArea(_T("%.2f"), _AS_SQMETER(GetOutline().Area()));
|
||
lstInfo.Append(new TObjInfoUnit(_T("面积"), sArea));
|
||
}
|
||
|
||
|
||
int
|
||
TDbBalcony::GetEdgeNum() const
|
||
{
|
||
assertReadEnabled();
|
||
return m_polyOutline.TotalSegments();
|
||
}
|
||
|
||
BOOL
|
||
TDbBalcony::HasRailAt(int idx) const
|
||
{
|
||
assertReadEnabled();
|
||
ASSERT(idx<GetEdgeNum());
|
||
int nTestBit=0x01;
|
||
nTestBit <<= idx;
|
||
return ((m_nRailEdge&nTestBit)==0);
|
||
}
|
||
|
||
double
|
||
TDbBalcony::GetOffsetDist(int idx) const
|
||
{
|
||
assertReadEnabled();
|
||
double nDist= HasRailAt(idx)? -m_nRailWidth : 0.0;
|
||
return nDist;
|
||
}
|
||
|
||
|
||
BOOL
|
||
TDbBalcony::Offset(const XPoly2D &src, XPoly2D &dest) const
|
||
{
|
||
assertReadEnabled();
|
||
int nTotalSeg=src.TotalSegments();
|
||
ASSERT(nTotalSeg==GetEdgeNum());
|
||
dest.Reset();
|
||
dest.SetFlag(1);
|
||
|
||
XDirectionCurve finalMidSeg, lastSeg;
|
||
src.Nth(nTotalSeg-1, finalMidSeg);
|
||
lastSeg = finalMidSeg.Offset(GetOffsetDist(nTotalSeg-1), LS_INFINITE);
|
||
if(!lastSeg)
|
||
return FALSE;
|
||
|
||
XPoint nextPt;
|
||
for(int i=0; i<nTotalSeg; i++) {
|
||
XDirectionCurve curMidSeg;
|
||
src.Nth(i, curMidSeg);
|
||
XDirectionCurve curSeg=curMidSeg.Offset(GetOffsetDist(i), LS_INFINITE);
|
||
if(!curSeg)
|
||
return FALSE;
|
||
|
||
XPoint pt1, pt2, curPt;
|
||
if(!i) { // 求当前点
|
||
if(!lastSeg) curPt=curSeg.StartPoint();
|
||
else {
|
||
int ptNum=curSeg.Intersection(lastSeg, pt1, pt2);
|
||
if(ptNum==2) curPt=XLine(pt1,pt2).NearPoint(curSeg.StartPoint());
|
||
else if(ptNum==1) curPt=pt1;
|
||
else {
|
||
return FALSE;
|
||
}
|
||
}
|
||
} else curPt=nextPt; //上次求得的下一点
|
||
|
||
int nextIndex= i>=nTotalSeg-1? 0 : i+1; // 当前段为最后时, 下一段为起始段
|
||
XDirectionCurve nextMidSeg;
|
||
src.Nth(nextIndex, nextMidSeg);
|
||
|
||
XDirectionCurve nextSeg=nextMidSeg.Offset(GetOffsetDist(nextIndex), LS_INFINITE);
|
||
if(!nextSeg)
|
||
return FALSE;
|
||
int ptNum=curSeg.Intersection(nextSeg, pt1, pt2);
|
||
if(ptNum==2) nextPt=XLine(pt1, pt2).NearPoint(curSeg.EndPoint());
|
||
else if(ptNum==1) nextPt=pt1;
|
||
else {
|
||
return FALSE;
|
||
}
|
||
|
||
lastSeg=curSeg;
|
||
if(curSeg.Is(CURVE_ARC)) {
|
||
XArc arc=curSeg.GetArc();
|
||
if(!curSeg.IsMinusArc()) { //逆时针
|
||
arc.SetStarAngle(ads_angle(arc.GetCenterPt(), curPt));
|
||
arc.SetEndAngle(ads_angle(arc.GetCenterPt(), nextPt));
|
||
curSeg.SetBulge(arc.Bulge());
|
||
}
|
||
else
|
||
{
|
||
arc.SetStarAngle(ads_angle(arc.GetCenterPt(), nextPt));
|
||
arc.SetEndAngle(ads_angle(arc.GetCenterPt(), curPt));
|
||
curSeg.SetBulge(-arc.Bulge());
|
||
}
|
||
curSeg.StartPoint()=curPt;
|
||
curSeg.EndPoint()=nextPt;
|
||
}
|
||
|
||
//添一段
|
||
dest.Append(new XPoint(curPt));
|
||
dest.AppendBugle(curSeg.GetBulge());
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
double
|
||
TDbBalcony::GetRailHeight() const
|
||
{
|
||
assertReadEnabled();
|
||
return m_nRailHeight;
|
||
}
|
||
|
||
double
|
||
TDbBalcony::GetRailWidth() const
|
||
{
|
||
assertReadEnabled();
|
||
return m_nRailWidth;
|
||
}
|
||
|
||
double
|
||
TDbBalcony::GetGirderThickness() const
|
||
{
|
||
assertReadEnabled();
|
||
return m_nGirderThickness;
|
||
}
|
||
|
||
BOOL
|
||
TDbBalcony::HasGirder() const
|
||
{
|
||
assertReadEnabled();
|
||
return (GetGirderThickness()-GetSlabThickness()>_DIST_SNAP);
|
||
}
|
||
|
||
double
|
||
TDbBalcony::GetSlabThickness() const
|
||
{
|
||
assertReadEnabled();
|
||
return m_nSlabThickness;
|
||
}
|
||
|
||
|
||
const XPoly2D &
|
||
TDbBalcony::GetOutline() const
|
||
{
|
||
assertReadEnabled();
|
||
return m_polyOutline;
|
||
}
|
||
|
||
|
||
|
||
void
|
||
TDbBalcony::SetRailHeight(double h)
|
||
{
|
||
assertWriteEnabled();
|
||
m_nRailHeight=h;
|
||
}
|
||
|
||
void
|
||
TDbBalcony::SetRailWidth(double w)
|
||
{
|
||
assertWriteEnabled();
|
||
m_nRailWidth = w;
|
||
}
|
||
|
||
void
|
||
TDbBalcony::SetOutline(const XPoly2D &poly)
|
||
{
|
||
assertWriteEnabled();
|
||
ASSERT(poly.PathArea()<0.0 && poly.GetFlag()==1);
|
||
m_polyOutline = poly;
|
||
}
|
||
|
||
void
|
||
TDbBalcony::SetRailAt(int idx, BOOL bHasRail)
|
||
{
|
||
assertWriteEnabled();
|
||
ASSERT(idx<GetEdgeNum());
|
||
int nTestBit=0x01;
|
||
nTestBit <<= idx;
|
||
if(!bHasRail)
|
||
m_nRailEdge |= nTestBit;
|
||
else
|
||
m_nRailEdge &= ~nTestBit;
|
||
}
|
||
|
||
double
|
||
TDbBalcony::GetElevation() const
|
||
{
|
||
assertReadEnabled();
|
||
double nElev=0;
|
||
if(!!m_polyOutline)
|
||
nElev=m_polyOutline[0].z;
|
||
return nElev;
|
||
}
|
||
|
||
void
|
||
TDbBalcony::SetElevation(double nElev)
|
||
{
|
||
assertWriteEnabled();
|
||
m_polyOutline.SetElevation(nElev);
|
||
}
|
||
|
||
|
||
void
|
||
TDbBalcony::SetSlabThickness(double val)
|
||
{
|
||
assertWriteEnabled();
|
||
m_nSlabThickness = val;
|
||
}
|
||
|
||
void
|
||
TDbBalcony::SetGirderThickness(double val)
|
||
{
|
||
assertWriteEnabled();
|
||
m_nGirderThickness = val;
|
||
}
|
||
BOOL TDbBalcony::GetPolyIn(XPoly2D&poly)const
|
||
{
|
||
XPoly2D polyNext(1),polyCur(1);
|
||
polyCur=m_polyOutline;
|
||
if(Offset(polyCur, polyNext))
|
||
{
|
||
poly=polyNext;
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
// From TDbPolyPathEnt
|
||
Acad::ErrorStatus
|
||
TDbBalcony::GetBindPath(XPoly2D &polyPath,AcGeVector3d &normal) const
|
||
{
|
||
assertReadEnabled();
|
||
XPoly2D poly1;
|
||
GetPathPoly(poly1,normal);
|
||
poly1.Offset(-m_nRailWidth/2, polyPath);
|
||
return Acad::eOk;
|
||
}
|
||
Acad::ErrorStatus
|
||
TDbBalcony::GetPathPoly(XPoly2D &polyPath,AcGeVector3d &normal) const
|
||
{
|
||
assertReadEnabled();
|
||
normal=AcGeVector3d::kZAxis;
|
||
polyPath=m_polyOutline;
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// sg add 100722，支持统一标高
|
||
bool TDbBalcony::UnifyElevation(double dElevation)
|
||
{
|
||
TGGePoly2D pathPoly;
|
||
pathPoly = GetOutline();
|
||
|
||
pathPoly.SetElevation(dElevation);
|
||
|
||
SetOutline(pathPoly);
|
||
return true;
|
||
}
|
||
|
||
// sg add 101119，支持导出XML
|
||
CString TDbBalcony::GetXml(const AcGeMatrix3d& mat) const
|
||
{
|
||
TXmlTree xmlTree;
|
||
POSITION posRoot = xmlTree.Insert(_T("ATS_BALCONY"), NULL, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posRoot, _T("name"), _T("阳台"));
|
||
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
||
}
|
||
|
||
CString strText;
|
||
POSITION posItem = NULL;
|
||
POSITION posItem1 = xmlTree.Insert(_T("Object_ID"), posRoot, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posItem1, _T("name"), _T("对象编号"));
|
||
xmlTree.SetAttribute(posItem1, _T("comment"), _T("当前对象的句柄"));
|
||
strText.Format(_T("%ld"), objectId());
|
||
xmlTree.SetItemText(posItem1, strText);
|
||
}
|
||
|
||
POSITION posItem2 = xmlTree.Insert(_T("Section"), posRoot, posItem1);
|
||
{
|
||
xmlTree.SetAttribute(posItem2, _T("name"), _T("截面参数"));
|
||
POSITION posItemBalHeight = xmlTree.Insert(_T("Bal_height"), posItem2, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posItemBalHeight, _T("name"), _T("栏板高"));
|
||
xmlTree.SetAttribute(posItemBalHeight, _T("comment"), _T("从阳台地面算的栏板高"));
|
||
strText.Format(_T("%f"), GetRailHeight());
|
||
xmlTree.SetItemText(posItemBalHeight, strText);
|
||
}
|
||
|
||
POSITION posItemBalWidth = xmlTree.Insert(_T("Bal_width"), posItem2, posItemBalHeight);
|
||
{
|
||
xmlTree.SetAttribute(posItemBalWidth, _T("name"), _T("栏板宽"));
|
||
xmlTree.SetAttribute(posItemBalWidth, _T("comment"), _T("从阳台外边算的栏板宽"));
|
||
strText.Format(_T("%f"), GetRailWidth());
|
||
xmlTree.SetItemText(posItemBalWidth, strText);
|
||
}
|
||
|
||
POSITION posItemFlrHeight = xmlTree.Insert(_T("Flr_height"), posItem2, posItemBalWidth);
|
||
{
|
||
xmlTree.SetAttribute(posItemFlrHeight, _T("name"), _T("地面标高"));
|
||
xmlTree.SetAttribute(posItemFlrHeight, _T("comment"), _T("阳台地面与楼面的相对标高"));
|
||
strText.Format(_T("%f"), GetElevation());
|
||
xmlTree.SetItemText(posItemFlrHeight, strText);
|
||
}
|
||
|
||
POSITION posItemFlrThick = xmlTree.Insert(_T("Flr_thick"), posItem2, posItemFlrHeight);
|
||
{
|
||
xmlTree.SetAttribute(posItemFlrThick, _T("name"), _T("阳台板厚"));
|
||
xmlTree.SetAttribute(posItemFlrThick, _T("comment"), _T("阳台板厚"));
|
||
strText.Format(_T("%f"), GetSlabThickness());
|
||
xmlTree.SetItemText(posItemFlrThick, strText);
|
||
}
|
||
|
||
POSITION posItemBmHeight = xmlTree.Insert(_T("Bm_height"), posItem2, posItemFlrThick);
|
||
{
|
||
xmlTree.SetAttribute(posItemBmHeight, _T("name"), _T("阳台梁高"));
|
||
xmlTree.SetAttribute(posItemBmHeight, _T("comment"), _T("阳台梁高"));
|
||
strText.Format(_T("%f"), GetGirderThickness());
|
||
xmlTree.SetItemText(posItemBmHeight, strText);
|
||
}
|
||
}
|
||
|
||
POSITION posItem3 = xmlTree.Insert(_T("Baseline"), posRoot, posItem2);
|
||
{
|
||
xmlTree.SetAttribute(posItem3, _T("name"), _T("截面参数"));
|
||
posItem = NULL;
|
||
TADSGePoint3d ptNode;
|
||
int iLen = m_polyOutline.Length();
|
||
for (int i = 0; i < iLen; i++)
|
||
{
|
||
ptNode = m_polyOutline[i];
|
||
// sg add 120117，对点进行坐标变换
|
||
ptNode.TransformBy(mat);
|
||
|
||
strText.Format(_T("Point_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItem3, posItem);
|
||
{
|
||
strText.Format(_T("第%d点"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%f,%f,%f"), ptNode.x, ptNode.y, ptNode.z);
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
|
||
strText.Format(_T("Ang_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItem3, posItem);
|
||
{
|
||
strText.Format(_T("圆心角%d"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%f"), m_polyOutline.GetBulge(i));
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
|
||
int nSign = -1;
|
||
if (HasRailAt(i))
|
||
nSign = 1;
|
||
else
|
||
nSign = 0;
|
||
strText.Format(_T("Show_%d"), i + 1);
|
||
posItem = xmlTree.Insert(strText, posItem3, posItem);
|
||
{
|
||
strText.Format(_T("点%d是否显示"), i + 1);
|
||
xmlTree.SetAttribute(posItem, _T("name"), strText);
|
||
strText.Format(_T("%d"), nSign);
|
||
xmlTree.SetItemText(posItem, strText);
|
||
}
|
||
}
|
||
}
|
||
|
||
POSITION posItem4 = xmlTree.Insert(_T("Ground_Layer"), posRoot, posItem3);
|
||
{
|
||
xmlTree.SetAttribute(posItem4, _T("name"), _T("地板图层"));
|
||
//xmlTree.SetAttribute(posItem4, _T("comment"), _T("当前对象的句柄"));
|
||
AcDbObjectId idGroundLayer = GetLayerGround3d();
|
||
AcDbLayerTableRecord * pLayer = NULL;
|
||
acdbOpenObject(pLayer, idGroundLayer, AcDb::kForRead);
|
||
if (pLayer != NULL)
|
||
{
|
||
TCHAR *pLayerName = NULL;
|
||
pLayer->getName(pLayerName);
|
||
strText = pLayerName;
|
||
pLayer->close();
|
||
}
|
||
xmlTree.SetItemText(posItem4, strText);
|
||
}
|
||
|
||
CString strBase = TEntityBase::GetXml(mat);
|
||
CString strXml = xmlTree.GetXml();
|
||
int nIndex = strXml.Find(_T("<Object_ID"));
|
||
if (nIndex != -1)
|
||
{
|
||
strXml.Insert(nIndex, strBase);
|
||
}
|
||
|
||
return strXml;
|
||
}
|
||
|
||
// Acad::ErrorStatus
|
||
//TDbBalcony::GetPathPoly(XPoly2D &polyPath,AcGeVector3d &normal) const
|
||
//{
|
||
// assertReadEnabled();
|
||
// normal=AcGeVector3d::kZAxis;
|
||
//
|
||
// polyPath.Reset();
|
||
// polyPath.flag=0;
|
||
// int nEdgeNum=GetEdgeNum();
|
||
// ASSERT(nEdgeNum);
|
||
// for(int n=0; n<nEdgeNum; n++) {
|
||
// if(HasRailAt(n)) {
|
||
// XDirectionCurve cv;
|
||
// m_polyOutline.Nth(n, cv);
|
||
// polyPath.AppendNode(cv.StartPoint(), cv.bulge);
|
||
// } else if(polyPath.Length()) {
|
||
// polyPath.AppendNode(m_polyOutline[n]);
|
||
// break;
|
||
// }
|
||
// }
|
||
// // 0~n段都已经完成
|
||
//
|
||
// if(n==nEdgeNum)
|
||
// polyPath.AppendNode(m_polyOutline[0]);
|
||
// else if(HasRailAt(0) && n<nEdgeNum-1) {
|
||
// for(int i=-1; i>n-nEdgeNum; i--) {
|
||
// if(HasRailAt(DePeriod(nEdgeNum, i))) {
|
||
// XDirectionCurve cv;
|
||
// m_polyOutline.Nth(n, cv);
|
||
// polyPath[0];
|
||
// polyPath.bulges[0];
|
||
// polyPath.Insert(new XPoint(cv.StartPoint()));
|
||
// polyPath.bulges.Insert(new double(cv.bulge));
|
||
// } else {
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// return Acad::eOk;
|
||
//}
|
||
|
||
void InitDbBalcony(BOOL bTrue)
|
||
{
|
||
AecObjectEditMethod pOldEdit=NULL;
|
||
if(bTrue) {
|
||
TDbBalcony::rxInit();
|
||
acrxBuildClassHierarchy();
|
||
TDbBalcony::InitMatchProtocol(TRUE);
|
||
pOldEdit=TDbBalcony::SetEditMethod(EditBalcony0);
|
||
} else {
|
||
TDbBalcony::InitMatchProtocol(FALSE);
|
||
TDbBalcony::SetEditMethod(pOldEdit);
|
||
deleteAcRxClass(TDbBalcony::desc());
|
||
}
|
||
}
|
||
|
||
// Command:编辑阳台
|
||
int EditBalcony0(AcDbObjectId id)
|
||
{
|
||
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbBalcony, pStep);
|
||
if(!pStep)
|
||
return RTERROR;
|
||
while(1) {
|
||
const TCHAR *szPrompt1=_T("\n选择 [拦板宽(W)/拦板高(H)/阳台地高(T)/梁高(G)/地板厚(S)/参数列表(L)]<退出>:");
|
||
XString sKeyword;
|
||
int nRet=0;
|
||
INITGET_BEG(0, _T("W H T G S L"));
|
||
nRet=ads_getkword(szPrompt1, sKeyword);
|
||
INITGET_END();
|
||
|
||
if(nRet!=RTNORM)
|
||
break;
|
||
if(sKeyword[0]==_T('W')) {
|
||
double nRailWidth=pStep->GetRailWidth();
|
||
nRet=GetReal(_T("\n拦板宽"), nRailWidth);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->SetRailWidth(nRailWidth);
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(sKeyword[0]==_T('H')) {
|
||
double nRailHeight=pStep->GetRailHeight();
|
||
nRet=GetReal(_T("\n拦板高"), nRailHeight);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->SetRailHeight(nRailHeight);
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(sKeyword[0]==_T('T')) {
|
||
double nElev=fabs(pStep->GetElevation());
|
||
nRet=GetReal(_T("\n地面高差"), nElev, RSG_NONEG);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->SetElevation(-nElev);
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(sKeyword[0]==_T('L')) {
|
||
pStep->list();
|
||
} else if(sKeyword[0]==_T('G')) {
|
||
double nVal=pStep->GetGirderThickness();
|
||
nRet=GetReal(_T("\n梁高"), nVal);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->SetGirderThickness(nVal);
|
||
pStep->downgradeOpen();
|
||
}
|
||
} else if(sKeyword[0]==_T('S')) {
|
||
double nVal=pStep->GetSlabThickness();
|
||
nRet=GetReal(_T("\n阳台板厚"), nVal);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->assertWriteEnabled();
|
||
pStep->SetSlabThickness(nVal);
|
||
pStep->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
//add by xlc on 110218 阳台遮挡保温
|
||
bool TDbBalcony::IsBalconyClipInsu() const
|
||
{
|
||
return (m_nFlag & BF_BALCONYCLIPINSU) != 0;
|
||
}
|
||
|
||
void TDbBalcony::SetBalconyClipInsu(BOOL bTrue)
|
||
{
|
||
assertWriteEnabled();
|
||
if(bTrue)
|
||
{
|
||
m_nFlag |= BF_BALCONYCLIPINSU;
|
||
}
|
||
else
|
||
{
|
||
m_nFlag &= ~BF_BALCONYCLIPINSU;
|
||
}
|
||
}
|
||
|
||
AcDbEntity* TDbBalcony::CreateWipeOut() const
|
||
{
|
||
//modify by xlc on 110519 调整阳台遮挡保温算法
|
||
return NULL;
|
||
|
||
bool bBalconyClipInsu = false;
|
||
if(IsBalconyClipInsu())
|
||
{
|
||
for (long i = 0; i < m_lstClipId.Length(); i++)
|
||
{
|
||
const AcDbObjectId &id = m_lstClipId[i];
|
||
if (id.isNull() || !id.isValid())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt);
|
||
if (pEnt->isKindOf(TDbWall::desc()))
|
||
{
|
||
int nWallFlag = ((TDbWall*)pEnt)->GetWallFlag();
|
||
if ((nWallFlag & WF_LEFT_INSULATE) || (nWallFlag & WF_RIGHT_INSULATE))
|
||
{
|
||
bBalconyClipInsu = true;
|
||
break;
|
||
}
|
||
}
|
||
else if (pEnt->isKindOf(TDbColumn::desc()))
|
||
{
|
||
bool bHasInsl = ((TDbColumn*)pEnt)->IsInsulateOnColumn();
|
||
double dInsThk = ((TDbColumn*)pEnt)->GetInsulateThick();
|
||
if (bHasInsl && dInsThk >= 1.e-3) //这里精度与柱子绘制精度保持一致
|
||
{
|
||
bBalconyClipInsu = true;
|
||
break;
|
||
}
|
||
}
|
||
else if(pEnt->isKindOf(TDbWallPatch::desc()))
|
||
{
|
||
BOOL bHasInsl = ((TDbWallPatch*)pEnt)->HasInsulate();
|
||
double dInsThk = ((TDbWallPatch*)pEnt)->GetInsulateThick();
|
||
if (bHasInsl && dInsThk >= 1.E-5) //这里精度与墙体造型绘制精度保持一致
|
||
{
|
||
bBalconyClipInsu = true;
|
||
break;
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
if(bBalconyClipInsu)
|
||
{
|
||
AcDbObjectId idImage=InitWipeout();
|
||
OPENOBJ_BEGIN(idImage, AcDb::kForRead, AcDbEntity, pImage);
|
||
if(pImage)
|
||
{
|
||
return (AcDbEntity *)pImage->clone();
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
AcDbObjectId TDbBalcony::InitWipeout() const
|
||
{
|
||
#if (ADS<16)
|
||
if(!AT_loaded(_T("wipeout"))) {
|
||
int nRet=acrxLoadModule(_T("wipeout.arx"), Adesk::kFalse, true);
|
||
if(!nRet) {
|
||
adsout << _T("\n请事先安装AutoCAD快捷工具!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
//LH 2013-2-27 修改原因当ADS=19时不执行下面代码
|
||
//#else if (ADS<19)
|
||
#endif
|
||
#if (16<ADS && ADS<19)
|
||
if(!AT_loaded(_T("AcWipeout"))) {
|
||
int nRet=acrxLoadModule(_T("AcWipeout.arx"), Adesk::kFalse, true);
|
||
if(!nRet) {
|
||
adsout << _T("\n无法加载AcWipeout.arx!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
#endif
|
||
//LH 2013-2-28 由于AutoCAD2013版本后去除了AcWipeout.arx文件，所以2013版本需要判断是否加载了acismobj19.dbx
|
||
#if (ADS==19)
|
||
if(!AT_loaded(_T("acismobj19")))
|
||
{
|
||
int nRet=acrxLoadModule(_T("acismobj19.dbx"), Adesk::kFalse, true);
|
||
if(!nRet) {
|
||
adsout << _T("\n无法加载acismobj19.dbx!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
#endif
|
||
#if (ADS==20)
|
||
if(!AT_loaded(_T("acismobj20")))
|
||
{
|
||
int nRet=acrxLoadModule(_T("acismobj20.dbx"), Adesk::kFalse, true);
|
||
if(!nRet) {
|
||
adsout << _T("\n无法加载acismobj20.dbx!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
#endif
|
||
AcRxClass* pClass = AcRxClass::cast(acrxClassDictionary->at(_T("AcDbWipeout")));
|
||
if (pClass == NULL)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL bFirstNew=FALSE;
|
||
AcDbObjectId idEnt=GetTempEntityId(pClass, _T("_$TMP_BLOCK"), &bFirstNew);
|
||
OPENOBJ_BEGIN(idEnt, AcDb::kForWrite, AcDbRasterImage, pAcDbRasterImage);
|
||
if(pAcDbRasterImage)
|
||
{
|
||
if(bFirstNew)
|
||
{
|
||
pAcDbRasterImage->setDatabaseDefaults();
|
||
}
|
||
SetupImageInfo(pAcDbRasterImage);
|
||
}
|
||
OPENOBJ_END();
|
||
return idEnt;
|
||
}
|
||
|
||
void TDbBalcony::SetupImageInfo(AcDbRasterImage *pAcDbRasterImage) const
|
||
{
|
||
XPoly2D polyCur(1);
|
||
polyCur=m_polyOutline;
|
||
polyCur.SetElevation(0.0);
|
||
|
||
XPoly2D polyNext(1);
|
||
if(!Offset(polyCur, polyNext))
|
||
{
|
||
return;
|
||
}
|
||
|
||
int nEdge=GetEdgeNum();
|
||
TGGePoly2D poly(1);
|
||
TDPtrList<TGGeCurveSegment> lstCurves;
|
||
bool bFirst = true;
|
||
TGGePoly2D poly1,poly2;
|
||
double dLength = _AS_SYS_UNIT(10);
|
||
for(int i=0; i<nEdge; i++)
|
||
{
|
||
if(!HasRailAt(i))
|
||
continue;
|
||
XCurveSegment seg1, seg2;
|
||
polyCur.Nth(i, seg1);
|
||
polyNext.Nth(i, seg2);
|
||
|
||
//modify by xlc on 110314 优化阳台遮挡保温算法
|
||
//lstCurves.Append(new TGGeCurveSegment(seg1));
|
||
//lstCurves.Append(new TGGeCurveSegment(seg2));
|
||
//XPoint ptE =seg1.EndPoint();
|
||
//if (bFirst)
|
||
//{
|
||
// TADSGePointDir2d ptDir;
|
||
// seg1.Polar(dLength, ptDir);
|
||
// poly.InsertNodeAt(0, ptDir);
|
||
//}
|
||
//poly.InsertNodeAt(0, ptE);
|
||
|
||
//ptE =seg2.EndPoint();
|
||
//if (bFirst)
|
||
//{
|
||
// TADSGePointDir2d ptDir;
|
||
// seg2.Polar(dLength, ptDir);
|
||
// poly.AppendNode(ptDir);
|
||
//}
|
||
//else
|
||
//{
|
||
// bFirst = false;
|
||
//}
|
||
//poly.AppendNode(ptE);
|
||
if (bFirst)
|
||
{
|
||
poly1.AppendNode(*polyCur[i],polyCur.GetBulge(i));
|
||
}
|
||
poly1.AppendNode(*polyCur[i+1],polyCur.GetBulge(i+1));
|
||
|
||
if (bFirst)
|
||
{
|
||
poly2.AppendNode(*polyNext[i],polyNext.GetBulge(i));
|
||
bFirst = false;
|
||
}
|
||
poly2.AppendNode(*polyNext[i+1],polyNext.GetBulge(i+1));
|
||
}
|
||
|
||
TDPtrList<TGGePoly2D> lstTemp;
|
||
for (i = 0; i < m_lstClipId.Length(); i++)
|
||
{
|
||
const AcDbObjectId &id = m_lstClipId[i];
|
||
if (id.isNull() || !id.isValid())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
AcDbEntity *pEnt = NULL;
|
||
acdbOpenObject(pEnt,id,AcDb::kForRead);
|
||
|
||
if (pEnt != NULL)
|
||
{
|
||
bool bAddPoly = false;
|
||
double dThick = 0;
|
||
TGGePoly2D polyOut;
|
||
if (pEnt->isKindOf(TDbWall::desc()))
|
||
{
|
||
bAddPoly = true;
|
||
((TDbWall*)pEnt)->GetOutlinePoly(0, polyOut);
|
||
|
||
int nWallFlag = ((TDbWall*)pEnt)->GetWallFlag();
|
||
if ((nWallFlag & WF_LEFT_INSULATE) || (nWallFlag & WF_RIGHT_INSULATE))
|
||
{
|
||
double dThick0 = ((TDbWall*)pEnt)->GetInsulateThick(0);
|
||
double dThick1 = ((TDbWall*)pEnt)->GetInsulateThick(1);
|
||
dThick = dThick0;
|
||
if (dThick > dThick1)
|
||
{
|
||
dThick = dThick1;
|
||
}
|
||
}
|
||
}
|
||
else if (pEnt->isKindOf(TDbColumn::desc()))
|
||
{
|
||
bAddPoly = true;
|
||
polyOut=((TDbColumn*)pEnt)->GetOutlinePoly();
|
||
|
||
bool bHasInsl = ((TDbColumn*)pEnt)->IsInsulateOnColumn();
|
||
double dInsThk = ((TDbColumn*)pEnt)->GetInsulateThick();
|
||
if (bHasInsl && dInsThk >= 1.e-3) //这里精度与柱子绘制精度保持一致
|
||
{
|
||
dThick = dInsThk;
|
||
}
|
||
|
||
}
|
||
else if(pEnt->isKindOf(TDbWallPatch::desc()))
|
||
{
|
||
bAddPoly = true;
|
||
((TDbWallPatch*)pEnt)->GetOutlinePoly(polyOut, false);
|
||
BOOL bHasInsl = ((TDbWallPatch*)pEnt)->HasInsulate();
|
||
double dInsThk = ((TDbWallPatch*)pEnt)->GetInsulateThick();
|
||
if (bHasInsl && dInsThk >= 1.E-5) //这里精度与墙体造型绘制精度保持一致
|
||
{
|
||
dThick = dInsThk;
|
||
}
|
||
}
|
||
|
||
if (bAddPoly)
|
||
{
|
||
if (dThick > dLength)
|
||
{
|
||
dThick = dLength;
|
||
}
|
||
else
|
||
{
|
||
dThick *= 0.5;
|
||
}
|
||
|
||
GetOffsetPoly2D(polyOut,polyOut,dThick);
|
||
lstTemp.Append(new TGGePoly2D(polyOut));
|
||
}
|
||
pEnt->close();
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < poly1.Length(); i++)
|
||
{
|
||
poly.AppendNode(*poly1[i],poly1.GetBulge(i));
|
||
}
|
||
poly2.Reverse();
|
||
for (i = 0; i < poly2.Length(); i++)
|
||
{
|
||
poly.AppendNode(*poly2[i],poly2.GetBulge(i));
|
||
}
|
||
poly.Compress();
|
||
|
||
TDPtrList<TGGePoly2D> lstBal,lstRes;
|
||
lstBal.Append(new TGGePoly2D(poly));
|
||
Subtract(lstBal, lstTemp, lstRes);
|
||
|
||
if (lstRes.Length()>0)
|
||
{
|
||
poly = *lstRes[0];
|
||
}
|
||
else
|
||
{
|
||
poly.Reset();
|
||
}
|
||
|
||
if(poly.Length() > 3)
|
||
{
|
||
//if (lstCurves.Length() >= 2)
|
||
{
|
||
//modify by xlc on 110314 优化阳台遮挡保温算法
|
||
//TGGeCurveSegment &cvSeg = *lstCurves[lstCurves.Length()-2];
|
||
//TADSGePointDir2d ptDir;
|
||
//cvSeg.Polar(cvSeg.GetLength()-dLength, ptDir, 1);
|
||
//poly.RemoveNode(0);
|
||
//poly.InsertNodeAt(0, ptDir);
|
||
|
||
//TGGeCurveSegment &cvSeg1 = *lstCurves[lstCurves.Length()-1];
|
||
//cvSeg1.Polar(cvSeg1.GetLength()-dLength, ptDir, 1);
|
||
//poly.RemoveNode(poly.Length()-1);
|
||
//poly.AppendNode(ptDir);
|
||
|
||
pAcDbRasterImage->setClipBoundaryToWholeImage();
|
||
|
||
AcGeMatrix3d matPixelToModel, matModelToPixel;
|
||
pAcDbRasterImage->getPixelToModelTransform(matPixelToModel);
|
||
matModelToPixel = matPixelToModel.invert();
|
||
|
||
AcGePoint2dArray ptArray;
|
||
AcGePoint3d pt;
|
||
for(i = 0; i < poly.Length(); i++)
|
||
{
|
||
pt = poly[i]->AsAcGePoint3d();
|
||
pt = pt.transformBy(matModelToPixel);
|
||
ptArray.append(AcGePoint2d(pt.x,pt.y));
|
||
}
|
||
pt = poly[0]->AsAcGePoint3d();
|
||
pt = pt.transformBy(matModelToPixel);
|
||
ptArray.append(AcGePoint2d(pt.x,pt.y));
|
||
|
||
pAcDbRasterImage->setClipBoundary( AcDbRasterImage::kPoly, ptArray);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
bool TDbBalcony::OnExplodeOrDraw(TGGiDrawStreamBase& dc)const
|
||
{
|
||
for (long i = 0; i < m_lstClipId.Length(); i++)
|
||
{
|
||
const AcDbObjectId &id = m_lstClipId[i];
|
||
if (id.isNull() || !id.isValid())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
AcDbEntity *pEnt = NULL;
|
||
acdbOpenObject(pEnt,id,AcDb::kForRead);
|
||
|
||
if (pEnt != NULL)
|
||
{
|
||
TEntityBase* pEntBase = TEntityBase::Cast(pEnt);
|
||
if (pEntBase != NULL)
|
||
{
|
||
TGGePoly2D poly;
|
||
|
||
bool bBalconyClipInsu = false;
|
||
if (IsBalconyClipInsu())
|
||
{
|
||
if (pEnt->isKindOf(TDbWall::desc()))
|
||
{
|
||
int nWallFlag = ((TDbWall*)pEnt)->GetWallFlag();
|
||
if ((nWallFlag & WF_LEFT_INSULATE) || (nWallFlag & WF_RIGHT_INSULATE))
|
||
{
|
||
bBalconyClipInsu = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (bBalconyClipInsu)
|
||
{
|
||
((TDbWall*)pEnt)->GetOutlinePoly(0, poly);
|
||
poly.SetElevation(0);
|
||
dc.PushClip(poly,TGGiClipBoundary::kClipIn);
|
||
}
|
||
else if (pEntBase->GetClipBoundary(poly) == Acad::eOk)
|
||
{
|
||
poly.SetElevation(0);
|
||
|
||
if (pEnt->isKindOf(TDbSymbCut::desc()))
|
||
{
|
||
TDbSymbCut* pCut = TDbSymbCut::cast(pEnt);
|
||
dc.PushClip(poly,pCut->GetClipType());
|
||
}
|
||
|
||
else if (pEnt->isKindOf(TDbColumn::desc()))
|
||
{
|
||
bool bHasInsl = ((TDbColumn*)pEnt)->IsInsulateOnColumn();
|
||
double dInsThk = ((TDbColumn*)pEnt)->GetInsulateThick();
|
||
if (!IsBalconyClipInsu() && bHasInsl && dInsThk >= 1.e-3) //这里精度与柱子绘制精度保持一致
|
||
{
|
||
poly = ((TDbColumn*)pEnt)->GetOutlinePoly();
|
||
GetOffsetPoly2D(poly, poly, dInsThk);
|
||
|
||
}
|
||
poly.SetElevation(0);
|
||
dc.PushClip(poly,TGGiClipBoundary::kClipIn);
|
||
}
|
||
else if(pEnt->isKindOf(TDbWallPatch::desc()))
|
||
{
|
||
BOOL bHasInsl = ((TDbWallPatch*)pEnt)->HasInsulate();
|
||
double dInsThk = ((TDbWallPatch*)pEnt)->GetInsulateThick();
|
||
if (!IsBalconyClipInsu() && bHasInsl && dInsThk >= 1.E-5) //这里精度与墙体造型绘制精度保持一致
|
||
{
|
||
((TDbWallPatch*)pEnt)->GetOutlinePoly(poly, TRUE);
|
||
}
|
||
|
||
poly.SetElevation(0);
|
||
dc.PushClip(poly,TGGiClipBoundary::kClipIn);
|
||
}
|
||
|
||
else
|
||
{
|
||
dc.PushClip(poly,TGGiClipBoundary::kClipIn);
|
||
}
|
||
}
|
||
}
|
||
|
||
pEnt->close();
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
// sg add 110614，设置与阳台相关联的墙体、造型、柱子对象更新
|
||
void TDbBalcony::UpdateClipEntity() const
|
||
{
|
||
int nLength = (int)m_lstClipId.Length();
|
||
for (long i = 0; i < nLength; i++)
|
||
{
|
||
const AcDbObjectId &id = m_lstClipId[i];
|
||
if (id.isNull() || !id.isValid())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt);
|
||
if (pEnt != NULL)
|
||
{
|
||
pEnt->recordGraphicsModified();
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|