3230 lines
98 KiB
C++
3230 lines
98 KiB
C++
#include "stdafx.h"
|
|
#include "dbmatch.h"
|
|
|
|
|
|
|
|
|
|
const Adesk::UInt8 TDbOpeningSlot::g_nVersion = 2;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSOpeningSlot, ATSEntity, AcDb::kDHL_CURRENT,
|
|
AcDb::kMReleaseCurrent, 1, ATS_OPENINGSLOT, "ATS_OPENINGSLOT图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
IMPLEMENT_TENTBASE(TDbOpeningSlot);
|
|
|
|
|
|
TDbOpeningSlot::TDbOpeningSlot()
|
|
{
|
|
m_bHasSlot = FALSE;
|
|
m_enumBoardKind = BS_NONE;
|
|
m_enumSlotSide = SIDE_NONE;
|
|
m_enumSlotKind = SLOT_STANDARD;
|
|
|
|
m_dSlotA = 0;
|
|
m_dSlotT = 0;
|
|
m_dInsideSlotW = 0;
|
|
m_dOutsideSlotW = 0;
|
|
m_dSlotBoardWid = 0;
|
|
|
|
m_dBoardA = 0;
|
|
m_dBoardH = 0;
|
|
m_dBoardW = 0;
|
|
m_dSillA = 0;
|
|
m_dSillH = 0;
|
|
m_dSillW = 0;
|
|
m_nBSSideFlag = 0;
|
|
|
|
m_nCMFlag = 0;
|
|
}
|
|
|
|
TDbOpeningSlot::~TDbOpeningSlot()
|
|
{
|
|
}
|
|
|
|
|
|
//**************************************************
|
|
// GetMethos //
|
|
//**************************************************
|
|
|
|
BOOL TDbOpeningSlot::HasSlot() const
|
|
{
|
|
BOOL bRet = m_bHasSlot &&
|
|
m_enumSlotSide != SIDE_NONE &&
|
|
m_polyShape.Length() > 2;
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
TDbOpeningSlot::SlotKind
|
|
TDbOpeningSlot::GetSlotKind() const
|
|
{
|
|
return m_enumSlotKind;
|
|
}
|
|
|
|
TDbOpeningSlot::SlotSide
|
|
TDbOpeningSlot::GetSlotSide() const
|
|
{
|
|
return m_enumSlotSide;
|
|
}
|
|
|
|
TDbOpeningSlot::BoardKind
|
|
TDbOpeningSlot::GetBoardKind() const
|
|
{
|
|
BOOL bBoard = ((m_nBSSideFlag&SIDE_NOBI)==0) ||
|
|
((m_nBSSideFlag&SIDE_NOBO)==0);
|
|
BOOL bSill = ((m_nBSSideFlag&SIDE_NOSI)==0) ||
|
|
((m_nBSSideFlag&SIDE_NOSO)==0);
|
|
|
|
if (m_enumBoardKind == BS_NONE || (!bBoard && !bSill))
|
|
return BS_NONE;
|
|
if (m_enumBoardKind == BS_BOARD && !bBoard)
|
|
return BS_NONE;
|
|
if (m_enumBoardKind == BS_SILL && !bSill)
|
|
return BS_NONE;
|
|
if (m_enumBoardKind == BS_BOTH && (!bSill && bBoard))
|
|
return BS_BOARD;
|
|
if (m_enumBoardKind == BS_BOTH && (bSill && !bBoard))
|
|
return BS_SILL;
|
|
if (m_enumBoardKind == BS_BOTH && (!bSill && !bBoard))
|
|
return BS_NONE;
|
|
return m_enumBoardKind;
|
|
}
|
|
|
|
AcDbObjectId TDbOpeningSlot::GetOpeningId() const
|
|
{
|
|
return m_idOpening;
|
|
}
|
|
|
|
const XPoly2D & TDbOpeningSlot::GetShapePoly() const
|
|
{
|
|
return m_polyShape;
|
|
}
|
|
|
|
void TDbOpeningSlot::GetBoardSide(BOOL &bInside, BOOL &bOutside) const
|
|
{
|
|
bInside = (m_nBSSideFlag&SIDE_NOBI) == 0;
|
|
bOutside = (m_nBSSideFlag&SIDE_NOBO) == 0;
|
|
}
|
|
|
|
void TDbOpeningSlot::GetSillSide(BOOL &bInside, BOOL &bOutside) const
|
|
{
|
|
bInside = (m_nBSSideFlag&SIDE_NOSI) == 0;
|
|
bOutside = (m_nBSSideFlag&SIDE_NOSO) == 0;
|
|
}
|
|
|
|
void TDbOpeningSlot::GetSlotAT(ads_real& dSlotA,ads_real& dSlotT) const
|
|
{
|
|
dSlotA = m_dSlotA;
|
|
dSlotT = m_dSlotT;
|
|
}
|
|
|
|
ads_real TDbOpeningSlot::GetSlotBoardWid() const
|
|
{
|
|
return m_dSlotBoardWid;
|
|
}
|
|
|
|
ads_real TDbOpeningSlot::GetInsideSlotW() const
|
|
{
|
|
return m_dInsideSlotW;
|
|
}
|
|
|
|
ads_real TDbOpeningSlot::GetOutsideSlotW() const
|
|
{
|
|
return m_dOutsideSlotW;
|
|
}
|
|
|
|
void TDbOpeningSlot::
|
|
GetBoardSize(ads_real& dBoardA,ads_real& dBoardH,ads_real& dBoardW) const
|
|
{
|
|
dBoardA = m_dBoardA;
|
|
dBoardH = m_dBoardH;
|
|
dBoardW = m_dBoardW;
|
|
}
|
|
|
|
void TDbOpeningSlot::
|
|
GetSillSize(ads_real& dSillA,ads_real& dSillH,ads_real& dSillW) const
|
|
{
|
|
dSillA = m_dSillA;
|
|
dSillH = m_dSillH;
|
|
dSillW = m_dSillW;
|
|
}
|
|
|
|
//檐板截面(平面)
|
|
XPoly2D TDbOpeningSlot::GetBoardShape() const
|
|
{
|
|
XPoly2D polyShape(1);
|
|
polyShape.AppendNode(XPoint(0,0,0));
|
|
polyShape.AppendNode(XPoint(m_dBoardH,0,0));
|
|
polyShape.AppendNode(XPoint(m_dBoardH,m_dBoardW,0));
|
|
polyShape.AppendNode(XPoint(0,m_dBoardW,0));
|
|
return polyShape;
|
|
}
|
|
|
|
//窗台截面(平面)
|
|
XPoly2D TDbOpeningSlot::GetSillShape() const
|
|
{
|
|
XPoly2D polyShape(1);
|
|
polyShape.AppendNode(XPoint(0,0,0));
|
|
polyShape.AppendNode(XPoint(m_dSillH,0,0));
|
|
polyShape.AppendNode(XPoint(m_dSillH,m_dSillW,0));
|
|
polyShape.AppendNode(XPoint(0,m_dSillW,0));
|
|
return polyShape;
|
|
}
|
|
|
|
//门窗的两侧截面
|
|
XPoly2D TDbOpeningSlot::GetSlotTShape() const
|
|
{
|
|
XPoly2D polyShapeT(1);
|
|
if (m_dSlotT > 0) {
|
|
OPENOBJ_BEGIN(m_idOpening, AcDb::kForRead, TDbOpening, pOpening);
|
|
if(pOpening != NULL) {
|
|
AcDbObjectId idWall=pOpening->GetWallId();
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall != NULL) {
|
|
double dThickness = pOpening->GetThickness()/2;
|
|
double dWallThickness = pWall->GetWidth(4)/2;
|
|
TOpeningData::OpeningKind enumOpeningKind = pOpening->GetKind();
|
|
XPoly2D polyOpening(1);
|
|
pOpening->GetOutlinePoly(0,polyOpening);
|
|
//中间有门窗
|
|
if (enumOpeningKind == TOpeningData::OP_DOORWIN||
|
|
enumOpeningKind == TOpeningData::OP_DOOR ||
|
|
enumOpeningKind == TOpeningData::OP_WINDOW ||
|
|
enumOpeningKind == TOpeningData::OP_TWODOOR) {
|
|
double dThickness1 = dWallThickness-dThickness;
|
|
polyShapeT.AppendNode(XPoint(0,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,dThickness1,0));
|
|
polyShapeT.AppendNode(XPoint(0,dThickness1,0));
|
|
}
|
|
//中间没有门窗
|
|
else if (enumOpeningKind == TOpeningData::OP_PROWIN ||
|
|
(enumOpeningKind==TOpeningData::OP_HOLE && polyOpening.Length()==4)) {
|
|
polyShapeT.AppendNode(XPoint(0,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,dWallThickness,0));
|
|
polyShapeT.AppendNode(XPoint(0,dWallThickness,0));
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
return polyShapeT;
|
|
}
|
|
|
|
|
|
//**************************************************
|
|
// SetMethos //
|
|
//**************************************************
|
|
void TDbOpeningSlot::SetHasSlot(BOOL bHas)
|
|
{
|
|
assertWriteEnabled();
|
|
m_bHasSlot = bHas;
|
|
}
|
|
|
|
void TDbOpeningSlot::SetOpeningId(const AcDbObjectId idOpening)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idOpening = idOpening;
|
|
}
|
|
|
|
|
|
void TDbOpeningSlot::SetShapePoly(const XPoly2D &polyShape)
|
|
{
|
|
assertWriteEnabled();
|
|
m_polyShape.Reset();
|
|
m_polyShape = polyShape;
|
|
m_polyShape.SetElevation(0);
|
|
}
|
|
|
|
void TDbOpeningSlot::SetInsideSlotW(const ads_real dInsideSlotW)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dInsideSlotW = dInsideSlotW;
|
|
}
|
|
|
|
void TDbOpeningSlot::SetOutsideSlotW(const ads_real dOutsideSlotW)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dOutsideSlotW = dOutsideSlotW;
|
|
}
|
|
|
|
void TDbOpeningSlot::
|
|
SetSlotAT(const ads_real dSlotA,const ads_real dSlotT)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dSlotA = dSlotA;
|
|
m_dSlotT = dSlotT;
|
|
}
|
|
|
|
void TDbOpeningSlot::SetSlotBoardWid(const ads_real dWidth)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dSlotBoardWid = dWidth;
|
|
}
|
|
|
|
void TDbOpeningSlot::
|
|
SetBoardSize(const ads_real dBoardA,const ads_real dBoardH,const ads_real dBoardW)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dBoardA = dBoardA;
|
|
m_dBoardH = dBoardH;
|
|
m_dBoardW = dBoardW;
|
|
}
|
|
|
|
void TDbOpeningSlot::
|
|
SetSillSize(const ads_real dSillA,const ads_real dSillH,const ads_real dSillW)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dSillA = dSillA;
|
|
m_dSillH = dSillH;
|
|
m_dSillW = dSillW;
|
|
}
|
|
|
|
|
|
void TDbOpeningSlot::SetBoardSide(BOOL bInside, BOOL bOutside)
|
|
{
|
|
assertWriteEnabled();
|
|
if (!bInside)
|
|
m_nBSSideFlag |= SIDE_NOBI;
|
|
else
|
|
m_nBSSideFlag &= ~SIDE_NOBI;
|
|
|
|
if (!bOutside)
|
|
m_nBSSideFlag |= SIDE_NOBO;
|
|
else
|
|
m_nBSSideFlag &= ~SIDE_NOBO;
|
|
}
|
|
|
|
void TDbOpeningSlot::SetSillSide( BOOL bInside, BOOL bOutside)
|
|
{
|
|
assertWriteEnabled();
|
|
if (!bInside)
|
|
m_nBSSideFlag |= SIDE_NOSI;
|
|
else
|
|
m_nBSSideFlag &= ~SIDE_NOSI;
|
|
|
|
if (!bOutside)
|
|
m_nBSSideFlag |= SIDE_NOSO;
|
|
else
|
|
m_nBSSideFlag &= ~SIDE_NOSO;
|
|
}
|
|
|
|
// 延长（缩短）XPoly2D首（尾）的CurveSegment
|
|
static BOOL ShortenStartCurve(const double length,XPoly2D &poly)
|
|
{
|
|
if (poly.Length() < 2 || length <= 0)
|
|
return FALSE;
|
|
|
|
XPointDir2d ptTemp;
|
|
XCurveSegment cvTemp;
|
|
poly.Nth(0,cvTemp);
|
|
double nCvLen = cvTemp.PathDistance(cvTemp.EndPoint())-length;
|
|
if (nCvLen > 0)
|
|
{
|
|
double bulge = poly.GetBulge(0) * nCvLen/
|
|
cvTemp.PathDistance(cvTemp.EndPoint());
|
|
if (cvTemp.StartPoint() == *poly[0])
|
|
cvTemp.Polar(length,ptTemp);
|
|
else
|
|
cvTemp.Polar(nCvLen,ptTemp);
|
|
*poly[0] = ptTemp;
|
|
poly.SetBulge(0, bulge);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL ExtendStartCurve(const double length,XPoly2D &poly)
|
|
{
|
|
if (poly.Length() < 2 || length <= 0)
|
|
return FALSE;
|
|
|
|
XPointDir2d ptTemp;
|
|
XCurveSegment cvTemp;
|
|
poly.Nth(0,cvTemp);
|
|
cvTemp.SetLineFlag(LS_INFINITE);
|
|
if (cvTemp.StartPoint() == *poly[0])
|
|
cvTemp.Polar(-length,ptTemp);
|
|
else
|
|
cvTemp.Polar(cvTemp.PathDistance(cvTemp.EndPoint())+length,ptTemp);
|
|
AcDbPolyline pline;
|
|
PolyConvert(poly,pline);
|
|
pline.extend(TRUE,ptTemp);
|
|
poly.Reset();
|
|
PolyConvert(pline,poly);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL ShortenEndCurve(const double length,XPoly2D &poly)
|
|
{
|
|
if (poly.Length() < 2 || length <= 0)
|
|
return FALSE;
|
|
|
|
XPointDir2d ptTemp;
|
|
XCurveSegment cvTemp;
|
|
poly.Nth(poly.Length()-2,cvTemp);
|
|
double nCvLen = cvTemp.PathDistance(cvTemp.EndPoint()) - length;
|
|
if (nCvLen > 0) {
|
|
double bulge = poly.GetBulge(0) * nCvLen/cvTemp.PathDistance(cvTemp.EndPoint());
|
|
if (cvTemp.EndPoint() == *poly[poly.Length()-1])
|
|
cvTemp.Polar(nCvLen,ptTemp);
|
|
else
|
|
cvTemp.Polar(length,ptTemp);
|
|
*poly[poly.Length()-1] = ptTemp;
|
|
poly.SetBulge(poly.Length() - 2, bulge);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL ExtendEndCurve(const double length,XPoly2D &poly)
|
|
{
|
|
if (poly.Length() < 2 || length <= 0)
|
|
return FALSE;
|
|
|
|
XPointDir2d ptTemp;
|
|
XCurveSegment cvTemp;
|
|
poly.Nth(poly.Length()-2,cvTemp);
|
|
cvTemp.SetLineFlag(LS_INFINITE);
|
|
if (cvTemp.EndPoint() == *poly[poly.Length()-1])
|
|
cvTemp.Polar(cvTemp.PathDistance(cvTemp.EndPoint()) + length,ptTemp);
|
|
else
|
|
cvTemp.Polar(-length,ptTemp);
|
|
AcDbPolyline pline;
|
|
PolyConvert(poly,pline);
|
|
pline.extend(FALSE,ptTemp);
|
|
poly.Reset();
|
|
PolyConvert(pline,poly);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static XPoint LeftLow(const XPoly2D& poly)
|
|
{
|
|
XPoint ptTemp;
|
|
XPoint ptLow,ptUp;
|
|
poly.GetExtend(ptLow,ptUp);
|
|
ptTemp = ptLow;
|
|
ptTemp.x = ptUp.x;
|
|
|
|
return ptTemp;
|
|
}
|
|
|
|
static XPoint LeftUp(const XPoly2D& poly)
|
|
{
|
|
XPoint ptTemp;
|
|
XPoint ptLow,ptUp;
|
|
poly.GetExtend(ptLow,ptUp);
|
|
ptTemp = ptUp;
|
|
|
|
return ptTemp;
|
|
}
|
|
|
|
static void Scale(XPoly2D& poly,double x,double y,double z)
|
|
{
|
|
ads_matrix mat;
|
|
XPoint ptLow,ptUp,ptMid;
|
|
poly.GetExtend(ptLow,ptUp);
|
|
Midpoint(ptLow,ptUp,ptMid);
|
|
ptMid.GetScaleMatrix(x,y,z,mat);
|
|
poly.TransUCS(mat);
|
|
}
|
|
|
|
static void Mirror(XPoly2D& poly,BOOL bOutside,BOOL bLeftExt)
|
|
{
|
|
if (bOutside) {
|
|
if (!bLeftExt) {
|
|
Scale(poly,1,-1,1);
|
|
}
|
|
}
|
|
else {
|
|
if (bLeftExt) {
|
|
Scale(poly,1,-1,1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static XPoint ShapeBase(const XPoly2D& polyShape,BOOL bOutside,BOOL bLeftExt)
|
|
{
|
|
if (bOutside) {
|
|
if (bLeftExt) {
|
|
return LeftLow(polyShape);
|
|
}
|
|
else {
|
|
return LeftUp(polyShape);
|
|
}
|
|
}
|
|
else {
|
|
if (bLeftExt) {
|
|
return LeftUp(polyShape);
|
|
}
|
|
else {
|
|
return LeftLow(polyShape);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//普通窗（也可普通门、字母门、凸窗、矩形洞）
|
|
void TDbOpeningSlot::
|
|
GetWinSlotUints(const BOOL bHasSlot,
|
|
const BOOL bNoLow,
|
|
const BoardKind enumBoardKind,
|
|
const XPoly2D& polySlotPlane,
|
|
const double dSlotW,
|
|
DList<XPoly2D>& lstSlot,
|
|
XPoly2D& polyBoard,
|
|
XPoly2D& polyBoardT,
|
|
XPoly2D& polySill,
|
|
XPoly2D& polySillT,
|
|
XPoly2D& polyBoardSlot,
|
|
XPoly2D& polyBoardSlotT) const
|
|
{
|
|
XPointDir2d ptLocTemp;
|
|
if (!polySlotPlane.IsClosed() && polySlotPlane.Length() != 4)//不是普通窗
|
|
return;
|
|
|
|
//改变大小 m_dSlotT
|
|
XPoly2D polySlotPlaneOffset = polySlotPlane;
|
|
if (fabs(m_dSlotT) > 1.0E-3) {
|
|
polySlotPlaneOffset.Reset();
|
|
polySlotPlane.Offset(m_dSlotT,polySlotPlaneOffset);
|
|
}
|
|
|
|
//最上面、最下面曲线段
|
|
XPoint ptMidUp,ptMidLow;
|
|
XDirectionCurve cvUp,cvLow;
|
|
if (polySlotPlaneOffset.Length() > 0) {
|
|
polySlotPlaneOffset.GetExtend(ptMidUp,ptMidLow);
|
|
polySlotPlaneOffset.Nth(0,cvUp);
|
|
cvLow = cvUp;
|
|
}
|
|
int nSeg = polySlotPlaneOffset.TotalSegments();
|
|
for (int i = 0; i < nSeg; i++) {
|
|
XPoint ptLow,ptUp,ptMid;
|
|
XDirectionCurve cvTemp;
|
|
polySlotPlaneOffset.Nth(i,cvTemp);
|
|
cvTemp.GetExtend(ptLow,ptUp);
|
|
Midpoint(ptLow,ptUp,ptMid);
|
|
if (ptMid.y > ptMidUp.y) {
|
|
ptMidUp = ptMid;
|
|
cvUp = cvTemp;
|
|
}
|
|
if (ptMid.y < ptMidLow.y) {
|
|
ptMidLow = ptMid;
|
|
cvLow = cvTemp;
|
|
}
|
|
}
|
|
//最上面、最下面
|
|
XPoly2D polyUp,polyLow;
|
|
cvUp.AsPoly2D(polyUp);
|
|
cvLow.AsPoly2D(polyLow);
|
|
|
|
//（除去最上面和最下面窗套线的）左右侧窗套线
|
|
XPoly2D polySideLeft,polySideRight,polyTemp;
|
|
SplitPoly2D(polySlotPlaneOffset,cvLow.StartPoint(),cvUp.EndPoint(),polyTemp,polySideRight);
|
|
SplitPoly2D(polySlotPlaneOffset,cvUp.StartPoint(),cvLow.EndPoint(),polyTemp,polySideLeft);
|
|
|
|
//bNoLow时（此时无窗台）,延长
|
|
XPoly2D polySideLeftElev = polySideLeft,
|
|
polySideRightElev = polySideRight;
|
|
ExtendEndCurve(m_dSlotT,polySideRightElev);
|
|
ExtendStartCurve(m_dSlotT,polySideLeftElev);
|
|
|
|
//檐板窗台路径
|
|
XCurveSegment cvBoard,cvSill;
|
|
XPoly2D polyBoardPath,polySillPath;
|
|
cvUp.Polar(cvUp.PathDistance(cvUp.EndPoint())/2,ptLocTemp);
|
|
cvUp.GetSubSegment(ptLocTemp,ads_distance(cvUp.StartPoint(),cvUp.EndPoint())
|
|
+ 2*m_dBoardA, cvBoard);
|
|
cvBoard.AsPoly2D(polyBoardPath);
|
|
|
|
cvLow.Polar(cvLow.PathDistance(cvLow.EndPoint())/2,ptLocTemp);
|
|
cvLow.GetSubSegment(ptLocTemp,ads_distance(cvLow.StartPoint(),cvLow.EndPoint())
|
|
+ 2*m_dSillA, cvSill);
|
|
cvSill.AsPoly2D(polySillPath);
|
|
|
|
switch(m_enumSlotKind) {//窗套线类型
|
|
case SLOT_STANDARD: //标准样式
|
|
{
|
|
//（除去最上面或者最下面窗套线）窗套线
|
|
XPoly2D polySplitUp,polySplitLow;
|
|
SplitPoly2D(polySlotPlaneOffset,cvLow.EndPoint(),cvLow.StartPoint(),polySplitLow,polyTemp);
|
|
SplitPoly2D(polySlotPlaneOffset,cvUp.EndPoint(),cvUp.StartPoint(),polySplitUp,polyTemp);
|
|
|
|
//bNoLow时（此时无窗台）,延长
|
|
XPoly2D polySplitLowElev = polySplitLow;
|
|
ExtendEndCurve(m_dSlotT,polySplitLowElev);
|
|
ExtendStartCurve(m_dSlotT,polySplitLowElev);
|
|
|
|
switch(enumBoardKind) {
|
|
case BS_BOTH: //有檐板和窗台
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (!bNoLow) {
|
|
polySill = polySillPath;
|
|
polySillT= polyLow;
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
}
|
|
}
|
|
break;
|
|
case BS_BOARD://仅檐板
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySplitUp));
|
|
}
|
|
}
|
|
break;
|
|
case BS_SILL: //仅窗台
|
|
if (!bNoLow) {
|
|
polySill = polySillPath;
|
|
polySillT= polyLow;
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySplitLowElev));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySplitLow));
|
|
}
|
|
}
|
|
break;
|
|
default://无檐板和窗台
|
|
if (bHasSlot) {
|
|
if (bNoLow)
|
|
lstSlot.Append(new XPoly2D(polySplitLowElev));
|
|
else
|
|
lstSlot.Append(new XPoly2D(polySlotPlaneOffset));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case SLOT_VERHEI://垂直通高
|
|
{
|
|
//垂直通高时 竖直线段 的延长
|
|
XPoly2D polySideLeftExt = polySideLeft,
|
|
polySideRightExt = polySideRight;
|
|
ExtendStartCurve(m_dSlotBoardWid,polySideRightExt);
|
|
ExtendEndCurve(dSlotW,polySideRightExt);
|
|
ExtendStartCurve(dSlotW,polySideLeftExt);
|
|
ExtendEndCurve(m_dSlotBoardWid,polySideLeftExt);
|
|
|
|
switch(enumBoardKind) {
|
|
case BS_BOTH: //有檐板和窗台
|
|
{
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (!bNoLow) {
|
|
polySill = polySillPath;
|
|
polySillT= polyLow;
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BS_BOARD://仅檐板
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
}
|
|
else {
|
|
XPoly2D polySideRightTemp = polySideRight,
|
|
polySideLeftTemp = polySideLeft;
|
|
ExtendEndCurve(dSlotW,polySideRightTemp);
|
|
ExtendStartCurve(dSlotW,polySideLeftTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideRightTemp));
|
|
lstSlot.Append(new XPoly2D(polySideLeftTemp));
|
|
lstSlot.Append(new XPoly2D(polyLow));
|
|
}
|
|
}
|
|
break;
|
|
case BS_SILL: //仅窗台
|
|
if (!bNoLow) {
|
|
polySill = polySillPath;
|
|
polySillT= polyLow;
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUp;
|
|
polyBoardSlotT = polyUp;
|
|
if (bNoLow) {
|
|
XPoly2D polySideRightTemp = polySideRightElev,
|
|
polySideLeftTemp = polySideLeftElev;
|
|
ExtendStartCurve(m_dSlotBoardWid,polySideRightTemp);
|
|
ExtendEndCurve(m_dSlotBoardWid,polySideLeftTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideRightTemp));
|
|
lstSlot.Append(new XPoly2D(polySideLeftTemp));
|
|
} else {
|
|
XPoly2D polySideRightTemp = polySideRight,
|
|
polySideLeftTemp = polySideLeft;
|
|
ExtendStartCurve(m_dSlotBoardWid,polySideRightTemp);
|
|
ExtendEndCurve(m_dSlotBoardWid,polySideLeftTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideRightTemp));
|
|
lstSlot.Append(new XPoly2D(polySideLeftTemp));
|
|
}
|
|
}
|
|
break;
|
|
default://无檐板和窗台
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUp;
|
|
polyBoardSlotT = polyUp;
|
|
if (!bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polyLow));
|
|
}
|
|
if (bNoLow) {
|
|
XPoly2D polySideRightTemp = polySideRightElev,
|
|
polySideLeftTemp = polySideLeftElev;
|
|
ExtendStartCurve(m_dSlotBoardWid,polySideRightTemp);
|
|
ExtendEndCurve(m_dSlotBoardWid,polySideLeftTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideRightTemp));
|
|
lstSlot.Append(new XPoly2D(polySideLeftTemp));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySideLeftExt));
|
|
lstSlot.Append(new XPoly2D(polySideRightExt));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case SLOT_HORLEN://水平通长
|
|
{
|
|
//水平通长时 水平线段 的延长
|
|
XPoly2D polyUpExt = polyUp,
|
|
polyLowExt = polyLow;
|
|
ExtendStartCurve(dSlotW,polyUpExt);
|
|
ExtendEndCurve(dSlotW,polyUpExt);
|
|
ExtendStartCurve(dSlotW,polyLowExt);
|
|
ExtendEndCurve(dSlotW,polyLowExt);
|
|
|
|
switch(enumBoardKind) {
|
|
case BS_BOTH: //有檐板和窗台
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (!bNoLow) {
|
|
polySill = polySillPath;
|
|
polySillT= polyLow;
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
}
|
|
}
|
|
break;
|
|
case BS_BOARD://仅檐板
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
lstSlot.Append(new XPoly2D(polyLowExt));
|
|
}
|
|
}
|
|
break;
|
|
case BS_SILL: //仅窗台
|
|
if (!bNoLow) {
|
|
polySill = polySillPath;
|
|
polySillT= polyLow;
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUpExt;
|
|
polyBoardSlotT = polyUp;
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
}
|
|
}
|
|
break;
|
|
default://无檐板和窗台
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUpExt;
|
|
polyBoardSlotT = polyUp;
|
|
if (!bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polyLowExt));
|
|
}
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//门联窗
|
|
void TDbOpeningSlot::
|
|
GetDoorWinSlotUints(const BOOL bHasSlot,
|
|
const BOOL bNoLow,
|
|
const BoardKind enumBoardKind,
|
|
const XPoly2D& polySlotPlane,
|
|
const double dSlotW,
|
|
DList<XPoly2D>& lstSlot,
|
|
DList<XPoly2D>& lstSlotT,
|
|
XPoly2D& polyBoard,
|
|
XPoly2D& polyBoardT,
|
|
XPoly2D& polySill,
|
|
XPoly2D& polySillT,
|
|
XPoly2D& polyBoardSlot,
|
|
XPoly2D& polyBoardSlotT) const
|
|
{
|
|
XPointDir2d ptLocTemp;
|
|
if (!polySlotPlane.IsClosed() && polySlotPlane.Length() != 6)//不是门联窗
|
|
return;
|
|
|
|
//改变大小 m_dSlotT
|
|
XPoly2D polySlotPlaneOffset = polySlotPlane;
|
|
if (fabs(m_dSlotT) > 1.0E-3) {
|
|
polySlotPlaneOffset.Reset();
|
|
polySlotPlane.Offset(m_dSlotT,polySlotPlaneOffset);
|
|
}
|
|
|
|
//最上面、最下面、中间曲线段(檐板)
|
|
XPoint ptMidUp,ptMidLow;
|
|
XDirectionCurve cvUp,cvLow,cvMid;
|
|
if (polySlotPlaneOffset.Length() > 0) {
|
|
polySlotPlaneOffset.GetExtend(ptMidUp,ptMidLow);
|
|
polySlotPlaneOffset.Nth(0,cvUp);
|
|
cvMid = cvLow = cvUp;
|
|
}
|
|
int nSeg = polySlotPlaneOffset.TotalSegments();
|
|
for (int i = 0; i < nSeg; i++) {
|
|
XPoint ptLow,ptUp,ptMid;
|
|
XDirectionCurve cvTemp;
|
|
polySlotPlaneOffset.Nth(i,cvTemp);
|
|
cvTemp.GetExtend(ptLow,ptUp);
|
|
Midpoint(ptLow,ptUp,ptMid);
|
|
if (ptMid.y > ptMidUp.y) {
|
|
ptMidUp = ptMid;
|
|
cvUp = cvTemp;
|
|
}
|
|
if (ptMid.y < ptMidLow.y) {
|
|
ptMidLow = ptMid;
|
|
cvLow = cvTemp;
|
|
}
|
|
}
|
|
for (i = 0; i < nSeg; i++) {
|
|
XDirectionCurve cvTemp;
|
|
polySlotPlaneOffset.Nth(i,cvTemp);
|
|
if (cvTemp.StartPoint().y < cvUp.StartPoint().y &&
|
|
cvTemp.StartPoint().y < cvUp.EndPoint().y &&
|
|
cvTemp.EndPoint().y < cvUp.StartPoint().y &&
|
|
cvTemp.EndPoint().y < cvUp.EndPoint().y &&
|
|
cvTemp.StartPoint().y > cvLow.StartPoint().y &&
|
|
cvTemp.StartPoint().y > cvLow.EndPoint().y &&
|
|
cvTemp.EndPoint().y > cvLow.StartPoint().y &&
|
|
cvTemp.EndPoint().y > cvLow.EndPoint().y) {
|
|
cvMid = cvTemp;
|
|
break;
|
|
}
|
|
}
|
|
//最上面、最下面和中间
|
|
XPoly2D polyUp,polyLow,polyMid;
|
|
cvUp.AsPoly2D(polyUp);
|
|
cvLow.AsPoly2D(polyLow);
|
|
cvMid.AsPoly2D(polyMid);
|
|
|
|
//（除去最上面和最下面窗套线的）左右侧窗套线
|
|
XPoly2D polySideLeft,polySideRight,polyTemp;
|
|
SplitPoly2D(polySlotPlaneOffset,cvLow.StartPoint(),cvUp.EndPoint(),polyTemp,polySideRight);
|
|
SplitPoly2D(polySlotPlaneOffset,cvUp.StartPoint(),cvLow.EndPoint(),polyTemp,polySideLeft);
|
|
|
|
//（除去最上面或者最下面窗套线或者中间（门联窗的窗台）的）窗套线
|
|
XPoly2D polySplitMid;
|
|
BOOL bWinLeft = TRUE;
|
|
XCurveSegment cvDoorWinSillUp,cvDoorWinSillLow;
|
|
XPoly2D polyDoorWinSillUp, polyDoorWinSillLow;
|
|
XPoly2D polyDoorWinSillLowSill;//有窗台时
|
|
SplitPoly2D(polySlotPlaneOffset,cvMid.EndPoint(),cvMid.StartPoint(),polySplitMid,polyTemp);
|
|
if (polySplitMid.Length() > 2) {
|
|
polySplitMid.Nth(0,cvDoorWinSillUp);
|
|
polySplitMid.Nth(polySplitMid.Length()-2,cvDoorWinSillLow);
|
|
if (cvDoorWinSillUp.EndPoint() == cvLow.StartPoint())
|
|
bWinLeft = FALSE;
|
|
if (!bWinLeft)
|
|
TchPrivate::Exchange(cvDoorWinSillUp,cvDoorWinSillLow);
|
|
|
|
cvDoorWinSillUp.AsPoly2D(polyDoorWinSillUp);
|
|
cvDoorWinSillLow.AsPoly2D(polyDoorWinSillLow);
|
|
|
|
polyDoorWinSillLowSill = polyDoorWinSillLow;
|
|
if (bWinLeft)
|
|
ShortenEndCurve(m_dSillH,polyDoorWinSillLowSill);
|
|
else
|
|
ShortenStartCurve(m_dSillH,polyDoorWinSillLowSill);
|
|
}
|
|
|
|
//bNoLow时（此时无窗台）,延长
|
|
XPoly2D polyDoorWinSillLowSillElev = polyDoorWinSillLowSill,//有窗台时
|
|
polySideLeftElev = polySideLeft,
|
|
polySideRightElev = polySideRight;
|
|
ExtendEndCurve(m_dSlotT,polySideRightElev);
|
|
ExtendStartCurve(m_dSlotT,polySideLeftElev);
|
|
if (bWinLeft)
|
|
ExtendStartCurve(m_dSlotT,polyDoorWinSillLowSillElev);
|
|
else
|
|
ExtendEndCurve(m_dSlotT,polyDoorWinSillLowSillElev);
|
|
|
|
XPoly2D polyDoorWinSillLowSillElevT = polyDoorWinSillLowSillElev;
|
|
if (bWinLeft)
|
|
ExtendEndCurve(m_dBoardH-m_dSlotT,polyDoorWinSillLowSillElevT);
|
|
else
|
|
ExtendStartCurve(m_dBoardH-m_dSlotT,polyDoorWinSillLowSillElevT);
|
|
|
|
//檐板窗台路径
|
|
XCurveSegment cvBoard,cvSill;
|
|
XPoly2D polyBoardPath,polySillPath;
|
|
double dSillAdd = 2*m_dSillA, dSillAdd1 = 0;
|
|
if (bHasSlot) {
|
|
dSillAdd -= dSlotW;
|
|
dSillAdd1 = dSlotW/2;
|
|
}
|
|
cvUp.Polar(cvUp.PathDistance(cvUp.EndPoint())/2,ptLocTemp);
|
|
cvUp.GetSubSegment(ptLocTemp,ads_distance(cvUp.StartPoint(),cvUp.EndPoint())
|
|
+ 2*m_dBoardA, cvBoard);
|
|
cvBoard.AsPoly2D(polyBoardPath);
|
|
if (bWinLeft) {
|
|
cvMid.Polar(cvMid.PathDistance(cvMid.EndPoint())/2 + dSillAdd1,ptLocTemp);
|
|
cvMid.GetSubSegment(ptLocTemp,ads_distance(cvMid.StartPoint(),cvMid.EndPoint())
|
|
+ dSillAdd, cvSill);
|
|
cvSill.AsPoly2D(polySillPath);
|
|
} else {
|
|
cvMid.Polar(cvMid.PathDistance(cvMid.EndPoint())/2 - dSillAdd1,ptLocTemp);
|
|
cvMid.GetSubSegment(ptLocTemp,ads_distance(cvMid.StartPoint(),cvMid.EndPoint())
|
|
+ dSillAdd, cvSill);
|
|
cvSill.AsPoly2D(polySillPath);
|
|
}
|
|
|
|
switch(m_enumSlotKind) {//窗套线类型
|
|
case SLOT_STANDARD: //标准样式
|
|
{
|
|
//（除去最上面或者最下面窗套线）窗套线
|
|
XPoly2D polySplitUp,polySplitLow;
|
|
SplitPoly2D(polySlotPlaneOffset,cvLow.EndPoint(),cvLow.StartPoint(),polySplitLow,polyTemp);
|
|
SplitPoly2D(polySlotPlaneOffset,cvUp.EndPoint(),cvUp.StartPoint(),polySplitUp,polyTemp);
|
|
//（除去中间）窗套线
|
|
if (bWinLeft)
|
|
ShortenEndCurve(m_dSillH,polySplitMid);
|
|
else
|
|
ShortenStartCurve(m_dSillH,polySplitMid);
|
|
//bNoLow时（此时无窗台）,延长
|
|
XPoly2D polySplitLowElev = polySplitLow;
|
|
ExtendEndCurve(m_dSlotT,polySplitLowElev);
|
|
ExtendStartCurve(m_dSlotT,polySplitLowElev);
|
|
|
|
switch(enumBoardKind) {
|
|
case BS_BOTH: //有檐板和窗台
|
|
{
|
|
polyBoard = polyBoardPath;
|
|
polySill = polySillPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
polySillT = polyMid;
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
} else {
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlotT.Append(new XPoly2D(polySideRightElev));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSillElev));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowSillElevT));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
}
|
|
else {
|
|
if (bWinLeft) {
|
|
XPoly2D polyAnotherSide = polySplitUp;
|
|
for (int i = 0; i < polyAnotherSide.Length() && i < 2; i++)
|
|
polyAnotherSide.Remove(polyAnotherSide.Length()-1);
|
|
ShortenEndCurve(m_dSillH,polyAnotherSide);
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
|
|
XPoly2D* pPolyAnotherSideT = new XPoly2D(polyAnotherSide);
|
|
ExtendEndCurve(m_dBoardH-m_dSlotT,*pPolyAnotherSideT);
|
|
lstSlotT.Append(pPolyAnotherSideT);
|
|
} else {
|
|
XPoly2D polyAnotherSide = polySplitUp;
|
|
for (int i = 0; i < polyAnotherSide.Length() && i < 2; i++)
|
|
polyAnotherSide.Remove(0);
|
|
ShortenStartCurve(m_dSillH,polyAnotherSide);
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
|
|
XPoly2D* pPolyAnotherSideT = new XPoly2D(polyAnotherSide);
|
|
ExtendStartCurve(m_dBoardH-m_dSlotT,*pPolyAnotherSideT);
|
|
lstSlotT.Append(pPolyAnotherSideT);
|
|
}
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BS_BOARD://仅檐板
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlotT.Append(new XPoly2D(polySideRightElev));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySplitUp));
|
|
lstSlotT.Append(new XPoly2D(polySplitUp));
|
|
}
|
|
}
|
|
break;
|
|
case BS_SILL: //仅窗台
|
|
polySill = polySillPath;
|
|
|
|
polySillT = polyMid;
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
} else {
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
XPoly2D polyAnotherSide = polySplitMid;
|
|
for (int i = 0; i < polyAnotherSide.Length() && i < 2; i++)
|
|
polyAnotherSide.Remove(polyAnotherSide.Length()-1);
|
|
ExtendEndCurve(m_dSlotT,polyAnotherSide);
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSillElev));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowSillElevT));
|
|
} else {
|
|
XPoly2D polyAnotherSide = polySplitMid;
|
|
for (int i = 0; i < polyAnotherSide.Length() && i < 2; i++)
|
|
polyAnotherSide.Remove(0);
|
|
ExtendStartCurve(m_dSlotT,polyAnotherSide);
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSillElev));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowSillElevT));
|
|
}
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySplitMid));
|
|
|
|
XPoly2D* pPolySplitMidT = new XPoly2D(polySplitMid);
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dBoardH-m_dSlotT,*pPolySplitMidT);
|
|
}
|
|
else {
|
|
ExtendStartCurve(m_dBoardH-m_dSlotT,*pPolySplitMidT);
|
|
}
|
|
lstSlotT.Append(pPolySplitMidT);
|
|
}
|
|
}
|
|
break;
|
|
default://无檐板和窗台
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polySplitLowElev));
|
|
lstSlotT.Append(new XPoly2D(polySplitLowElev));
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polySlotPlaneOffset));
|
|
lstSlotT.Append(new XPoly2D(polySlotPlaneOffset));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case SLOT_VERHEI://垂直通高
|
|
{
|
|
//垂直通高时 中间线段（窗台） 的缩短
|
|
XPoly2D polyMidShort = polyMid;
|
|
if (bWinLeft)
|
|
ShortenStartCurve(dSlotW,polyMidShort);
|
|
else
|
|
ShortenEndCurve(dSlotW,polyMidShort);
|
|
|
|
//垂直通高时 竖直线段 的延长
|
|
XPoly2D polySideLeftExt = polySideLeft,
|
|
polySideRightExt = polySideRight,
|
|
polyDoorWinSillUpExt = polyDoorWinSillUp,
|
|
polyDoorWinSillLowExt = polyDoorWinSillLow;
|
|
ExtendStartCurve(m_dSlotBoardWid,polySideRightExt);
|
|
ExtendEndCurve(dSlotW,polySideRightExt);
|
|
ExtendStartCurve(dSlotW,polySideLeftExt);
|
|
ExtendEndCurve(m_dSlotBoardWid,polySideLeftExt);
|
|
if (bWinLeft) {
|
|
ExtendStartCurve(dSlotW,polyDoorWinSillUpExt);
|
|
ExtendEndCurve(m_dSlotBoardWid,polyDoorWinSillUpExt);
|
|
ExtendStartCurve(dSlotW,polyDoorWinSillLowExt);
|
|
} else {
|
|
ExtendStartCurve(m_dSlotBoardWid,polyDoorWinSillUpExt);
|
|
ExtendEndCurve(dSlotW,polyDoorWinSillUpExt);
|
|
ExtendEndCurve(dSlotW,polyDoorWinSillLowExt);
|
|
}
|
|
|
|
switch(enumBoardKind) {
|
|
case BS_BOTH: //有檐板和窗台
|
|
{
|
|
polyBoard = polyBoardPath;
|
|
polySill = polySillPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
polySillT = polyMid;
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
} else {
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
|
|
if (bHasSlot) {
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlotT.Append(new XPoly2D(polySideRightElev));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSillElev));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowSillElevT));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
}
|
|
else {
|
|
if (bWinLeft) {
|
|
XPoly2D polyAnotherSide = polySideRight;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ExtendStartCurve(dSlotW,polyDoorWinSillLowTemp);
|
|
ExtendEndCurve(dSlotW,polyAnotherSide);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT = new XPoly2D(polyDoorWinSillLowTemp);
|
|
ExtendEndCurve(m_dBoardH-m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
} else {
|
|
XPoly2D polyAnotherSide = polySideLeft;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ExtendStartCurve(dSlotW,polyAnotherSide);
|
|
ExtendEndCurve(dSlotW,polyDoorWinSillLowTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT = new XPoly2D(polyDoorWinSillLowTemp);
|
|
ExtendStartCurve(m_dBoardH-m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
}
|
|
lstSlot.Append(new XPoly2D(polyLow));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyLow));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BS_BOARD://仅檐板
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (bHasSlot) {
|
|
lstSlot.Append(new XPoly2D(polyMidShort));
|
|
XPoly2D *pPolyMidShortT = new XPoly2D(polyMid);
|
|
if (bWinLeft) {
|
|
ShortenStartCurve(m_dSlotT,*pPolyMidShortT);
|
|
} else {
|
|
ShortenEndCurve(m_dSlotT,*pPolyMidShortT);
|
|
}
|
|
lstSlotT.Append(pPolyMidShortT);
|
|
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
XPoly2D polyAnotherSide = polySideRight;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLow;
|
|
ExtendStartCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
ExtendEndCurve(m_dSlotT,polyAnotherSide);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendStartCurve(dSlotW,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
} else {
|
|
XPoly2D polyAnotherSide = polySideLeft;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLow;
|
|
ExtendStartCurve(m_dSlotT,polyAnotherSide);
|
|
ExtendEndCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendEndCurve(dSlotW,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
}
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polyLow));
|
|
lstSlotT.Append(new XPoly2D(polyLow));
|
|
if (bWinLeft) {
|
|
XPoly2D polyAnotherSide = polySideRight;
|
|
ExtendEndCurve(dSlotW,polyAnotherSide);
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLow;
|
|
ExtendStartCurve(dSlotW,polyDoorWinSillLowTemp);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendStartCurve(dSlotW,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
} else {
|
|
XPoly2D polyAnotherSide = polySideLeft;
|
|
ExtendStartCurve(dSlotW,polyAnotherSide);
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLow;
|
|
ExtendEndCurve(dSlotW,polyDoorWinSillLowTemp);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendEndCurve(dSlotW,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BS_SILL: //仅窗台
|
|
polySill = polySillPath;
|
|
|
|
polySillT = polyMid;
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
} else {
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUp;
|
|
polyBoardSlotT = polyUp;
|
|
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
XPoly2D polyAnotherSide = polySideRightExt;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ExtendStartCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
ShortenEndCurve(dSlotW-m_dSlotT,polyAnotherSide);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendEndCurve(m_dSlotBoardWid,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ExtendStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
ShortenEndCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
} else {
|
|
XPoly2D polyAnotherSide = polySideLeftExt;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ShortenStartCurve(dSlotW-m_dSlotT,polyAnotherSide);
|
|
ExtendEndCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendStartCurve(m_dSlotBoardWid,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
ExtendEndCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
}
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polyLow));
|
|
lstSlotT.Append(new XPoly2D(polyLow));
|
|
if (bWinLeft) {
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ExtendStartCurve(dSlotW,polyDoorWinSillLowTemp);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendEndCurve(m_dSlotBoardWid,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polySideRightExt));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlotT.Append(new XPoly2D(polySideRightExt));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
} else {
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ExtendEndCurve(dSlotW,polyDoorWinSillLowTemp);
|
|
XPoly2D polyDoorWinSillUpTemp = polyDoorWinSillUp;
|
|
ExtendStartCurve(m_dSlotBoardWid,polyDoorWinSillUpTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlot.Append(new XPoly2D(polySideLeftExt));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpTemp));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftExt));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default://无檐板和窗台
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUp;
|
|
polyBoardSlotT = polyUp;
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUpExt));
|
|
lstSlot.Append(new XPoly2D(polyMidShort));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUpExt));
|
|
|
|
XPoly2D *pPolyMidShortT = new XPoly2D(polyMid);
|
|
if (bWinLeft) {
|
|
ShortenStartCurve(m_dSlotT,*pPolyMidShortT);
|
|
} else {
|
|
ShortenEndCurve(m_dSlotT,*pPolyMidShortT);
|
|
}
|
|
lstSlotT.Append(pPolyMidShortT);
|
|
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
XPoly2D polyAnotherSide = polySideRightExt;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ExtendStartCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
ExtendEndCurve(dSlotW+m_dSlotT,polyDoorWinSillLowTemp);
|
|
ShortenEndCurve(dSlotW-m_dSlotT,polyAnotherSide);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
} else {
|
|
XPoly2D polyAnotherSide = polySideLeftExt;
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSill;
|
|
ShortenStartCurve(dSlotW-m_dSlotT,polyAnotherSide);
|
|
ExtendEndCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
ExtendStartCurve(dSlotW+m_dSlotT,polyDoorWinSillLowTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polyAnotherSide));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
}
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowExt));
|
|
lstSlot.Append(new XPoly2D(polyLow));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowExt));
|
|
lstSlotT.Append(new XPoly2D(polyLow));
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRightExt));
|
|
lstSlotT.Append(new XPoly2D(polySideRightExt));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeftExt));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftExt));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case SLOT_HORLEN://水平通长
|
|
{
|
|
//水平通长时 水平线段 的延长
|
|
XPoly2D polyUpExt = polyUp,
|
|
polyMidExt = polyMid,
|
|
polyLowExt = polyLow;
|
|
ExtendStartCurve(dSlotW,polyUpExt);
|
|
ExtendEndCurve(dSlotW,polyUpExt);
|
|
ExtendStartCurve(dSlotW,polyLowExt);
|
|
ExtendEndCurve(dSlotW,polyLowExt);
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(dSlotW,polyMidExt);
|
|
} else {
|
|
ExtendStartCurve(dSlotW,polyMidExt);
|
|
}
|
|
|
|
//缩短窗台下面的线段
|
|
XPoly2D polyDoorWinSillLowSho = polyDoorWinSillLow;
|
|
if (bWinLeft) {
|
|
ShortenEndCurve(dSlotW,polyDoorWinSillLowSho);
|
|
} else {
|
|
ShortenStartCurve(dSlotW,polyDoorWinSillLowSho);
|
|
}
|
|
|
|
switch(enumBoardKind) {
|
|
case BS_BOTH: //有檐板和窗台
|
|
{
|
|
polyBoard = polyBoardPath;
|
|
polySill = polySillPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
polySillT = polyMid;
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
} else {
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
|
|
if (bHasSlot) {
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlotT.Append(new XPoly2D(polySideRightElev));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSillElev));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowSillElevT));
|
|
}
|
|
else {
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlotT.Append(new XPoly2D(polySideRight));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
lstSlotT.Append(new XPoly2D(polySideLeft));
|
|
}
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSill));
|
|
lstSlot.Append(new XPoly2D(polyLowExt));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowSillT = new XPoly2D(polyDoorWinSillLowSill);
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dBoardH-m_dSlotT,*pPolyDoorWinSillLowSillT);
|
|
} else {
|
|
ExtendStartCurve(m_dBoardH-m_dSlotT,*pPolyDoorWinSillLowSillT);
|
|
}
|
|
lstSlotT.Append(pPolyDoorWinSillLowSillT);
|
|
lstSlotT.Append(new XPoly2D(polyLowExt));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BS_BOARD://仅檐板
|
|
polyBoard = polyBoardPath;
|
|
|
|
polyBoardT = polyUp;
|
|
ExtendEndCurve(m_dSlotT,polyBoardT);
|
|
ExtendStartCurve(m_dSlotT,polyBoardT);
|
|
|
|
if (bHasSlot) {
|
|
lstSlot.Append(new XPoly2D(polyMidExt));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyMidExt));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSho;
|
|
ExtendStartCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polySideRightElev));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
ExtendEndCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
} else {
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSho;
|
|
ExtendEndCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftElev));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
ExtendEndCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
}
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polyLowExt));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSho));
|
|
lstSlotT.Append(new XPoly2D(polyLowExt));
|
|
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlotT.Append(new XPoly2D(polySideRight));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
lstSlotT.Append(new XPoly2D(polySideLeft));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BS_SILL: //仅窗台
|
|
polySill = polySillPath;
|
|
|
|
polySillT = polyMid;
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dSlotT,polySillT);
|
|
} else {
|
|
ExtendStartCurve(m_dSlotT,polySillT);
|
|
}
|
|
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUpExt;
|
|
polyBoardSlotT = polyUp;
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
|
|
if (bNoLow) {
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSillElev));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillLowSillElevT));
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlotT.Append(new XPoly2D(polySideRightElev));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftElev));
|
|
}
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polyLowExt));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSill));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowSillT = new XPoly2D(polyDoorWinSillLowSill);
|
|
if (bWinLeft) {
|
|
ExtendEndCurve(m_dBoardH-m_dSlotT,*pPolyDoorWinSillLowSillT);
|
|
} else {
|
|
ExtendStartCurve(m_dBoardH-m_dSlotT,*pPolyDoorWinSillLowSillT);
|
|
}
|
|
lstSlotT.Append(new XPoly2D(polyLowExt));
|
|
lstSlotT.Append(pPolyDoorWinSillLowSillT);
|
|
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlotT.Append(new XPoly2D(polySideRight));
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
lstSlotT.Append(new XPoly2D(polySideLeft));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default://无檐板和窗台
|
|
if (bHasSlot) {
|
|
polyBoardSlot = polyUpExt;
|
|
polyBoardSlotT = polyUp;
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlot.Append(new XPoly2D(polyMidExt));
|
|
lstSlotT.Append(new XPoly2D(polyDoorWinSillUp));
|
|
lstSlotT.Append(new XPoly2D(polyMidExt));
|
|
|
|
if (bNoLow) {
|
|
if (bWinLeft) {
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSho;
|
|
ExtendStartCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideRightElev));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polySideRightElev));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
ExtendEndCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
} else {
|
|
XPoly2D polyDoorWinSillLowTemp = polyDoorWinSillLowSho;
|
|
ExtendEndCurve(m_dSlotT,polyDoorWinSillLowTemp);
|
|
|
|
lstSlot.Append(new XPoly2D(polySideLeftElev));
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowTemp));
|
|
lstSlotT.Append(new XPoly2D(polySideLeftElev));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
ExtendEndCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
}
|
|
}
|
|
else {
|
|
lstSlot.Append(new XPoly2D(polyDoorWinSillLowSho));
|
|
lstSlot.Append(new XPoly2D(polyLowExt));
|
|
lstSlotT.Append(new XPoly2D(polyLowExt));
|
|
if (bWinLeft) {
|
|
lstSlot.Append(new XPoly2D(polySideRight));
|
|
lstSlotT.Append(new XPoly2D(polySideRight));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
} else {
|
|
lstSlot.Append(new XPoly2D(polySideLeft));
|
|
lstSlotT.Append(new XPoly2D(polySideLeft));
|
|
|
|
XPoly2D* pPolyDoorWinSillLowTempT=new XPoly2D(polyDoorWinSillLow);
|
|
ShortenStartCurve(m_dSlotT,*pPolyDoorWinSillLowTempT);
|
|
lstSlotT.Append(pPolyDoorWinSillLowTempT);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL TDbOpeningSlot::IsValid() const
|
|
{
|
|
assertReadEnabled();
|
|
BOOL bRet2 = TDbEntity::IsValid();
|
|
BOOL bRet = FALSE;
|
|
if (m_idOpening.isValid()) {
|
|
BOOL bHasSlot = HasSlot();
|
|
BOOL bHasBoard = (m_enumBoardKind == BS_BOTH ||
|
|
m_enumBoardKind == BS_BOARD) &&
|
|
((m_nBSSideFlag&SIDE_NOBI)==0 ||
|
|
(m_nBSSideFlag&SIDE_NOBO)==0);
|
|
BOOL bHasSill = (m_enumBoardKind == BS_BOTH ||
|
|
m_enumBoardKind == BS_SILL) &&
|
|
((m_nBSSideFlag&SIDE_NOSI)==0 ||
|
|
(m_nBSSideFlag&SIDE_NOSO)==0);
|
|
if (bHasSlot || bHasBoard || bHasSill)
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return (bRet && bRet2);
|
|
}
|
|
|
|
BOOL TDbOpeningSlot::IsShapeShow() const
|
|
{
|
|
assertReadEnabled();
|
|
return ((m_nCMFlag&CMF_SHOWSHAPE) != 0);
|
|
}
|
|
|
|
BOOL TDbOpeningSlot::Has2D() const
|
|
{
|
|
assertReadEnabled();
|
|
return ((m_nCMFlag&CMF_NO2D) == 0);
|
|
}
|
|
|
|
BOOL TDbOpeningSlot::Has3D() const
|
|
{
|
|
assertReadEnabled();
|
|
return ((m_nCMFlag&CMF_NO3D) == 0);
|
|
}
|
|
|
|
void TDbOpeningSlot::ShowShape(BOOL bFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bFlag)
|
|
m_nCMFlag |= CMF_SHOWSHAPE;
|
|
else
|
|
m_nCMFlag &= ~CMF_SHOWSHAPE;
|
|
}
|
|
|
|
void TDbOpeningSlot::SetHas2D(BOOL bFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
if(!bFlag) {
|
|
m_nCMFlag |= CMF_NO2D;
|
|
if(!Has3D())
|
|
m_nCMFlag &= ~CMF_NO3D;
|
|
} else {
|
|
m_nCMFlag &= ~CMF_NO2D;
|
|
}
|
|
}
|
|
|
|
void TDbOpeningSlot::SetHas3D(BOOL bFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
if(!bFlag) {
|
|
m_nCMFlag |= CMF_NO3D;
|
|
if(!Has2D())
|
|
m_nCMFlag &= ~CMF_NO2D;
|
|
} else
|
|
m_nCMFlag &= ~CMF_NO3D;
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbOpeningSlot::
|
|
CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbOpeningSlot *pSrc = TDbOpeningSlot::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
m_nCMFlag = pSrc->m_nCMFlag;
|
|
m_enumSlotKind = pSrc->m_enumSlotKind;
|
|
m_polyShape = pSrc->m_polyShape;
|
|
m_enumSlotSide = pSrc->m_enumSlotSide;
|
|
m_enumBoardKind=pSrc->m_enumBoardKind;
|
|
m_bHasSlot=pSrc->m_bHasSlot;
|
|
m_dInsideSlotW=pSrc->m_dInsideSlotW;
|
|
m_dOutsideSlotW=pSrc->m_dOutsideSlotW;
|
|
m_dSlotA=pSrc->m_dSlotA;
|
|
m_dSlotT=pSrc->m_dSlotT;
|
|
m_dSlotBoardWid=pSrc->m_dSlotBoardWid;
|
|
m_dBoardA=pSrc->m_dBoardA;
|
|
m_dBoardH=pSrc->m_dBoardH;
|
|
m_dBoardW=pSrc->m_dBoardW;
|
|
m_dSillA=pSrc->m_dSillA;
|
|
m_dSillH=pSrc->m_dSillH;
|
|
m_dSillW=pSrc->m_dSillW;
|
|
m_nBSSideFlag=pSrc->m_nBSSideFlag;
|
|
|
|
if(database()==NULL||
|
|
pSrcEntity->database()==NULL||
|
|
database()==pSrcEntity->database())//add by whl on 060317
|
|
{
|
|
m_idLayerBoard3d=pSrc->m_idLayerBoard3d;
|
|
m_idLayerSill3d=pSrc->m_idLayerSill3d;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 输入来自于DWG文件的文档数据:
|
|
Acad::ErrorStatus TDbOpeningSlot::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
|
|
es = TDbEntity::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;
|
|
}
|
|
|
|
Adesk::UInt16 iBoardKind= 0;
|
|
Adesk::UInt16 iSlotSide = 3;
|
|
Adesk::UInt16 iSlotKind = 0;
|
|
|
|
pFiler->readItem(&m_nCMFlag);
|
|
pFiler->readItem(&m_idOpening);
|
|
pFiler->readItem(&m_bHasSlot);
|
|
|
|
pFiler->readItem(&iBoardKind);
|
|
pFiler->readItem(&iSlotSide);
|
|
pFiler->readItem(&iSlotKind);
|
|
|
|
Adesk::UInt16 nPolyFlag;
|
|
Adesk::UInt16 nCount=0;
|
|
m_polyShape.Reset();
|
|
pFiler->readItem(&nPolyFlag);
|
|
pFiler->readItem(&nCount);
|
|
m_polyShape.SetFlag(nPolyFlag);
|
|
for(Adesk::UInt16 i = 0; i < nCount; i++) {
|
|
AcGePoint3d pt;
|
|
double nBulge=0.0;
|
|
pFiler->readItem(&pt);
|
|
pFiler->readItem(&nBulge);
|
|
m_polyShape.AppendNode(XPoint(pt), nBulge);
|
|
}
|
|
|
|
pFiler->readItem(&m_dInsideSlotW);
|
|
pFiler->readItem(&m_dOutsideSlotW);
|
|
pFiler->readItem(&m_dSlotT);
|
|
pFiler->readItem(&m_dSlotA);
|
|
pFiler->readItem(&m_dSlotBoardWid);
|
|
pFiler->readItem(&m_dBoardA);
|
|
pFiler->readItem(&m_dBoardH);
|
|
pFiler->readItem(&m_dBoardW);
|
|
pFiler->readItem(&m_dSillA);
|
|
pFiler->readItem(&m_dSillH);
|
|
pFiler->readItem(&m_dSillW);
|
|
|
|
pFiler->readItem(&m_nBSSideFlag);
|
|
|
|
//类型
|
|
switch (iBoardKind) {
|
|
case 1: m_enumBoardKind = BS_BOTH; break;
|
|
case 2: m_enumBoardKind = BS_BOARD; break;
|
|
case 3: m_enumBoardKind = BS_SILL; break;
|
|
default: m_enumBoardKind = BS_NONE; break;
|
|
}
|
|
|
|
switch (iSlotSide) {
|
|
case 0: m_enumSlotSide = SIDE_OUT; break;
|
|
case 1: m_enumSlotSide = SIDE_IN; break;
|
|
case 2: m_enumSlotSide = SIDE_BOTH; break;
|
|
default: m_enumSlotSide = SIDE_NONE; break;
|
|
}
|
|
|
|
switch (iSlotKind) {
|
|
case 1: m_enumSlotKind = SLOT_VERHEI; break;
|
|
case 2: m_enumSlotKind = SLOT_HORLEN; break;
|
|
default: m_enumSlotKind = SLOT_STANDARD; break;
|
|
}
|
|
|
|
if(nVer>1) {
|
|
pFiler->readItem(&m_idLayerBoard3d);
|
|
pFiler->readItem(&m_idLayerSill3d);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
// 文档数据输出到一个DWG文件：
|
|
Acad::ErrorStatus TDbOpeningSlot::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
|
|
es = TDbEntity::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
Adesk::UInt16 iBoardKind = 0;
|
|
switch (m_enumBoardKind) {
|
|
case BS_BOTH: iBoardKind = 1; break;
|
|
case BS_BOARD: iBoardKind = 2; break;
|
|
case BS_SILL: iBoardKind = 3; break;
|
|
default: break;
|
|
}
|
|
Adesk::UInt16 iSlotSide = 3;
|
|
switch (m_enumSlotSide) {
|
|
case SIDE_OUT: iSlotSide = 0; break;
|
|
case SIDE_IN: iSlotSide = 1; break;
|
|
case SIDE_BOTH: iSlotSide = 2; break;
|
|
default: break;
|
|
}
|
|
Adesk::UInt16 iSlotKind = 0;
|
|
switch (m_enumSlotKind) {
|
|
case SLOT_VERHEI: iSlotKind = 1; break;
|
|
case SLOT_HORLEN: iSlotKind = 2; break;
|
|
default: break;
|
|
}
|
|
|
|
pFiler->writeItem(m_nCMFlag);
|
|
pFiler->writeItem(m_idOpening);
|
|
pFiler->writeItem(m_bHasSlot);
|
|
|
|
pFiler->writeItem(iBoardKind);
|
|
pFiler->writeItem(iSlotSide);
|
|
pFiler->writeItem(iSlotKind);
|
|
|
|
pFiler->writeItem((Adesk::UInt16)m_polyShape.GetFlag());
|
|
Adesk::UInt16 nCount = m_polyShape.Length();
|
|
pFiler->writeItem(nCount);
|
|
for(Adesk::UInt16 i=0; i<nCount; i++) {
|
|
pFiler->writeItem((AcGePoint3d &)m_polyShape[i]);
|
|
pFiler->writeItem(m_polyShape.GetBulge(i));
|
|
}
|
|
|
|
pFiler->writeItem(m_dInsideSlotW);
|
|
pFiler->writeItem(m_dOutsideSlotW);
|
|
pFiler->writeItem(m_dSlotT);
|
|
pFiler->writeItem(m_dSlotA);
|
|
pFiler->writeItem(m_dSlotBoardWid);
|
|
pFiler->writeItem(m_dBoardA);
|
|
pFiler->writeItem(m_dBoardH);
|
|
pFiler->writeItem(m_dBoardW);
|
|
pFiler->writeItem(m_dSillA);
|
|
pFiler->writeItem(m_dSillH);
|
|
pFiler->writeItem(m_dSillW);
|
|
|
|
pFiler->writeItem(m_nBSSideFlag);
|
|
|
|
pFiler->writeItem(m_idLayerBoard3d);
|
|
pFiler->writeItem(m_idLayerSill3d);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
// 从DXF文件读入文档数据：
|
|
Acad::ErrorStatus TDbOpeningSlot::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
|
|
es = TDbEntity::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
if (!pFiler->atSubclassData(_T("TDbOpeningSlot")))
|
|
return Acad::eBadDxfSequence;
|
|
|
|
resbuf rb;
|
|
Adesk::UInt16 iBoardKind= 0;
|
|
Adesk::UInt16 iSlotSide = 3;
|
|
Adesk::UInt16 iSlotKind = 0;
|
|
DList<XPoint> lstPoints;
|
|
DList<double> lstBulges;
|
|
DList<double> lstParameters;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfInt16:
|
|
m_nCMFlag=rb.resval.rint;
|
|
break;
|
|
case AcDb::kDxfSoftPointerId:
|
|
acdbGetObjectId(m_idOpening, rb.resval.rlname);
|
|
break;
|
|
case AcDb::kDxfInt16+1:
|
|
m_bHasSlot=rb.resval.rint;
|
|
break;
|
|
case AcDb::kDxfInt16+2:
|
|
iBoardKind=rb.resval.rint;
|
|
break;
|
|
case AcDb::kDxfInt16+3:
|
|
iSlotSide=rb.resval.rint;
|
|
break;
|
|
case AcDb::kDxfInt16+4:
|
|
iSlotKind=rb.resval.rint;
|
|
break;
|
|
case AcDb::kDxfInt16+5:
|
|
m_polyShape.SetFlag(rb.resval.rint);
|
|
break;
|
|
case AcDb::kDxfXCoord:
|
|
lstPoints.Append(new XPoint(rb.resval.rpoint));
|
|
break;
|
|
case AcDb::kDxfAngle:
|
|
lstBulges.Append(new double(rb.resval.rreal));
|
|
break;
|
|
case AcDb::kDxfReal:
|
|
lstParameters.Append(new double(rb.resval.rreal));
|
|
break;
|
|
case AcDb::kDxfInt16+6:
|
|
m_nBSSideFlag=rb.resval.rint;
|
|
break;
|
|
default:
|
|
pFiler->pushBackItem();
|
|
es = Acad::eEndOfFile;
|
|
break;
|
|
}
|
|
}
|
|
if (es != Acad::eEndOfFile)
|
|
return Acad::eInvalidResBuf;
|
|
|
|
if(lstPoints.Length() < 3 || lstPoints.Length()!=lstBulges.Length()) {
|
|
pFiler->setError(_T("\nError DXF group code: 10, 50"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
//门窗套的参数共11个
|
|
if (lstParameters.Length() != 11) {
|
|
pFiler->setError(_T("\nError DXF group code: 40"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
|
|
m_polyShape.Reset();
|
|
int nCount = lstPoints.Length();
|
|
for(int i = 0; i < nCount; i++)
|
|
m_polyShape.AppendNode(*lstPoints[i], *lstBulges[i]);
|
|
|
|
//门窗套的参数
|
|
m_dInsideSlotW = *lstParameters[0];
|
|
m_dOutsideSlotW = *lstParameters[1];
|
|
m_dSlotT = *lstParameters[2];
|
|
m_dSlotA = *lstParameters[3];
|
|
m_dSlotBoardWid = *lstParameters[4];
|
|
m_dBoardA = *lstParameters[5];
|
|
m_dBoardH = *lstParameters[6];
|
|
m_dBoardW = *lstParameters[7];
|
|
m_dSillA = *lstParameters[8];
|
|
m_dSillH = *lstParameters[9];
|
|
m_dSillW = *lstParameters[10];
|
|
|
|
//类型
|
|
switch (iBoardKind) {
|
|
case 1: m_enumBoardKind = BS_BOTH; break;
|
|
case 2: m_enumBoardKind = BS_BOARD; break;
|
|
case 3: m_enumBoardKind = BS_SILL; break;
|
|
default: m_enumBoardKind = BS_NONE; break;
|
|
}
|
|
|
|
switch (iSlotSide) {
|
|
case 0: m_enumSlotSide = SIDE_OUT; break;
|
|
case 1: m_enumSlotSide = SIDE_IN; break;
|
|
case 2: m_enumSlotSide = SIDE_BOTH; break;
|
|
default: m_enumSlotSide = SIDE_NONE; break;
|
|
}
|
|
|
|
switch (iSlotKind) {
|
|
case 1: m_enumSlotKind = SLOT_VERHEI; break;
|
|
case 2: m_enumSlotKind = SLOT_HORLEN; break;
|
|
default: m_enumSlotKind = SLOT_STANDARD; break;
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
// 保存文档数据，输出到一个DXF文件：
|
|
Acad::ErrorStatus TDbOpeningSlot::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = TDbEntity::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
if (es != Acad::eOk) return es;
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbOpeningSlot"));
|
|
assert(es == Acad::eOk);
|
|
if (es != Acad::eOk) return es;
|
|
if (m_idOpening.asOldId() == 0L) {
|
|
es = Acad::eNullObjectId;
|
|
return es;
|
|
}
|
|
|
|
Adesk::UInt16 iBoardKind = 0;
|
|
switch (m_enumBoardKind) {
|
|
case BS_BOTH: iBoardKind = 1; break;
|
|
case BS_BOARD: iBoardKind = 2; break;
|
|
case BS_SILL: iBoardKind = 3; break;
|
|
default: break;
|
|
}
|
|
|
|
Adesk::UInt16 iSlotSide = 3;
|
|
switch (m_enumSlotSide) {
|
|
case SIDE_OUT: iSlotSide = 0; break;
|
|
case SIDE_IN: iSlotSide = 1; break;
|
|
case SIDE_BOTH: iSlotSide = 2; break;
|
|
default: break;
|
|
}
|
|
|
|
Adesk::UInt16 iSlotKind = 0;
|
|
switch (m_enumSlotKind) {
|
|
case SLOT_VERHEI: iSlotKind = 1; break;
|
|
case SLOT_HORLEN: iSlotKind = 2; break;
|
|
default: break;
|
|
}
|
|
|
|
//属性类型
|
|
pFiler->writeInt16(AcDb::kDxfInt16, m_nCMFlag);
|
|
pFiler->writeObjectId(AcDb::kDxfSoftPointerId ,m_idOpening);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+1, m_bHasSlot);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+2, iBoardKind);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+3, iSlotSide);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+4, iSlotKind);
|
|
|
|
//门窗套线
|
|
pFiler->writeInt16(AcDb::kDxfInt16+5, m_polyShape.GetFlag());
|
|
int nCount = m_polyShape.Length();
|
|
for(int i = 0; i < nCount; i++) {
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord, m_polyShape[i]);
|
|
pFiler->writeDouble(AcDb::kDxfAngle, m_polyShape.GetBulge(i));
|
|
}
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dInsideSlotW);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dOutsideSlotW);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dSlotT);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dSlotA);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dSlotBoardWid);
|
|
|
|
//檐板
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dBoardA);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dBoardH);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dBoardW);
|
|
|
|
//窗台
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dSillA);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dSillH);
|
|
pFiler->writeDouble(AcDb::kDxfReal,m_dSillW);
|
|
|
|
pFiler->writeInt16(AcDb::kDxfInt16+6,m_nBSSideFlag);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbOpeningSlot::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbOpeningSlot::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& ptPick,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
return TDbEntity::subGetOsnapPoints(osnapMode, gsSelectionMark,
|
|
ptPick, lastPoint, viewXform, snapPoints, geomIds);
|
|
}
|
|
|
|
// 绘制断面形状
|
|
Acad::ErrorStatus TDbOpeningSlot::
|
|
DrawShape(const XPoint &ptBase,XExplodeDraw &dc) const
|
|
{
|
|
AcGeVector3d vtNormal = AcGeVector3d(0,0,1);
|
|
ads_matrix mat;
|
|
XPoint ptLow, ptUp;
|
|
m_polyShape.GetExtend(ptLow, ptUp);
|
|
XPoint ptShapeBase = ptLow;
|
|
ptShapeBase.x = ptUp.x;
|
|
|
|
ptShapeBase.GetMoveMatrix(ptBase,mat);
|
|
ptShapeBase.TransformBy(mat);
|
|
|
|
Adesk::UInt16 nColor=dc.GetColor();
|
|
dc.SetColor(1);
|
|
double ptSize=m_polyShape.Distance2d()/40.0;
|
|
dc << XLine(Ecs2Wcs(ptShapeBase+XPoint(ptSize, ptSize), vtNormal),
|
|
Ecs2Wcs(ptShapeBase-XPoint(ptSize, ptSize), vtNormal))
|
|
<< XLine(Ecs2Wcs(ptShapeBase+XPoint(ptSize, -ptSize), vtNormal),
|
|
Ecs2Wcs(ptShapeBase+XPoint(-ptSize, ptSize), vtNormal));
|
|
|
|
XPoly2D polyShape = m_polyShape;
|
|
polyShape.TransUCS(mat);
|
|
AcDbPolyline pline;
|
|
PolyConvert(polyShape, pline);
|
|
pline.setNormal(vtNormal);
|
|
XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;
|
|
if(viewDraw.m_pWd)
|
|
pline.worldDraw(viewDraw.m_pWd);
|
|
else
|
|
pline.viewportDraw(viewDraw.m_pVd);
|
|
|
|
dc.SetColor(nColor);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 绘制2D的显示
|
|
Acad::ErrorStatus TDbOpeningSlot::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (!IsValid())
|
|
return Acad::eInvalidInput;
|
|
if (!Has2D())
|
|
return Acad::eOk;
|
|
|
|
OPENOBJ_BEGIN(m_idOpening, AcDb::kForRead, TDbOpening, pOpening);
|
|
if(pOpening == NULL)
|
|
return Acad::eNullObjectId;
|
|
AcDbObjectId idWall=pOpening->GetWallId();
|
|
if(!idWall.isValid())
|
|
return Acad::eNullObjectId;
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbWall, pWall);
|
|
|
|
if (pOpening!=NULL && pWall!=NULL) {
|
|
//暂时不支持任意洞、转角窗和弧窗
|
|
TOpeningData::OpeningKind enumOpeningKind = pOpening->GetKind();
|
|
XPoly2D polyOpeningZ;
|
|
pOpening->GetElevOutline(polyOpeningZ);
|
|
if (enumOpeningKind==TOpeningData::OP_ARCWIN ||
|
|
enumOpeningKind==TOpeningData::OP_CORNWIN ||
|
|
(enumOpeningKind==TOpeningData::OP_HOLE && polyOpeningZ.Length() != 4)) {
|
|
return Acad::eNotApplicable;
|
|
}
|
|
|
|
//有无窗台、门窗套(内外侧)
|
|
BOOL bSillInside = ((m_nBSSideFlag&SIDE_NOSI)==0) &&
|
|
(GetBoardKind()==BS_BOTH||GetBoardKind()==BS_SILL);
|
|
BOOL bSlotInside = HasSlot() &&
|
|
(GetSlotSide()==SIDE_BOTH || GetSlotSide()==SIDE_IN);
|
|
|
|
BOOL bSillOutside = ((m_nBSSideFlag&SIDE_NOSO)==0) &&
|
|
(GetBoardKind()==BS_BOTH||GetBoardKind()==BS_SILL);
|
|
BOOL bSlotOutside = HasSlot() &&
|
|
(GetSlotSide()==SIDE_BOTH || GetSlotSide()==SIDE_OUT);
|
|
|
|
if (bSillInside && enumOpeningKind!=TOpeningData::OP_DOORWIN &&
|
|
(pOpening->GetElevation()-pOpening->GetWallElevation()<m_dOutsideSlotW))
|
|
bSillInside = FALSE;
|
|
if (bSillOutside && enumOpeningKind!=TOpeningData::OP_DOORWIN &&
|
|
(pOpening->GetElevation()-pOpening->GetWallElevation()<m_dOutsideSlotW))
|
|
bSillOutside = FALSE;
|
|
|
|
if (bSillInside || bSlotInside || bSillOutside || bSlotOutside) {
|
|
//前点、后点
|
|
XPoint ptSideBack,ptSideFront;
|
|
XPoly2D polyOpening(1);
|
|
pOpening->GetSidePoints(ptSideBack, ptSideFront);
|
|
ptSideBack.z = ptSideFront.z = 0;
|
|
pOpening->GetOutlinePoly(0,polyOpening);
|
|
int nCount = polyOpening.Length();
|
|
if (nCount < 3) {
|
|
return Acad::eNotApplicable;
|
|
}
|
|
|
|
//平面棱廓线的前后侧
|
|
XCurveSegment cvFront,cvBack;
|
|
for (int i = 0; i < nCount; i++) {
|
|
XCurveSegment curve;
|
|
polyOpening.Nth(i, curve);
|
|
if ((ptSideBack&curve) == PR_EDGE || (ptSideBack&curve) == PR_INSIDE)
|
|
cvBack = curve;
|
|
else if ((ptSideFront&curve) == PR_EDGE || (ptSideFront&curve) == PR_INSIDE)
|
|
cvFront= curve;
|
|
}
|
|
cvFront.SetLineFlag(LS_INFINITE);
|
|
cvBack.SetLineFlag(LS_INFINITE);
|
|
|
|
//显示参数
|
|
DList<BOOL> lstOutside,lstSlot,lstSill;
|
|
DList<double> lstSlotWid;
|
|
|
|
//内侧
|
|
if (bSillOutside || bSlotOutside) {
|
|
lstOutside.Append(new BOOL(TRUE));
|
|
lstSlot.Append(new BOOL(bSlotOutside));
|
|
lstSill.Append(new BOOL(bSillOutside));
|
|
lstSlotWid.Append(new double(m_dOutsideSlotW));
|
|
}
|
|
|
|
//外侧
|
|
if (bSillInside || bSlotInside) {
|
|
lstOutside.Append(new BOOL(FALSE));
|
|
lstSlot.Append(new BOOL(bSlotInside));
|
|
lstSill.Append(new BOOL(bSillInside));
|
|
lstSlotWid.Append(new double(m_dInsideSlotW));
|
|
}
|
|
|
|
if ( (lstOutside.Length() != lstSlot.Length()) ||
|
|
(lstOutside.Length() != lstSill.Length()) ||
|
|
(lstOutside.Length() != lstSlotWid.Length()) ) {
|
|
return Acad::eNotApplicable;
|
|
}
|
|
|
|
for (int j=0; j<lstOutside.Length(); j++) {
|
|
BOOL bOutSide = *lstOutside[j];
|
|
BOOL bSlot = *lstSlot[j];
|
|
BOOL bSill = *lstSill[j];
|
|
double dSlotWid = *lstSlotWid[j];
|
|
|
|
XCurveSegment cvWall,cvSlot,cvSill;
|
|
BOOL bLeftExt = (pWall->GetWallFlag()&WF_LEFTEXT)!=0; //IsExternal(OFFSET_LEFT);
|
|
if (bLeftExt) {
|
|
cvWall = pWall->GetStandardSideCurve1(bOutSide?OFFSET_LEFT:OFFSET_RIGHT);
|
|
cvSlot = pWall->GetStandardSideCurve1(bOutSide?OFFSET_LEFT:OFFSET_RIGHT,m_dSlotA);
|
|
cvSill = pWall->GetStandardSideCurve1(bOutSide?OFFSET_LEFT:OFFSET_RIGHT,m_dSillW);
|
|
}
|
|
else {
|
|
cvWall = pWall->GetStandardSideCurve1(bOutSide?OFFSET_RIGHT:OFFSET_LEFT);
|
|
cvSlot = pWall->GetStandardSideCurve1(bOutSide?OFFSET_RIGHT:OFFSET_LEFT,m_dSlotA);
|
|
cvSill = pWall->GetStandardSideCurve1(bOutSide?OFFSET_RIGHT:OFFSET_LEFT,m_dSillW);
|
|
}
|
|
cvWall.SetElevation(0);
|
|
cvSlot.SetElevation(0);
|
|
cvSill.SetElevation(0);
|
|
|
|
//两端点
|
|
XPoint ptBack,ptFront;
|
|
XPoint ptTemp;
|
|
cvBack.Intersection(cvWall,ptBack,ptTemp);
|
|
cvFront.Intersection(cvWall,ptFront,ptTemp);
|
|
|
|
//有门窗套
|
|
if (bSlot) {
|
|
XCurveSegment cvWallBack,cvSlotBack;
|
|
XCurveSegment cvWallFront,cvSlotFront;
|
|
|
|
//两端点
|
|
XPointDir2d ptBack1,ptFront1;
|
|
XPointDir2d ptBackSlot,ptFrontSlot;
|
|
XPointDir2d ptBackSlot1,ptFrontSlot1;
|
|
//中点
|
|
XPointDir2d ptMidFront,ptMidFrontSlot;
|
|
XPointDir2d ptMidBack,ptMidBackSlot;
|
|
|
|
cvSlot.ProjectToMe(ptBack,ptBackSlot);
|
|
cvSlot.ProjectToMe(ptFront,ptFrontSlot);
|
|
|
|
cvWall.Polar(cvWall.PathDistance(ptBack) - dSlotWid,ptBack1);
|
|
cvWall.Polar(cvWall.PathDistance(ptFront) + dSlotWid,ptFront1);
|
|
cvSlot.ProjectToMe(ptBack1,ptBackSlot1);
|
|
cvSlot.ProjectToMe(ptFront1,ptFrontSlot1);
|
|
|
|
cvWall.Polar(cvWall.PathDistance(ptFront) +
|
|
fabs(cvWall.PathDistance(ptFront1) -
|
|
cvWall.PathDistance(ptFront))/2,
|
|
ptMidFront);
|
|
cvWall.Polar(cvWall.PathDistance(ptBack) -
|
|
fabs(cvWall.PathDistance(ptBack1) -
|
|
cvWall.PathDistance(ptBack))/2,
|
|
ptMidBack);
|
|
cvSlot.Polar(cvSlot.PathDistance(ptFrontSlot) +
|
|
fabs(cvSlot.PathDistance(ptFrontSlot1) -
|
|
cvSlot.PathDistance(ptFrontSlot))/2,
|
|
ptMidFrontSlot);
|
|
cvSlot.Polar(cvSlot.PathDistance(ptBackSlot) -
|
|
fabs(cvSlot.PathDistance(ptBackSlot1) -
|
|
cvSlot.PathDistance(ptBackSlot))/2,
|
|
ptMidBackSlot);
|
|
|
|
cvWall.GetSubSegment((XPoint)ptMidFront,
|
|
ads_distance(ptFront,ptFront1),
|
|
cvWallFront);
|
|
cvWall.GetSubSegment((XPoint)ptMidBack,
|
|
ads_distance(ptBack,ptBack1),
|
|
cvWallBack);
|
|
cvSlot.GetSubSegment((XPoint)ptMidFrontSlot,
|
|
ads_distance(ptFrontSlot,ptFrontSlot1),
|
|
cvSlotFront);
|
|
cvSlot.GetSubSegment((XPoint)ptMidBackSlot,
|
|
ads_distance(ptBackSlot,ptBackSlot1),
|
|
cvSlotBack);
|
|
|
|
//绘制门窗套
|
|
dc << XLine(ptFront,ptFrontSlot) << XLine(ptFront1,ptFrontSlot1);
|
|
dc << XLine(ptBack,ptBackSlot) << XLine(ptBack1,ptBackSlot1);
|
|
dc << cvSlotFront << cvSlotBack;
|
|
dc << cvWallFront << cvWallBack;
|
|
}
|
|
|
|
//有窗台
|
|
if (bSill) {
|
|
//窗台总宽度
|
|
double dTotalSillWid = fabs(cvWall.PathDistance(ptBack) -
|
|
cvWall.PathDistance(ptFront));
|
|
if (pOpening->GetKind()==TOpeningData::OP_DOORWIN) {
|
|
double dScale = 0;
|
|
if (pOpening->GetWidth() > 0)
|
|
dScale = pOpening->m_nDoorWidth/pOpening->GetWidth();
|
|
dTotalSillWid *= fabs(1-dScale);
|
|
}
|
|
dTotalSillWid += 2*m_dSillA;
|
|
|
|
XCurveSegment cvWallSill,cvSillSill;//窗台曲线
|
|
XPointDir2d ptSillSide,ptWallSide,
|
|
ptSillSide1,ptWallSide1;//两端点
|
|
|
|
//门联窗
|
|
if (pOpening->GetKind()==TOpeningData::OP_DOORWIN) {
|
|
//窗在后
|
|
if (pOpening->m_nQuadrant == 3 || pOpening->m_nQuadrant == 0) {
|
|
cvWall.Polar(cvWall.PathDistance(ptBack) - m_dSillA,ptWallSide);
|
|
cvWall.Polar(cvWall.PathDistance(ptWallSide) + dTotalSillWid,ptWallSide1);
|
|
cvSill.ProjectToMe(ptWallSide,ptSillSide);
|
|
cvSill.ProjectToMe(ptWallSide1,ptSillSide1);
|
|
}
|
|
//窗在前
|
|
else{
|
|
cvWall.Polar(cvWall.PathDistance(ptFront) + m_dSillA,ptWallSide1);
|
|
cvWall.Polar(cvWall.PathDistance(ptWallSide1) - dTotalSillWid,ptWallSide);
|
|
cvSill.ProjectToMe(ptWallSide,ptSillSide);
|
|
cvSill.ProjectToMe(ptWallSide1,ptSillSide1);
|
|
}
|
|
}
|
|
//非门联窗
|
|
else {
|
|
cvWall.Polar(cvWall.PathDistance(ptBack) - m_dSillA,ptWallSide);
|
|
cvWall.Polar(cvWall.PathDistance(ptWallSide) + dTotalSillWid,ptWallSide1);
|
|
cvSill.ProjectToMe(ptWallSide,ptSillSide);
|
|
cvSill.ProjectToMe(ptWallSide1,ptSillSide1);
|
|
}
|
|
|
|
XPointDir2d ptSillMid,ptWallMid; //中点
|
|
cvWall.Polar(cvWall.PathDistance(ptWallSide) + dTotalSillWid/2,
|
|
ptWallMid);
|
|
cvSill.Polar(cvSill.PathDistance(ptSillSide) +
|
|
fabs(cvSill.PathDistance(ptSillSide1) -
|
|
cvSill.PathDistance(ptSillSide))/2,
|
|
ptSillMid);
|
|
|
|
cvWall.GetSubSegment((XPoint)ptWallMid,
|
|
ads_distance(ptWallSide,ptWallSide1),
|
|
cvWallSill);
|
|
cvSill.GetSubSegment((XPoint)ptSillMid,
|
|
ads_distance(ptSillSide,ptSillSide1),
|
|
cvSillSill);
|
|
|
|
//绘制窗台
|
|
dc << XLine(ptWallSide,ptSillSide) << XLine(ptWallSide1,ptSillSide1);
|
|
dc << cvWallSill << cvSillSill;
|
|
}
|
|
}
|
|
|
|
// 绘制断面形状，显示位置：门窗的基点
|
|
if(IsShapeShow() && HasSlot() &&
|
|
_tcsicmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) {
|
|
XPoint ptDest = pOpening->GetLocation();
|
|
ptDest.z = 0;
|
|
DrawShape(ptDest,dc);
|
|
}
|
|
}
|
|
}
|
|
|
|
OPENOBJ_END();//pWall
|
|
OPENOBJ_END();//pOpening
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus TDbOpeningSlot::Draw3D(
|
|
XExplodeDraw &dc,
|
|
const DList<XPoly2D>& lstSlot,//窗套线路径
|
|
const DList<XPoly2D>& lstSlotT,
|
|
const XPoly2D& polyBoard,//檐板路径
|
|
const XPoly2D& polyBoardT,
|
|
const XPoly2D& polySill,//窗台路径
|
|
const XPoly2D& polySillT,
|
|
const XPoly2D& polyBoardSlot,//窗套线檐板路径
|
|
const XPoly2D& polyBoardSlotT,
|
|
const XPoly2D& polyShapeT,
|
|
const XVector3D& vtNormal,
|
|
const BOOL bOutside,
|
|
const BOOL bLeftExt,
|
|
const BOOL bQuadrant) const
|
|
{
|
|
double dSlotW=bOutside?m_dOutsideSlotW:m_dInsideSlotW;
|
|
TDbCurveMesh mesh;
|
|
mesh.setPropertiesFrom(this);
|
|
mesh.SetNormal(vtNormal);
|
|
|
|
//窗套线
|
|
int nCount = lstSlot.Length();
|
|
if (nCount>0) {
|
|
if (m_polyShape.Length() > 2) {
|
|
XPoly2D polyShape(1);//截面形状
|
|
polyShape = m_polyShape;
|
|
XPoint ptLow,ptUp,ptMid;
|
|
polyShape.GetExtend(ptLow,ptUp);
|
|
ads_real dScale = dSlotW/(ptUp.x-ptLow.x);
|
|
if (fabs(dScale) > 1.0E-3) {
|
|
Scale(polyShape,dScale,1,1);
|
|
}
|
|
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?(!bLeftExt):bLeftExt);
|
|
Mirror(polyShape,bOutside,bLeftExt);
|
|
if (bQuadrant) {
|
|
Scale(polyShape,1,-1,1);
|
|
}
|
|
|
|
for(int n=0; n<nCount; n++) {
|
|
if (lstSlot[n].Length()>0) {
|
|
//mesh.setLayer(dc.GetLayerId());
|
|
mesh.SetPathPoly(lstSlot[n],mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//两侧
|
|
nCount = lstSlotT.Length();
|
|
if (nCount>0) {
|
|
if (polyShapeT.Length()==4) {
|
|
XPoly2D polyShape = polyShapeT;
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?bLeftExt:(!bLeftExt));
|
|
Mirror(polyShape,bOutside,bLeftExt);
|
|
for(int n=0; n<nCount; n++) {
|
|
if (lstSlotT[n].Length()>0) {
|
|
//mesh.setLayer(dc.GetLayerId());
|
|
mesh.SetPathPoly(lstSlotT[n],mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//檐板
|
|
if (polyBoard.Length()>0) {
|
|
XPoly2D polyShape=GetBoardShape();
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?(!bLeftExt):bLeftExt);
|
|
if(m_idLayerBoard3d.isValid())
|
|
mesh.setLayer(m_idLayerBoard3d);
|
|
else
|
|
mesh.setLayer(layerId());
|
|
mesh.SetPathPoly(polyBoard,mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
|
|
TPushProperty vProp(&mesh, dc);
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
|
|
if (polyBoardT.Length()>0 && polyShapeT.Length()==4) {
|
|
XPoly2D polyShape = polyShapeT;
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?bLeftExt:(!bLeftExt));
|
|
if(m_idLayerBoard3d.isValid())
|
|
mesh.setLayer(m_idLayerBoard3d);
|
|
else
|
|
mesh.setLayer(layerId());
|
|
mesh.SetPathPoly(polyBoardT,mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
TPushProperty vProp(&mesh, dc);
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
|
|
//窗台
|
|
if (polySill.Length()>0) {
|
|
XPoly2D polyShape=GetSillShape();
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?(!bLeftExt):bLeftExt);
|
|
if(m_idLayerSill3d.isValid())
|
|
mesh.setLayer(m_idLayerSill3d);
|
|
else
|
|
mesh.setLayer(layerId());
|
|
mesh.SetPathPoly(polySill,mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
TPushProperty vProp(&mesh, dc);
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
|
|
if (polySillT.Length()>0 && polyShapeT.Length()==4) {
|
|
XPoly2D polyShape = polyShapeT;
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?bLeftExt:(!bLeftExt));
|
|
if(m_idLayerSill3d.isValid())
|
|
mesh.setLayer(m_idLayerSill3d);
|
|
else
|
|
mesh.setLayer(layerId());
|
|
mesh.SetPathPoly(polySillT,mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
TPushProperty vProp(&mesh, dc);
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
|
|
//窗套线檐板
|
|
if (polyBoardSlot.Length()>0) {
|
|
XPoly2D polyShape = m_polyShape;
|
|
if (polyShape.Length() > 2) {
|
|
ads_real dScale = m_dSlotBoardWid/dSlotW;
|
|
if (fabs(dScale) > 1.0E-3) {
|
|
Scale(polyShape,dScale,1,1);
|
|
}
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?(!bLeftExt):bLeftExt);
|
|
Mirror(polyShape,bOutside,bLeftExt);
|
|
if (bQuadrant) {
|
|
Scale(polyShape,1,-1,1);
|
|
}
|
|
|
|
mesh.setLayer(dc.GetLayerId());
|
|
mesh.SetPathPoly(polyBoardSlot,mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
TPushProperty vProp(&mesh, dc);
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
}
|
|
|
|
if (polyBoardSlotT.Length()>0 && polyShapeT.Length()==4) {
|
|
XPoly2D polyShape = polyShapeT;
|
|
XPoint ptBase=ShapeBase(polyShape,bOutside,bQuadrant?bLeftExt:(!bLeftExt));
|
|
mesh.setLayer(dc.GetLayerId());
|
|
mesh.SetPathPoly(polyBoardSlotT,mesh.GetNormal().AsAcGeVector3d());
|
|
mesh.SetShapePoly(polyShape);
|
|
mesh.SetShapeBase(ptBase);
|
|
|
|
if(dc.IsFullExplode())
|
|
mesh.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(mesh);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 绘制3d的显示
|
|
Acad::ErrorStatus
|
|
TDbOpeningSlot::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
if (!IsValid())
|
|
return Acad::eInvalidInput;
|
|
//if (!Has3D())
|
|
// return Acad::eOk;
|
|
|
|
OPENOBJ_BEGIN(m_idOpening, AcDb::kForRead, TDbOpening, pOpening);
|
|
if(pOpening == NULL)
|
|
return Acad::eNullObjectId;
|
|
AcDbObjectId idWall=pOpening->GetWallId();
|
|
if(!idWall.isValid())
|
|
return Acad::eNullObjectId;
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbWall, pWall);
|
|
|
|
if (pOpening!=NULL && pWall!=NULL) {
|
|
//暂时不支持任意洞、转角窗和弧窗
|
|
TOpeningData::OpeningKind enumOpeningKind = pOpening->GetKind();
|
|
XPoly2D polyOpeningZ;
|
|
pOpening->GetElevOutline(polyOpeningZ);
|
|
if (enumOpeningKind==TOpeningData::OP_ARCWIN ||
|
|
enumOpeningKind==TOpeningData::OP_CORNWIN ||
|
|
(enumOpeningKind==TOpeningData::OP_HOLE && polyOpeningZ.Length() != 4)) {
|
|
return Acad::eNotApplicable;
|
|
}
|
|
|
|
BOOL bLeftExt=(pWall->GetWallFlag()&WF_LEFTEXT)!=0; //pWall->IsExternal(OFFSET_LEFT);//内外否
|
|
XPoly2D polyOpening(1); //门窗
|
|
XCurveSegment cvWall;
|
|
|
|
pOpening->GetElevOutline(polyOpening);
|
|
int nPolyLength = polyOpening.Length();
|
|
if (nPolyLength < 3) {
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
AcGePlane plane((AcGePoint3d)*polyOpening[1],
|
|
(AcGePoint3d)*polyOpening[0],
|
|
(AcGePoint3d)*polyOpening[2]);
|
|
AcGeVector3d vtNormal = plane.normal();
|
|
|
|
XPoint ptSideBack,ptSideFront;
|
|
pOpening->GetSidePoints(ptSideBack, ptSideFront);
|
|
ptSideBack.z = ptSideFront.z = 0;
|
|
|
|
|
|
//门窗的两侧截面
|
|
XPoly2D polyShapeT(1);
|
|
if (m_dSlotT > 0) {
|
|
double dThickness = pOpening->GetThickness()/2;
|
|
double dWallThickness = pWall->GetWidth(4)/2;
|
|
//中间有门窗
|
|
if (enumOpeningKind == TOpeningData::OP_DOORWIN||
|
|
enumOpeningKind == TOpeningData::OP_DOOR ||
|
|
enumOpeningKind == TOpeningData::OP_WINDOW ||
|
|
enumOpeningKind == TOpeningData::OP_TWODOOR) {
|
|
double dThickness1 = dWallThickness-dThickness;
|
|
polyShapeT.AppendNode(XPoint(0,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,dThickness1,0));
|
|
polyShapeT.AppendNode(XPoint(0,dThickness1,0));
|
|
}
|
|
//中间没有门窗
|
|
else if (enumOpeningKind == TOpeningData::OP_PROWIN ||
|
|
(enumOpeningKind==TOpeningData::OP_HOLE && polyOpening.Length()==4)) {
|
|
polyShapeT.AppendNode(XPoint(0,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,0,0));
|
|
polyShapeT.AppendNode(XPoint(m_dSlotT,dWallThickness,0));
|
|
polyShapeT.AppendNode(XPoint(0,dWallThickness,0));
|
|
}
|
|
}
|
|
|
|
BOOL bBoardInside = ((m_nBSSideFlag&SIDE_NOBI)==0);
|
|
BOOL bBoardOutside = ((m_nBSSideFlag&SIDE_NOBO)==0);
|
|
BOOL bSillInside = ((m_nBSSideFlag&SIDE_NOSI)==0);
|
|
BOOL bSillOutside = ((m_nBSSideFlag&SIDE_NOSO)==0);
|
|
|
|
//外侧门窗套
|
|
if ((HasSlot() && (GetSlotSide() == SIDE_BOTH || GetSlotSide() == SIDE_OUT)) ||
|
|
(GetBoardKind() != BS_NONE && (bBoardOutside || bSillOutside)) ) {
|
|
XPointDir2d ptBackDir,ptFrontDir;
|
|
cvWall = pWall->GetStandardSideCurve1(bLeftExt?OFFSET_LEFT:OFFSET_RIGHT);
|
|
cvWall.SetElevation(0);
|
|
cvWall.ProjectToMe(ptSideBack, ptBackDir);
|
|
cvWall.ProjectToMe(ptSideFront, ptFrontDir);
|
|
ptBackDir.z = ptFrontDir.z = 0;
|
|
|
|
XPoly2D polyOutSlotPlane=polyOpening; //外侧门窗套立面
|
|
ads_matrix matMove;
|
|
XPoint ptWallBack = (XPoint)ptBackDir;
|
|
XPoint ptWallFront = (XPoint)ptFrontDir;
|
|
XPoint ptWallMid, ptSideMid;
|
|
Midpoint(ptWallBack,ptWallFront,ptWallMid);
|
|
Midpoint(ptSideFront,ptSideBack,ptSideMid);
|
|
ptSideMid.GetMoveMatrix(ptWallMid,matMove);
|
|
polyOutSlotPlane.TransUCS(matMove);
|
|
|
|
for (int i=0; i<nPolyLength; i++) {
|
|
XPoint& ptTemp = *polyOutSlotPlane[i];
|
|
ptTemp = Wcs2Ecs(ptTemp,vtNormal);
|
|
}
|
|
if (polyOutSlotPlane.PathArea() < 0) { //确保顺时针
|
|
polyOutSlotPlane.Reverse();
|
|
}
|
|
|
|
/*
|
|
if (ads_distance(ptSideBack,ptSideFront) != 0) {//弧窗时
|
|
ads_real dXScale = ads_distance(ptWallBack,ptWallFront)/
|
|
ads_distance(ptSideBack,ptSideFront);
|
|
if (fabs(dXScale - 1) > 1.0E-3) {
|
|
Scale(polyOutSlotPlane,dXScale,1,1);
|
|
}
|
|
}
|
|
*/
|
|
|
|
//檐板窗台类型
|
|
TDbOpeningSlot::BoardKind enumBoardKind = m_enumBoardKind;
|
|
BOOL bBoard = ((m_nBSSideFlag&SIDE_NOBO)==0);
|
|
BOOL bSill = ((m_nBSSideFlag&SIDE_NOSO)==0);
|
|
if (m_enumBoardKind == BS_NONE || (!bBoard && !bSill))
|
|
enumBoardKind = BS_NONE;
|
|
if (m_enumBoardKind == BS_BOARD && !bBoard)
|
|
enumBoardKind = BS_NONE;
|
|
if (m_enumBoardKind == BS_SILL && !bSill)
|
|
enumBoardKind = BS_NONE;
|
|
if (m_enumBoardKind == BS_BOTH && (!bSill && bBoard))
|
|
enumBoardKind = BS_BOARD;
|
|
if (m_enumBoardKind == BS_BOTH && (bSill && !bBoard))
|
|
enumBoardKind = BS_SILL;
|
|
if (m_enumBoardKind == BS_BOTH && (!bSill && !bBoard))
|
|
enumBoardKind = BS_NONE;
|
|
|
|
BOOL bQuadrant = FALSE;
|
|
int nQuadrant=pOpening->m_nQuadrant;
|
|
if (enumOpeningKind == TOpeningData::OP_DOORWIN) {
|
|
if (nQuadrant==2 || nQuadrant==1) {
|
|
bQuadrant = TRUE;
|
|
}
|
|
}
|
|
|
|
DList<XPoly2D> lstSlot; //窗套线路径
|
|
DList<XPoly2D> lstSlotT;//
|
|
XPoly2D polyBoard; //檐板路径
|
|
XPoly2D polyBoardT; //
|
|
XPoly2D polySill; //窗台路径
|
|
XPoly2D polySillT; //
|
|
XPoly2D polyBoardSlot; //窗套线檐板路径
|
|
XPoly2D polyBoardSlotT;//
|
|
|
|
//取得显示的路径和截面（链表）
|
|
if (enumOpeningKind==TOpeningData::OP_DOORWIN) {
|
|
GetDoorWinSlotUints(
|
|
HasSlot() && (GetSlotSide() == SIDE_BOTH || GetSlotSide() == SIDE_OUT),
|
|
(pOpening->GetElevation() - pOpening->GetWallElevation() < m_dOutsideSlotW)?TRUE:FALSE,
|
|
enumBoardKind,polyOutSlotPlane,m_dOutsideSlotW,
|
|
lstSlot,lstSlotT,polyBoard,polyBoardT,
|
|
polySill,polySillT,polyBoardSlot,polyBoardSlotT);
|
|
|
|
Draw3D(dc,lstSlot,lstSlotT,polyBoard,polyBoardT,polySill,
|
|
polySillT,polyBoardSlot,polyBoardSlotT,polyShapeT,vtNormal,
|
|
TRUE,bLeftExt,bQuadrant);
|
|
}
|
|
else if (enumOpeningKind == TOpeningData::OP_DOOR ||
|
|
enumOpeningKind == TOpeningData::OP_WINDOW ||
|
|
enumOpeningKind == TOpeningData::OP_PROWIN ||
|
|
enumOpeningKind == TOpeningData::OP_TWODOOR||
|
|
enumOpeningKind == TOpeningData::OP_HOLE) {
|
|
GetWinSlotUints(
|
|
HasSlot() && (GetSlotSide()==SIDE_BOTH || GetSlotSide()==SIDE_OUT),
|
|
(pOpening->GetElevation()-pOpening->GetWallElevation()<m_dOutsideSlotW)?TRUE:FALSE,
|
|
enumBoardKind,polyOutSlotPlane,m_dOutsideSlotW,
|
|
lstSlot,polyBoard,polyBoardT,polySill,
|
|
polySillT,polyBoardSlot,polyBoardSlotT);
|
|
|
|
Draw3D(dc,lstSlot,lstSlot,polyBoard,polyBoardT,polySill,
|
|
polySillT,polyBoardSlot,polyBoardSlotT,polyShapeT,vtNormal,
|
|
TRUE,bLeftExt,bQuadrant);
|
|
}
|
|
}
|
|
|
|
//内侧门窗套
|
|
if (HasSlot() && (GetSlotSide() == SIDE_BOTH || GetSlotSide() == SIDE_IN) ||
|
|
(GetBoardKind() != BS_NONE && (bBoardInside || bSillInside)) ) {
|
|
XPointDir2d ptBackDir,ptFrontDir;
|
|
cvWall = pWall->GetStandardSideCurve1(bLeftExt?OFFSET_RIGHT:OFFSET_LEFT);
|
|
cvWall.SetElevation(0);
|
|
cvWall.ProjectToMe(ptSideBack, ptBackDir);
|
|
cvWall.ProjectToMe(ptSideFront, ptFrontDir);
|
|
ptBackDir.z = ptFrontDir.z = 0;
|
|
|
|
XPoly2D polyInSlotPlane=polyOpening; //内侧门窗套立面
|
|
ads_matrix matMove;
|
|
XPoint ptWallBack = (XPoint)ptBackDir;
|
|
XPoint ptWallFront = (XPoint)ptFrontDir;
|
|
XPoint ptWallMid, ptSideMid;
|
|
Midpoint(ptWallBack,ptWallFront,ptWallMid);
|
|
Midpoint(ptSideFront,ptSideBack,ptSideMid);
|
|
ptSideMid.GetMoveMatrix(ptWallMid,matMove);
|
|
polyInSlotPlane.TransUCS(matMove);
|
|
|
|
for (int i=0; i<nPolyLength; i++) {
|
|
XPoint& ptTemp = *polyInSlotPlane[i];
|
|
ptTemp = Wcs2Ecs(ptTemp,vtNormal);
|
|
}
|
|
if (polyInSlotPlane.PathArea() < 0) { //确保顺时针
|
|
polyInSlotPlane.Reverse();
|
|
}
|
|
|
|
/*
|
|
if (ads_distance(ptSideBack,ptSideFront) != 0) {//弧窗时
|
|
ads_real dXScale = ads_distance(ptWallBack,ptWallFront)/
|
|
ads_distance(ptSideBack,ptSideFront);
|
|
if (fabs(dXScale - 1) > 1.0E-3) {
|
|
Scale(polyInSlotPlane,dXScale,1,1);
|
|
}
|
|
}
|
|
*/
|
|
|
|
//檐板窗台类型
|
|
TDbOpeningSlot::BoardKind enumBoardKind = m_enumBoardKind;
|
|
BOOL bBoard = ((m_nBSSideFlag&SIDE_NOBI)==0);
|
|
BOOL bSill = ((m_nBSSideFlag&SIDE_NOSI)==0);
|
|
if (m_enumBoardKind == BS_NONE || (!bBoard && !bSill))
|
|
enumBoardKind = BS_NONE;
|
|
if (m_enumBoardKind == BS_BOARD && !bBoard)
|
|
enumBoardKind = BS_NONE;
|
|
if (m_enumBoardKind == BS_SILL && !bSill)
|
|
enumBoardKind = BS_NONE;
|
|
if (m_enumBoardKind == BS_BOTH && (!bSill && bBoard))
|
|
enumBoardKind = BS_BOARD;
|
|
if (m_enumBoardKind == BS_BOTH && (bSill && !bBoard))
|
|
enumBoardKind = BS_SILL;
|
|
if (m_enumBoardKind == BS_BOTH && (!bSill && !bBoard))
|
|
enumBoardKind = BS_NONE;
|
|
|
|
BOOL bQuadrant = FALSE;
|
|
int nQuadrant=pOpening->m_nQuadrant;
|
|
if (enumOpeningKind == TOpeningData::OP_DOORWIN) {
|
|
if (nQuadrant==2 || nQuadrant==1) {
|
|
bQuadrant = TRUE;
|
|
}
|
|
}
|
|
|
|
DList<XPoly2D> lstSlot; //窗套线路径
|
|
DList<XPoly2D> lstSlotT;//
|
|
XPoly2D polyBoard; //檐板路径
|
|
XPoly2D polyBoardT; //
|
|
XPoly2D polySill; //窗台路径
|
|
XPoly2D polySillT; //
|
|
XPoly2D polyBoardSlot; //窗套线檐板路径
|
|
XPoly2D polyBoardSlotT; //
|
|
|
|
//取得显示的路径和截面（链表）
|
|
if (enumOpeningKind==TOpeningData::OP_DOORWIN) {
|
|
GetDoorWinSlotUints(
|
|
HasSlot() && (GetSlotSide()==SIDE_BOTH || GetSlotSide()==SIDE_IN),
|
|
(pOpening->GetElevation()-pOpening->GetWallElevation()<m_dInsideSlotW)?TRUE:FALSE,
|
|
enumBoardKind,polyInSlotPlane,m_dOutsideSlotW,
|
|
lstSlot,lstSlotT,polyBoard,polyBoardT,
|
|
polySill,polySillT,polyBoardSlot,polyBoardSlotT);
|
|
|
|
Draw3D(dc,lstSlot,lstSlotT,polyBoard,polyBoardT,polySill,
|
|
polySillT,polyBoardSlot,polyBoardSlotT,polyShapeT,vtNormal,
|
|
FALSE,bLeftExt,bQuadrant);
|
|
}
|
|
else if (enumOpeningKind == TOpeningData::OP_DOOR ||
|
|
enumOpeningKind == TOpeningData::OP_WINDOW ||
|
|
enumOpeningKind == TOpeningData::OP_PROWIN ||
|
|
enumOpeningKind == TOpeningData::OP_TWODOOR||
|
|
enumOpeningKind == TOpeningData::OP_HOLE) {
|
|
GetWinSlotUints(
|
|
HasSlot() && (GetSlotSide()==SIDE_BOTH || GetSlotSide()==SIDE_IN),
|
|
(pOpening->GetElevation()-pOpening->GetWallElevation()<m_dInsideSlotW)?TRUE:FALSE,
|
|
enumBoardKind,polyInSlotPlane,m_dOutsideSlotW,
|
|
lstSlot,polyBoard,polyBoardT,polySill,
|
|
polySillT,polyBoardSlot,polyBoardSlotT);
|
|
|
|
Draw3D(dc,lstSlot,lstSlot,polyBoard,polyBoardT,polySill,
|
|
polySillT,polyBoardSlot,polyBoardSlotT,polyShapeT,vtNormal,
|
|
FALSE,bLeftExt,bQuadrant);
|
|
}
|
|
}
|
|
|
|
// 绘制断面形状，显示位置：门窗的基点
|
|
if(IsShapeShow() && HasSlot() &&
|
|
_tcsicmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) {
|
|
XPoint ptDest = pOpening->GetLocation();
|
|
ptDest.z = 0;
|
|
DrawShape(ptDest,dc);
|
|
}
|
|
}
|
|
|
|
OPENOBJ_END();//pWall
|
|
OPENOBJ_END();//pOpening
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 取动态属性显示数据的函数
|
|
void TDbOpeningSlot::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("门窗套")));
|
|
if (m_bHasSlot) {
|
|
//门窗套类型
|
|
switch(m_enumSlotKind) {
|
|
case SLOT_STANDARD:
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套样式"), _T("标准样式")));
|
|
break;
|
|
case SLOT_VERHEI:
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套样式"), _T("垂直通高")));
|
|
break;
|
|
case SLOT_HORLEN:
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套样式"), _T("水平通长")));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
//门窗套侧类型
|
|
switch (m_enumSlotSide) {
|
|
case SIDE_NONE:
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套"), _T("无")));
|
|
break;
|
|
case SIDE_BOTH:
|
|
lstInfo.Append(new TObjInfoUnit(_T("外侧 W"), Dist2Str(m_dOutsideSlotW)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("内侧 W"), Dist2Str(m_dInsideSlotW)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套 A"), Dist2Str(m_dSlotA)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套 T"), Dist2Str(m_dSlotT)));
|
|
if (m_enumSlotKind != SLOT_STANDARD &&
|
|
(m_enumBoardKind == BS_NONE || m_enumBoardKind == BS_SILL))
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套檐板"), Dist2Str(m_dSlotBoardWid)));
|
|
break;
|
|
case SIDE_OUT:
|
|
lstInfo.Append(new TObjInfoUnit(_T("外侧 W"), Dist2Str(m_dOutsideSlotW)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("内侧"), _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套 A"), Dist2Str(m_dSlotA)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套 T"), Dist2Str(m_dSlotT)));
|
|
if (m_enumSlotKind != SLOT_STANDARD &&
|
|
(m_enumBoardKind == BS_NONE || m_enumBoardKind == BS_SILL))
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套檐板"), Dist2Str(m_dSlotBoardWid)));
|
|
break;
|
|
case SIDE_IN:
|
|
lstInfo.Append(new TObjInfoUnit(_T("外侧"), _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("内侧 W"), Dist2Str(m_dInsideSlotW)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套 A"), Dist2Str(m_dSlotA)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套 T"), Dist2Str(m_dSlotT)));
|
|
if (m_enumSlotKind != SLOT_STANDARD &&
|
|
(m_enumBoardKind == BS_NONE || m_enumBoardKind == BS_SILL))
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套檐板"), Dist2Str(m_dSlotBoardWid)));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else
|
|
lstInfo.Append(new TObjInfoUnit(_T("门窗套"), _T("无")));
|
|
|
|
if (m_enumBoardKind == BS_BOTH || m_enumBoardKind == BS_SILL) {
|
|
//檐板窗台
|
|
if (((m_nBSSideFlag&SIDE_NOSI)==0) && ((m_nBSSideFlag&SIDE_NOSO)==0))
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台所在侧"), _T("内外侧")));
|
|
else if (!((m_nBSSideFlag&SIDE_NOSI)==0) && ((m_nBSSideFlag&SIDE_NOSO)==0))
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台所在侧"), _T("外侧")));
|
|
else if (((m_nBSSideFlag&SIDE_NOSI)==0) && !((m_nBSSideFlag&SIDE_NOSO)==0))
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台所在侧"), _T("内侧")));
|
|
else
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台所在侧"), _T("两侧都无")));
|
|
}
|
|
|
|
if (m_enumBoardKind == BS_BOTH || m_enumBoardKind == BS_BOARD) {
|
|
if (((m_nBSSideFlag&SIDE_NOBI)==0) && ((m_nBSSideFlag&SIDE_NOBO)==0))
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板所在侧"), _T("内外侧")));
|
|
else if (!((m_nBSSideFlag&SIDE_NOBI)==0) && ((m_nBSSideFlag&SIDE_NOBO)==0))
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板所在侧"), _T("外侧")));
|
|
else if (((m_nBSSideFlag&SIDE_NOBI)==0) && !((m_nBSSideFlag&SIDE_NOBO)==0))
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板所在侧"), _T("内侧")));
|
|
else
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板所在侧"), _T("两侧都无")));
|
|
}
|
|
|
|
switch(m_enumBoardKind) {
|
|
case BS_BOTH:
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台 A"), Dist2Str(m_dSillA)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台 H"), Dist2Str(m_dSillH)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台W"), Dist2Str(m_dSillW)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板 A"), Dist2Str(m_dBoardA)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板 H"), Dist2Str(m_dBoardH)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板W"), Dist2Str(m_dBoardW)));
|
|
break;
|
|
case BS_BOARD:
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台"), _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板 A"), Dist2Str(m_dBoardA)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板 H"), Dist2Str(m_dBoardH)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板W"), Dist2Str(m_dBoardW)));
|
|
break;
|
|
case BS_SILL:
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台 A"), Dist2Str(m_dSillA)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台 H"), Dist2Str(m_dSillH)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台W"), Dist2Str(m_dSillW)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板"), _T("无")));
|
|
break;
|
|
case BS_NONE:
|
|
lstInfo.Append(new TObjInfoUnit(_T("窗台"), _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("檐板"), _T("无")));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Overriden functions for edit
|
|
Acad::ErrorStatus
|
|
TDbOpeningSlot::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//形状上的夹点
|
|
if(IsShapeShow()) {
|
|
OPENOBJ_BEGIN(m_idOpening, AcDb::kForRead, TDbOpening, pOpening);
|
|
if(pOpening) {
|
|
//转换矩阵
|
|
ads_matrix mat;
|
|
XPoint ptShapeBase, ptUp;
|
|
m_polyShape.GetExtend(ptShapeBase, ptUp);
|
|
ptShapeBase.x = ptUp.x;
|
|
XPoint ptDest = pOpening->GetLocation();
|
|
ptDest.z = 0;
|
|
ptShapeBase.GetMoveMatrix(ptDest,mat);
|
|
|
|
XPoly2D polyShape = m_polyShape;
|
|
int nCount = polyShape.Length();
|
|
polyShape.TransUCS(mat);
|
|
for(int i=0; i<nCount; i++)
|
|
gripPoints.append(*polyShape[i]);
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus
|
|
TDbOpeningSlot::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
if(!IsShapeShow())
|
|
return Acad::eOk;
|
|
|
|
int nCount = indices.length();
|
|
if (nCount > 0) {
|
|
XPoint ptLow, ptUp;
|
|
m_polyShape.GetExtend(ptLow, ptUp);
|
|
double dYOld = ptUp.y-ptLow.y;
|
|
double dXOld = ptUp.x-ptLow.x;
|
|
double dOSlotWScale = 1;
|
|
double dISlotWScale = 1;
|
|
double dSlotAScale = 1;
|
|
|
|
if (dXOld != 0 && dYOld != 0) {
|
|
dOSlotWScale = m_dOutsideSlotW/dXOld;
|
|
dISlotWScale = m_dInsideSlotW/dXOld;
|
|
dSlotAScale = m_dSlotA/dYOld;
|
|
|
|
XPoint vtOffset =Wcs2Ecs(*(XPoint *)&offset, AcGeVector3d(0,0,1));
|
|
vtOffset.z=0;
|
|
for (int i = 0; i < nCount; i++) {
|
|
int nShapeIndex = indices[i];
|
|
if(nShapeIndex < m_polyShape.Length())
|
|
*m_polyShape[nShapeIndex] += vtOffset;
|
|
}
|
|
|
|
m_polyShape.GetExtend(ptLow, ptUp);
|
|
double dYNew = ptUp.y-ptLow.y;
|
|
double dXNew = ptUp.x-ptLow.x;
|
|
|
|
m_dOutsideSlotW *= dOSlotWScale*(dXNew/dXOld);
|
|
m_dInsideSlotW *= dISlotWScale*(dXNew/dXOld);
|
|
m_dSlotA *= dSlotAScale*(dYNew/dYOld);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 取得夹点说明
|
|
Acad::ErrorStatus TDbOpeningSlot::GetGripText(int idx, CString &cs) const
|
|
{
|
|
assertReadEnabled();
|
|
if(IsShapeShow()) {
|
|
if (idx < m_polyShape.Length())
|
|
cs = _T("改变断面形状");
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// derived from AcDbObject, Reactor的唤醒函数
|
|
|
|
// INSERT实体要被删除/恢复
|
|
void TDbOpeningSlot::erased(const AcDbObject* pDbObj, Adesk::Boolean erasing)
|
|
{
|
|
if(pDbObj->objectId()==m_idOpening && !isWriteEnabled() && isNotifyEnabled()) {
|
|
Adesk::Boolean wasWritable=Adesk::kFalse;
|
|
if(upgradeFromNotify(wasWritable)==Acad::eOk) {
|
|
erase(erasing);
|
|
downgradeToNotify(wasWritable);
|
|
}
|
|
}
|
|
}
|
|
|
|
//门窗发生变化时
|
|
void TDbOpeningSlot::modified(const AcDbObject* pDbObj)
|
|
{
|
|
if(pDbObj->objectId()==m_idOpening) {
|
|
if(!isWriteEnabled()) {
|
|
if(isNotifyEnabled()) {
|
|
Adesk::Boolean wasWritable=Adesk::kFalse;
|
|
if(upgradeFromNotify(wasWritable)==Acad::eOk) {
|
|
assertWriteEnabled();
|
|
downgradeToNotify(wasWritable);
|
|
}
|
|
}
|
|
} else {
|
|
assertWriteEnabled();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void InitOpeningSlot(BOOL bTrue)
|
|
{
|
|
if(bTrue) {
|
|
TDbOpeningSlot::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbOpeningSlot::InitMatchProtocol(TRUE);
|
|
} else {
|
|
TDbOpeningSlot::InitMatchProtocol(FALSE);
|
|
deleteAcRxClass(TDbOpeningSlot::desc());
|
|
}
|
|
} |