3314 lines
71 KiB
C++
3314 lines
71 KiB
C++
#include "StdAfx.h"
|
|
#include "StdArx.h"
|
|
#include "CoreTools.h"
|
|
#include "KTCadUtility.h"
|
|
#include "KTCADUtilityEx.h"
|
|
#include "DXCHDlg.h"
|
|
#include "ZJCHDlg.h"
|
|
#include "ZXLTDlg.h"
|
|
#include "FZPDDlg.h"
|
|
#include "FZYTDlg.h"
|
|
#include "YHLTDlg.h"
|
|
#include "SFPXLTDlg.h"
|
|
#include "CSFZJLTDlg.h"
|
|
#include "CNewLineType.h"
|
|
#include "Base64.h"
|
|
#include "SFSPDlg.h"
|
|
#include "JCLTDlg.h"
|
|
#include "SJLTDlg.h"
|
|
#include "CJXZJDlg.h"
|
|
#include "JDLTDlg.h"
|
|
#include "FZTJDlg.h"
|
|
#include "FZSSDlg.h"
|
|
#include "AcPolylineJig.h"
|
|
#include "AecDb3dRoadAxisLine.h"
|
|
#include "FZSS2Dlg.h"
|
|
#include "HZMQDlg.h"
|
|
#include "CRJZDlg.h"
|
|
#include "AecDbEarthWorm.h"
|
|
#include "AecDbColumn.h"
|
|
#include "BZJJDlg.h"
|
|
#include "CGZZZDlg.h"
|
|
|
|
DLLIMPEXP bool GetDoubleClickEnt(LPCTSTR pszCmd, AcDbObjectId& id);
|
|
DLLIMPEXP AcDbArc* FormatArc(AcGePoint3d& ptGe1,AcGePoint3d& ptGe2,AcGePoint3d& ptGe3);
|
|
AcGePoint3d DLLIMPEXP MidPoint(AcGePoint3d& pt1,AcGePoint3d& pt2);
|
|
DLLIMPEXP AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts, int nCount);
|
|
|
|
namespace
|
|
{
|
|
bool isLineWallCorner(const AcDbObjectIdArray& idS)
|
|
{
|
|
if (idS.length() < 1) return false;
|
|
|
|
AcDbObjectId idA, idB;
|
|
idA = idS.at(0);
|
|
idB = idS.at(1);
|
|
|
|
AcDbEntity* pEntA(NULL), * pEntB(NULL);
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEntA, idA, AcDb::kForRead))
|
|
{
|
|
return false;
|
|
}
|
|
AecDbXWall* pWallA = AecDbXWall::cast(pEntA);
|
|
if (!pWallA)
|
|
{
|
|
pEntA->close();
|
|
return false;
|
|
}
|
|
AcDbCurve* pCurveA = pWallA->GetBaseCurve(true);
|
|
pEntA->close();
|
|
if (!pCurveA)
|
|
{
|
|
return false;
|
|
}
|
|
AcDbLine* pLine = AcDbLine::cast(pCurveA);
|
|
if (!pLine)
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
return false;
|
|
}
|
|
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEntB, idB, AcDb::kForRead))
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
return false;
|
|
}
|
|
AecDbXWall* pWallB = AecDbXWall::cast(pEntB);
|
|
if (!pWallB)
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
pEntB->close();
|
|
return false;
|
|
}
|
|
AcDbCurve* pCurveB = pWallB->GetBaseCurve(true);
|
|
pEntB->close();
|
|
if (!pCurveB)
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
return false;
|
|
}
|
|
pLine = AcDbLine::cast(pCurveB);
|
|
if (!pLine)
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
DELETE_PTR(pCurveB);
|
|
return false;
|
|
}
|
|
|
|
DELETE_PTR(pCurveA);
|
|
DELETE_PTR(pCurveB);
|
|
|
|
return true;
|
|
}
|
|
|
|
AcDbObjectId GetWallAB(const AcDbObjectIdArray& idS
|
|
, const AcGePoint3d& pt
|
|
, const WallData& data)
|
|
{
|
|
AcDbObjectId bkID(AcDbObjectId::kNull);
|
|
|
|
if (idS.length() < 1) return bkID;
|
|
|
|
AcDbObjectId idA, idB, id;
|
|
idA = idS.at(0);
|
|
idB = idS.at(1);
|
|
|
|
AcDbEntity* pEntA(NULL), * pEntB(NULL);
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEntA, idA, AcDb::kForRead))
|
|
{
|
|
return bkID;
|
|
}
|
|
AecDbXWall* pWallA = AecDbXWall::cast(pEntA);
|
|
if (!pWallA)
|
|
{
|
|
pEntA->close();
|
|
return bkID;
|
|
}
|
|
AcDbCurve* pCurveA = pWallA->GetBaseCurve(true);
|
|
pEntA->close();
|
|
if (!pCurveA)
|
|
{
|
|
return bkID;
|
|
}
|
|
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEntB, idB, AcDb::kForRead))
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
return bkID;
|
|
}
|
|
AecDbXWall* pWallB = AecDbXWall::cast(pEntB);
|
|
if (!pWallB)
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
pEntB->close();
|
|
return bkID;
|
|
}
|
|
AcDbCurve* pCurveB = pWallB->GetBaseCurve(true);
|
|
pEntB->close();
|
|
if (!pCurveB)
|
|
{
|
|
DELETE_PTR(pCurveA);
|
|
return bkID;
|
|
}
|
|
|
|
AcGePoint3d ptA, ptB;
|
|
pCurveA->getClosestPointTo(pt, ptA, true);
|
|
double dDistA = pt.distanceTo(ptA);
|
|
pCurveB->getClosestPointTo(pt, ptB, true);
|
|
double dDistB = pt.distanceTo(ptB);
|
|
|
|
if ((dDistA - data.dThick * .5) < 1e-6)
|
|
{
|
|
id = idA;
|
|
}
|
|
else
|
|
{
|
|
id = idB;
|
|
}
|
|
|
|
DELETE_PTR(pCurveA);
|
|
DELETE_PTR(pCurveB);
|
|
|
|
return id;
|
|
}
|
|
|
|
double GetWallThick(const AcDbObjectId& id)
|
|
{
|
|
AcDbEntity* pEnt(NULL);
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
|
|
{
|
|
return 0;
|
|
}
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (!pWall)
|
|
{
|
|
pEnt->close();
|
|
return 0;
|
|
}
|
|
WallData data;
|
|
::memset(&data, 0, sizeof(WallData));
|
|
pWall->GetWallData(data);
|
|
pEnt->close();
|
|
return data.dThick;
|
|
}
|
|
|
|
void CutWall(AcDbObjectId& id, const AcGePoint3d& ptInt, const double dDist, const WallData& data)
|
|
{
|
|
AcDbEntity* pEnt(NULL);
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
|
|
{
|
|
return;
|
|
}
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (!pWall)
|
|
{
|
|
pEnt->close();
|
|
return;
|
|
}
|
|
AcDbCurve* pCurve = pWall->GetBaseCurve(true);
|
|
if (!pCurve)
|
|
{
|
|
pEnt->close();
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptS, ptE, pt, ptCut;
|
|
pCurve->getClosestPointTo(ptInt, pt, true);
|
|
double dDistCut(.0), dDistSE(.0);
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
dDistSE = ptS.distanceTo(ptE);
|
|
AcDbLine* pL(NULL);
|
|
if (pt.distanceTo(ptS) < pt.distanceTo(ptE))
|
|
{
|
|
pL = AcDbLine::cast(pCurve);
|
|
if (!pL)
|
|
{
|
|
pEnt->close();
|
|
DELETE_PTR(pCurve);
|
|
return;
|
|
}
|
|
|
|
dDistCut = ptS.distanceTo(pt);
|
|
pL->getPointAtDist(dDist + dDistCut, ptCut);
|
|
pL->setStartPoint(ptCut);
|
|
pL->setEndPoint(ptE);
|
|
|
|
Acad::ErrorStatus es = pWall->SetBaseCurve(pL);
|
|
if (es != eOk)
|
|
{
|
|
pEnt->close();
|
|
DELETE_PTR(pCurve);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pL = AcDbLine::cast(pCurve);
|
|
if (!pL)
|
|
{
|
|
pEnt->close();
|
|
DELETE_PTR(pCurve);
|
|
return;
|
|
}
|
|
|
|
pL->setStartPoint(ptS);
|
|
dDistCut = ptE.distanceTo(pt);
|
|
pL->getPointAtDist(dDistSE - dDist - dDistCut, ptCut);
|
|
pL->setEndPoint(ptCut);
|
|
|
|
Acad::ErrorStatus es = pWall->SetBaseCurve(pL);
|
|
if (es != eOk)
|
|
{
|
|
pWall->close();
|
|
pEnt->close();
|
|
DELETE_PTR(pCurve);
|
|
return;
|
|
}
|
|
}
|
|
|
|
pEnt->close();
|
|
}
|
|
|
|
AcDbLine* IsPtOnLine(const AcDbVoidPtrArray& arReg, const AcGePoint3d& pt, const double& dLen)
|
|
{
|
|
if (arReg.length() < 1) return NULL;
|
|
|
|
AcDbEntity* pSubEnt(NULL);
|
|
AcDbLine* pLine(NULL);
|
|
double dDist, dLenSE;
|
|
AcGePoint3d ptOnLine, ptS, ptE;
|
|
double dLenGe[6];
|
|
for (int i(0); i < arReg.length(); i++)
|
|
{
|
|
pSubEnt = (AcDbEntity*)arReg.at(i);
|
|
pLine = AcDbLine::cast(pSubEnt);
|
|
pLine->getStartPoint(ptS);
|
|
pLine->getEndPoint(ptE);
|
|
dLenSE = ptS.distanceTo(ptE);
|
|
dLenGe[i] = dLenSE;
|
|
dDist = dLenSE - dLen;
|
|
if (fabs(dLenSE - dLen) < 1e-6)
|
|
{
|
|
return pLine;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
AcDbLine* ModifyLineLen(AcDbLine* pLine, const AcGePoint3d& ptC, const double& dLen)
|
|
{
|
|
if (!pLine) return NULL;
|
|
|
|
double dLenS, dLenE, dLen1, dLen2;
|
|
AcGePoint3d ptS, ptE, pt;
|
|
AcGeVector3d vecSE;
|
|
|
|
AcDbLine* pNewLine = (AcDbLine*)pLine->clone();
|
|
if (!pNewLine) return NULL;
|
|
|
|
pNewLine->getStartPoint(ptS);
|
|
pNewLine->getEndPoint(ptE);
|
|
|
|
dLen1 = ptS.distanceTo(ptE);
|
|
|
|
dLenS = ptC.distanceTo(ptS);
|
|
dLenE = ptC.distanceTo(ptE);
|
|
|
|
if (dLenS < dLenE)
|
|
{
|
|
pNewLine->setStartPoint(ptC);
|
|
|
|
vecSE = (pt - ptE).normalize();
|
|
pt = ptC - vecSE * dLen;
|
|
pNewLine->setEndPoint(pt);
|
|
}
|
|
else
|
|
{
|
|
pNewLine->setEndPoint(ptC);
|
|
|
|
vecSE = (ptC - ptS).normalize();
|
|
pt = ptC - vecSE * dLen;
|
|
pNewLine->setStartPoint(pt);
|
|
}
|
|
|
|
dLen2 = ptS.distanceTo(ptE);
|
|
|
|
return pNewLine;
|
|
}
|
|
|
|
bool IsLineStaByPt(AcDbLine* pLine, const AcGePoint3d& ptC)
|
|
{
|
|
if (!pLine) return false;
|
|
|
|
AcGePoint3d ptS;
|
|
AcDbLine* pNewLine = (AcDbLine*)pLine->clone();
|
|
pNewLine->getStartPoint(ptS);
|
|
double dDist = ptC.distanceTo(ptS);
|
|
if (fabs(dDist) < 1e-6)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static void FreeBuffer(int n, AcDbVoidPtrArray& arEntPtrs)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
while (arEntPtrs.length() > n)
|
|
{
|
|
pEnt = (AcDbEntity*)arEntPtrs.last();
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
DELETE_PTR(pEnt);
|
|
arEntPtrs.removeLast();
|
|
}
|
|
}
|
|
|
|
void CR_SCGXCmdFnc()
|
|
{
|
|
}
|
|
|
|
AcGePoint3d GetArcMidPoint(AcDbArc* pArc)
|
|
{
|
|
double dSta = 0.0,dEnd = 0.0;
|
|
pArc->getStartParam(dSta);
|
|
pArc->getEndParam(dEnd);
|
|
|
|
AcGePoint3d ptMid;
|
|
pArc->getPointAtParam((dSta + dEnd) / 2.0,ptMid);
|
|
|
|
return ptMid;
|
|
}
|
|
|
|
AcDbCurve* GetHeadCurve(AcDbVoidPtrArray& arCurPtrs,AcGePoint3d& ptNear)
|
|
{
|
|
AcGePoint3d ptOn;
|
|
AcDbCurve* pCurve = NULL,*pNear = NULL;
|
|
|
|
double dMax = 9999999.0,dLen = 0,dMin = 0;
|
|
AcGeVector3d vt;
|
|
for(int i = 0;i < arCurPtrs.length();i++)
|
|
{
|
|
pCurve = (AcDbCurve*)arCurPtrs.at(i);
|
|
pCurve->getClosestPointTo(ptNear,ptOn);
|
|
|
|
vt = ptOn - ptNear;
|
|
vt.z = 0.0;
|
|
|
|
dLen = vt.length();
|
|
if (dLen < dMax)
|
|
{
|
|
dMin = dLen;
|
|
pNear = pCurve;
|
|
}
|
|
else
|
|
{
|
|
if (dLen < dMin)
|
|
{
|
|
dMin = dLen;
|
|
pNear = pCurve;
|
|
}
|
|
}
|
|
}
|
|
return pNear;
|
|
}
|
|
|
|
void Trim(AcDbCurve* pCurve1,const AcGePoint3d& ptOn)
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pCurve1);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d pt1 = pLn->startPoint();
|
|
AcGePoint3d pt2 = pLn->endPoint();
|
|
if (pt1.distanceTo(ptOn) < pt2.distanceTo(ptOn))
|
|
{
|
|
//剪去sta端
|
|
pLn->setStartPoint(ptOn);
|
|
}
|
|
else
|
|
{
|
|
//剪去end端
|
|
pLn->setEndPoint(ptOn);
|
|
}
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(pCurve1);
|
|
if (pArc != NULL)
|
|
{
|
|
AcGePoint3d pt1,pt2;
|
|
pArc->getClosestPointTo(ptOn,pt1);
|
|
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(pt1);
|
|
|
|
AcDbVoidPtrArray arArc;
|
|
pArc->getSplitCurves(arPts,arArc);
|
|
|
|
if (arArc.length() == 2)
|
|
{
|
|
AcDbArc* pArc1 = AcDbArc::cast((AcDbEntity*)arArc.first());
|
|
AcDbArc* pArc2 = AcDbArc::cast((AcDbEntity*)arArc.last());
|
|
|
|
double dAng1 = fabs(pArc1->endAngle() - pArc1->startAngle());
|
|
double dAng2 = fabs(pArc2->endAngle() - pArc2->startAngle());
|
|
|
|
if (dAng1 > dAng2)
|
|
{
|
|
pArc->setStartAngle(pArc1->startAngle());
|
|
pArc->setEndAngle(pArc1->endAngle());
|
|
}
|
|
else
|
|
{
|
|
pArc->setStartAngle(pArc2->startAngle());
|
|
pArc->setEndAngle(pArc2->endAngle());
|
|
}
|
|
delete pArc1;
|
|
delete pArc2;
|
|
}
|
|
else if(arArc.isEmpty())
|
|
{
|
|
AcGePoint3d pt1,pt2;
|
|
pArc->getStartPoint(pt1);
|
|
pArc->getEndPoint(pt2);
|
|
|
|
double dDis1 = ptOn.distanceTo(pt1);
|
|
double dDis2 = ptOn.distanceTo(pt2);
|
|
|
|
pArc->extend( (dDis1 < dDis2 ) ? Adesk::kTrue : Adesk::kFalse,ptOn);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Trim(AcDbCurve* pCurve1,AcGePoint3d ptE1,AcDbCurve* pCurve2,AcGePoint3d ptE2)
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
pCurve1->intersectWith(pCurve2,AcDb::kExtendBoth,arPts);
|
|
|
|
//距离Mid(ptE1,ptE2)最近
|
|
AcGePoint3d ptGe;
|
|
AcGePoint3d ptMid = MidPoint(ptE1,ptE2);
|
|
|
|
int nIndex = -1;
|
|
double dMin = 9999999.0,dDis = 0;
|
|
for(int i = 0;i < arPts.length();i++)
|
|
{
|
|
ptGe = arPts.at(i);
|
|
dDis = ptGe.distanceTo(ptMid);
|
|
|
|
if (dDis < dMin)
|
|
{
|
|
dMin = dDis;
|
|
nIndex = i;
|
|
}
|
|
}
|
|
if (nIndex != -1)
|
|
{
|
|
ptGe = arPts.at(nIndex);
|
|
Trim(pCurve1,ptGe);
|
|
Trim(pCurve2,ptGe);
|
|
}
|
|
}
|
|
|
|
bool MakeConnect(AcDbVoidPtrArray& arCurPtrs,AcDbCurve* pHead,double dMinDis)
|
|
{
|
|
//只考虑直线和圆弧
|
|
AcDbCurve* pCurve = NULL;
|
|
AcGePoint3dArray arPts;
|
|
AcGePoint3d ptInt,ptS1,ptE1,ptS2,ptE2;
|
|
|
|
bool bContinue = false;
|
|
for(int i = 0;i < arCurPtrs.length();i++)
|
|
{
|
|
pCurve = (AcDbCurve*)arCurPtrs.at(i);
|
|
|
|
arPts.removeAll();
|
|
pCurve->intersectWith(pHead,AcDb::kOnBothOperands,arPts);
|
|
|
|
if (arPts.isEmpty())//不相交
|
|
{
|
|
//取两头端点最近距离
|
|
pHead->getStartPoint(ptS1);
|
|
pHead->getEndPoint(ptE1);
|
|
|
|
pCurve->getStartPoint(ptS2);
|
|
pCurve->getEndPoint(ptE2);
|
|
|
|
//如果距离小于dMinDis
|
|
double d1 = ptS1.distanceTo(ptS2);
|
|
double d2 = ptS1.distanceTo(ptE2);
|
|
double d3 = ptE1.distanceTo(ptS2);
|
|
double d4 = ptE1.distanceTo(ptE2);
|
|
|
|
//在最近端相互延长Trim
|
|
if (d1 < dMinDis)
|
|
{
|
|
Trim(pHead,ptS1,pCurve,ptS2);
|
|
bContinue = true;
|
|
}
|
|
|
|
if (d2 < dMinDis)
|
|
{
|
|
Trim(pHead,ptS1,pCurve,ptE2);
|
|
bContinue = true;
|
|
}
|
|
|
|
if (d3 < dMinDis)
|
|
{
|
|
Trim(pHead,ptE1,pCurve,ptS2);
|
|
bContinue = true;
|
|
}
|
|
|
|
if (d4 < dMinDis)
|
|
{
|
|
Trim(pHead,ptE1,pCurve,ptE2);
|
|
bContinue = true;
|
|
}
|
|
|
|
if (bContinue)
|
|
{
|
|
pHead = pCurve;
|
|
arCurPtrs.removeAt(i);
|
|
break;
|
|
}
|
|
}
|
|
else//相交,裁剪,只认一个交点
|
|
{
|
|
ptInt = arPts.first();
|
|
Trim(pHead,ptInt);
|
|
Trim(pCurve,ptInt);
|
|
|
|
bContinue = true;
|
|
pHead = pCurve;
|
|
arCurPtrs.removeAt(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bContinue && !arCurPtrs.isEmpty())
|
|
{
|
|
MakeConnect(arCurPtrs,pHead,dMinDis);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TestPoint(AcGePoint3d& ptOn)
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle;
|
|
pCir->setCenter(ptOn);
|
|
pCir->setRadius(10.0);
|
|
pCir->setColorIndex(1);
|
|
CoreTools::AddToModelSpace(pCir, true);
|
|
}
|
|
|
|
typedef struct PointParam
|
|
{
|
|
AcGePoint3d ptOn;
|
|
double dParam;
|
|
}POINTPARAM;
|
|
|
|
|
|
static bool ComparePtparam(PointParam ptParam1, PointParam ptParam2)
|
|
{
|
|
if (ptParam1.dParam - ptParam2.dParam < 1.e-10)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SortPoints(AcGePoint3dArray &points, AcDbCurve *pLine)
|
|
{
|
|
PointParam ptParam;
|
|
std::vector<PointParam> points2;
|
|
|
|
for (int i = 0; i < points.length(); i++)
|
|
{
|
|
ptParam.ptOn = points.at(i);
|
|
pLine->getParamAtPoint(points.at(i), ptParam.dParam);
|
|
points2.push_back(ptParam);
|
|
}
|
|
std::sort(points2.begin(), points2.end(), ComparePtparam);
|
|
|
|
points.setLogicalLength(0);
|
|
std::vector<PointParam>::iterator it;
|
|
for (it = points2.begin(); it < points2.end(); it++)
|
|
{
|
|
points.append((*it).ptOn);
|
|
}
|
|
}
|
|
|
|
|
|
AcDbCurve* GetPathOnWall(AcDbObjectIdArray& arWallIds,WallData& wallData,AcGeVector3d& vtDir,BOOL bPickDir = FALSE)
|
|
{
|
|
ads_point pt1,pt2;
|
|
AcDbObjectId id;
|
|
|
|
int nRes = acedGetPoint(NULL,_T("\n请在墙上选择起始点位置:"),pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(NULL,_T("\n请在墙上选择终点位置:"),pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
ads_name ent,ss;
|
|
|
|
resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
|
|
while(nRes == RTNORM)
|
|
{
|
|
nRes = CKTCadUtility::SelectEntities(_T("\n请顺序选择经过的墙<退出>:"), ss, pRb);
|
|
}
|
|
acutRelRb(pRb);
|
|
|
|
#if ARX <= 20
|
|
long nLen = 0;
|
|
#else
|
|
Adesk::Int32 nLen = 0;
|
|
#endif
|
|
acedSSLength(ss,&nLen);
|
|
for(int n = 0;n < nLen;n++)
|
|
{
|
|
acedSSName(ss,n,ent);
|
|
acdbGetObjectId(id,ent);
|
|
arWallIds.append(id);
|
|
}
|
|
acedSSFree(ss);
|
|
|
|
if (arWallIds.isEmpty())
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
ads_point pt11,pt22;
|
|
acdbUcs2Wcs(pt1,pt11,false);
|
|
acdbUcs2Wcs(pt2,pt22,false);
|
|
|
|
if (bPickDir)
|
|
{
|
|
ads_point pt3,pt33;
|
|
nRes = acedGetPoint(pt1,_T("\n请拾取点确认墙侧方向:"),pt3);
|
|
if (nRes == RTNORM)
|
|
{
|
|
acdbUcs2Wcs(pt3,pt33,false);
|
|
vtDir = asPnt3d(pt33) - asPnt3d(pt11);
|
|
vtDir.normalize();
|
|
}
|
|
else
|
|
{
|
|
acutPrintf(_T("\n错误!没有指定墙侧方向!"));
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
double dWallThick = 9999;
|
|
AcDbVoidPtrArray arCurPtrs,arReslt;
|
|
AcDbEntity* pEnt = NULL;
|
|
AcDbCurve* pCurve = NULL;
|
|
for(int i = 0;i < arWallIds.length();i++)
|
|
{
|
|
id = arWallIds.at(i);
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
pWall->GetWallData(wallData);
|
|
dWallThick = __min(dWallThick,wallData.dThick);
|
|
pCurve = pWall->GetBaseCurve(true);
|
|
arCurPtrs.append(pCurve);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
//找 pt1 点最近的线
|
|
AcDbVoidPtrArray arCurPtrsNew;
|
|
AcDbCurve* pHead = GetHeadCurve(arCurPtrs,asPnt3d(pt11));
|
|
if (pHead != NULL)
|
|
{
|
|
//首位连接
|
|
arCurPtrsNew.append(arCurPtrs);
|
|
|
|
arCurPtrs.remove(pHead);
|
|
MakeConnect(arCurPtrs,pHead,wallData.dThick);
|
|
}
|
|
|
|
AcDbCurve* pPath = KTCADUtilityEx::ConvertBoundCurve(arCurPtrsNew,arReslt);
|
|
if (pPath != NULL)
|
|
{
|
|
AcGePoint3d ptOn1,ptOn2;
|
|
Acad::ErrorStatus es1,es2;
|
|
|
|
es1 = pPath->getClosestPointTo(asPnt3d(pt11),ptOn1);
|
|
es2 = pPath->getClosestPointTo(asPnt3d(pt22),ptOn2);
|
|
|
|
//TestPoint(ptOn1);
|
|
//TestPoint(ptOn2);
|
|
|
|
if (es1 == Acad::eOk && es2 == Acad::eOk)
|
|
{
|
|
AcDbPolyline *pPl = AcDbPolyline::cast(pPath);
|
|
if (pPl != NULL)
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(ptOn1);
|
|
arPts.append(ptOn2);
|
|
SortPoints(arPts, pPath);
|
|
|
|
AcDbVoidPtrArray arSegPtrs;
|
|
pPl->getSplitCurves(arPts, arSegPtrs);
|
|
|
|
AcGePoint3d ptS, ptE;
|
|
AcDbCurve *pCrvT = NULL;
|
|
for (int n = 0;n < arSegPtrs.length();n++)
|
|
{
|
|
pCrvT = (AcDbCurve *)arSegPtrs.at(n);
|
|
|
|
pCrvT->getStartPoint(ptS);
|
|
pCrvT->getEndPoint(ptE);
|
|
|
|
if (arPts.find(ptS) != -1 &&
|
|
arPts.find(ptE) != -1)
|
|
{
|
|
delete pPath;
|
|
pPath = pCrvT;
|
|
|
|
arSegPtrs.removeAt(n);
|
|
while (!arSegPtrs.isEmpty())
|
|
{
|
|
pCrvT = (AcDbCurve *)arSegPtrs.first();
|
|
arSegPtrs.removeFirst();
|
|
delete pCrvT;
|
|
}
|
|
return pPath;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Trim(pPath,ptOn1);
|
|
Trim(pPath,ptOn2);
|
|
}
|
|
return pPath;
|
|
}
|
|
delete pPath;
|
|
pPath = NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AcDbCurve* GetPathOnWall(AcDbObjectIdArray& arWallIds,WallData& wallData,ads_point pt1,ads_point pt2)
|
|
{
|
|
ads_point pt11,pt22;
|
|
acdbUcs2Wcs(pt1,pt11,false);
|
|
acdbUcs2Wcs(pt2,pt22,false);
|
|
|
|
AcDbObjectId id;
|
|
double dWallThick = 9999;
|
|
AcDbVoidPtrArray arCurPtrs,arReslt;
|
|
AcDbEntity* pEnt = NULL;
|
|
AcDbCurve* pCurve = NULL;
|
|
for(int i = 0;i < arWallIds.length();i++)
|
|
{
|
|
id = arWallIds.at(i);
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
pWall->GetWallData(wallData);
|
|
dWallThick = __min(dWallThick,wallData.dThick);
|
|
pCurve = pWall->GetBaseCurve(true);
|
|
arCurPtrs.append(pCurve);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
//找 pt1 点最近的线
|
|
AcDbVoidPtrArray arCurPtrsNew;
|
|
AcDbCurve* pHead = GetHeadCurve(arCurPtrs,asPnt3d(pt11));
|
|
if (pHead != NULL)
|
|
{
|
|
//首位连接
|
|
arCurPtrsNew.append(arCurPtrs);
|
|
|
|
arCurPtrs.remove(pHead);
|
|
MakeConnect(arCurPtrs,pHead,wallData.dThick);
|
|
}
|
|
|
|
AcDbCurve* pPath = KTCADUtilityEx::ConvertBoundCurve(arCurPtrsNew,arReslt);
|
|
if (pPath != NULL)
|
|
{
|
|
AcGePoint3d ptOn1,ptOn2;
|
|
Acad::ErrorStatus es1,es2;
|
|
|
|
es1 = pPath->getClosestPointTo(asPnt3d(pt11),ptOn1);
|
|
es2 = pPath->getClosestPointTo(asPnt3d(pt22),ptOn2);
|
|
|
|
if (es1 == Acad::eOk && es2 == Acad::eOk)
|
|
{
|
|
AcDbPolyline *pPl = AcDbPolyline::cast(pPath);
|
|
if (pPl != NULL)
|
|
{
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(ptOn1);
|
|
arPts.append(ptOn2);
|
|
|
|
AcDbVoidPtrArray arSegPtrs;
|
|
pPl->getSplitCurves(arPts, arSegPtrs);
|
|
|
|
AcGePoint3d ptS, ptE;
|
|
AcDbCurve *pCrvT = NULL;
|
|
for (int n = 0; n < arSegPtrs.length(); n++)
|
|
{
|
|
pCrvT = (AcDbCurve *)arSegPtrs.at(n);
|
|
|
|
pCrvT->getStartPoint(ptS);
|
|
pCrvT->getEndPoint(ptE);
|
|
|
|
if (arPts.find(ptS) != -1 &&
|
|
arPts.find(ptE) != -1)
|
|
{
|
|
delete pPath;
|
|
pPath = pCrvT;
|
|
|
|
arSegPtrs.removeAt(n);
|
|
while (!arSegPtrs.isEmpty())
|
|
{
|
|
pCrvT = (AcDbCurve *)arSegPtrs.first();
|
|
arSegPtrs.removeFirst();
|
|
delete pCrvT;
|
|
}
|
|
return pPath;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Trim(pPath, ptOn1);
|
|
Trim(pPath, ptOn2);
|
|
}
|
|
return pPath;
|
|
}
|
|
delete pPath;
|
|
pPath = NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
extern void MakeConnect(AcDbCurve *pLast, AcDbCurve *pNext);
|
|
void AR_TESTCmdFnc()
|
|
{
|
|
/*AcDbObjectIdArray arWallIds;
|
|
WallData wallData;
|
|
AcGeVector3d vtDir(0,0,0);
|
|
|
|
AcDbCurve* pPl = GetPathOnWall(arWallIds,wallData,vtDir,0);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setColorIndex(4);
|
|
CoreTools::AddToModelSpace(pPl);
|
|
}*/
|
|
|
|
ads_name ent1,ent2;
|
|
ads_point pt;
|
|
int nRes = acedEntSel(_T("\npick line or arc 1:"), ent1, pt);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedEntSel(_T("\npick line or arc 2:"), ent2, pt);
|
|
if (nRes == RTNORM)
|
|
{
|
|
AcDbObjectId id1, id2;
|
|
acdbGetObjectId(id1, ent1);
|
|
acdbGetObjectId(id2, ent2);
|
|
|
|
AcDbEntity *pEnt1 = NULL, *pEnt2 = NULL;
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, id1, AcDb::kForWrite))
|
|
{
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt2, id2, AcDb::kForWrite))
|
|
{
|
|
AcDbCurve *pCr1 = AcDbCurve::cast(pEnt1);
|
|
AcDbCurve *pCr2 = AcDbCurve::cast(pEnt2);
|
|
|
|
if (pCr1 != NULL && pCr2 != NULL)
|
|
{
|
|
MakeConnect(pCr1, pCr2);
|
|
}
|
|
|
|
pEnt2->close();
|
|
}
|
|
pEnt1->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//带型窗户
|
|
void PL_DXCHCmdFnc()
|
|
{
|
|
AcDbObjectIdArray arIds;
|
|
WallData wallData;
|
|
AcGeVector3d vtDir(0,0,0);
|
|
|
|
AcDbCurve* pPath = GetPathOnWall(arIds,wallData,vtDir,TRUE);
|
|
if (pPath == NULL)
|
|
return;
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CDXCHDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
OpeningData data;
|
|
memset(&data,0,sizeof(OpeningData));
|
|
dlg.GetOpeningData(data);
|
|
data.dThick = wallData.dThick;
|
|
data.dBomEl += wallData.dBomEl;
|
|
|
|
if (pPath != NULL)
|
|
{
|
|
AcDbPolyline* pPl = AcDbPolyline::cast(pPath);
|
|
if (pPl != NULL)
|
|
{
|
|
AcDbObjectId idWall;
|
|
AecDbZLineXOpening* pZXOpening = new AecDbZLineXOpening;
|
|
pZXOpening->SetOpeningData(data,arIds);
|
|
pZXOpening->GetSpecialtyData()->SetAt(KEY_StartDir,vtDir);
|
|
|
|
AcGePoint3d ptV;
|
|
AcGePoint3dArray arPts;
|
|
for(int i = 0;i < pPl->numVerts();i++)
|
|
{
|
|
pPl->getPointAt(i,ptV);
|
|
arPts.append(ptV);
|
|
}
|
|
|
|
pZXOpening->SetZLinePoints(arPts);
|
|
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_WIN"));
|
|
pZXOpening->setLayer(idLayer);
|
|
|
|
AecComplexCurve win2d;
|
|
pZXOpening->GetStandardDraw2d(win2d,false);
|
|
|
|
|
|
AcDbObjectId idOpen;
|
|
idOpen = CoreTools::AddToModelSpace(pZXOpening,true);
|
|
|
|
for(int i = 0;i < arIds.length();i++)
|
|
{
|
|
idWall = arIds.at(i);
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idWall,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
pWall->AppendAssocPart(idOpen);
|
|
//去掉,影响墙体三维显示
|
|
//pWall->SubtractDraw2d(win2d);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
acutPrintf(_T("连接墙线有误!"));
|
|
}
|
|
delete pPath;
|
|
}
|
|
}
|
|
|
|
//绘制幕墙
|
|
void PL_HZMQCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CHZMQDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
OpeningData data;
|
|
memset(&data, 0, sizeof(OpeningData));
|
|
dlg.GetOpeningData(data);
|
|
data.dBomEl += data.dXData[5];
|
|
|
|
AcPolylineJig jig;
|
|
jig.InitStatusRecsFor2DLineSegs();
|
|
if (jig.DoIt())
|
|
{
|
|
AcDbObjectId id = jig.GetRoadAxisLineId();
|
|
|
|
AcDbEntity *pEnt = NULL;
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
|
|
{
|
|
AecDb3dRoadAxisLine *pRoadAxLn = AecDb3dRoadAxisLine::cast(pEnt);
|
|
if (pRoadAxLn != NULL)
|
|
{
|
|
AcDbPolyline* pPl = pRoadAxLn->ConvertTo2dPline();
|
|
if (pPl != NULL)
|
|
{
|
|
AcGeVector3d vtDir(0, 0, 0);
|
|
AcDbObjectId idWall;
|
|
AcDbObjectIdArray arIds;
|
|
|
|
AecDbGlassCurtainWall *pZXOpening = new AecDbGlassCurtainWall;
|
|
pZXOpening->SetOpeningData(data, arIds);
|
|
pZXOpening->GetSpecialtyData()->SetAt(KEY_StartDir, vtDir);
|
|
|
|
AcGePoint3d ptV;
|
|
AcGePoint3dArray arPts;
|
|
for (int i = 0; i < pPl->numVerts(); i++)
|
|
{
|
|
pPl->getPointAt(i, ptV);
|
|
pPl->getBulgeAt(i, ptV.z);
|
|
arPts.append(ptV);
|
|
}
|
|
|
|
pZXOpening->SetZLinePoints(arPts);
|
|
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_WIN"));
|
|
pZXOpening->setLayer(idLayer);
|
|
|
|
AecComplexCurve win2d;
|
|
pZXOpening->GetStandardDraw2d(win2d, false);
|
|
|
|
AcDbObjectId idOpen;
|
|
idOpen = CoreTools::AddToModelSpace(pZXOpening, true);
|
|
}
|
|
}
|
|
|
|
//TEST
|
|
//pEnt->erase();
|
|
pEnt->setColorIndex(1);
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//直角窗户
|
|
void PL_ZJCHCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CZJCHDlg dlg;
|
|
if (IDOK == dlg.DoModal() )
|
|
{
|
|
ads_point pt0,pt1,pt2;
|
|
int nRes = acedGetPoint(NULL,_T("\n请选取两墙体的墙角<退出>"),pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
ads_point ptL,ptR;
|
|
ads_point_set(pt1, ptL);
|
|
ads_point_set(pt1, ptR);
|
|
ptL[X] -= CoreTools::PixelToWcs(10);
|
|
ptL[Y] -= CoreTools::PixelToWcs(10);
|
|
ptR[X] += CoreTools::PixelToWcs(10);
|
|
ptR[Y] += CoreTools::PixelToWcs(10);
|
|
|
|
//AecDbXWall
|
|
ads_name ss,ent;
|
|
TCHAR szBuf[256];
|
|
struct resbuf eb1;
|
|
eb1.restype = 0;
|
|
_tcscpy(szBuf, _T("AEC_DBWALL"));
|
|
eb1.resval.rstring = szBuf;
|
|
eb1.rbnext = NULL;
|
|
|
|
acedSSGet(_T("C"), ptL, ptR, &eb1, ss);
|
|
Adesk::Int32 lLen = 0;
|
|
acedSSLength(ss, &lLen);
|
|
|
|
AcDbObjectIdArray idWalls;
|
|
if (lLen == 2)
|
|
{
|
|
AcDbObjectId id;
|
|
acedSSName(ss,0,ent);
|
|
acdbGetObjectId(id,ent);
|
|
idWalls.append(id);
|
|
|
|
acedSSName(ss,1,ent);
|
|
acdbGetObjectId(id,ent);
|
|
idWalls.append(id);
|
|
}
|
|
else
|
|
{
|
|
acutPrintf(_T("\n选择的位置没有选到墙角的两面墙体!"));
|
|
return;
|
|
}
|
|
acedSSFree(ss);
|
|
|
|
OpeningData data;
|
|
memset(&data, 0, sizeof(OpeningData));
|
|
dlg.GetOpeningData(data);
|
|
|
|
//acedsse
|
|
nRes = acedGetPoint(pt1,_T("\n请选择转角距离1<1000>"),pt0);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1,_T("\n请选择转角距离2<1000>"),pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
WallData wallData;
|
|
double dWallThick = 0;
|
|
AcDbEntity* pEnt = NULL;
|
|
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idWalls.first(),AcDb::kForRead))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
pWall->GetWallData(wallData);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
|
|
AcDbCurve* pPath = GetPathOnWall(idWalls,wallData,pt0,pt2);
|
|
if (pPath != NULL)
|
|
{
|
|
AcDbPolyline* pPl = AcDbPolyline::cast(pPath);
|
|
if (pPl != NULL)
|
|
{
|
|
data.dThick = wallData.dThick;
|
|
AcDbObjectId idWall;
|
|
AecDbZLineXOpening* pZXOpening = new AecDbZLineXOpening;
|
|
pZXOpening->SetOpeningData(data,idWalls);
|
|
|
|
AcGeVector3d vtDir(0,0,0);
|
|
pZXOpening->GetSpecialtyData()->SetAt(KEY_StartDir,vtDir);
|
|
|
|
AcGePoint3d ptV;
|
|
AcGePoint3dArray arPts;
|
|
for(int i = 0;i < pPl->numVerts();i++)
|
|
{
|
|
pPl->getPointAt(i,ptV);
|
|
arPts.append(ptV);
|
|
}
|
|
|
|
pZXOpening->SetZLinePoints(arPts);
|
|
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_WIN"));
|
|
pZXOpening->setLayer(idLayer);
|
|
|
|
AecComplexCurve win2d;
|
|
pZXOpening->GetStandardDraw2d(win2d,false);
|
|
|
|
AcDbObjectId idOpen;
|
|
idOpen = CoreTools::AddToModelSpace(pZXOpening,true);
|
|
|
|
for(int i = 0;i < idWalls.length();i++)
|
|
{
|
|
idWall = idWalls.at(i);
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idWall,AcDb::kForWrite))
|
|
{
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (pWall != NULL)
|
|
{
|
|
pWall->AppendAssocPart(idOpen);
|
|
pWall->SubtractDraw2d(win2d);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
delete pPath;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//直线楼梯
|
|
void PL_ZXLTCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CZXLTDlg dlg;
|
|
if (IDOK == dlg.DoModal() )
|
|
{
|
|
LineStair data;
|
|
memset(&data,0,sizeof(LineStair));
|
|
|
|
ads_point pt1,pt2;
|
|
int nRes = acedGetPoint(NULL,_T("\n选择楼梯起点位置:"),pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1,_T("\n选择楼梯放置方向:"),pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2,pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"),dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1,ptGe2;
|
|
|
|
ads_point pt11,pt22;
|
|
acdbUcs2Wcs(pt1,pt11,false);
|
|
acdbUcs2Wcs(pt2,pt22,false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
ptGe1.z = dlg.m_dBomEl;
|
|
ptGe2.z = dlg.m_dBomEl + data.nSteepS * data.dSteepH;
|
|
|
|
dlg.GetLineStairData(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"),true);
|
|
|
|
AecDbLineSegStair* pLnStair = new AecDbLineSegStair;
|
|
pLnStair->setLayer(idLayStair);
|
|
|
|
pLnStair->SetLineStairData(data);
|
|
pLnStair->SetSection(data.bar.dD,0.0);
|
|
pLnStair->SetBaseCurve(&ln);
|
|
|
|
pLnStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE,0);
|
|
CKTCadUtility::AddToBlockTableRecord(pLnStair);
|
|
pLnStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PL_FZPDCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CFZPDDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
AscentData data;
|
|
memset(&data,0,sizeof(AscentData));
|
|
|
|
dlg.GetAscentData(data);
|
|
|
|
ads_point pt0,pt1;
|
|
int nRes = acedGetPoint(NULL,_T("\n选择坡道放置起点:"),pt0);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt0,_T("\n选择坡道放置终点:"),pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
ads_point pt00,pt11;
|
|
acdbUcs2Wcs(pt0,pt00,false);
|
|
acdbUcs2Wcs(pt1,pt11,false);
|
|
|
|
AecDbAscent* pAsent = new AecDbAscent;
|
|
pAsent->SetAscentData(data);
|
|
pAsent->SetBaseCurve(asPnt3d(pt00),asPnt3d(pt11));
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"),true);
|
|
pAsent->setLayer(idLayStair);
|
|
|
|
CKTCadUtility::AddToBlockTableRecord(pAsent);
|
|
pAsent->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PL_FZYTCmdFnc()
|
|
{
|
|
AcDbObjectIdArray arIds;
|
|
WallData wallData;
|
|
AcGeVector3d vtDir(0,0,0);
|
|
|
|
AcDbCurve* pPath = GetPathOnWall(arIds,wallData,vtDir,TRUE);
|
|
if (pPath == NULL)
|
|
return;
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CFZYTDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
BalconyData data;
|
|
memset(&data,0,sizeof(BalconyData));
|
|
dlg.GetBalconyData(data);
|
|
data.dBomEl += wallData.dBomEl;
|
|
data.dRailWidth += wallData.dThick * .5;
|
|
|
|
//LINE,POLYLINE
|
|
if (pPath != NULL)
|
|
{
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_BALCONY"),true);
|
|
|
|
AecDbBalcony* pBalcony = new AecDbBalcony;
|
|
|
|
if (idLayer.isValid())
|
|
pBalcony->setLayer(idLayer);
|
|
|
|
pBalcony->SetBalconyData(data);
|
|
pBalcony->SetBaseCurve(pPath);
|
|
|
|
pBalcony->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_StartDir,vtDir);
|
|
pBalcony->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_2DSTYLE,0);
|
|
|
|
AcDbObjectId idBny = CoreTools::AddToModelSpace(pBalcony);
|
|
|
|
DELETE_PTR(pPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_DBASCENT()
|
|
{
|
|
//阳台双击
|
|
}
|
|
|
|
//放置台阶
|
|
void PL_FZTJCmdFnc()
|
|
{
|
|
//从墙上依次选择路径点,和带型窗户类似
|
|
AcDbObjectIdArray arIds;
|
|
WallData wallData;
|
|
AcGeVector3d vtDir(0, 0, 0);
|
|
|
|
AcDbCurve* pPath = GetPathOnWall(arIds, wallData, vtDir, TRUE);
|
|
if (pPath == NULL)
|
|
return;
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CFZTJDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
XStepData data;
|
|
memset(&data, 0, sizeof(XStepData));
|
|
dlg.GetXStepData(data);
|
|
data.dBaseEl += wallData.dBomEl;
|
|
|
|
//根据路径，和外方向创建台阶
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_BALCONY"), true);
|
|
AecDbXStep* pXStep = new AecDbXStep;
|
|
|
|
if (idLayer.isValid())
|
|
pXStep->setLayer(idLayer);
|
|
|
|
pXStep->SetXStepData(data);
|
|
pXStep->SetBaseCurve(pPath);
|
|
|
|
pXStep->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_StartDir, vtDir);
|
|
pXStep->GetSpecialtyData(AcDb::kForWrite)->SetAt(KEY_2DSTYLE, 0);
|
|
|
|
AcDbObjectId idBny = CoreTools::AddToModelSpace(pXStep);
|
|
|
|
DELETE_PTR(pPath);
|
|
}
|
|
}
|
|
|
|
//双击台阶
|
|
void DBL_AEC_DBXSTEP()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBXSTEP"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbXStep, pXStep)
|
|
if (pXStep)
|
|
{
|
|
XStepData data;
|
|
::memset(&data, 0, sizeof(XStepData));
|
|
pXStep->GetXStepData(data);
|
|
CAcModuleResourceOverride myResources;
|
|
CFZTJDlg dlg;
|
|
dlg.SetXStepData(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(XStepData));
|
|
dlg.GetXStepData(data);
|
|
pXStep->SetXStepData(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
//放置散水
|
|
void PL_FZSSCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
CFZSSDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
AcGeVector3d vtDir(0, 0, 0);
|
|
|
|
AcPolylineJig jig;
|
|
jig.InitStatusRecsForPolyline();
|
|
if (jig.DoIt())
|
|
{
|
|
AcDbObjectId id = jig.GetRoadAxisLineId();
|
|
|
|
AcDbEntity *pEnt = NULL;
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
|
|
{
|
|
AecDb3dRoadAxisLine *pRoadAxLn = AecDb3dRoadAxisLine::cast(pEnt);
|
|
if (pRoadAxLn != NULL)
|
|
{
|
|
AcDbPolyline* pPl = pRoadAxLn->ConvertTo2dPline();
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setClosed(Adesk::kTrue);
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_BALCONY"), true);
|
|
|
|
AecDbXApron *pApron = new AecDbXApron;
|
|
pApron->setLayer(idLayer);
|
|
|
|
pApron->SetBaseCurve(pPl);
|
|
pApron->SetSection(10, 10, 0);//占位
|
|
pApron->SetConstantWidth(dlg.m_dW);
|
|
pApron->SetInsideThick(dlg.m_dInThick);
|
|
pApron->SetOutSideThick(dlg.m_dOutThick);
|
|
pApron->SetOffsetFromWall(dlg.m_dOffFrWall);
|
|
pApron->GetSpecialtyData()->SetAt(KEY_BOMEL, dlg.m_dEl);
|
|
pApron->GetSpecialtyData()->SetAt(KEY_StartDir, vtDir);
|
|
|
|
AcDbObjectId idBny = CoreTools::AddToModelSpace(pApron);
|
|
delete pPl;
|
|
}
|
|
}
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//双击散水
|
|
void DBL_AEC_DBXAPRON()
|
|
{
|
|
//使用 CFZSS2Dlg 修改每段宽度
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBXAPRON"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbXApron, pApron)
|
|
if (!pApron)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double dInThick = pApron->GetInsideThick();
|
|
double dOutThick = pApron->GetOutSideThick();
|
|
double dOffFrWall = pApron->GetOffsetFromWall();
|
|
double dEl(.0);
|
|
pApron->GetSpecialtyData()->GetAt(KEY_BOMEL, dEl);
|
|
|
|
std::vector<double> arWidthd;
|
|
arWidthd.clear();
|
|
int nCount = pApron->GetWidthSegCount();
|
|
double dW(.0);
|
|
for (int i(0); i < nCount; ++i)
|
|
{
|
|
dW = pApron->GetWidth(i);
|
|
arWidthd.push_back(dW);
|
|
}
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CFZSS2Dlg dlg(arWidthd, dOffFrWall, dEl, dInThick, dOutThick);
|
|
if (dlg.DoModal() != IDOK)
|
|
{
|
|
return;
|
|
}
|
|
std::vector<CString> arWidths;
|
|
arWidths.clear();
|
|
dlg.getUserInputData(arWidths);
|
|
for (int i(0); i < arWidths.size(); ++i)
|
|
{
|
|
dW = _ttof(arWidths.at(i));
|
|
pApron->SetWidth(i, dW);
|
|
}
|
|
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void AR_YHLTCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CYHLTDlg dlg;
|
|
if (IDOK != dlg.DoModal()) return;
|
|
|
|
SFPXStair data;
|
|
memset(&data, 0, sizeof(SFPXStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
|
|
if (nRes != RTNORM) return;
|
|
|
|
nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
|
|
if (nRes != RTNORM) return;
|
|
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
ptGe1.z = dlg.m_dBomEl;
|
|
ptGe2.z = dlg.m_dBomEl + data.nSteepS * data.dSteepH;
|
|
|
|
dlg.GetSFPXStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbArcSegStair* pArcStair = new AecDbArcSegStair;
|
|
pArcStair->setLayer(idLayStair);
|
|
|
|
pArcStair->SetSFPXStair(data);
|
|
pArcStair->SetSection(data.dGarSize[0], 0.0);
|
|
pArcStair->SetBaseCurve(&ln);
|
|
|
|
pArcStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pArcStair);
|
|
pArcStair->close();
|
|
}
|
|
|
|
void PL_SFPXCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CSFPXLTDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
SFPXStair data;
|
|
memset(&data, 0, sizeof(SFPXStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
dlg.GetSFPXStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbParaLlelStair *pLnStair = new AecDbParaLlelStair;
|
|
pLnStair->setLayer(idLayStair);
|
|
|
|
pLnStair->SetSFPXStair(data);
|
|
pLnStair->SetSection(data.dBarSize[0], 0.0);
|
|
pLnStair->SetBaseCurve(&ln);
|
|
|
|
pLnStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pLnStair);
|
|
pLnStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PL_SFZJCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CSFZJLTDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
SFPXStair data;
|
|
memset(&data, 0, sizeof(SFPXStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
dlg.GetSFPXStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbCornerStair *pLnStair = new AecDbCornerStair;
|
|
pLnStair->setLayer(idLayStair);
|
|
|
|
pLnStair->SetSFPXStair(data);
|
|
pLnStair->SetSection(data.dBarSize[0], 0.0);
|
|
pLnStair->SetBaseCurve(&ln);
|
|
|
|
pLnStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pLnStair);
|
|
pLnStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PL_SPSPCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CSFSPLTDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
SFSPStair data;
|
|
memset(&data, 0, sizeof(SFSPStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
dlg.GetSFSPStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbDoubleMulStair *pStair = new AecDbDoubleMulStair;
|
|
pStair->setLayer(idLayStair);
|
|
|
|
pStair->SetSFPXStair(data);
|
|
pStair->SetSection(data.dBarSize[0], 0.0);
|
|
pStair->SetBaseCurve(&ln);
|
|
|
|
pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pStair);
|
|
pStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PL_JCLTCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CJCLTDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
SFSPStair data;
|
|
memset(&data, 0, sizeof(SFSPStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
dlg.GetSFPXStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbScissorsStair *pStair = new AecDbScissorsStair;
|
|
pStair->setLayer(idLayStair);
|
|
|
|
pStair->SetSFPXStair(data);
|
|
pStair->SetSection(data.dBarSize[0], 0.0);
|
|
pStair->SetBaseCurve(&ln);
|
|
|
|
pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pStair);
|
|
pStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PL_shltCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CNewLineType dlg;
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
CString ss;
|
|
CString sLtName(dlg.m_sName), sLtDesc, sLtWord(dlg.m_sWord), sLtStyle(dlg.m_sTextStyle);
|
|
double dLineSpace(dlg.m_dLineL), dSpace1(dlg.m_dSpace1), dSpace2(dlg.m_dSpace2)
|
|
, dS(dlg.m_dS), dR(dlg.m_dR), dX(dlg.m_dX), dY(dlg.m_dY);
|
|
|
|
sLtDesc.Format(_T("%s----%s----%s----%s----%s----%s----%s"), sLtName
|
|
, sLtWord
|
|
, sLtWord
|
|
, sLtWord
|
|
, sLtWord
|
|
, sLtWord
|
|
, sLtWord);
|
|
|
|
ss.Format(_T("*%s,%s\nA,%.2f,%.2f,[\"%s\",%s,S=%.2f,R=%.2f,X=%.2f,Y=%.2f],%.2f"), sLtName
|
|
, sLtDesc
|
|
, dLineSpace
|
|
, dSpace1
|
|
, sLtWord
|
|
, sLtStyle
|
|
, dS
|
|
, dR
|
|
, dX
|
|
, dY
|
|
, dSpace2 );
|
|
|
|
std::string str = Base64::unicode2Ansii(ss, CP_UTF8);
|
|
|
|
CString path = CoreTools::getSystemTemporaryFolder() + _T("\\shlt.lin");
|
|
CFile file;
|
|
if (file.Open(path, CFile::modeReadWrite | CFile::modeCreate))
|
|
{
|
|
file.Write(str.c_str(), str.size() * sizeof(char));
|
|
file.Close();
|
|
CoreTools::loadLineType(CoreTools::getSystemTemporaryFolder(), sLtName);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
//剪刀楼梯
|
|
void PL_JDLTCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CJDLTDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
SFSPStair data;
|
|
memset(&data, 0, sizeof(SFSPStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择楼梯起点位置:"), pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1, _T("\n选择楼梯放置方向:"), pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
dlg.GetSFPXStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbCrossStair *pStair = new AecDbCrossStair;
|
|
pStair->setLayer(idLayStair);
|
|
|
|
pStair->SetSFPXStair(data);
|
|
pStair->SetSection(data.dBarSize[0], 0.0);
|
|
pStair->SetBaseCurve(&ln);
|
|
|
|
pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pStair);
|
|
pStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//三角楼梯
|
|
void PL_SJLTCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CSJLTDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
SFSPStair data;
|
|
memset(&data, 0, sizeof(SFSPStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择三角楼梯一边起点位置:"), pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1, _T("\n选择三角楼梯一边终点位置:"), pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
dlg.GetSFPXStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbTriangleStair *pStair = new AecDbTriangleStair;
|
|
pStair->setLayer(idLayStair);
|
|
|
|
pStair->SetSFPXStair(data);
|
|
pStair->SetSection(data.dBarSize[0], 0.0);
|
|
pStair->SetBaseCurve(&ln);
|
|
|
|
pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pStair);
|
|
pStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//矩形转角
|
|
void PL_JXZJCmdFnc()
|
|
{
|
|
CAcModuleResourceOverride myResources;
|
|
|
|
CJXZJDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
SFSPStair data;
|
|
memset(&data, 0, sizeof(SFSPStair));
|
|
|
|
ads_point pt1, pt2;
|
|
int nRes = acedGetPoint(NULL, _T("\n选择矩形转角楼梯一边起点位置:"), pt1);
|
|
if (nRes == RTNORM)
|
|
{
|
|
nRes = acedGetPoint(pt1, _T("\n选择矩形转角楼梯一边终点位置:"), pt2);
|
|
if (nRes == RTNORM)
|
|
{
|
|
double dDis = acutDistance(pt2, pt1);
|
|
if (dDis < 1.0)
|
|
{
|
|
acutPrintf(_T("\n拾取的两点距离(%g)太短，创建不了楼梯!"), dDis);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptGe1, ptGe2;
|
|
|
|
ads_point pt11, pt22;
|
|
acdbUcs2Wcs(pt1, pt11, false);
|
|
acdbUcs2Wcs(pt2, pt22, false);
|
|
|
|
ptGe1 = asPnt3d(pt11);
|
|
ptGe2 = asPnt3d(pt22);
|
|
|
|
dlg.GetSFPXStair(data);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe1);
|
|
ln.setEndPoint(ptGe2);
|
|
|
|
AcDbObjectId idLayStair = KTSetting::InitLayer(_T("LAY_CSTAIR"), true);
|
|
|
|
AecDbRectCornerStair *pStair = new AecDbRectCornerStair;
|
|
pStair->setLayer(idLayStair);
|
|
|
|
pStair->SetSFPXStair(data);
|
|
pStair->SetSection(data.dBarSize[0], 0.0);
|
|
pStair->SetBaseCurve(&ln);
|
|
|
|
pStair->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 0);
|
|
CKTCadUtility::AddToBlockTableRecord(pStair);
|
|
pStair->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void PL_DPLTCmdFnc()
|
|
{
|
|
|
|
}
|
|
|
|
//取中心位置为做块的插入位置
|
|
bool MakeBlockRecord(AcDbVoidPtrArray& arEntPtrs,AcDbObjectId& idRec,AcGePoint3d& ptIns,CString& sNameSet,AcDbDatabase* pDb = NULL)
|
|
{
|
|
if (pDb == NULL)
|
|
pDb = acdbCurDwg();
|
|
|
|
AcGeVector3d vtMove = ptIns.asVector();
|
|
vtMove.negate();
|
|
|
|
AcGeMatrix3d xform;
|
|
xform.setToTranslation(vtMove);
|
|
|
|
//名称必须唯一,待定
|
|
CString sName;
|
|
|
|
AcDbBlockTableRecord *pRec = new AcDbBlockTableRecord;
|
|
pRec->setName(_T("*U"));
|
|
pRec->setOrigin(AcGePoint3d::kOrigin);
|
|
|
|
AcDbEntity* pEnt(NULL);
|
|
for (int i = 0; i < arEntPtrs.length(); i++)
|
|
{
|
|
pEnt = (AcDbEntity *)arEntPtrs.at(i);
|
|
pEnt->transformBy(xform);
|
|
pRec->appendAcDbEntity(pEnt);
|
|
pEnt->close();
|
|
}
|
|
arEntPtrs.removeAll();
|
|
|
|
AcDbBlockTable *pTbl = NULL;
|
|
if (Acad::eOk == pDb->getBlockTable(pTbl, AcDb::kForWrite))
|
|
{
|
|
pTbl->add(idRec, pRec);
|
|
pTbl->close();
|
|
|
|
TCHAR szHd[17];
|
|
idRec.handle().getIntoAsciiBuffer(szHd);
|
|
|
|
if (sNameSet.CompareNoCase(_T("*U")) == 0 )
|
|
{
|
|
//内部分配的名称
|
|
LPCTSTR pszName = NULL;
|
|
pRec->getName(pszName);
|
|
sNameSet = pszName;
|
|
}
|
|
else
|
|
{
|
|
sName.Format(_T("%s@%s"), sNameSet, szHd);
|
|
Acad::ErrorStatus es = pRec->setName(sName);
|
|
}
|
|
pRec->close();
|
|
}
|
|
return idRec.isValid();
|
|
}
|
|
|
|
//插入角柱
|
|
void PL_CRJZCmdFnc()
|
|
{
|
|
/*
|
|
// 1.请选择墙体的内侧角点: ptInt
|
|
// != 2
|
|
// ss --> ids
|
|
|
|
// 1.1 验证选择是 2 直线墙
|
|
if ( !IsLineWallCorner(idS,ptInt))
|
|
{
|
|
//。。。
|
|
}
|
|
|
|
//请选择墙体1上一点(长度A): ptA
|
|
//请选择墙体2上一点(长度B): ptB
|
|
|
|
2. 通过 ptA,ptB 分出 墙A id 墙B id
|
|
2.1 提取墙的属性后,立刻关闭
|
|
GetWallAB(idS,ptA,idA,idB);
|
|
|
|
s----a------ e b1
|
|
|
|
|
|
|
|
|b b-b1 < wall.t.05
|
|
vt1 = a - s
|
|
vt2 = a - e
|
|
vt1.isparll(vt2 ) vt1.dotpr(vt2) < 1.e-10
|
|
|
|
AcDbCurve* pBaseCrv = ;
|
|
ptBaseCrv->getcloseto(ptA,ptA1,true);
|
|
|
|
|
|
//提取idA,idB 的数据 和 ptInt,到 ptA,ptB的长度
|
|
|
|
dlg.Set...).
|
|
3. 弹出对话框 ,填入从墙提取的需要的数据
|
|
|
|
|
|
3.1 确定 创建柱子
|
|
3.2 根据ptA 裁剪 墙A ，根据 ptB裁剪墙B
|
|
此处重复，可以方法重调用
|
|
CutWall(idA,ptInt,dlg.m_dA);
|
|
CutWall(idB,ptInt,dlg.m_dB);
|
|
|
|
-------------------+
|
|
ptS,ptE;
|
|
if ( ptS.distanceto(ptInt) < ptE.distanceto(ptE) )
|
|
{
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
ads_point ptInt;
|
|
int nRes = acedGetPoint(NULL, _T("\n请选择墙体的内侧角点:"), ptInt);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double dSize = CoreTools::PixelToWcs(5);//5
|
|
ads_point pt1, pt2;
|
|
ads_point_set(ptInt, pt1);
|
|
ads_point_set(ptInt, pt2);
|
|
pt1[X] -= dSize;
|
|
pt1[Y] -= dSize;
|
|
pt2[X] += dSize;
|
|
pt2[Y] += dSize;
|
|
|
|
//得到墙体
|
|
ads_name ss, ent;
|
|
struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
|
|
nRes = acedSSGet(_T("C"), pt1, pt2, pRb, ss);
|
|
acutRelRb(pRb);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Adesk::Int32 nLen = 0;
|
|
acedSSLength(ss, &nLen);
|
|
if (nLen != 2)
|
|
{
|
|
acedSSFree(ss);
|
|
return;
|
|
}
|
|
|
|
AcDbObjectId id, idLay;
|
|
AcDbObjectIdArray arWallIds;
|
|
arWallIds.removeAll();
|
|
acedSSLength(ss, &nLen);
|
|
for (int n = 0; n < nLen; n++)
|
|
{
|
|
acedSSName(ss, n, ent);
|
|
acdbGetObjectId(id, ent);
|
|
|
|
arWallIds.append(id);
|
|
}
|
|
|
|
bool b = isLineWallCorner(arWallIds);
|
|
if (!b)
|
|
{
|
|
acedSSFree(ss);
|
|
return;
|
|
}
|
|
|
|
acedSSName(ss, 0, ent);
|
|
acdbGetObjectId(id, ent);
|
|
acedSSFree(ss);
|
|
|
|
AcDbEntity* pEnt(NULL);
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
|
|
{
|
|
return;
|
|
}
|
|
|
|
idLay = pEnt->layerId();
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (!pWall)
|
|
{
|
|
pEnt->close();//2023-8-1
|
|
return;
|
|
}
|
|
|
|
WallData data;
|
|
::memset(&data, 0, sizeof(WallData));
|
|
pWall->GetWallData(data);
|
|
pEnt->close();
|
|
|
|
nRes = acedGetPoint(ptInt, _T("\n请选择墙体1上一点(长度A):"), pt1);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
nRes = acedGetPoint(ptInt, _T("\n请选择墙体2上一点(长度B):"), pt2);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ads_point ptWInt, ptW1, ptW2;
|
|
acdbUcs2Wcs(ptInt, ptWInt, false);
|
|
acdbUcs2Wcs(pt1, ptW1, false);
|
|
acdbUcs2Wcs(pt2, ptW2, false);
|
|
|
|
AcGeVector3d vt, Z(AcGeVector3d::kZAxis);
|
|
AcGePoint3d ptGe[3];
|
|
ptGe[0] = asPnt3d(ptW1);
|
|
ptGe[1] = asPnt3d(ptWInt);
|
|
ptGe[2] = asPnt3d(ptW2);
|
|
|
|
AcDbObjectId idA, idB;
|
|
idA = GetWallAB(arWallIds, ptGe[0], data);
|
|
idB = GetWallAB(arWallIds, ptGe[2], data);
|
|
|
|
double dThickA = GetWallThick(idA);
|
|
double dThickB = GetWallThick(idB);
|
|
|
|
double dDistA = ptGe[1].distanceTo(ptGe[0]);
|
|
double dDistB = ptGe[1].distanceTo(ptGe[2]);
|
|
ColumnParam ColParam;
|
|
memset(&ColParam, 0, sizeof(ColumnParam));
|
|
ColParam.m_dBomEl = data.dBomEl;
|
|
ColParam.m_dH = data.dH;
|
|
ColParam.m_dSizes[0] = dDistA;
|
|
ColParam.m_dSizes[1] = dDistB;
|
|
ColParam.m_dSizes[2] = dThickA;//墙A 厚度 2023-8-1
|
|
ColParam.m_dSizes[3] = dThickB;//墙B 厚度 2023-8-1
|
|
|
|
AcDbRegion *pReg = CCRJZDlg::makeRegion(ptGe[1], ptGe[0], ptGe[2], dThickA, dThickB);
|
|
if (!pReg)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*... 参考如下
|
|
pRegAll 角点为0,0点造region, 并且做成块
|
|
ptPos角点*/
|
|
|
|
/*AcDbRegion* pRegClone = (AcDbRegion*)pReg->clone();
|
|
if (!pRegClone)
|
|
{
|
|
DELETE_PTR(pReg);
|
|
return;
|
|
}*/
|
|
|
|
//弹出对话框
|
|
CAcModuleResourceOverride myResources;
|
|
CCRJZDlg dlg;
|
|
dlg.SetColumnParam(ColParam);
|
|
dlg.setColumnReg(pReg);
|
|
if (IDOK != dlg.DoModal())
|
|
{
|
|
DELETE_PTR(pReg);
|
|
return;
|
|
}
|
|
|
|
CutWall(idA, ptGe[1], dDistA, data);
|
|
CutWall(idB, ptGe[1], dDistB, data);
|
|
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_COLU"));
|
|
|
|
AecDbColumn* pCol = new AecDbColumn;
|
|
pCol->setLayer(idLayer);
|
|
pCol->SetSection(pReg, AcGePoint3d::kOrigin);
|
|
|
|
AcGePoint3d ptSta, ptEnd;
|
|
ptSta = ptGe[1];
|
|
ptSta.z = ColParam.m_dBomEl;
|
|
ptEnd = ptGe[1];
|
|
ptEnd.z = ColParam.m_dBomEl + ColParam.m_dH;
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptSta);
|
|
ln.setEndPoint(ptEnd);
|
|
pCol->SetBaseCurve(&ln);
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(-ptGe[1].asVector());
|
|
ptGe[0].transformBy(mat);
|
|
ptGe[1].transformBy(mat);
|
|
ptGe[2].transformBy(mat);
|
|
pCol->GetSpecialtyData()->SetAt(CCRJZDlg::_JZ_PT_A, ptGe[0]);
|
|
pCol->GetSpecialtyData()->SetAt(CCRJZDlg::_JZ_PT_INNER, ptGe[1]);
|
|
pCol->GetSpecialtyData()->SetAt(CCRJZDlg::_JZ_PT_B, ptGe[2]);
|
|
|
|
//pCol->GetSpecialtyData()->SetAt(KEY_NO,pCol->m_sGUID);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_MATERIAL, ColParam.m_sMaterial);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SHAPE, 6);//6 ColParam.m_nShape
|
|
|
|
//Section 已经按照ref做了旋转
|
|
pCol->GetSpecialtyData()->SetAt(KEY_ROTATION, 0.0);//ColParam.m_dRotAngle * PI / 180.0);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_ROTATIONBK, ColParam.m_dRotAngle);
|
|
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE1, ColParam.m_dSizes[0]);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE2, ColParam.m_dSizes[1]);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE3, ColParam.m_dSizes[2]);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE4, ColParam.m_dSizes[3]);
|
|
|
|
//pCol->GetSpecialtyData()->SetAt(AecDbColumn::KEY_COL_MODEL, ColParam.m_sModel);// 会出错
|
|
|
|
//结构信息
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SECTION_HATCH, dlg.m_sHatch);
|
|
|
|
// 匿名块
|
|
AcDbEntity* pSubEnt(NULL);
|
|
AcDbVoidPtrArray arEnt, arReg;
|
|
arEnt.removeAll();
|
|
arReg.removeAll();
|
|
pReg->explode(arReg);
|
|
DELETE_PTR(pReg);
|
|
for (int i(0); i < arReg.length(); i++)
|
|
{
|
|
pSubEnt = (AcDbEntity*)arReg.at(i);
|
|
arEnt.append(pSubEnt);
|
|
}
|
|
|
|
//2023-8-1
|
|
CString sNameSet = _T("*U");
|
|
MakeBlockRecord(arEnt, ColParam.m_idRec, ptGe[1], sNameSet);
|
|
_tcscpy(ColParam.m_sBlockName, (LPCTSTR)sNameSet);
|
|
|
|
pCol->GetSpecialtyData()->SetAt(KEY_BLOCKNAME, ColParam.m_sBlockName);
|
|
|
|
CKTCadUtility::AddToBlockTableRecord(pCol);
|
|
|
|
pCol->close();
|
|
}
|
|
|
|
//选择闭合pl线创建柱子
|
|
void PL_GZZZCmdFnc()
|
|
{
|
|
struct resbuf *pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE"), 0);
|
|
|
|
ads_name ent;
|
|
ads_point adsPt;
|
|
int nRes = CKTCadUtility::SelectEntity(_T("\n请选择柱子投影闭合Pl线:"), ent, pRb, adsPt);
|
|
acutRelRb(pRb);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ads_point ptCen;
|
|
nRes = acedGetPoint(NULL, _T("\n请从投影闭合Pl线上选择柱子插入基点:"), ptCen);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//弹出柱子界面
|
|
CAcModuleResourceOverride myResources;
|
|
CGZZZDlg dlg;
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
ColumnParam ColParam;
|
|
memset(&ColParam, 0, sizeof(ColumnParam));
|
|
ColParam.m_dBomEl = dlg.m_dBomEl;
|
|
ColParam.m_dH = dlg.m_dH;
|
|
_tcscpy(ColParam.m_sMaterial, dlg.m_sMaterial);
|
|
_tcscpy(ColParam.m_sModel, dlg.m_sModel);
|
|
|
|
AcDbObjectId id;
|
|
acdbGetObjectId(id, ent);
|
|
|
|
AcDbVoidPtrArray arCrv, arReg;
|
|
|
|
AcDbEntity *pEnt = NULL;
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead))
|
|
{
|
|
AcDbPolyline *pPl = AcDbPolyline::cast(pEnt);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setElevation(0);
|
|
arCrv.append(pPl->clone());
|
|
AcDbRegion::createFromCurves(arCrv, arReg);
|
|
}
|
|
pEnt->close();
|
|
}
|
|
|
|
if (arReg.isEmpty())
|
|
{
|
|
acutPrintf(_T("\n创建柱子截面失败!请检查选择的曲线是否是闭合pl线!"));
|
|
return;
|
|
}
|
|
|
|
|
|
ads_point pt2;
|
|
acdbUcs2Wcs(ptCen, pt2, false);
|
|
AcGeVector3d vt = asPnt3d(pt2).asVector();
|
|
vt.z = 0.0;
|
|
|
|
CString sNameSet = _T("*U");
|
|
MakeBlockRecord(arCrv, ColParam.m_idRec, asPnt3d(pt2), sNameSet);
|
|
_tcscpy(ColParam.m_sBlockName, (LPCTSTR)sNameSet);
|
|
|
|
AcGeMatrix3d xM;
|
|
xM.setToTranslation(vt);
|
|
|
|
AcDbRegion *pReg = (AcDbRegion *)arReg.first();
|
|
pReg->transformBy(xM);
|
|
|
|
AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_COLU"));
|
|
|
|
AecDbColumn *pCol = new AecDbColumn;
|
|
pCol->setLayer(idLayer);
|
|
pCol->SetSection(pReg, AcGePoint3d::kOrigin);
|
|
|
|
AcGePoint3d ptSta, ptEnd;
|
|
ptSta = asPnt3d(pt2);
|
|
ptSta.z = ColParam.m_dBomEl;
|
|
ptEnd = ptSta;
|
|
ptEnd.z = ColParam.m_dBomEl + ColParam.m_dH;
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptSta);
|
|
ln.setEndPoint(ptEnd);
|
|
pCol->SetBaseCurve(&ln);
|
|
pCol->SetSection(pReg, AcGePoint3d::kOrigin);
|
|
|
|
//pCol->GetSpecialtyData()->SetAt(KEY_NO,pCol->m_sGUID);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_MATERIAL, ColParam.m_sMaterial);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SHAPE, 7);//6 ColParam.m_nShape
|
|
pCol->GetSpecialtyData()->SetAt(KEY_BLOCKNAME, ColParam.m_sBlockName);
|
|
|
|
//Section 已经按照ref做了旋转
|
|
pCol->GetSpecialtyData()->SetAt(KEY_ROTATION, 0.0);//ColParam.m_dRotAngle * PI / 180.0);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_ROTATIONBK, ColParam.m_dRotAngle);
|
|
|
|
//pCol->GetSpecialtyData()->SetAt(AecDbColumn::KEY_COL_MODEL, ColParam.m_sModel);// 会出错
|
|
|
|
//结构信息
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SECTION_HATCH, dlg.m_sHatch);
|
|
|
|
CKTCadUtility::AddToBlockTableRecord(pCol);
|
|
|
|
pCol->close();
|
|
}
|
|
}
|
|
|
|
//柱子底座
|
|
void PL_ZZDZCmdFnc()
|
|
{
|
|
void implement_ZZDZ();
|
|
implement_ZZDZ();
|
|
}
|
|
|
|
//布置洁具
|
|
void PL_BZJJCmdFnc()
|
|
{
|
|
void implement_BZJJ();
|
|
implement_BZJJ();
|
|
}
|
|
|
|
//布置隔板
|
|
void PL_BZGBCmdFnc()
|
|
{
|
|
void implement_BZGB();
|
|
implement_BZGB();
|
|
}
|
|
|
|
//布置隔间
|
|
void PL_BZGJCmdFnc()
|
|
{
|
|
void implement_BZGJ();
|
|
implement_BZGJ();
|
|
}
|
|
|
|
// 基线对齐
|
|
void PL_JXDQCmdFnc()
|
|
{
|
|
ads_name ent;
|
|
ads_point adsPt, adsPtSelect;
|
|
struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
|
|
int nRes = CKTCadUtility::SelectEntity(_T("\n请选择墙体:"), ent, pRb, adsPt);
|
|
acutRelRb(pRb);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
nRes = acedGetPoint(NULL, _T("\n请选择基线对齐点:"), adsPtSelect);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbObjectId idWall;
|
|
Acad::ErrorStatus es = acdbGetObjectId(idWall, ent);
|
|
if (es != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d pt(asPnt3d(adsPtSelect));
|
|
CoreTools::UCS2WCS(pt, pt);
|
|
|
|
AcDbEntity* pEnt(NULL);
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEnt, idWall, AcDb::kForWrite))
|
|
{
|
|
return;
|
|
}
|
|
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (!pWall)
|
|
{
|
|
pEnt->close();
|
|
return;
|
|
}
|
|
WallData data;
|
|
pWall->GetWallData(data);
|
|
|
|
AcDbCurve* pCurve = pWall->GetBaseCurve();
|
|
if (!pCurve)
|
|
{
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
AcDbLine* pL(NULL);
|
|
AcDbArc* pArc(NULL);
|
|
AcDbCircle* pCir(NULL);
|
|
pL = AcDbLine::cast(pCurve);
|
|
pArc = AcDbArc::cast(pCurve);
|
|
pCir = AcDbCircle::cast(pCurve);
|
|
if (!pL && !pArc && !pCir)
|
|
{
|
|
acutPrintf(_T("\n存在除直线、弧线、圆形之外的曲线类型！"));
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptCurve;
|
|
es = pCurve->getClosestPointTo(pt, ptCurve);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
double dDist = ptCurve.distanceTo(pt);
|
|
AcGeVector3d vt = (ptCurve - pt).normalize();
|
|
|
|
if (pL)
|
|
{
|
|
AcGeMatrix3d mat;
|
|
mat.setTranslation(-vt * dDist);
|
|
pCurve->transformBy(mat);
|
|
|
|
es = pWall->SetBaseCurve(pCurve);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
DELETE_PTR(pL);
|
|
DELETE_PTR(pArc);
|
|
DELETE_PTR(pCir);
|
|
}
|
|
else
|
|
{
|
|
if (pArc)
|
|
{
|
|
AcGePoint3d ptC = pArc->center();
|
|
dDist = ptC.distanceTo(pt);
|
|
if (dDist < data.dThick)
|
|
{
|
|
acutPrintf(_T("\n选取点不合适！"));
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
pArc->setRadius(dDist);
|
|
|
|
es = pWall->SetBaseCurve(pArc);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
DELETE_PTR(pL);
|
|
DELETE_PTR(pCir);
|
|
}
|
|
else if (pCir)
|
|
{
|
|
AcGePoint3d ptC = pCir->center();
|
|
dDist = ptC.distanceTo(pt);
|
|
if (dDist < data.dThick)
|
|
{
|
|
acutPrintf(_T("\n选取点不合适！"));
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
pCir->setRadius(dDist);
|
|
|
|
es = pWall->SetBaseCurve(pCir);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
DELETE_PTR(pL);
|
|
DELETE_PTR(pArc);
|
|
}
|
|
|
|
DELETE_PTR(pCurve);
|
|
}
|
|
|
|
pWall->close();
|
|
}
|
|
|
|
// 边线对齐
|
|
void PL_BXDQCmdFnc()
|
|
{
|
|
ads_name ent;
|
|
ads_point adsPt, adsPtSelect;
|
|
struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_DBWALL"), 0);
|
|
int nRes = CKTCadUtility::SelectEntity(_T("\n请选择墙体边线:"), ent, pRb, adsPt);
|
|
acutRelRb(pRb);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
nRes = acedGetPoint(NULL, _T("\n请选择墙边边线应通过的点:"), adsPtSelect);
|
|
if (nRes != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbObjectId idWall;
|
|
acdbGetObjectId(idWall, ent);
|
|
|
|
AcGePoint3d pt(asPnt3d(adsPtSelect));
|
|
CoreTools::UCS2WCS(pt, pt);
|
|
|
|
AcDbEntity* pEnt(NULL);
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEnt, idWall, AcDb::kForWrite))
|
|
{
|
|
return;
|
|
}
|
|
|
|
AecDbXWall* pWall = AecDbXWall::cast(pEnt);
|
|
if (!pWall)
|
|
{
|
|
pEnt->close();
|
|
return;
|
|
}
|
|
WallData data;
|
|
pWall->GetWallData(data);
|
|
|
|
AcDbCurve* pCurve = pWall->GetBaseCurve();
|
|
if (!pCurve)
|
|
{
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
AcDbLine* pL(NULL);
|
|
AcDbArc* pArc(NULL);
|
|
AcDbCircle* pCir(NULL);
|
|
pL = AcDbLine::cast(pCurve);
|
|
pArc = AcDbArc::cast(pCurve);
|
|
pCir = AcDbCircle::cast(pCurve);
|
|
if (!pL && !pArc && !pCir)
|
|
{
|
|
acutPrintf(_T("\n存在除直线、弧线、圆形之外的曲线类型！"));
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptCurve;
|
|
Acad::ErrorStatus es = pCurve->getClosestPointTo(pt, ptCurve);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
double dDist = ptCurve.distanceTo(pt);
|
|
AcGeVector3d vt = (ptCurve - pt).normalize();
|
|
|
|
// 判断点在左墙边线、右墙边线
|
|
AcDbCurve* pCurveL = pWall->GetLeftCurve();
|
|
if (!pCurveL)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
AcDbCurve* pCurveR = pWall->GetRightCurve();
|
|
if (!pCurveR)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
AcGePoint3d ptWall(asPnt3d(adsPt));
|
|
CoreTools::UCS2WCS(ptWall, ptWall);
|
|
double dDistWall = ptWall.distanceTo(pt);
|
|
AcGePoint3d ptCurveL, ptCurveR;
|
|
double dDistL(.0), dDistR(.0);
|
|
es = pCurveL->getClosestPointTo(ptWall, ptCurveL);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
es = pCurveR->getClosestPointTo(ptWall, ptCurveR);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
dDistL = ptWall.distanceTo(ptCurveL);
|
|
dDistR = ptWall.distanceTo(ptCurveR);
|
|
|
|
if (pL)
|
|
{
|
|
// 判断点在基点上方、下方
|
|
AcGePoint3d ptCurveLNew, ptCurveRNew;
|
|
double dDistLNew(.0), dDistRNew(.0);
|
|
es = pCurveL->getClosestPointTo(pt, ptCurveLNew);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
es = pCurveR->getClosestPointTo(pt, ptCurveRNew);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
dDistLNew = pt.distanceTo(ptCurveLNew);
|
|
dDistRNew = pt.distanceTo(ptCurveRNew);
|
|
|
|
double dDistNew(.0);
|
|
if (dDistL < dDistR)
|
|
{
|
|
// 左墙边线
|
|
if (dDistLNew < dDistRNew)
|
|
{
|
|
// 点在基点下方
|
|
dDistNew = dDist + data.dThick * -.5;
|
|
}
|
|
else
|
|
{
|
|
// 点在基点上方
|
|
dDistNew = dDist + data.dThick * .5;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 右墙边线
|
|
if (dDistLNew < dDistRNew)
|
|
{
|
|
// 点在基点下方
|
|
dDistNew = dDist + data.dThick * .5;
|
|
}
|
|
else
|
|
{
|
|
// 点在基点上方
|
|
dDistNew = dDist + data.dThick * -.5;
|
|
}
|
|
}
|
|
|
|
if (dDistNew < data.dThick)
|
|
{
|
|
acutPrintf(_T("\n选取点距离墙体太近！"));
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
AcGeMatrix3d mat;
|
|
mat.setTranslation(dDistNew * -vt);
|
|
pCurve->transformBy(mat);
|
|
|
|
es = pWall->SetBaseCurve(pCurve);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
DELETE_PTR(pL);
|
|
DELETE_PTR(pArc);
|
|
DELETE_PTR(pCir);
|
|
}
|
|
else
|
|
{
|
|
if (pArc)
|
|
{
|
|
AcGePoint3d ptC = pArc->center();
|
|
dDist = ptC.distanceTo(pt);
|
|
|
|
double dRNew(.0);
|
|
if (dDistL < dDistR)
|
|
{
|
|
// 内侧
|
|
dRNew = dDist + data.dThick * .5;
|
|
}
|
|
else
|
|
{
|
|
// 外侧
|
|
dRNew = dDist + data.dThick * -.5;
|
|
}
|
|
if (dRNew < data.dThick)
|
|
{
|
|
acutPrintf(_T("\n选取点距离圆弧曲线圆心太近！"));
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
pArc->setRadius(dRNew);
|
|
|
|
es = pWall->SetBaseCurve(pArc);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
DELETE_PTR(pL);
|
|
DELETE_PTR(pCir);
|
|
}
|
|
else if (pCir)
|
|
{
|
|
AcGePoint3d ptC = pCir->center();
|
|
dDist = ptC.distanceTo(pt);
|
|
|
|
double dRNew(.0);
|
|
if (dDistL < dDistR)
|
|
{
|
|
// 内侧
|
|
dRNew = dDist + data.dThick * .5;
|
|
}
|
|
else
|
|
{
|
|
// 外侧
|
|
dRNew = dDist + data.dThick * -.5;
|
|
}
|
|
if (dRNew < data.dThick)
|
|
{
|
|
acutPrintf(_T("\n选取点距离圆弧曲线圆心太近！"));
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
pCir->setRadius(dRNew);
|
|
|
|
es = pWall->SetBaseCurve(pCir);
|
|
if (es != Acad::eOk)
|
|
{
|
|
DELETE_PTR(pCurve);
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
pWall->close();
|
|
return;
|
|
}
|
|
|
|
DELETE_PTR(pL);
|
|
DELETE_PTR(pArc);
|
|
}
|
|
|
|
DELETE_PTR(pCurve);
|
|
}
|
|
|
|
DELETE_PTR(pCurveL);
|
|
DELETE_PTR(pCurveR);
|
|
|
|
pWall->close();
|
|
}
|
|
|
|
void DBL_AEC_DBLNSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBLNSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbLineSegStair, pStair)
|
|
if (pStair)
|
|
{
|
|
LineStair data;
|
|
::memset(&data, 0, sizeof(LineStair));
|
|
pStair->GetLineStairData(data);
|
|
CAcModuleResourceOverride myResources;
|
|
CZXLTDlg dlg;
|
|
dlg.SetLineStairData(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(LineStair));
|
|
dlg.GetLineStairData(data);
|
|
pStair->SetLineStairData(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_SCISSORSSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_SCISSORSSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbScissorsStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFSPStair data;
|
|
::memset(&data, 0, sizeof(SFSPStair));
|
|
pStair->GetSFPXStair(data);
|
|
CAcModuleResourceOverride myResources;
|
|
CJCLTDlg dlg;
|
|
dlg.SetSFPXStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFSPStair));
|
|
dlg.GetSFPXStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_DOUBLEMULSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DOUBLEMULSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbDoubleMulStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFSPStair data;
|
|
::memset(&data, 0, sizeof(SFSPStair));
|
|
pStair->GetSFPXStair(data);
|
|
CAcModuleResourceOverride myResources;
|
|
CSFSPLTDlg dlg;
|
|
dlg.SetSFSPStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFSPStair));
|
|
dlg.GetSFSPStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_RECTCORNERSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_RECTCORNERSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbRectCornerStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFPXStair data;
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
CAcModuleResourceOverride myResources;
|
|
CJXZJDlg dlg;
|
|
dlg.SetSFPXStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
dlg.GetSFPXStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_DBASSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBASSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbArcSegStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFPXStair data;
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
CAcModuleResourceOverride myResources;
|
|
CYHLTDlg dlg;
|
|
dlg.SetSFPXStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
dlg.GetSFPXStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_PARALLELSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_PARALLELSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbParaLlelStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFPXStair data;
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CSFPXLTDlg dlg;
|
|
dlg.SetSFPXStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
dlg.GetSFPXStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
|
|
}
|
|
|
|
void DBL_AEC_DBCNRSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBCNRSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbCornerStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFPXStair data;
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CSFZJLTDlg dlg;
|
|
dlg.SetSFPXStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
dlg.GetSFPXStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_CROSSSTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_CROSSSTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbCrossStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFPXStair data;
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CJDLTDlg dlg;
|
|
dlg.SetSFPXStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
dlg.GetSFPXStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
|
|
}
|
|
|
|
void DBL_AEC_TRIANGLESTAIR()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_TRIANGLESTAIR"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbTriangleStair, pStair)
|
|
if (pStair)
|
|
{
|
|
SFPXStair data;
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
pStair->GetSFPXStair(data);
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CSJLTDlg dlg;
|
|
dlg.SetSFPXStair(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(SFPXStair));
|
|
dlg.GetSFPXStair(data);
|
|
pStair->SetSFPXStair(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_DBBALCONY()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBBALCONY"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbBalcony, pBalcony)
|
|
if (pBalcony)
|
|
{
|
|
BalconyData data;
|
|
::memset(&data, 0, sizeof(BalconyData));
|
|
pBalcony->GetBalconyData(data);
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CFZYTDlg dlg;
|
|
dlg.SetBalconyData(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(BalconyData));
|
|
dlg.GetBalconyData(data);
|
|
pBalcony->SetBalconyData(data);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_DBZXOPENING()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBZXOPENING"), id);
|
|
if (bIsOk && id.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbZLineXOpening, pZXOpening)
|
|
if (pZXOpening)
|
|
{
|
|
OpeningData data;
|
|
::memset(&data, 0, sizeof(OpeningData));
|
|
AcDbObjectIdArray arIds;
|
|
pZXOpening->GetOpeningData(data);
|
|
CAcModuleResourceOverride myResources;
|
|
CDXCHDlg dlg;
|
|
dlg.SetOpeningData(data);
|
|
if (IDOK == dlg.DoModal())
|
|
{
|
|
::memset(&data, 0, sizeof(OpeningData));
|
|
dlg.GetOpeningData(data);
|
|
pZXOpening->SetOpeningData(data, arIds);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
|
|
void DBL_AEC_DBCOLMN_CRJZ()
|
|
{
|
|
AcDbObjectId id;
|
|
bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_DBCOLMN"), id);
|
|
if (!bIsOk || !id.isValid()) return;
|
|
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AecDbColumn, pCol)
|
|
if (pCol)
|
|
{
|
|
AcDbRegion* pReg = pCol->GetSection();
|
|
if (!pReg) return;
|
|
|
|
ColumnParam data;
|
|
memset(&data, 0, sizeof(ColumnParam));
|
|
pCol->GetColumnData(data);
|
|
|
|
CAcModuleResourceOverride myResources;
|
|
CCRJZDlg dlg;
|
|
dlg.SetColumnParam(data);
|
|
dlg.setColumnReg(pReg);
|
|
|
|
if (dlg.DoModal() != IDOK) return;
|
|
|
|
pCol->GetSpecialtyData()->SetAt(KEY_MATERIAL, dlg.m_sMaterial);
|
|
//pCol->GetSpecialtyData()->SetAt(KEY_BLOCKNAME, ColParam.m_sBlockName);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE1, dlg.m_dA);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE2, dlg.m_dB);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE3, dlg.m_dAW);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SIZE4, dlg.m_dBW);
|
|
pCol->GetSpecialtyData()->SetAt(KEY_SECTION_HATCH, dlg.m_sHatch);
|
|
|
|
AcDbCurve* pCur = pCol->GetBaseCurve();
|
|
if (!pCur) return;
|
|
AcDbLine* pLn = AcDbLine::cast(pCur);
|
|
if (!pLn)
|
|
{
|
|
DELETE_PTR(pCur);
|
|
return;
|
|
}
|
|
|
|
AcGePoint3d ptSta = pLn->startPoint();
|
|
AcGePoint3d ptEnd = pLn->endPoint();
|
|
ptSta.z = dlg.m_dBomEl;
|
|
ptEnd.z = ptSta.z + dlg.m_dH;
|
|
pLn->setStartPoint(ptSta);
|
|
pLn->setEndPoint(ptEnd);
|
|
pCol->SetBaseCurve(ptSta, ptEnd);
|
|
DELETE_PTR(pCur);
|
|
|
|
AcGePoint3d ptGe[3];
|
|
AcGePoint3d ptA, ptB, ptInner;
|
|
pCol->GetSpecialtyData(AcDb::kForWrite)->GetAt(CCRJZDlg::_JZ_PT_INNER, ptInner);
|
|
pCol->GetSpecialtyData(AcDb::kForWrite)->GetAt(CCRJZDlg::_JZ_PT_A, ptA);
|
|
pCol->GetSpecialtyData(AcDb::kForWrite)->GetAt(CCRJZDlg::_JZ_PT_B, ptB);
|
|
|
|
AcGeVector3d vt(ptA - ptInner);
|
|
vt.normalize();
|
|
vt *= dlg.m_dA;
|
|
ptA = ptInner + vt;
|
|
|
|
vt = ptB - ptInner;
|
|
vt.normalize();
|
|
vt *= dlg.m_dB;
|
|
ptB = ptInner + vt;
|
|
|
|
AcDbRegion *pRegNew = CCRJZDlg::makeRegion(ptInner, ptA, ptB, dlg.m_dAW, dlg.m_dBW);
|
|
if (!pRegNew) return;
|
|
|
|
pCol->GetSpecialtyData(AcDb::kForWrite)->SetAt(CCRJZDlg::_JZ_PT_INNER, ptInner);
|
|
pCol->GetSpecialtyData(AcDb::kForWrite)->SetAt(CCRJZDlg::_JZ_PT_A, ptA);
|
|
pCol->GetSpecialtyData(AcDb::kForWrite)->SetAt(CCRJZDlg::_JZ_PT_B, ptB);
|
|
|
|
pCol->SetSection(pRegNew, AcGePoint3d::kOrigin);
|
|
}
|
|
OPENOBJ_END()
|
|
} |