3320 lines
89 KiB
C++
3320 lines
89 KiB
C++
// ColumnDlg.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "TArchCmdReactor.h"
|
|
#include "ColumnDlg.h"
|
|
#include "column_xdata_key.h"
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
extern TUTIL_IMPEXP int XOsnap(XPoint &ptPick1, int nMode, const RBList & rbMask, ads_real nHalfSize=0.0, int bInsideAperture=1, int bAdcendent=0);
|
|
// [11/15/2007 nsh]
|
|
//-----------------初始化---------------
|
|
int CColumnDlg::m_iColuType =0;
|
|
TDbColumn* CColumnDlg::pEntM =NULL;
|
|
TDbColumn* CColumnDlg::pEntY =NULL;
|
|
BOOL CColumnDlg::m_bChange =FALSE;
|
|
CString CColumnDlg::m_sSaveRotation =_T("0");
|
|
//保留轴的镜像
|
|
BOOL CColumnDlg::m_bXAxisMirror =FALSE;
|
|
BOOL CColumnDlg::m_bYAxisMirror =FALSE;
|
|
BOOL CColumnDlg::m_bInitFirst =TRUE;
|
|
static BOOL bFirst=TRUE;
|
|
CString CColumnDlg::m_csHeight =(const TCHAR *)Dist2Str(DocGetLHeight());
|
|
ads_real GetXDirection1(const XCurveSegment &cv1, const XCurveSegment &cv2, const XPoint &ptLoc);
|
|
//--------------------------------------
|
|
BOOL InsertColumn(TDbColumn *pColu);
|
|
// [2010-3-16 10:42 wubo] 移植到新Geo库
|
|
// 已定义在tchkernalglobalfunc.h
|
|
//inline resbuf *AxisMask() {
|
|
// return ads_buildlist(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
|
//}
|
|
ads_real GetAxisXDirection(const XPoint &ptLoc);
|
|
|
|
// [2010-3-16 10:44 wubo] 移植到新Geo库
|
|
// extern GEOAPI int XGetCorner(const XPoint &ptCorn1, const TCHAR *pszMsg, XPoint &ptCorn2);
|
|
//
|
|
class CurveEntity {
|
|
public:
|
|
Entity entCurve;
|
|
XCurveSegment curveSeg;
|
|
public:
|
|
CurveEntity(const Entity &e): entCurve(e), curveSeg(e, LS_FINITE) {
|
|
}
|
|
};
|
|
|
|
class IntersCurveEntity {
|
|
public:
|
|
Entity entCurve1, entCurve2;
|
|
XPointDir2d ptDir;
|
|
public:
|
|
IntersCurveEntity(const Entity &e1, const Entity &e2, const XPointDir2d &pt):
|
|
entCurve1(e1), entCurve2(e2), ptDir(pt)
|
|
{}
|
|
};
|
|
|
|
class IntersAxisRegion: public DList<IntersCurveEntity> {
|
|
public:
|
|
IntersAxisRegion() {}
|
|
int Inters(const CurveEntity &curve1, const CurveEntity &curve2);
|
|
int Find(const Entity &e1, const Entity &e2);
|
|
int Find(const XPoint &pt);
|
|
};
|
|
|
|
int IntersAxisRegion::Find(const XPoint &pt)
|
|
{
|
|
IntersAxisRegion &me=*this;
|
|
for(int i=0; i<me.Length(); i++) {
|
|
IntersCurveEntity &rec=*me[i];
|
|
if (rec.ptDir==pt)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int IntersAxisRegion::Find(const Entity &e1, const Entity &e2)
|
|
{
|
|
IntersAxisRegion &me=*this;
|
|
for(int i=0; i<me.Length(); i++) {
|
|
IntersCurveEntity &rec=*me[i];
|
|
if (rec.entCurve1==e1 && rec.entCurve2==e2 ||
|
|
rec.entCurve2==e1 && rec.entCurve1==e2)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
//###################################################################################
|
|
// -1--Already inters
|
|
int IntersAxisRegion::Inters(const CurveEntity &curve1, const CurveEntity &curve2)
|
|
{
|
|
//if (Find(curve1.entCurve, curve2.entCurve))
|
|
// return -1;
|
|
XPoint ptInters[2];
|
|
int nRet=0;
|
|
int nInter=curve1.curveSeg.Intersection(curve2.curveSeg, ptInters[0], ptInters[1]);
|
|
for(int n=0; n<nInter; n++) {
|
|
if (!Find(ptInters[n])) {
|
|
//ads_real nDrt=GetAxisXDirection(curve1.curveSeg, curve2.curveSeg, ptInters[n]);
|
|
ads_real nDrt=GetXDirection1(curve1.curveSeg, curve2.curveSeg, ptInters[n]);// [1/8/2008 nsh]
|
|
XPointDir2d ptDrt(nDrt);
|
|
(XPoint &)ptDrt=ptInters[n];
|
|
Append(new IntersCurveEntity(curve1.entCurve, curve2.entCurve, ptDrt));
|
|
nRet++;
|
|
}
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
void GetAxisInt(PickSet &ssAxis, AcGePoint3dArray &points,Array<ads_real> & aixDir);
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CColumnDlg dialog
|
|
static const TCHAR *g_coluTypeArray[]=
|
|
{ _T("矩形"), _T("圆形"), _T("正三角形"), _T("正五边形"), _T("正六边形"), _T("正八边形"), _T("正十二边形") ,_T("异形柱")};
|
|
static TColumnData::TSectionShape g_coluShapeArray[]=
|
|
{ TColumnData::kRect, TColumnData::kCircle,
|
|
TColumnData::kStd3, TColumnData::kStd5, TColumnData::kStd6,
|
|
TColumnData::kStd8, TColumnData::kStd12,TColumnData::kPoly};
|
|
enum TColumnNewMaterial {kFireBrick = 80/*, kRocket = 90, kConcrete = 100, kSteel = 110*/};
|
|
static TColumnData::TColumnMaterial g_materArray[]=
|
|
{ TColumnData::kBrick, TColumnData::kRocket, TColumnData::kConcrete, TColumnData::kSteel};
|
|
//顺序不能改
|
|
TCHAR *g_NewMaterArray[]=
|
|
{ _T("钢筋砼"), _T("混凝土"), _T("砖"), _T("耐火砖"), _T("石材") , _T("毛石"), _T("金属")};
|
|
//使用这个变量将T20的材料传入InsertColum中，使用完后会被赋空
|
|
TCHAR *sNewCloumMater = NULL;
|
|
|
|
CString CColumnDlg::m_csXOffset=_T("0");
|
|
CString CColumnDlg::m_csXSize=_T("600");
|
|
CString CColumnDlg::m_csRotation=_T("0");
|
|
CString CColumnDlg::m_csYOffset=_T("0");
|
|
CString CColumnDlg::m_csYSize=_T("600");
|
|
CString CColumnDlg::m_sBlockName;
|
|
int CColumnDlg::m_iMaterial = 2; //钢筋混凝土
|
|
int CColumnDlg::m_nInsertMode = ID_POINT_COLUMN;
|
|
|
|
CColumnDlg::CColumnDlg(CWnd* pParent /*=NULL*/)
|
|
: CModelessDialog(CColumnDlg::IDD, pParent)
|
|
//, m_csHeight(_T("当前层高"))
|
|
{
|
|
//{{AFX_DATA_INIT(CColumnDlg)
|
|
m_iColuType = -1;
|
|
m_csXSizeText = _T("横向");
|
|
m_csYSizeText = _T("纵向");
|
|
//}}AFX_DATA_INIT
|
|
|
|
//m_csHeight=(const TCHAR *)Dist2Str(DocGetLHeight());// [12/20/2007 nsh]
|
|
|
|
// 问题描述:对话框中“柱高”始终都是“当前层高”,应保留用户最后设置的柱高参数。(890)
|
|
// 解决方法:去掉初始化对话框时对m_csHeight的赋值
|
|
// 修改人,修改时间:Zyu modify on 100322
|
|
// Begin
|
|
//m_csHeight=_T("当前层高");
|
|
// End
|
|
|
|
m_xDir=0;
|
|
m_polyOutline.SetFlag(1);
|
|
m_strColumAngle = _T("0");
|
|
////add by xlc on 070718
|
|
//m_bXAxisMirror = FALSE;
|
|
//m_bYAxisMirror = FALSE;
|
|
|
|
m_bLib = FALSE;
|
|
|
|
// Add by Zyu on 100412
|
|
m_bIsEdit = false;
|
|
}
|
|
|
|
|
|
void CColumnDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CModelessDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CColumnDlg)
|
|
DDX_Control(pDX, IDC_YSIZE, m_ySizeBox);
|
|
DDX_Control(pDX, IDC_XSIZE, m_xSizeBox);
|
|
DDX_Control(pDX, IDC_ROTATION, m_rotationBox);
|
|
DDX_Control(pDX, IDC_COLU_TYPE, m_coluTypeBox);
|
|
DDX_CBIndex(pDX, IDC_COLU_TYPE, m_iColuType);
|
|
|
|
//modify by xlc on 070511
|
|
//DDX_Text(pDX, IDC_HEIGHT, m_csHeight);
|
|
DDX_CBString(pDX, IDC_HEIGHT, m_csHeight);
|
|
|
|
DDX_Text(pDX, IDC_XSIZE_TEXT, m_csXSizeText);
|
|
DDX_Text(pDX, IDC_YSIZE_TEXT, m_csYSizeText);
|
|
DDX_CBIndex(pDX, IDC_MATERIAL, m_iMaterial);
|
|
DDX_Text(pDX, IDC_XOFFSET, m_csXOffset);
|
|
DDX_Text(pDX, IDC_XSIZE, m_csXSize);
|
|
DDX_Text(pDX, IDC_YOFFSET, m_csYOffset);
|
|
DDX_Text(pDX, IDC_YSIZE, m_csYSize);
|
|
DDX_Text(pDX, IDC_ROTATION, m_csRotation);
|
|
//}}AFX_DATA_MAP
|
|
if (pDX->m_bSaveAndValidate) {
|
|
UINT idArray[]={ID_POINT_COLUMN, ID_LINE_COLUMN, ID_REGION_COLUMN, ID_REPLACE_COLUMN,ID_OTHERCOLUMN,ID_CHECKPLINE,};
|
|
for(int i=0; i<ELEMENTS(idArray); i++) {
|
|
if (m_toolbar.IsButtonChecked(idArray[i])){
|
|
m_nInsertMode = idArray[i];
|
|
}
|
|
}
|
|
} else {
|
|
m_toolbar.CheckButton(m_nInsertMode);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CColumnDlg, CModelessDialog)
|
|
//{{AFX_MSG_MAP(CColumnDlg)
|
|
ON_CBN_SELENDOK(IDC_COLU_TYPE, OnSelendokColuType)
|
|
ON_CBN_SELENDOK(IDC_ROTATION, OnSelendokRotation)
|
|
ON_EN_KILLFOCUS(IDC_XOFFSET, OnKillfocusXoffset)
|
|
ON_CBN_KILLFOCUS(IDC_XSIZE, OnKillfocusXsize)
|
|
ON_EN_KILLFOCUS(IDC_YOFFSET, OnKillfocusYoffset)
|
|
ON_CBN_KILLFOCUS(IDC_YSIZE, OnKillfocusYsize)
|
|
ON_CBN_KILLFOCUS(IDC_ROTATION, OnKillfocusRotation)
|
|
ON_CBN_SELENDOK(IDC_XSIZE, OnSelendokXsize)
|
|
ON_CBN_SELENDOK(IDC_YSIZE, OnSelendokYsize)
|
|
ON_WM_PAINT()
|
|
ON_COMMAND(ID_REPLACE_COLUMN, OnReplaceColumn)
|
|
ON_COMMAND(ID_REGION_COLUMN, OnRegionColumn)
|
|
ON_COMMAND(ID_LINE_COLUMN, OnLineColumn)
|
|
ON_COMMAND(ID_POINT_COLUMN, OnPointColumn)
|
|
ON_COMMAND(ID_OTHERCOLUMN,OnOtherColumn)
|
|
ON_COMMAND(ID_CHECKPLINE,OnCheckPline)
|
|
ON_COMMAND(IDC_GJK,OnGJK)
|
|
ON_WM_CLOSE()
|
|
ON_WM_CREATE()
|
|
|
|
//add by xlc on 070511
|
|
ON_CBN_KILLFOCUS(IDC_HEIGHT, OnKillfocusHeight)
|
|
//add by xlc on 071105
|
|
ON_CBN_SELENDOK(IDC_MATERIAL, OnSelendokMaterial)
|
|
|
|
//}}AFX_MSG_MAP
|
|
ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipText)
|
|
ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CColumnDlg message handlers
|
|
// toolbar
|
|
void CColumnDlg::CreateToolbar()
|
|
{
|
|
CAcModuleResourceOverride vTmp;
|
|
m_toolbar.Create( WS_VISIBLE | WS_CHILD | CCS_BOTTOM | TBSTYLE_TOOLTIPS
|
|
| CCS_ADJUSTABLE ,CRect(0,0,0,0),this, IDR_COLUMN);
|
|
int ButtonID[]={ ID_POINT_COLUMN, ID_LINE_COLUMN, ID_REGION_COLUMN, ID_REPLACE_COLUMN,ID_OTHERCOLUMN,ID_SEPARATOR,ID_CHECKPLINE, };
|
|
TBBUTTON *pIndex, *pRTF_Button = new TBBUTTON[7];
|
|
pIndex = pRTF_Button;
|
|
for(int lIndex = 0; lIndex <7; lIndex++) {
|
|
memset(pIndex ,NULL, sizeof(TBBUTTON));
|
|
if (lIndex==5)
|
|
pIndex->fsStyle=TBBS_SEPARATOR|TBSTYLE_CHECKGROUP;
|
|
else
|
|
{
|
|
pIndex->iBitmap = lIndex;
|
|
pIndex->idCommand = ButtonID[lIndex];
|
|
pIndex->fsStyle = TBSTYLE_CHECKGROUP;
|
|
pIndex->fsState = TBSTATE_ENABLED;
|
|
}
|
|
|
|
pIndex++;
|
|
}
|
|
|
|
|
|
CSize size(16, 15);
|
|
m_toolbar.SetButtonSize(size);
|
|
m_toolbar.AddButtons(7, pRTF_Button);
|
|
|
|
delete[] pRTF_Button;
|
|
|
|
m_toolbar.SetBitmapSize(size);
|
|
m_toolbar.ModifyStyle(0,TBSTYLE_FLAT);
|
|
m_toolbar.AddBitmap(7, IDR_COLUMN);
|
|
//m_toolbar.CheckButton(ID_POINT_COLUMN);
|
|
}
|
|
BOOL CColumnDlg::GetOutlinePoly(XPoint ptPick, XPoly2D &poly) const
|
|
{
|
|
TColumnData::TSectionShape shape=g_coluShapeArray[m_iColuType];
|
|
//if (shape==TColumnData::kPoly)
|
|
// return FALSE;
|
|
double nSizeX=_tstof(m_csXSize);
|
|
double nSizeY=_tstof(m_csYSize);
|
|
|
|
//modify by xlc on 090520参数错误时切换柱子类型时不起作用
|
|
// if (nSizeX<_DIST_SNAP || nSizeY<_DIST_SNAP)
|
|
// return FALSE;
|
|
if (shape== TColumnData::kRect)
|
|
{
|
|
if (nSizeX<_DIST_SNAP || nSizeY<_DIST_SNAP)
|
|
return FALSE;
|
|
}
|
|
else if (shape==TColumnData::kPoly) //XSize和YSize对异型柱无效
|
|
{
|
|
}
|
|
else //YSize对圆和多边形无效
|
|
{
|
|
if (nSizeX<_DIST_SNAP)
|
|
return FALSE;
|
|
}
|
|
|
|
poly.Reset();
|
|
poly.SetFlag(1);
|
|
|
|
ads_matrix mat;
|
|
ptPick.GetRotationMatrix(_tstof(m_csRotation)*PI/180, mat);
|
|
if (shape == TColumnData::kRect) {
|
|
XRectAngle rectangle1(ptPick, nSizeX, nSizeY);
|
|
rectangle1.AsPoly2D(poly);
|
|
poly.TransUCS(mat);
|
|
} else if (shape == TColumnData::kCircle) {
|
|
XCircle circle(ptPick,nSizeX/2);
|
|
XCurveSegment seg;
|
|
seg = circle;
|
|
seg.AsPoly2D(poly);
|
|
}
|
|
else if (shape==TColumnData::kPoly){
|
|
if (m_polyOutline.Length()<1)
|
|
return FALSE;
|
|
poly=m_polyOutline;
|
|
if (m_bModeless)
|
|
XPoint().GetRotationMatrix(_tstof(m_csRotation)*PI/180,mat);
|
|
else
|
|
XPoint().GetRotationMatrix(_tstof(m_csRotation)*PI/180-m_xDir,mat);
|
|
poly.TransUCS(mat);
|
|
XPoint().GetMoveMatrix(ptPick,mat);
|
|
poly.TransUCS(mat);
|
|
}
|
|
else {
|
|
int nNumSides=3;
|
|
|
|
switch(shape) {
|
|
case TColumnData::kStd3:
|
|
nNumSides=3;
|
|
break;
|
|
case TColumnData::kStd5:
|
|
nNumSides=5;
|
|
break;
|
|
case TColumnData::kStd6:
|
|
nNumSides=6;
|
|
break;
|
|
case TColumnData::kStd8:
|
|
nNumSides=8;
|
|
break;
|
|
case TColumnData::kStd12:
|
|
nNumSides=12;
|
|
break;
|
|
}
|
|
double circumRadius = nSizeX*0.5/cos(PI/2-PI/nNumSides);
|
|
XPoint vertex;
|
|
double increment,base;
|
|
|
|
|
|
increment = 2.0 * PI / nNumSides;
|
|
base = CT_std_angle(-increment/2.0+1.5*PI+_tstof(m_csRotation)*PI/180);
|
|
|
|
for (int i = 0; i < nNumSides ; i++) {
|
|
vertex.x = circumRadius * cos(increment*i+base);
|
|
vertex.y = circumRadius * sin(increment*i+base);
|
|
poly.AppendNode((ptPick+vertex));
|
|
}
|
|
}
|
|
//add by xlc on 070718
|
|
/*if (m_bXAxisMirror)//上下翻转
|
|
{
|
|
AcGeMatrix3d mat1;
|
|
|
|
//XVector3D vt = Ucs2Wcs(XVector3D(1,0,0),TRUE);
|
|
XVector3D vt = XVector3D(1,0,0);
|
|
|
|
mat1.setToMirroring(AcGeLine3d((AcGePoint3d &)ptPick, (AcGeVector3d &)vt));
|
|
mat1(2,2) = 1;
|
|
poly.TransformBy((mat1));
|
|
}
|
|
if (m_bYAxisMirror)//左右翻转
|
|
{
|
|
AcGeMatrix3d mat1;
|
|
|
|
//XVector3D vt = Ucs2Wcs(XVector3D(0,1,0),TRUE);
|
|
XVector3D vt = XVector3D(0,1,0);
|
|
|
|
mat1.setToMirroring(AcGeLine3d((AcGePoint3d &)ptPick, (AcGeVector3d &)vt));
|
|
mat1(1,1) = 1;
|
|
poly.TransformBy((mat1));
|
|
}*/
|
|
return TRUE;
|
|
}
|
|
|
|
void CColumnDlg::UpdateImage()
|
|
{
|
|
//UpdateData(TRUE);
|
|
|
|
TDbColumn colu;
|
|
colu.SetLocation(XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset)));
|
|
UpdateObject(&colu);
|
|
|
|
CWnd *pImageBox=GetDlgItem(IDC_SLIDE);
|
|
ASSERT(pImageBox);
|
|
CRect rect;
|
|
pImageBox->GetClientRect(rect);
|
|
CDC *pDC=pImageBox->GetDC();
|
|
m_image.InitDC(pDC, rect, GetAcadBackColor());
|
|
m_image.Reset();
|
|
if (!colu.IsValid()) {
|
|
XString sFileName(256);
|
|
//if (FindFile(_T("ErrorInput.Sld"), sFileName))
|
|
m_image.PaintSlide(_T("TArch(ErrorInput)"));
|
|
} else {
|
|
m_image.Fill(GetAcadBackColor());
|
|
m_image.SetColor(7);
|
|
colu.ExplodeOrDraw2d(m_image);
|
|
|
|
//modified by whl
|
|
if (bAxisExist||m_bModeless)
|
|
{
|
|
XPoint ptLow, ptUp;
|
|
colu.GetExtents2d(ptLow, ptUp);
|
|
double sx=ptUp.x-ptLow.x;
|
|
double sy=ptUp.y-ptLow.y;
|
|
XLine ln1(XPoint(-sx,0), XPoint(sx,0));
|
|
XLine ln2(XPoint(0,-sy), XPoint(0, sy));
|
|
m_image.SetColor(1);
|
|
m_image << ln1 << ln2;
|
|
}
|
|
|
|
m_image.Redraw();
|
|
}
|
|
m_image.SetDC(NULL);
|
|
pImageBox->ReleaseDC(pDC);
|
|
}
|
|
|
|
//add by whl
|
|
ads_real GetAxisXDirection(const TDbColumn *pColu)
|
|
{
|
|
double nRes=0.0;
|
|
XPoly2D poly;
|
|
pColu->GetOutline(poly);
|
|
for(long i=0;i<poly.Length();i++){
|
|
XPoint pt=*poly[i];
|
|
pt=Wcs2Ucs(pt);
|
|
pt.z=0;
|
|
*poly[i]=pt;
|
|
}
|
|
PickSet ssAxis(SS_FREE);
|
|
RBList rbPoly=poly.Polygon(),rbAxis=AxisMask();
|
|
if (ssAxis.Get(_T("CP"),rbPoly,NULL,rbAxis)==RTNORM){
|
|
long len=ssAxis.Length();
|
|
if (len==1) {
|
|
Entity eAxis=ssAxis[0L];
|
|
XCurveSegment cv(eAxis, LS_FINITE);
|
|
ads_real nDrt=cv.Direction(pColu->GetLocation());
|
|
if (cv.Is(CURVE_LINE)) {
|
|
ads_real nDrtRev=CT_std_angle(nDrt+PI);
|
|
XSector sec(nDrt, nDrtRev);
|
|
nRes = *sec.NearAngle(0.0);
|
|
}
|
|
} else if (len>1){
|
|
Entity eAxis1=ssAxis[0L];
|
|
Entity eAxis2=ssAxis[1L];
|
|
XCurveSegment cv1(eAxis1, LS_FINITE), cv2(eAxis2, LS_FINITE);
|
|
nRes=GetXDirection1(cv1,cv2,pColu->GetLocation());// [1/8/2008 nsh]
|
|
}
|
|
}
|
|
return nRes;
|
|
}
|
|
//add by whl
|
|
bool GetColumnAxisInfo(const TDbColumn *pColu,XPoint& vtOffset,double &xDirection)
|
|
{
|
|
XPoint ptLoc=Wcs2Ucs(pColu->GetLocation());
|
|
xDirection=GetAxisXDirection(pColu);
|
|
XPoly2D poly;
|
|
pColu->GetOutline(poly);
|
|
for(long i=0;i<poly.Length();i++){
|
|
XPoint pt=*poly[i];
|
|
pt=Wcs2Ucs(pt);
|
|
pt.z=0;
|
|
*poly[i]=pt;
|
|
}
|
|
PickSet ss(SS_FREE);
|
|
RBList rbPoly=poly.Polygon(),rbAxis=AxisMask();
|
|
if (ss.Get(_T("CP"),rbPoly,NULL,rbAxis)!=RTNORM)
|
|
return false;
|
|
DList<CurveEntity> lstCurves;
|
|
long len=ss.Length();
|
|
for(long n=0; n<len; n++){
|
|
Entity ent=ss[n];
|
|
lstCurves.Append(new CurveEntity(ent));
|
|
}
|
|
IntersAxisRegion lstInters;
|
|
int nNum=lstCurves.Length();
|
|
for(i=0; i<nNum; i++) {
|
|
CurveEntity &ce1=*lstCurves[i];
|
|
for(int j=i+1; j<nNum; j++) {
|
|
CurveEntity &ce2=*lstCurves[j];
|
|
lstInters.Inters(ce1, ce2);
|
|
}
|
|
}
|
|
if (lstInters.Length()==0)
|
|
return false;
|
|
double curMin=100000;
|
|
int curIndex=-1;
|
|
for(i=0; i<lstInters.Length(); i++) {
|
|
XPoint pt=Wcs2Ucs(lstInters[i]->ptDir);
|
|
if ((pt&poly)!=PR_INSIDE)
|
|
continue;
|
|
double dist=pt.Distance2d(ptLoc);
|
|
if (dist<curMin){
|
|
curMin=dist;
|
|
curIndex=i;
|
|
}
|
|
}
|
|
if (curIndex==-1)
|
|
return false;
|
|
xDirection=GetAxisXDirection(lstInters[curIndex]->ptDir);//修正到原拾取点
|
|
vtOffset=pColu->GetLocation()-lstInters[curIndex]->ptDir;
|
|
ads_matrix matRot;
|
|
XPoint().GetRotationMatrix(-xDirection, matRot);
|
|
vtOffset.TransformBy(matRot);//校正到轴网坐标系
|
|
return true;
|
|
}
|
|
BOOL CColumnDlg::Obj2Dlg(const TDbColumn *pColu)
|
|
{
|
|
/*if (pColu->GetSectionShape()==TColumnData::kPoly)
|
|
return FALSE;*/
|
|
TColumnData::TSectionShape shape=pColu->GetSectionShape();
|
|
for(int i=0; i<ELEMENTS(g_coluShapeArray); i++) {
|
|
if (g_coluShapeArray[i]==shape) {
|
|
m_iColuType=i;
|
|
break;
|
|
}
|
|
}
|
|
m_csHeight=(const TCHAR *)Dist2Str(pColu->GetHeight());
|
|
|
|
//得到材料的索引
|
|
CString stmp(COLMATE_Brick);
|
|
int iCurSel = 1;
|
|
pColu->GetSpecialtyDataReadOnly()->GetAt(sKEY_COLUMN_HATCH_PATTERN, stmp);
|
|
if(stmp == COLMATE_Concrete)
|
|
{
|
|
iCurSel = 0;
|
|
}
|
|
else if(stmp == COLMATE_Concrete1)
|
|
{
|
|
iCurSel = 1;
|
|
}
|
|
else if(stmp == COLMATE_Brick)
|
|
{
|
|
iCurSel = 2;
|
|
}
|
|
else if(stmp == COLMATE_Brick1)
|
|
{
|
|
iCurSel = 3;
|
|
}
|
|
else if(stmp == COLMATE_Rocket)
|
|
{
|
|
iCurSel = 4;
|
|
}
|
|
else if(stmp == COLMATE_Rocket1)
|
|
{
|
|
iCurSel = 5;
|
|
}
|
|
else if(stmp == COLMATE_Steel)
|
|
{
|
|
iCurSel = 6;
|
|
}
|
|
m_iMaterial = iCurSel;
|
|
|
|
//modified by whl
|
|
bAxisExist=GetColumnAxisInfo(pColu,oldOffset,m_xDir);
|
|
if (bAxisExist)
|
|
{
|
|
//modify by xlc on 090428 编辑时出现-0
|
|
//m_csXOffset=(const TCHAR *)Dist2Str(oldOffset.x);
|
|
//m_csYOffset=(const TCHAR *)Dist2Str(oldOffset.y);
|
|
double dOffsetX=oldOffset.x,dOffsetY=oldOffset.y;
|
|
if (fabs(dOffsetX)<_DIST_SNAP)
|
|
dOffsetX=0;
|
|
if (fabs(dOffsetY)<_DIST_SNAP)
|
|
dOffsetY=0;
|
|
m_csXOffset=(const TCHAR *)Dist2Str(dOffsetX);
|
|
m_csYOffset=(const TCHAR *)Dist2Str(dOffsetY);
|
|
}else{
|
|
m_csXOffset=_T("0");
|
|
m_csYOffset=_T("0");
|
|
|
|
//modify by xlc on 090417修正用户坐标系下转角
|
|
m_xDir=Ucs2Wcs(0.0);
|
|
}
|
|
if (pColu->GetSectionShape()!=TColumnData::kPoly)
|
|
{
|
|
if (m_iColuType==1)//圆形
|
|
m_csRotation=_T("0");
|
|
else
|
|
{
|
|
//modify by xlc on 090417
|
|
//m_csRotation=(const TCHAR *)Angle2Str((pColu->GetRotation()-m_xDir)*180/PI);//相对轴网转角
|
|
double dAngle=pColu->GetRotation()-m_xDir;
|
|
if (fabs(dAngle)<1E-5)
|
|
dAngle=0;
|
|
|
|
//modify by xlc on 090428 编辑时出现-0
|
|
//m_csRotation=(const TCHAR *)Angle2Str(dAngle*180/PI);//相对轴网转角
|
|
double ang=dAngle*180/PI;
|
|
if (fabs(ang)<_DIST_SNAP)
|
|
ang=0;
|
|
m_csRotation=(const TCHAR *)Angle2Str(ang);
|
|
}
|
|
XPoint ptParam=pColu->GetParameters();
|
|
m_csXSize=(const TCHAR *)Dist2Str(ptParam.x);
|
|
m_csYSize=(const TCHAR *)Dist2Str(ptParam.y);
|
|
}
|
|
else
|
|
{
|
|
pColu->GetOutline(m_polyOutline);
|
|
ads_matrix mat;
|
|
pColu->GetLocation().GetMoveMatrix(XPoint(),mat);
|
|
m_polyOutline.TransUCS(mat);
|
|
m_csRotation=_T("0");
|
|
}
|
|
return TRUE;
|
|
}
|
|
AcDbEntity* LoadGJKEntity(const TCHAR *pszLib,XString&sBlockName);
|
|
void CColumnDlg::OnGJK()
|
|
{
|
|
// 修改描述:标准柱的形状列表中选中异形柱项后不进行提示,而是直接调出构件库,
|
|
// 此时需要对构件库中时是否成功选择进行判断,而OnGJK()函数需要保证为void类型,
|
|
// 所以对原来OnGJK中的操作再进行一次函数封装.
|
|
// Began
|
|
/*
|
|
XPushAutoHide noAutoHide(this);
|
|
|
|
XString sLibFile,sBlockName=m_sBlockName;
|
|
sLibFile << g_sDwbPath << _T("Column.TKW");
|
|
AcDbEntity *pEnt=LoadGJKEntity(sLibFile,sBlockName);
|
|
if (pEnt!=NULL)
|
|
{
|
|
if (pEnt->isKindOf(TDbColumn::desc()))
|
|
{
|
|
UpdateData();
|
|
TDbColumn *pColu=TDbColumn::cast(pEnt);
|
|
pColu->GetOutline(m_polyOutline);
|
|
m_sBlockName=sBlockName;
|
|
|
|
//add by xlc on 090301
|
|
{
|
|
if (pColu->GetMaterial()==TColumnData::kBrick)
|
|
m_iMaterial=0;
|
|
else if (pColu->GetMaterial()==TColumnData::kRocket)
|
|
m_iMaterial=1;
|
|
else if (pColu->GetMaterial()==TColumnData::kConcrete)
|
|
m_iMaterial=2;
|
|
else
|
|
m_iMaterial=3;
|
|
|
|
//modify by xlc on 090602 选中构件库后柱子材料仍可选
|
|
//m_bLib=TRUE;
|
|
//GetDlgItem(IDC_MATERIAL)->EnableWindow(FALSE);
|
|
}
|
|
|
|
TColumnData::TSectionShape shape=pColu->GetSectionShape();
|
|
for(int i=0; i<ELEMENTS(g_coluShapeArray); i++)
|
|
{
|
|
if (g_coluShapeArray[i]==shape)
|
|
{
|
|
m_iColuType=i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (shape==TColumnData::kRect) {
|
|
m_csXSizeText=_T("横向");
|
|
m_csYSizeText=_T("纵向");
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
} else if (shape==TColumnData::kCircle) {
|
|
m_csXSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else if (shape==TColumnData::kPoly){
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else {
|
|
m_csXSizeText=_T("边长");
|
|
m_csYSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
CColumnDlg::pEntY=pColu;// [12/11/2007 nsh]
|
|
//Obj2Dlg(pColu);// [12/21/2007 nsh]
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
}
|
|
else
|
|
MessageBox(_T("请选择柱构件!"));
|
|
|
|
//delete pEnt;
|
|
}
|
|
*/
|
|
SelEntFromGJK();
|
|
// End
|
|
}
|
|
// Add by Zyu on 100322
|
|
// 从构件库中选择要绘制的实体
|
|
bool CColumnDlg::SelEntFromGJK()
|
|
{
|
|
XPushAutoHide noAutoHide(this);
|
|
|
|
XString sLibFile,sBlockName=m_sBlockName;
|
|
sLibFile << g_sDwbPath << _T("Column.TKW");
|
|
AcDbEntity *pEnt=LoadGJKEntity(sLibFile,sBlockName);
|
|
if (pEnt!=NULL)
|
|
{
|
|
if (pEnt->isKindOf(TDbColumn::desc()))
|
|
{
|
|
UpdateData();
|
|
TDbColumn *pColu=TDbColumn::cast(pEnt);
|
|
pColu->GetOutline(m_polyOutline);
|
|
m_sBlockName=sBlockName;
|
|
|
|
//add by xlc on 090301
|
|
{
|
|
CString sPattern;
|
|
pColu->GetSpecialtyDataReadOnly()->GetAt(sKEY_COLUMN_HATCH_PATTERN, sPattern);
|
|
|
|
if (pColu->GetMaterial()==TColumnData::kConcrete)
|
|
{
|
|
if (sPattern == COLMATE_Concrete1)
|
|
m_iMaterial=1;
|
|
else
|
|
m_iMaterial=0;
|
|
}
|
|
else if (pColu->GetMaterial()==TColumnData::kBrick)
|
|
{
|
|
if (sPattern == COLMATE_Brick1)
|
|
m_iMaterial=3;
|
|
else
|
|
m_iMaterial=2;
|
|
}
|
|
else if (pColu->GetMaterial()==TColumnData::kRocket)
|
|
{
|
|
if (sPattern == COLMATE_Rocket1)
|
|
m_iMaterial=5;
|
|
else
|
|
m_iMaterial=4;
|
|
}
|
|
else
|
|
{
|
|
if (sPattern == COLMATE_Steel)
|
|
m_iMaterial=6;
|
|
else
|
|
m_iMaterial=3;
|
|
}
|
|
//modify by xlc on 090602 选中构件库后柱子材料仍可选
|
|
//m_bLib=TRUE;
|
|
//GetDlgItem(IDC_MATERIAL)->EnableWindow(FALSE);
|
|
}
|
|
|
|
TColumnData::TSectionShape shape=pColu->GetSectionShape();
|
|
for(int i=0; i<ELEMENTS(g_coluShapeArray); i++)
|
|
{
|
|
if (g_coluShapeArray[i]==shape)
|
|
{
|
|
m_iColuType=i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (shape==TColumnData::kRect) {
|
|
m_csXSizeText=_T("横向");
|
|
m_csYSizeText=_T("纵向");
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
} else if (shape==TColumnData::kCircle) {
|
|
m_csXSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else if (shape==TColumnData::kPoly){
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else {
|
|
m_csXSizeText=_T("边长");
|
|
m_csYSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
CColumnDlg::pEntY=pColu;// [12/11/2007 nsh]
|
|
//Obj2Dlg(pColu);// [12/21/2007 nsh]
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
MessageBox(_T("请选择柱构件!"));
|
|
return false;
|
|
}
|
|
//delete pEnt;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
BOOL CColumnDlg::UpdateObject(TDbColumn *pColu) const
|
|
{
|
|
if (m_iColuType<0 || m_iColuType>=ELEMENTS(g_coluShapeArray))
|
|
return FALSE;
|
|
|
|
//modify by xlc on 070510
|
|
double nHeight=_tstof(m_csHeight);
|
|
if (m_csHeight==_T("当前层高"))
|
|
nHeight = DocGetLHeight();
|
|
else
|
|
nHeight = _tstof(m_csHeight);
|
|
|
|
if (nHeight<_DIST_SNAP)
|
|
return FALSE;
|
|
XPoint ptLoc=pColu->GetLocation();
|
|
XPoly2D poly;
|
|
if (!GetOutlinePoly(ptLoc, poly))
|
|
return FALSE;
|
|
pColu->SetSectionShape(g_coluShapeArray[m_iColuType]);
|
|
pColu->SetOutlinePoly(poly);
|
|
pColu->SetHeight(nHeight);
|
|
|
|
TColumnData::TColumnMaterial mater = TColumnData::kConcrete;
|
|
if (m_iMaterial == 2 || m_iMaterial == 3 )
|
|
{
|
|
mater = TColumnData::kBrick;
|
|
}
|
|
if (m_iMaterial == 4 || m_iMaterial == 5 )
|
|
{
|
|
mater = TColumnData::kRocket;
|
|
}
|
|
else if (m_iMaterial == 6)
|
|
{
|
|
mater = TColumnData::kSteel;
|
|
}
|
|
pColu->SetMaterial(mater);
|
|
pColu->GetSpecialtyData()->SetAt(sKEY_COLUMN_HATCH_PATTERN, g_NewMaterArray[m_iMaterial]);
|
|
return TRUE;
|
|
}
|
|
BOOL CColumnDlg::OnInitDialog()
|
|
{
|
|
CModelessDialog::OnInitDialog();
|
|
|
|
CComboBox* pBox = (CComboBox*)GetDlgItem(IDC_MATERIAL);
|
|
pBox->ResetContent();
|
|
pBox->AddString(COLMATE_Concrete);
|
|
pBox->AddString(COLMATE_Concrete1);
|
|
pBox->AddString(COLMATE_Brick);
|
|
pBox->AddString(COLMATE_Brick1);
|
|
pBox->AddString(COLMATE_Rocket);
|
|
pBox->AddString(COLMATE_Rocket1);
|
|
pBox->AddString(COLMATE_Steel);
|
|
pBox->SetCurSel(m_iMaterial);
|
|
|
|
bFirst=TRUE;// [1/14/2008 nsh]
|
|
for(int i=0; i<ELEMENTS(g_coluTypeArray);i++){
|
|
m_coluTypeBox.AddString(g_coluTypeArray[i]);
|
|
}
|
|
if (m_iColuType<0)
|
|
m_iColuType=0;
|
|
m_coluTypeBox.SetCurSel(0);
|
|
|
|
// 修改描述:标准柱的转角列表增加常用的60（-60）和90（-90）度。(1640)
|
|
// 修改人,修改时间: Zyu modify on 100322
|
|
// Begin A
|
|
m_rotationBox.AddString(_T("90"));
|
|
m_rotationBox.AddString(_T("60"));
|
|
// End A
|
|
for( i=45; i>=-45; i-=5) {
|
|
CString csItem;
|
|
csItem.Format(_T("%d"), i);
|
|
m_rotationBox.AddString(csItem);
|
|
}
|
|
// Begin B
|
|
m_rotationBox.AddString(_T("-60"));
|
|
m_rotationBox.AddString(_T("-90"));
|
|
// End B
|
|
|
|
for(i=350; i<1250; i+=50) {
|
|
CString csItem;
|
|
csItem.Format(_T("%d"), i);
|
|
m_xSizeBox.AddString(csItem);
|
|
m_ySizeBox.AddString(csItem);
|
|
}
|
|
UpdateImage();
|
|
if (m_bModeless) {
|
|
GetDlgItem(IDOK)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDCANCEL)->ShowWindow(SW_HIDE);
|
|
} else
|
|
{ //modified by whl
|
|
if (!bAxisExist)//无轴网定位点
|
|
{
|
|
GetDlgItem(IDC_XOFFSET)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_YOFFSET)->EnableWindow(FALSE);
|
|
}
|
|
|
|
UpdateData(FALSE);
|
|
OnSelendokColuType();
|
|
}
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CColumnDlg::OnPointColumn()
|
|
{
|
|
ShowChildWindow();
|
|
OnChangeInsertMode(ID_POINT_COLUMN);
|
|
}
|
|
|
|
|
|
|
|
void CColumnDlg::OnLineColumn()
|
|
{
|
|
ShowChildWindow();
|
|
OnChangeInsertMode(ID_LINE_COLUMN);
|
|
}
|
|
|
|
void CColumnDlg::OnRegionColumn()
|
|
{
|
|
ShowChildWindow();
|
|
OnChangeInsertMode(ID_REGION_COLUMN);
|
|
}
|
|
|
|
void CColumnDlg::OnReplaceColumn()
|
|
{
|
|
ShowChildWindow();
|
|
OnChangeInsertMode(ID_REPLACE_COLUMN);
|
|
}
|
|
void CColumnDlg::OnOtherColumn()
|
|
{
|
|
ShowChildWindow();
|
|
OnChangeInsertMode(ID_OTHERCOLUMN);
|
|
}
|
|
void CColumnDlg::OnCheckPline()
|
|
{
|
|
ShowChildWindow();
|
|
OnChangeInsertMode(ID_CHECKPLINE);
|
|
}
|
|
void CColumnDlg::OnChangeInsertMode(UINT id)
|
|
{
|
|
if (GetInsertMode() != id) {
|
|
UpdateData(TRUE);
|
|
UpdateData(FALSE);
|
|
acedPostCommand(_T("\n"));
|
|
}
|
|
}
|
|
|
|
UINT CColumnDlg::GetInsertMode()
|
|
{
|
|
return m_nInsertMode;
|
|
}
|
|
|
|
|
|
void CColumnDlg::OnSelendokColuType()
|
|
{
|
|
int oldType=m_iColuType;
|
|
UpdateData(TRUE);
|
|
m_iColuType=m_coluTypeBox.GetCurSel();
|
|
ASSERT(m_iColuType>=0);
|
|
TColumnData::TSectionShape shape=g_coluShapeArray[m_iColuType];
|
|
if (shape==TColumnData::kRect) {
|
|
m_csXSizeText=_T("横向");
|
|
m_csYSizeText=_T("纵向");
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
} else if (shape==TColumnData::kCircle) {
|
|
m_csXSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else if (shape==TColumnData::kPoly){
|
|
// 修改描述:标准柱的形状列表中选中异形柱项后不进行提示,而是直接调出构件库
|
|
// 修改人,修改时间: Zyu modify on 100412
|
|
// Begin
|
|
// if (oldType!=m_iColuType)
|
|
// AfxMessageBox(_T("异形柱只能从标准构件库选取!"));
|
|
// m_iColuType=oldType;
|
|
if (!m_bIsEdit && !SelEntFromGJK())
|
|
{
|
|
m_iColuType = oldType;
|
|
}
|
|
// End
|
|
}
|
|
else {
|
|
m_csXSizeText=_T("边长");
|
|
m_csYSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
|
|
//modify by xlc on 090602 选中构件库后柱子材料仍可选
|
|
//add by xlc on 090301
|
|
//if (shape!=TColumnData::kPoly&&m_bLib)
|
|
//{
|
|
// m_bLib=FALSE;
|
|
// GetDlgItem(IDC_MATERIAL)->EnableWindow();
|
|
//}
|
|
|
|
// Add by Zyu on 100412
|
|
m_bIsEdit = false;
|
|
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
}
|
|
|
|
void CColumnDlg::OnSelendokRotation()
|
|
{
|
|
m_bChange =TRUE;// [12/11/2007 nsh]
|
|
int nCurSel=m_rotationBox.GetCurSel();
|
|
|
|
// 修改描述:标准柱的转角列表增加常用的60（-60）和90（-90）度。(1640)
|
|
// 修改人,修改时间: Zyu modify on 100322
|
|
// Begin
|
|
// m_csRotation.Format(_T("%d"), 45-nCurSel*5);
|
|
m_rotationBox.GetLBText(nCurSel, m_csRotation);
|
|
// End
|
|
|
|
m_sSaveRotation=m_csRotation;
|
|
UpdateRotateImage();
|
|
//UpdateImage();
|
|
}
|
|
void CColumnDlg::OnSelendokXsize()
|
|
{
|
|
int nCurSel=m_xSizeBox.GetCurSel();
|
|
m_csXSize.Format(_T("%d"), 350+nCurSel*50);
|
|
UpdateImage();
|
|
}
|
|
|
|
void CColumnDlg::OnSelendokYsize()
|
|
{
|
|
int nCurSel=m_ySizeBox.GetCurSel();
|
|
m_csYSize.Format(_T("%d"), 350+nCurSel*50);
|
|
UpdateImage();
|
|
}
|
|
|
|
void CColumnDlg::OnKillfocusXoffset()
|
|
{
|
|
UpdateData(TRUE);
|
|
UpdateImage();
|
|
}
|
|
|
|
void CColumnDlg::OnKillfocusXsize()
|
|
{
|
|
UpdateData(TRUE);
|
|
UpdateImage();
|
|
}
|
|
|
|
void CColumnDlg::OnKillfocusYoffset()
|
|
{
|
|
UpdateData(TRUE);
|
|
UpdateImage();
|
|
}
|
|
|
|
void CColumnDlg::OnKillfocusYsize()
|
|
{
|
|
UpdateData(TRUE);
|
|
UpdateImage();
|
|
}
|
|
void CColumnDlg::OnKillfocusRotation()
|
|
{
|
|
UpdateData(TRUE);
|
|
//UpdateImage();
|
|
UpdateRotateImage();
|
|
}
|
|
void CColumnDlg::UpdateRotateImage()
|
|
{
|
|
TDbColumn colu;
|
|
XPoint ptOffset(XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset)));
|
|
AcGeVector3d vec = ptOffset-AcGePoint3d(0,0,0);
|
|
//double dAngle =
|
|
vec.rotateBy(_tstof(m_csRotation)*PI/180-_tstof(m_strColumAngle)*PI/180,AcGeVector3d(0,0,1));
|
|
ptOffset = vec;
|
|
m_csXOffset.Format(_T("%.2f"),ptOffset.x);
|
|
m_csYOffset.Format(_T("%.2f"),ptOffset.y);
|
|
SetDlgItemText(IDC_XOFFSET,m_csXOffset);
|
|
SetDlgItemText(IDC_YOFFSET,m_csYOffset);
|
|
colu.SetLocation(XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset)));
|
|
UpdateObject(&colu);
|
|
m_strColumAngle = m_csRotation;
|
|
CWnd *pImageBox=GetDlgItem(IDC_SLIDE);
|
|
ASSERT(pImageBox);
|
|
CRect rect;
|
|
pImageBox->GetClientRect(rect);
|
|
CDC *pDC=pImageBox->GetDC();
|
|
m_image.InitDC(pDC, rect, GetAcadBackColor());
|
|
m_image.Reset();
|
|
if (!colu.IsValid()) {
|
|
XString sFileName(256);
|
|
//if (FindFile(_T("ErrorInput.Sld"), sFileName))
|
|
m_image.PaintSlide(_T("TArch(ErrorInput)"));
|
|
} else {
|
|
m_image.Fill(GetAcadBackColor());
|
|
m_image.SetColor(7);
|
|
colu.ExplodeOrDraw2d(m_image);
|
|
|
|
//modified by whl
|
|
if (bAxisExist||m_bModeless)
|
|
{
|
|
XPoint ptLow, ptUp;
|
|
colu.GetExtents2d(ptLow, ptUp);
|
|
double sx=ptUp.x-ptLow.x;
|
|
double sy=ptUp.y-ptLow.y;
|
|
XLine ln1(XPoint(-sx,0), XPoint(sx,0));
|
|
XLine ln2(XPoint(0,-sy), XPoint(0, sy));
|
|
m_image.SetColor(1);
|
|
m_image << ln1 << ln2;
|
|
}
|
|
|
|
m_image.Redraw();
|
|
}
|
|
m_image.SetDC(NULL);
|
|
pImageBox->ReleaseDC(pDC);
|
|
}
|
|
//add by xlc on 070511
|
|
void CColumnDlg::OnKillfocusHeight()
|
|
{
|
|
UpdateData(TRUE);
|
|
UpdateImage();
|
|
}
|
|
|
|
//add by xlc on 071105
|
|
void CColumnDlg::OnSelendokMaterial()
|
|
{
|
|
UpdateData(TRUE);
|
|
}
|
|
|
|
|
|
BOOL CColumnDlg::OnToolTipText(UINT, NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);
|
|
|
|
// if there is a top level routing frame then let it handle the message
|
|
if (GetRoutingFrame() != NULL) return FALSE;
|
|
|
|
// to be thorough we will need to handle UNICODE versions of the message also !!
|
|
TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
|
|
TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
|
|
//TCHAR szFullText[512];
|
|
CString strTipText;
|
|
UINT nID = (UINT)pNMHDR->idFrom;
|
|
|
|
if (pNMHDR->code == TTN_NEEDTEXTA && (pTTTA->uFlags & TTF_IDISHWND) ||
|
|
pNMHDR->code == TTN_NEEDTEXTW && (pTTTW->uFlags & TTF_IDISHWND)) {
|
|
// idFrom is actually the HWND of the tool
|
|
|
|
//nID = ::GetDlgCtrlID((HWND)nID);
|
|
return FALSE;//Add by whl on 060308
|
|
}
|
|
|
|
if (nID != 0) {// will be zero on a separator
|
|
{
|
|
CAcModuleResourceOverride vTmp;
|
|
strTipText.LoadString(nID); //=szFullText;
|
|
}
|
|
|
|
#ifndef _UNICODE
|
|
if (pNMHDR->code == TTN_NEEDTEXTA) {
|
|
lstrcpyn(pTTTA->szText, strTipText, sizeof(pTTTA->szText));
|
|
} else {
|
|
_mbstowcsz(pTTTW->szText, strTipText, sizeof(pTTTW->szText));
|
|
}
|
|
#else
|
|
if (pNMHDR->code == TTN_NEEDTEXTA) {
|
|
_wcstombsz(pTTTA->szText, strTipText,sizeof(pTTTA->szText));
|
|
} else {
|
|
lstrcpyn(pTTTW->szText, strTipText, sizeof(pTTTW->szText));
|
|
}
|
|
#endif
|
|
|
|
*pResult = 0;
|
|
|
|
// bring the tooltip window above other popup windows
|
|
::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,SWP_NOACTIVATE|
|
|
SWP_NOSIZE|SWP_NOMOVE|SWP_NOOWNERZORDER); return TRUE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
void CColumnDlg::OnPaint()
|
|
{
|
|
CPaintDC dc(this); // device context for painting
|
|
|
|
CWnd *pImageBox=GetDlgItem(IDC_SLIDE);
|
|
ASSERT(pImageBox);
|
|
CRect rect;
|
|
pImageBox->GetClientRect(rect);
|
|
CDC *pDC=pImageBox->GetDC();
|
|
m_image.InitDC(pDC, rect, GetAcadBackColor());
|
|
//m_image.Fill(GetAcadBackColor());
|
|
m_image.Redraw();
|
|
m_image.SetDC(NULL);
|
|
pImageBox->ReleaseDC(pDC);
|
|
// Do not call CModelessDialog::OnPaint() for painting messages
|
|
}
|
|
|
|
|
|
BOOL CColumnDlg::GetInsertExtend(double& pX, double& pY)
|
|
{
|
|
XPoly2D poly;
|
|
if (!GetOutlinePoly(XPoint(), poly))
|
|
return FALSE;
|
|
XPoint ptLow, ptUp;
|
|
poly.GetExtend(ptLow, ptUp);
|
|
pX=ptUp.x-ptLow.x;
|
|
pY=ptUp.y-ptLow.y;
|
|
return TRUE;
|
|
}
|
|
|
|
//add by xlc on 070423
|
|
//柱子JIG类
|
|
class TDbColumnJig : public AcEdJig
|
|
{
|
|
public:
|
|
TDbColumnJig(TDbColumn *m_pEnt,CColumnDlg *dlg);
|
|
~TDbColumnJig();
|
|
virtual DragStatus sampler();
|
|
virtual Adesk::Boolean update();
|
|
virtual AcDbEntity* entity() const;
|
|
void SetPrompt(const TCHAR *m_pTemp);
|
|
int GetRetCode() const;
|
|
void SetKeyword(const TCHAR *pszKeyword);
|
|
int doIt();
|
|
ads_real GetAxisXDirect(XPoint point);
|
|
BOOL GetOutlinePoly(XPoint& ptPick, XPoly2D &poly) const;
|
|
int m_nRetCode; //返回码
|
|
const TCHAR *m_pszPrompt; //提示信息
|
|
const TCHAR *m_pszKeyword; //关键字
|
|
AcGePoint3d m_point; //插入点
|
|
XPoint m_ptPoint; //插入点
|
|
TDbColumn *m_column; //柱子实体
|
|
CColumnDlg *m_dlg; //柱子参数对话框
|
|
Array<ads_real> m_axisDrt; //轴网交点的方向数组
|
|
Array<XPoint> m_ptIntArray; //轴网交点
|
|
ads_real nAxisXDrt; //轴线方向
|
|
BOOL m_bRot; //是否旋转
|
|
|
|
//add by xlc on 090301
|
|
XPoint m_ptRot; //旋转时记录柱子的基点Loc
|
|
double m_dStartAngle; //旋转时记录柱子的起始转角
|
|
};
|
|
|
|
//交点插柱子
|
|
/*/ BOOL CColumnDlg::PointColumn()
|
|
{
|
|
XPushVar<int> vOsMode(_T("OSMODE"), OS_INT);
|
|
XPoint ptPick;
|
|
RBList rbMask=AxisMask();
|
|
|
|
|
|
while(XGetPoint(NULL, _T("\n点取柱子的插入位置<退出>"), ptPick)==RTNORM) {
|
|
UpdateData(TRUE);
|
|
//Get Extend
|
|
ads_real nLimX, nLimY;
|
|
GetInsertExtend(nLimX, nLimY);
|
|
|
|
ptPick=Ucs2Wcs(ptPick);
|
|
XOsnap(ptPick, OS_INT, rbMask, max(nLimX, nLimY)/2.0);
|
|
ads_real nAxisXDrt=GetAxisXDirection(ptPick);
|
|
ads_matrix mat;
|
|
ptPick.GetRotationMatrix(nAxisXDrt, mat);
|
|
XPoint ptLoc=ptPick+XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset));
|
|
ptLoc.TransformBy(mat);
|
|
|
|
ptLoc.GetRotationMatrix(nAxisXDrt, mat);
|
|
TDbColumn *pColu=new TDbColumn;
|
|
pColu->SetLocation(ptLoc);
|
|
UpdateObject(pColu);
|
|
pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
if (!InsertColumn(pColu))
|
|
delete pColu;
|
|
TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
return (GetInsertMode()!=ID_POINT_COLUMN);
|
|
}
|
|
*/
|
|
BOOL CColumnDlg::PointColumn()
|
|
{
|
|
// 问题描述:原来在选择插入点时,只设置了交叉点的对象捕捉,没有保存用户原来的设置
|
|
// 解决方法:保留原来用户的设置,加入交叉点的捕捉
|
|
// 修改人,修改时间:Zyu modify on 100412
|
|
// Begin
|
|
int iOsMode = 0;
|
|
TGGetVar(_T("OSMODE"), &iOsMode);
|
|
//XPushVar<int> vOsMode(_T("OSMODE"), OS_INT);
|
|
XPushVar<int> vOsMode(_T("OSMODE"), iOsMode & ~0x4000 | OS_INT);
|
|
// End
|
|
XPoint ptPick(0,0,0);
|
|
RBList rbMask=AxisMask();
|
|
|
|
//modify by xlc on 070423
|
|
// XGetPoint(NULL, _T("\n点取柱子的插入位置<退出>"), ptPick);
|
|
// UpdateData(TRUE);
|
|
//Get Extend
|
|
// ads_real nLimX, nLimY;
|
|
// GetInsertExtend(nLimX, nLimY);
|
|
|
|
// ptPick=Ucs2Wcs(ptPick);
|
|
// XOsnap(ptPick, OS_INT, rbMask, max(nLimX, nLimY)/2.0);
|
|
// ads_real nAxisXDrt=GetAxisXDirection(ptPick);
|
|
// ads_matrix mat;
|
|
// ptPick.GetRotationMatrix(nAxisXDrt, mat);
|
|
// XPoint ptLoc=ptPick+XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset));
|
|
// ptLoc.TransformBy(mat);
|
|
|
|
// ptLoc.GetRotationMatrix(nAxisXDrt, mat);
|
|
// UpdateObject(pColu);
|
|
// pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
//------------start---------------------
|
|
//选择轴网
|
|
PickSet ssAxis(SS_FREE);
|
|
ssAxis.Get(_T("X"), NULL, NULL, rbMask);
|
|
AcGePoint3dArray ptIntArray; //轴网交点
|
|
static Array<XPoint> ptArray; //轴网交点
|
|
static Array<ads_real> axisDrt; //坐标的转化
|
|
// [1/14/2008 nsh]
|
|
//----------------------begin-------------------
|
|
if (bFirst)
|
|
{
|
|
|
|
if (ptArray.GetLength()!=0)
|
|
{
|
|
ptArray.Clear();
|
|
}
|
|
if (axisDrt.GetLength()!=0)
|
|
{
|
|
axisDrt.Clear();
|
|
}
|
|
GetAxisInt(ssAxis,ptIntArray,axisDrt);
|
|
ptArray.Realloc(ptIntArray.length());
|
|
for(long i=0;i<ptIntArray.length();i++)
|
|
{
|
|
ptArray[i] = ptIntArray[i];
|
|
}
|
|
bFirst=FALSE;
|
|
}
|
|
//ptArray.Arrange(); //升序排序
|
|
|
|
//
|
|
//for(i=0;i<ptArray.GetLength();i++)
|
|
//{
|
|
// ads_real nAxisXDrt=GetAxisXDirection(ptArray[i]);
|
|
// axisDrt.AddTail(nAxisXDrt);
|
|
//}
|
|
//-------------------end--------------------------
|
|
TDbColumn *pColu=new TDbColumn;
|
|
pColu->setLayer(InitLayer(LAY_COLU));
|
|
UpdateObject(pColu);
|
|
|
|
TDbColumnJig jig(pColu,this);
|
|
jig.m_axisDrt = axisDrt;
|
|
jig.m_ptIntArray = ptArray;
|
|
while(1)
|
|
{
|
|
jig.SetPrompt(_T("\n点取位置或 [转90度(A)/左右翻(S)/上下翻(D)/对齐(F)/改转角(R)/改基点(T)/参考点(G)]<退出>:"));
|
|
jig.SetKeyword(_T("A S D F R T G"));
|
|
|
|
int nRet = jig.doIt();
|
|
if (nRet == RTNORM)
|
|
{
|
|
pColu = (TDbColumn *)jig.entity();
|
|
TDbColumn *pNew = (TDbColumn *)pColu->clone();
|
|
pEntM =(TDbColumn *)pColu->clone();// [7/21/2008 nsh]
|
|
if (!InsertColumn(pNew)){
|
|
//delete pNew; modify by nsh
|
|
}
|
|
//modify by xlc on 070718
|
|
TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
else if (nRet == RTKWORD)
|
|
{
|
|
ads_printf(_T("%c%c %c"), 8,8,8); //消除回答的字符
|
|
|
|
pColu = (TDbColumn *)jig.entity();
|
|
AcGeMatrix3d mat;
|
|
double rot = _tstof(m_csRotation);
|
|
double xOffset = _tstof(m_csXOffset);
|
|
double yOffset = _tstof(m_csYOffset);
|
|
double r=sqrt(xOffset*xOffset+yOffset*yOffset);
|
|
switch(jig.m_nRetCode)
|
|
{
|
|
case 1://旋转90
|
|
{
|
|
rot += 90;
|
|
if (rot >= 360)
|
|
{
|
|
rot -= 360;
|
|
}
|
|
else if (rot <= -360)
|
|
{
|
|
rot += 360;
|
|
}
|
|
|
|
|
|
//modify by xlc on 090305
|
|
//xOffset = r * cos(rot * PI/180.0);
|
|
//yOffset = r * sin(rot * PI/180.0);
|
|
XPoint loc=pColu->GetLocation(),ptBase;
|
|
ptBase=loc+XPoint(xOffset,yOffset,0);
|
|
ads_matrix mat;
|
|
ptBase.GetRotationMatrix(-PI/2, mat);
|
|
loc.TransformBy(AsAcGeMatrix3d(mat));
|
|
|
|
xOffset=loc.x-ptBase.x;
|
|
yOffset=loc.y-ptBase.y;
|
|
|
|
|
|
//add by xlc on 090224
|
|
if (fabs(xOffset)<_DIST_SNAP)
|
|
xOffset = 0;
|
|
if (fabs(yOffset)<_DIST_SNAP)
|
|
yOffset = 0;
|
|
if (fabs(rot)<_DIST_SNAP)
|
|
rot = 0;
|
|
|
|
m_csRotation.Format(_T("%.f"),rot);
|
|
m_strColumAngle.Format(_T("%.f"),rot);
|
|
m_csXOffset.Format(_T("%.2f"),xOffset);
|
|
m_csYOffset.Format(_T("%.2f"),yOffset);
|
|
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
}
|
|
break;
|
|
case 2://左右翻转
|
|
{
|
|
//modify by xlc on 070718
|
|
//可以在非对称情况下翻转
|
|
// rot *= -1;
|
|
// xOffset *= -1;
|
|
// m_csXOffset.Format(_T("%.2f"),xOffset);
|
|
// m_csRotation.Format(_T("%.f"),rot);
|
|
//xOffset *= -1;
|
|
|
|
//add by xlc on 090224
|
|
//if (fabs(xOffset)<_DIST_SNAP)
|
|
// xOffset = 0;
|
|
|
|
//m_csXOffset.Format(_T("%.2f"),xOffset);
|
|
m_bYAxisMirror = !m_bYAxisMirror;
|
|
rot *=-1;
|
|
XPoint ptLoc = jig.m_ptPoint;
|
|
AcGePoint2d pt(Ucs2Wcs(ptLoc).AsAcGePoint2d());
|
|
XVector3D xv(0,1,0);
|
|
xv = Ucs2Wcs(xv);
|
|
AcGeLine2d geline2d(pt,xv.AsAcGeVector2d());
|
|
AcGePoint2d PointTemp=jig.m_column->GetLocation();
|
|
PointTemp = Ucs2Wcs(PointTemp).AsAcGePoint2d();
|
|
PointTemp=PointTemp.mirror(geline2d);
|
|
XPoint ptOffset = (XPoint)PointTemp - Ucs2Wcs(ptLoc);
|
|
//add by xlc on 090224
|
|
if (fabs(ptOffset.x)<_DIST_SNAP)
|
|
xOffset = 0;
|
|
if (fabs(ptOffset.y)<_DIST_SNAP)
|
|
yOffset = 0;
|
|
if (fabs(rot)<_DIST_SNAP)
|
|
rot = 0;
|
|
m_csRotation.Format(_T("%.f"),rot);
|
|
m_strColumAngle.Format(_T("%.f"),rot);
|
|
m_csXOffset.Format(_T("%.2f"),ptOffset.x);
|
|
m_csYOffset.Format(_T("%.2f"),ptOffset.y);
|
|
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
break;
|
|
}
|
|
case 3://上下翻转
|
|
{
|
|
|
|
//modify by xlc on 070718
|
|
//可以在非对称情况下翻转
|
|
/*XPoint ptLoc = pColu->GetLocation();
|
|
|
|
AcGeMatrix3d mat1;
|
|
XVector3D vt = Ucs2Wcs(XVector3D(1,0,0),TRUE);
|
|
mat1.setToMirroring(AcGeLine3d((AcGePoint3d &)ptLoc, (AcGeVector3d &)vt));
|
|
mat1(2,2) = 1;
|
|
pColu->transformBy((mat1));
|
|
|
|
if (m_iColuType == 7||m_iColuType == 0)//异型柱和矩形例外
|
|
{
|
|
rot *= -1;
|
|
m_csRotation.Format(_T("%.f"),rot);
|
|
}
|
|
else
|
|
{
|
|
m_csRotation = (const TCHAR *)Angle2Str(
|
|
(pColu->GetRotation()-jig.nAxisXDrt)*180/PI);//相对轴网转角
|
|
}
|
|
yOffset *= -1;
|
|
m_csYOffset.Format(_T("%.2f"),yOffset);*/
|
|
//yOffset *= -1;
|
|
//add by xlc on 090224
|
|
//if (fabs(yOffset)<_DIST_SNAP)
|
|
// yOffset = 0;
|
|
|
|
//m_csYOffset.Format(_T("%.2f"),yOffset);
|
|
m_bXAxisMirror = !m_bXAxisMirror;
|
|
rot =180-rot;
|
|
XPoint ptLoc = jig.m_ptPoint;
|
|
AcGePoint2d pt(Wcs2Ucs(ptLoc).AsAcGePoint2d());
|
|
XVector3D xv(1,0,0);
|
|
xv = Ucs2Wcs(xv);
|
|
AcGeLine2d geline2d(pt,xv.AsAcGeVector2d());
|
|
AcGePoint2d PointTemp=jig.m_column->GetLocation();
|
|
PointTemp = Ucs2Wcs(PointTemp).AsAcGePoint2d();
|
|
PointTemp=PointTemp.mirror(geline2d);
|
|
XPoint ptOffset = (XPoint)PointTemp - Ucs2Wcs(ptLoc);
|
|
//add by xlc on 090224
|
|
if (fabs(ptOffset.x)<_DIST_SNAP)
|
|
xOffset = 0;
|
|
if (fabs(ptOffset.y)<_DIST_SNAP)
|
|
yOffset = 0;
|
|
if (fabs(rot)<_DIST_SNAP)
|
|
rot = 0;
|
|
m_csRotation.Format(_T("%.f"),rot);
|
|
m_strColumAngle.Format(_T("%.f"),rot);
|
|
m_csXOffset.Format(_T("%.2f"),ptOffset.x);
|
|
m_csYOffset.Format(_T("%.2f"),ptOffset.y);
|
|
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
break;
|
|
}
|
|
case 4://对齐
|
|
{
|
|
int nOsMode=0;
|
|
xg_getvar(_T("OSMODE"), &nOsMode);
|
|
nOsMode &= ~0x4000;
|
|
nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
|
|
XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
|
|
|
|
TDbColumn *pTempEnt=(TDbColumn *)pColu->clone();
|
|
AcDbObjectId idTemp=AddToCurrentSpace(pTempEnt, Adesk::kTrue);
|
|
|
|
XPoint pt1, pt2, qt1, qt2;
|
|
if (ads_getpoint(NULL, _T("\n对齐参考点："), pt1)==RTNORM &&
|
|
ads_getpoint(pt1, _T("\n对齐参考轴："), pt2)==RTNORM &&
|
|
ads_getpoint(NULL, _T("\n对齐目标点："), qt1)==RTNORM &&
|
|
ads_getpoint(qt1, _T("\n对齐目标轴："), qt2)==RTNORM)
|
|
{
|
|
pt1=Ucs2Wcs(pt1);
|
|
pt2=Ucs2Wcs(pt2);
|
|
qt1=Ucs2Wcs(qt1);
|
|
qt2=Ucs2Wcs(qt2);
|
|
|
|
double nRot=CT_std_angle(ads_angle(qt1, qt2)-ads_angle(pt1, pt2));
|
|
ads_matrix matMov, matRot;
|
|
pt1.GetMoveMatrix(qt1, matMov);
|
|
qt1.GetRotationMatrix(nRot, matRot);
|
|
|
|
OPENOBJ_BEGIN(idTemp, AcDb::kForWrite, AcDbEntity, pEnt);
|
|
if (pEnt)
|
|
{
|
|
pEnt->transformBy(AsAcGeMatrix3d(matMov));
|
|
pEnt->transformBy(AsAcGeMatrix3d(matRot));
|
|
}
|
|
|
|
TDbColumn *pNew = (TDbColumn *)pEnt->clone();
|
|
if (!InsertColumn(pNew)){
|
|
//delete pNew; modify by nsh
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
}
|
|
|
|
OPENOBJ_BEGIN(idTemp, AcDb::kForWrite, AcDbEntity, pEnt);
|
|
if (pEnt) pEnt->erase();
|
|
OPENOBJ_END();
|
|
|
|
break;
|
|
}
|
|
case 5://旋转
|
|
{
|
|
TDbColumnJig jig1(pColu,this);
|
|
jig1.SetPrompt(_T("\n旋转角度:"));
|
|
jig1.m_bRot=TRUE;
|
|
jig1.m_ptPoint = jig.m_ptPoint;
|
|
|
|
//add by xlc on 090301
|
|
jig1.m_ptRot=pColu->GetLocation();
|
|
jig1.m_dStartAngle=rot;
|
|
|
|
int nRet1 = jig1.doIt();
|
|
if (nRet == RTNORM)
|
|
{
|
|
jig1.m_bRot = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
case 6://换基点
|
|
{
|
|
XPoint pt;
|
|
int nOsMode=0;
|
|
xg_getvar(_T("OSMODE"), &nOsMode);
|
|
nOsMode &= ~0x4000;
|
|
nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
|
|
XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
|
|
|
|
AcDbEntity *pTempEnt=(AcDbEntity *)pColu->clone();
|
|
AcDbObjectId idTemp=AddToCurrentSpace(pTempEnt, Adesk::kTrue);
|
|
int nRet=XGetPoint(NULL, _T("\n输入插入点"), pt);
|
|
|
|
if (nRet == RTNORM)
|
|
{
|
|
XPoint ptLoc=pColu->GetLocation();
|
|
|
|
//modify by xlc on 090227
|
|
// m_csXOffset.Format(_T("%.3f"),ptLoc.x-pt.x);
|
|
// m_csYOffset.Format(_T("%.3f"),ptLoc.y-pt.y);
|
|
XPoint pt1=Wcs2Ucs(ptLoc);
|
|
m_csXOffset.Format(_T("%.3f"),pt1.x-pt.x);
|
|
m_csYOffset.Format(_T("%.3f"),pt1.y-pt.y);
|
|
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
}
|
|
|
|
OPENOBJ_BEGIN(idTemp, AcDb::kForWrite, AcDbEntity, pEnt);
|
|
if (pEnt) pEnt->erase();
|
|
OPENOBJ_END();
|
|
break;
|
|
}
|
|
// [3/4/2008 nsh]
|
|
//---------------begin-----------------
|
|
case 7:
|
|
{//参考点
|
|
int nOsMode=0;
|
|
xg_getvar(_T("OSMODE"), &nOsMode);
|
|
nOsMode &= ~0x4000;
|
|
nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
|
|
XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
|
|
XPoint xtemp;
|
|
XPoint xInsert;
|
|
|
|
//modify by xlc on 090310
|
|
// ads_getpoint(NULL,_T("\n请选取参考点:"),xtemp);
|
|
// ads_getpoint(xtemp,_T("\n请输入插入点:"),xInsert);
|
|
// TDbColumnJig jig1(pColu,this);
|
|
// jig1.m_bRot=TRUE;
|
|
// jig1.m_ptPoint=/*Ucs2Wcs*/(xInsert);
|
|
// jig1.SetPrompt(_T("\n请输入旋转的角度:"));
|
|
// int rt=jig1.doIt();
|
|
// if (rt==RTNORM)
|
|
// {
|
|
// TDbColumn *pBlockTemp=(TDbColumn*)jig1.m_column->clone();
|
|
// AddToCurrentSpace(pBlockTemp,TRUE);
|
|
// }
|
|
if (ads_getpoint(NULL,_T("\n请选取参考点:"),xtemp)==RTNORM
|
|
&&ads_getpoint(xtemp,_T("\n请输入插入点:"),xInsert)==RTNORM)
|
|
{
|
|
TDbColumn *pBlockTemp=(TDbColumn*)pColu->clone();
|
|
|
|
ads_matrix matMov;
|
|
jig.m_ptPoint.GetMoveMatrix(Ucs2Wcs(xInsert), matMov);
|
|
|
|
pBlockTemp->transformBy(AsAcGeMatrix3d(matMov));
|
|
AddToCurrentSpace(pBlockTemp,TRUE);
|
|
}
|
|
break;
|
|
}
|
|
//-------------end-----------------
|
|
default:;
|
|
}
|
|
pEntM =(TDbColumn *)pColu->clone();// [12/12/2007 nsh]
|
|
}
|
|
else
|
|
{
|
|
m_bInitFirst =FALSE;// [12/14/2007 nsh]
|
|
break;
|
|
}
|
|
|
|
}
|
|
//delete pColu; delete by nsh
|
|
//------------end---------------------
|
|
|
|
/*TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();*/
|
|
|
|
return (GetInsertMode()!=ID_POINT_COLUMN);
|
|
}
|
|
|
|
|
|
//轴线插柱子
|
|
BOOL CColumnDlg::LineColumn()
|
|
{
|
|
Entity entAxis0;
|
|
RBList axisMask=AxisMask();
|
|
while(1)
|
|
{
|
|
int i=entAxis0.FilterSelect(_T("\n请选择一轴线<退出>:"), axisMask);
|
|
if (i==RTNORM)
|
|
{
|
|
UpdateData(TRUE);
|
|
XCurveSegment cv0(entAxis0, LS_FINITE);
|
|
XCurveSegment cvUcs(cv0);
|
|
cvUcs.StartPoint() = Wcs2Ucs(cv0.StartPoint());
|
|
cvUcs.EndPoint() = Wcs2Ucs(cv0.EndPoint());
|
|
XPoint ptLow, ptUp;
|
|
cvUcs.GetExtend(ptLow, ptUp);
|
|
AssureOnScreen(Ucs2Wcs(ptLow), Ucs2Wcs(ptUp));// [12/14/2007 nsh]
|
|
|
|
RBList rbFence=cvUcs.AsFence();
|
|
PickSet ssAxis(SS_FREE);
|
|
if (ssAxis.Get(_T("F"), rbFence, NULL, axisMask)!=RTNORM)
|
|
continue;
|
|
long len=ssAxis.Length();
|
|
for(long i=0; i<len; i++) {
|
|
Entity eAxis=ssAxis[i];
|
|
XCurveSegment cv1(eAxis, LS_FINITE);
|
|
XPoint ptInt[2];
|
|
int nIntNum=cv0.Intersection(cv1, ptInt[0], ptInt[1]);
|
|
for(int n=0; n<nIntNum; n++) {
|
|
if (CT_IsSameDrt(cv0.Direction(ptInt[n]), cv1.Direction(ptInt[n]), 0.1))
|
|
continue;
|
|
ads_real nAxisXDrt=GetXDirection1(cv0, cv1, ptInt[n]);
|
|
XPoint ptLoc=ptInt[n]+XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset));
|
|
|
|
ads_matrix mat;
|
|
ptInt[n].GetRotationMatrix(nAxisXDrt, mat);
|
|
ptLoc.TransformBy(mat);
|
|
ptLoc.GetRotationMatrix(nAxisXDrt, mat);
|
|
TDbColumn *pColu=new TDbColumn;
|
|
pColu->SetLocation(ptLoc);
|
|
pColu->setLayer (InitLayer (LAY_COLU));
|
|
UpdateObject(pColu);
|
|
pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
if (!InsertColumn(pColu)){
|
|
//delete pColu; modify by nsh
|
|
}
|
|
}
|
|
}
|
|
entAxis0.FreeGroups();
|
|
TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
else
|
|
{
|
|
m_bInitFirst =FALSE;// [12/14/2007 nsh]
|
|
break;
|
|
}
|
|
|
|
}
|
|
return (GetInsertMode()!=ID_LINE_COLUMN);
|
|
}
|
|
|
|
//区域插柱子
|
|
BOOL CColumnDlg::RegionColumn()
|
|
{
|
|
RBList axisMask=AxisMask();
|
|
while(1) {
|
|
XPoint ptCorner1, ptCorner2;
|
|
if (ads_getpoint(NULL, _T("\n第一个角点<退出>:"), ptCorner1)==RTNORM &&
|
|
XGetCorner(ptCorner1, _T("\n另一个角点<退出>: "), ptCorner2)==RTNORM) {
|
|
PickSet ss(SS_FREE);
|
|
if (ss.Get(_T("C"), ptCorner1, ptCorner2, axisMask)!=RTNORM) {
|
|
adsout << _T("\n没有选中轴线!");
|
|
continue;
|
|
}
|
|
UpdateData(TRUE);//add by whl
|
|
XRectAngle rect(ptCorner1, ptCorner2);
|
|
DList<CurveEntity> lstCurves;
|
|
long len=ss.Length();
|
|
for(long n=0; n<len; n++) {
|
|
Entity ent=ss[n];
|
|
lstCurves.Append(new CurveEntity(ent));
|
|
}
|
|
|
|
IntersAxisRegion lstInters;
|
|
int nNum=lstCurves.Length();
|
|
for(int i=0; i<nNum; i++) {
|
|
CurveEntity &ce1=*lstCurves[i];
|
|
for(int j=i+1; j<nNum; j++) {
|
|
CurveEntity &ce2=*lstCurves[j];
|
|
lstInters.Inters(ce1, ce2);
|
|
}
|
|
}
|
|
|
|
for(i=0; i<lstInters.Length(); i++) {
|
|
XPointDir2d pt=lstInters[i]->ptDir;
|
|
if ((Wcs2Ucs(pt)&rect)!=PR_INSIDE) continue;
|
|
XPoint ptLoc=pt+XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset));
|
|
|
|
ads_matrix mat;
|
|
pt.GetRotationMatrix(pt.nDirection, mat);
|
|
ptLoc.TransformBy(mat);
|
|
ptLoc.GetRotationMatrix(pt.nDirection, mat);
|
|
TDbColumn *pColu=new TDbColumn;
|
|
pColu->SetLocation(ptLoc);
|
|
pColu->setLayer (InitLayer (LAY_COLU));
|
|
UpdateObject(pColu);
|
|
pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
if (!InsertColumn(pColu)){
|
|
//delete pColu; modify by nsh
|
|
}
|
|
}
|
|
|
|
} else {
|
|
m_bInitFirst =FALSE;// [12/14/2007 nsh]
|
|
break;
|
|
}
|
|
TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
return (GetInsertMode()!=ID_REGION_COLUMN);
|
|
}
|
|
// [4/2/2008 nsh]
|
|
//--------------------------------------------------------------
|
|
int InsertColumn(const XPoly2D &idStyle, TColumnData::TColumnMaterial mater, const XPoint &ptLoc,
|
|
double nHeight, TColumnData::TSectionShape nUsage, CString sT20Mat);
|
|
void CColumnDlg::ShowChildWindow()
|
|
{
|
|
TColumnData::TSectionShape shape=g_coluShapeArray[m_iColuType];
|
|
if (shape==TColumnData::kRect) {
|
|
m_csXSizeText=_T("横向");
|
|
m_csYSizeText=_T("纵向");
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
} else if (shape==TColumnData::kCircle) {
|
|
m_csXSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else if (shape==TColumnData::kPoly){
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else {
|
|
m_csXSizeText=_T("边长");
|
|
m_csYSizeText=_T("直径");
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
GetDlgItem(IDC_STATIC_XOFFSET)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_STATIC_YOFFSET)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_STATIC_ROTATION)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_XOFFSET)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_YOFFSET)->ShowWindow(SW_SHOW);
|
|
GetDlgItem(IDC_ROTATION)->ShowWindow(SW_SHOW);
|
|
return;
|
|
}
|
|
BOOL CColumnDlg::OtherColumn()
|
|
{
|
|
RBList mask(RTDXF0, _T("POLYLINE,LWPOLYLINE"), NULL);
|
|
PickSet ss(SS_FREE);
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_HIDE);
|
|
|
|
GetDlgItem(IDC_STATIC_XOFFSET)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_STATIC_YOFFSET)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_STATIC_ROTATION)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XOFFSET)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YOFFSET)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_ROTATION)->ShowWindow(SW_HIDE);
|
|
|
|
GetDlgItem(IDC_COLU_TYPE)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_GJK)->EnableWindow(FALSE);
|
|
while(1)
|
|
{
|
|
long iRet=SelectEntities(_T("\n请选择作为柱子的封闭多段线:"), ss, mask );
|
|
if (iRet==RTNORM)
|
|
{
|
|
int nMater;
|
|
UpdateData();
|
|
nMater=m_iMaterial;
|
|
long lCount=ss.Length();
|
|
int count1(0),count2(0);
|
|
for(long i=0L; i<lCount; i++)
|
|
{
|
|
Entity ent=ss[i];
|
|
XPoly2D poly(ent);
|
|
poly.SetFlag(1);
|
|
poly.Compress();
|
|
if (poly.Length()<2)
|
|
continue;
|
|
XPoint ptCen;
|
|
poly.Center(ptCen);
|
|
|
|
//modify by xlc on 090226
|
|
//double dHeight=::_tstof(m_csHeight);
|
|
double dHeight=0;
|
|
if (m_csHeight==_T("当前层高"))
|
|
dHeight = DocGetLHeight();
|
|
else
|
|
dHeight = _tstof(m_csHeight);
|
|
|
|
TColumnData::TColumnMaterial mater = TColumnData::kConcrete;
|
|
if (m_iMaterial == 2 || m_iMaterial == 3 )
|
|
{
|
|
mater = TColumnData::kBrick;
|
|
}
|
|
if (m_iMaterial == 4 || m_iMaterial == 5 )
|
|
{
|
|
mater = TColumnData::kRocket;
|
|
}
|
|
else if (m_iMaterial == 6)
|
|
{
|
|
mater = TColumnData::kSteel;
|
|
}
|
|
|
|
iRet=InsertColumn(poly, mater,ptCen, dHeight, TColumnData::kPoly, g_NewMaterArray[m_iMaterial]);
|
|
if (iRet==RTNORM)
|
|
{
|
|
//modify by xlc on 090301
|
|
//acutPrintf(_T("\n所选PLine线已经转化为柱子"));
|
|
count1++;
|
|
ent.Delete();
|
|
|
|
}
|
|
else if (iRet==RTERROR)
|
|
{
|
|
//modify by xlc on 090301
|
|
// acutPrintf(_T("\n插入柱子失败"));
|
|
count2++;
|
|
}
|
|
}
|
|
|
|
CString strPrompt;
|
|
strPrompt.Format(_T("\n所选PLine线转化为柱子:\n成功 %d 个\n失败 %d 个"),count1,count2);
|
|
MessageBox(strPrompt);
|
|
|
|
//add by xlc on 081013
|
|
m_nInsertMode=ID_POINT_COLUMN;
|
|
m_toolbar.CheckButton(m_nInsertMode);
|
|
ShowChildWindow();
|
|
OnChangeInsertMode(ID_POINT_COLUMN);
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
GetDlgItem(IDC_COLU_TYPE)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_GJK)->EnableWindow(TRUE);
|
|
return (GetInsertMode()!=ID_OTHERCOLUMN);
|
|
}
|
|
BOOL CColumnDlg::CheckPline()
|
|
{//这个地方的函数是选择图形
|
|
GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_XSIZE)->ShowWindow(SW_HIDE);
|
|
UpdateData(TRUE);
|
|
while(1)
|
|
{
|
|
Entity ent;
|
|
RBList rmask(RTDXF0, _T("POLYLINE,LWPOLYLINE,TCH_COLUMN"), NULL);
|
|
long iRet=SelectEntity(_T("\n请选择封闭的多段线或柱子 <退出>:"),ent,rmask);
|
|
if (iRet==RTNORM)
|
|
{
|
|
XPoint ptloc;
|
|
|
|
BOOL bColumn=FALSE;
|
|
int iColuType=7;
|
|
XPoly2D poly(ent);
|
|
XPoint ptParam; //柱子尺寸参数 //add by xlc on 090722
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbColumn, pColu);
|
|
if (pColu)
|
|
{
|
|
pColu->assertReadEnabled();
|
|
ptloc=pColu->GetLocation();
|
|
poly.Reset();
|
|
|
|
CString sPattern;
|
|
pColu->GetSpecialtyDataReadOnly()->GetAt(sKEY_COLUMN_HATCH_PATTERN, sPattern);
|
|
|
|
if (pColu->GetMaterial()==TColumnData::kConcrete)
|
|
{
|
|
if (sPattern == COLMATE_Concrete1)
|
|
m_iMaterial=1;
|
|
else
|
|
m_iMaterial=0;
|
|
}
|
|
else if (pColu->GetMaterial()==TColumnData::kBrick)
|
|
{
|
|
if (sPattern == COLMATE_Brick1)
|
|
m_iMaterial=3;
|
|
else
|
|
m_iMaterial=2;
|
|
}
|
|
else if (pColu->GetMaterial()==TColumnData::kRocket)
|
|
{
|
|
if (sPattern == COLMATE_Rocket1)
|
|
m_iMaterial=5;
|
|
else
|
|
m_iMaterial=4;
|
|
}
|
|
else
|
|
{
|
|
if (sPattern == COLMATE_Steel)
|
|
m_iMaterial=6;
|
|
else
|
|
m_iMaterial=3;
|
|
}
|
|
|
|
CComboBox* pBox = (CComboBox*)GetDlgItem(IDC_MATERIAL);
|
|
pBox->SetCurSel(m_iMaterial);
|
|
TColumnData::TSectionShape shape=pColu->GetSectionShape();
|
|
if (shape == TColumnData::kRect)
|
|
{
|
|
iColuType=0;
|
|
}
|
|
else if (shape == TColumnData::kCircle)
|
|
{
|
|
iColuType=1;
|
|
}
|
|
else if (shape==TColumnData::kPoly)
|
|
{
|
|
iColuType=7;
|
|
}
|
|
else
|
|
{
|
|
switch(shape)
|
|
{
|
|
case TColumnData::kStd3:
|
|
iColuType=2;
|
|
break;
|
|
case TColumnData::kStd5:
|
|
iColuType=3;
|
|
break;
|
|
case TColumnData::kStd6:
|
|
iColuType=4;
|
|
break;
|
|
case TColumnData::kStd8:
|
|
iColuType=5;
|
|
break;
|
|
case TColumnData::kStd12:
|
|
iColuType=6;
|
|
break;
|
|
}
|
|
}
|
|
pColu->GetOutline(poly);
|
|
// ptloc=Wcs2Ucs(ptloc);
|
|
bColumn=TRUE;
|
|
ptParam=pColu->GetParameters();
|
|
}
|
|
OPENOBJ_END();
|
|
if (!bColumn)
|
|
{
|
|
XPoint ospt=Ucs2Wcs(XPoint(0,0,0));
|
|
iRet=acedGetPoint(NULL,_T("\n请选择基点 <退出>:"),ptloc);
|
|
if (iRet!=RTNORM)
|
|
return false;
|
|
ptloc=Ucs2Wcs(ptloc);
|
|
}
|
|
|
|
UpdateData(TRUE);
|
|
m_iColuType=iColuType;
|
|
|
|
m_csXSize=(const TCHAR *)Dist2Str(ptParam.x);
|
|
m_csYSize=(const TCHAR *)Dist2Str(ptParam.y);
|
|
|
|
poly.SetFlag(1);
|
|
poly.Compress();
|
|
|
|
TDbColumn *pColumn=new TDbColumn();
|
|
pColumn->SetLayerHatch2d(InitLayer(LAY_HATCH, FALSE));
|
|
pColumn->SetLocation(ptloc);
|
|
|
|
TColumnData::TColumnMaterial mater = TColumnData::kConcrete;
|
|
if (m_iMaterial == 2 || m_iMaterial == 3 )
|
|
{
|
|
mater = TColumnData::kBrick;
|
|
}
|
|
if (m_iMaterial == 4 || m_iMaterial == 5 )
|
|
{
|
|
mater = TColumnData::kRocket;
|
|
}
|
|
else if (m_iMaterial == 6)
|
|
{
|
|
mater = TColumnData::kSteel;
|
|
}
|
|
pColumn->SetMaterial(mater);
|
|
pColumn->GetSpecialtyData()->SetAt(sKEY_COLUMN_HATCH_PATTERN, g_NewMaterArray[m_iMaterial]);
|
|
|
|
//pColumn->m_material=g_materArray[m_iMaterial];
|
|
pColumn->SetOutlinePoly(poly);
|
|
pColumn->SetSectionShape(g_coluShapeArray[m_iColuType]);
|
|
AcGeMatrix3d mat;
|
|
XVector3D xv(XPoint(-ptloc.x,-ptloc.y,0));
|
|
mat.setTranslation(xv);
|
|
pColumn->transformBy(mat);
|
|
pColumn->GetOutline(m_polyOutline);
|
|
CColumnDlg::pEntM=(TDbColumn *)pColumn->clone();//保存结果 //- 20080721
|
|
CColumnDlg::pEntY=(TDbColumn *)pColumn->clone();// [7/21/2008 nsh]
|
|
UpdateData(FALSE);
|
|
UpdateImage();
|
|
|
|
//add by xlc on 081013
|
|
m_nInsertMode=ID_POINT_COLUMN;
|
|
m_toolbar.CheckButton(m_nInsertMode);
|
|
OnChangeInsertMode(ID_POINT_COLUMN);
|
|
ShowChildWindow();
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
return (GetInsertMode()!=ID_CHECKPLINE);
|
|
}
|
|
//--------------------------------------------------------------
|
|
//更新柱子
|
|
BOOL CColumnDlg::ReplaceColumn()
|
|
{
|
|
XPushVar<int> vOsMode(_T("OSMODE"), 0);
|
|
RBList mask(RTDXF0, _T("TCH_COLUMN"), NULL);
|
|
RBList rbMask=AxisMask();
|
|
|
|
PickSet ss(SS_FREE);
|
|
g_ssPickFirst.Free();
|
|
while(1)
|
|
{
|
|
int i=SelectEntities(_T("\n选择被替换的柱子:"), ss, mask);
|
|
if (i==RTNORM)
|
|
{
|
|
UpdateData(TRUE);//add by whl on 060214
|
|
long lCount=ss.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent=ss[i];
|
|
XPoint ptMin, ptMax;
|
|
ent.GetExtend(ptMin, ptMax);
|
|
double nLimX=ptMax.x-ptMin.x;
|
|
double nLimY=ptMax.y-ptMin.y;
|
|
XPoint ptPick;
|
|
Midpoint(ptMin, ptMax, ptPick);
|
|
XOsnap(ptPick, OS_INT, rbMask, max(nLimX, nLimY)/2.0);
|
|
ads_real nAxisXDrt=GetAxisXDirection(ptPick);
|
|
|
|
//add by xlc on 090120 用户坐标系下的轴向
|
|
if (fabs(nAxisXDrt)<_DIST_SNAP)
|
|
nAxisXDrt=Ucs2Wcs(nAxisXDrt);
|
|
|
|
ads_matrix mat;
|
|
ptPick.GetRotationMatrix(nAxisXDrt, mat);
|
|
XPoint ptLoc=ptPick+XPoint(_tstof(m_csXOffset), _tstof(m_csYOffset));
|
|
ptLoc.TransformBy(mat);
|
|
ptLoc.GetRotationMatrix(nAxisXDrt, mat);
|
|
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbColumn, pColu);
|
|
if (pColu) {
|
|
pColu->assertWriteEnabled();
|
|
pColu->SetLocation(ptLoc);
|
|
UpdateObject(pColu);
|
|
CColumnDlg::pEntM =(TDbColumn *)pColu->clone();// [12/12/2007 nsh]
|
|
pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
ss.Free();
|
|
TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
else
|
|
{
|
|
m_bInitFirst =FALSE;// [12/14/2007 nsh]
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
return (GetInsertMode()!=ID_REPLACE_COLUMN);
|
|
}
|
|
void CColumnDlg::OnClose()
|
|
{
|
|
m_bInitFirst =TRUE;// [12/14/2007 nsh]
|
|
if (m_bModeless)
|
|
acedPostCommand(_T("\33\33"));
|
|
else
|
|
CModelessDialog::OnClose();
|
|
}
|
|
|
|
int CColumnDlg::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
if (CModelessDialog::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
if (m_bModeless)
|
|
CreateToolbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
void ShapeColu()
|
|
{
|
|
CColumnDlg dlg;
|
|
{
|
|
CAcModuleResourceOverride vTemp;
|
|
dlg.Create(dlg.IDD, acedGetAcadFrame());
|
|
}
|
|
acedGetAcadDwgView()->SetFocus();
|
|
CColumnDlg::m_bInitFirst =TRUE;// [12/14/2007 nsh]
|
|
BOOL bContinue=TRUE;
|
|
while (bContinue) {
|
|
UINT nInsMode=dlg.GetInsertMode();
|
|
//---------------------------------------------Begin----------------------------------------// [11/15/2007 nsh]
|
|
if (CColumnDlg::m_bInitFirst)
|
|
{
|
|
CString sColuType;
|
|
dlg.GetDlgItemText(IDC_COLU_TYPE,sColuType);
|
|
if (CColumnDlg::pEntM!=NULL)
|
|
{
|
|
if (CColumnDlg::pEntM->isKindOf(TDbColumn::desc()))
|
|
{
|
|
TColumnData::TSectionShape shape=CColumnDlg::pEntM->GetSectionShape();
|
|
int m =ELEMENTS(g_coluShapeArray);
|
|
for(int i=0; i<ELEMENTS(g_coluShapeArray); i++) // -1 [7/21/2008 nsh]
|
|
{
|
|
if (g_coluShapeArray[i]==shape)
|
|
{
|
|
CColumnDlg::m_iColuType=i;
|
|
break;
|
|
}
|
|
}
|
|
if (shape==TColumnData::kRect) {
|
|
dlg.m_csXSizeText=_T("横向");
|
|
dlg.m_csYSizeText=_T("纵向");
|
|
dlg.GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
dlg.GetDlgItem(IDC_YSIZE)->ShowWindow(SW_SHOW);
|
|
dlg.GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
dlg.GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
} else if (shape==TColumnData::kCircle) {
|
|
dlg.m_csXSizeText=_T("直径");
|
|
dlg.GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
dlg.GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
dlg.GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
dlg.GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
else if (shape==TColumnData::kPoly){
|
|
dlg.GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
dlg.GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
dlg.GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
dlg.GetDlgItem(IDC_XSIZE)->ShowWindow(SW_HIDE);
|
|
|
|
if (CColumnDlg::pEntY!=NULL)
|
|
{
|
|
CColumnDlg::pEntM =(TDbColumn *)CColumnDlg::pEntY->clone();// [7/21/2008 nsh]
|
|
}
|
|
}
|
|
else {
|
|
dlg.m_csXSizeText=_T("边长");
|
|
dlg.m_csYSizeText=_T("直径");
|
|
dlg.GetDlgItem(IDC_XSIZE_TEXT)->ShowWindow(SW_SHOW);
|
|
dlg.GetDlgItem(IDC_XSIZE)->ShowWindow(SW_SHOW);
|
|
dlg.GetDlgItem(IDC_YSIZE_TEXT)->ShowWindow(SW_HIDE);
|
|
dlg.GetDlgItem(IDC_YSIZE)->ShowWindow(SW_HIDE);
|
|
}
|
|
static CString sXOffset,sYOffset,sRotation,sHeight,sXSize,sYSize;
|
|
static int iMatarial,iShape;
|
|
sXOffset =CColumnDlg::m_csXOffset;
|
|
sYOffset =CColumnDlg::m_csYOffset;
|
|
sRotation =CColumnDlg::m_csRotation;
|
|
iMatarial =CColumnDlg::m_iMaterial;
|
|
sHeight =CColumnDlg::m_csHeight;
|
|
sXSize =CColumnDlg::m_csXSize;
|
|
sYSize =CColumnDlg::m_csYSize;
|
|
iShape=CColumnDlg::m_iColuType;
|
|
dlg.Obj2Dlg(CColumnDlg::pEntM);
|
|
CColumnDlg::m_csXOffset=sXOffset;
|
|
CColumnDlg::m_csYOffset=sYOffset;
|
|
dlg.m_csRotation =sRotation;
|
|
dlg.m_iMaterial =iMatarial;
|
|
dlg.m_csHeight =sHeight;
|
|
dlg.m_csXSize =sXSize;
|
|
dlg.m_csYSize =sYSize;
|
|
dlg.m_iColuType =iShape;
|
|
dlg.UpdateData(FALSE);
|
|
dlg.UpdateImage();
|
|
}
|
|
}
|
|
CColumnDlg::m_bInitFirst =FALSE;
|
|
}
|
|
//---------------------------------------------End------------------------------------------
|
|
if (nInsMode == ID_POINT_COLUMN) bContinue=dlg.PointColumn();
|
|
else if (nInsMode == ID_LINE_COLUMN) bContinue=dlg.LineColumn();
|
|
else if (nInsMode == ID_REGION_COLUMN) bContinue=dlg.RegionColumn();
|
|
else if (nInsMode == ID_REPLACE_COLUMN) bContinue=dlg.ReplaceColumn();
|
|
else if (nInsMode==ID_OTHERCOLUMN) bContinue=dlg.OtherColumn();// [4/2/2008 nsh]
|
|
else if (nInsMode==ID_CHECKPLINE) bContinue=dlg.CheckPline();// [4/2/2008 nsh]
|
|
else bContinue=FALSE;
|
|
}
|
|
dlg.DestroyWindow();
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// 插入一柱子到模型空间,并把穿过的墙断为两段
|
|
// Update New: 加入判据, 避免当墙的端点位于柱子内部时, 进行打断产生无效短墙
|
|
BOOL InsertColumn(TDbColumn *pColu)
|
|
{
|
|
if (!pColu->IsValid())
|
|
{
|
|
return FALSE;
|
|
}
|
|
CColumnDlg::pEntM =(TDbColumn *)pColu->clone();// [7/21/2008 nsh]
|
|
|
|
XPoint ptLow, ptUp;
|
|
pColu->GetExtents2d(ptLow, ptUp);
|
|
PickSet ssColu(SS_FREE);
|
|
|
|
//modify by lgy 20120110 柱子插入时如果存在其他柱子，插入柱子并没有跟其他柱子相交仍不能插入
|
|
// if (GetSafeSelection(ssColu, 1, ptLow, ptUp, _T("TCH_COLUMN"))==Acad::eOk && !!ssColu && ssColu.Length()>0) {
|
|
// adsout << _T("\n同一位置已经有其他柱子!");
|
|
// return FALSE; //同一位置已经有其他柱子
|
|
// }
|
|
XPoly2D polyColumn, polyTemp;
|
|
pColu->GetOutline(polyColumn);
|
|
if (GetSafeSelection(ssColu, 1, ptLow, ptUp, _T("TCH_COLUMN"))==Acad::eOk)
|
|
{
|
|
Entity ent;
|
|
//循环打开实体集判断外包装框是否相交如果相交则返回
|
|
for (long i = 0L; i < ssColu.Length(); i++)
|
|
{
|
|
ent = ssColu[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbColumn, pColumn);
|
|
if (!pColumn)
|
|
{
|
|
continue;
|
|
}
|
|
pColumn->GetOutline(polyTemp);
|
|
DList<XPoly2D> lstPoly2D;
|
|
TchSubExport::Union(polyTemp, polyColumn, lstPoly2D); // 求交集
|
|
if (lstPoly2D.Length() == 0)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
adsout << _T("\n同一位置已经有其他柱子!");
|
|
return FALSE; //同一位置已经有其他柱子
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
|
|
XPoly2D poly2d;
|
|
pColu->GetOutline(poly2d);
|
|
pColu->SetLayerHatch2d(InitLayer(LAY_HATCH, FALSE));
|
|
|
|
// add by xly on 110407 设置柱子的保温层
|
|
pColu->SetInsulateLayerId(InitLayer(LAY_SURFACE)); // 设置保温图层
|
|
|
|
pColu->AddToMSpace(Adesk::kTrue);
|
|
PickSet ssWall(SS_FREE);
|
|
if (GetSafeSelection(ssWall, 1, ptLow, ptUp, _T("TCH_WALL,TCH_CURTAIN_WALL"))==RTNORM) {
|
|
long nssLen=ssWall.Length();
|
|
for(long i=0; i<nssLen; i++) {
|
|
Entity ent=ssWall[i];
|
|
XDbObject obj(ent, AcDb::kForWrite);
|
|
if (!obj) continue;
|
|
TDbWall *pWall=TDbWall::cast(obj.m_pObject);
|
|
if (pWall && pWall->BreakAt(pColu->GetLocation(), AcDbObjectId(), &poly2d)==Adesk::kTrue) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
// [1/8/2008 nsh]
|
|
//--------------------------------------------begin---------------------------------------------
|
|
ads_real _cdecl GetAxisXDirection(const XPoint &ptLoc, Array<ads_real> * axDir=NULL, Array<XPoint> * pointarr=NULL)
|
|
{
|
|
XPoint ptLoc0=Wcs2Ucs(ptLoc);
|
|
RBList rbMask=AxisMask();
|
|
PickSet ssAxis(SS_FREE);
|
|
XPoint ptLow=ptLoc0-XPoint(100,100),
|
|
ptUp=ptLoc0+XPoint(100,100);
|
|
ads_real nRes=0.0;
|
|
if (axDir!=NULL && pointarr !=NULL)
|
|
{
|
|
long pos = pointarr->Find(ptLoc); // [1/14/2008 nsh]
|
|
if (pos != -1)//轴网交点位置
|
|
{
|
|
nRes = (*axDir)[pos];
|
|
return nRes;
|
|
}
|
|
}
|
|
int rt=ssAxis.Get(_T("C"), ptLow, ptUp, rbMask);
|
|
if (rt==RTNORM) {
|
|
long len=ssAxis.Length();
|
|
if (len==1)
|
|
{
|
|
Entity eAxis=ssAxis[0L];
|
|
XCurveSegment cv(eAxis, LS_FINITE);
|
|
ads_real nDrt=cv.Direction(ptLoc);
|
|
if (cv.Is(CURVE_LINE))
|
|
{
|
|
ads_real nDrtRev=CT_std_angle(nDrt+PI);
|
|
XSector sec(nDrt, nDrtRev);
|
|
nRes = *sec.NearAngle(0.0);
|
|
}
|
|
else
|
|
{
|
|
nRes=nDrt;
|
|
}
|
|
}
|
|
// 问题描述:搜索到多个轴线时,返回的nRes为WCS下的X轴方向,在UCS下会出现角度错误的问题
|
|
// 解决方法:令nRes等于UCS下的X轴方向
|
|
// 修改人,修改时间:Add by Zyu on 100414
|
|
// Begin
|
|
else
|
|
{
|
|
nRes = Ucs2Wcs((0));
|
|
}
|
|
// End
|
|
}
|
|
else if (rt!=RTNORM && rt!=RTCAN)
|
|
{
|
|
nRes=Ucs2Wcs((0));
|
|
}
|
|
return nRes;
|
|
}
|
|
ads_real GetXDirection1(const XCurveSegment &cv1, const XCurveSegment &cv2, const XPoint &ptLoc)
|
|
{
|
|
ads_real nRes=0.0;
|
|
XPoint pTemp=ptLoc;
|
|
//pTemp=Wcs2Ucs(pTemp);
|
|
if (!cv1.Is(CURVE_LINE))
|
|
{
|
|
nRes=cv1.Direction(pTemp);
|
|
}
|
|
else if (!cv2.Is(CURVE_LINE))
|
|
{
|
|
nRes=cv2.Direction(pTemp);
|
|
}
|
|
else
|
|
{
|
|
// 问题描述:当前坐标系是UCS的情况下，柱子在轴线交点处插入时始终
|
|
// 是以接近WCS-X方向的轴线为横向基准方向插入的
|
|
// 解决方法:在当前坐标系是UCS的情况下，按照用户自定义的UCS坐标系统下
|
|
// 最接近X轴方向的轴线方向为横向基准方向插入柱子
|
|
// 修改人,修改时间: Zyu modify on 100409
|
|
// Begin
|
|
// Ucs的X轴在Wcs下的方向
|
|
AcGeVector3d vtXAxisUCS = Ucs2Wcs(AcGeVector3d::kXAxis, true);
|
|
// Ucs的X轴在Wcs下的方向的角度
|
|
double dRot = acutAngle(asDblArray(AcGePoint3d::kOrigin), asDblArray(vtXAxisUCS));
|
|
|
|
XPoint startPoint,endPoint;
|
|
startPoint=cv1.StartPoint();
|
|
endPoint =cv1.EndPoint();
|
|
// Add by Zyu on 100409
|
|
// Begin
|
|
startPoint = Wcs2Ucs(startPoint);
|
|
endPoint = Wcs2Ucs(endPoint);
|
|
// End
|
|
ads_real angle=ads_angle(startPoint,endPoint);
|
|
ads_real nDrt1=cv1.Direction(pTemp);
|
|
ads_real nDrtRev1=CT_std_angle(nDrt1+PI);
|
|
XSector sec1(nDrt1, nDrtRev1);
|
|
//ads_real nRes1 = *sec1.NearAngle(0.0);
|
|
ads_real nRes1 = *sec1.NearAngle(dRot);
|
|
ads_real nDrt2=cv2.Direction(pTemp);
|
|
ads_real nDrtRev2=CT_std_angle(nDrt2+PI);
|
|
XSector sec2(nDrt2, nDrtRev2);
|
|
//ads_real nRes2 = *sec2.NearAngle(0.0);
|
|
ads_real nRes2 = *sec2.NearAngle(dRot);
|
|
if (fabs(angle-PI/4)<=1e-6 || fabs(angle-7*PI/4) <=1e-6)
|
|
{
|
|
nRes =nRes1;
|
|
}
|
|
else if (fabs(angle-5*PI/4)<=1e-6 || fabs(angle-3*PI/4)<=1e-6)
|
|
{
|
|
nRes=nRes2;
|
|
}
|
|
else
|
|
{
|
|
XSector sec(nRes1, nRes2);
|
|
//nRes= *sec.NearAngle(0.0);
|
|
nRes = *sec.NearAngle(dRot);
|
|
}
|
|
// End
|
|
}
|
|
return nRes;
|
|
}
|
|
//---------------------------------------------end-----------------------------------------------
|
|
|
|
// 取得点ptLoc位置的X的轴线方向
|
|
// ptLoc--WCS
|
|
ads_real GetAxisXDirection(const XPoint &ptLoc)
|
|
{
|
|
XPoint ptLoc0=Wcs2Ucs(ptLoc);
|
|
RBList rbMask=AxisMask();
|
|
PickSet ssAxis(SS_FREE);
|
|
XPoint ptLow=ptLoc0-XPoint(100,100),
|
|
ptUp=ptLoc0+XPoint(100,100);
|
|
AssureOnScreen(Ucs2Wcs(ptLow),Ucs2Wcs(ptUp));// [1/10/2008 nsh]
|
|
ads_real nRes=0.0;
|
|
int rt=ssAxis.Get(_T("C"), ptLow,ptUp, rbMask);
|
|
if (rt==RTNORM) {
|
|
long len=ssAxis.Length();
|
|
if (len==1) {
|
|
Entity eAxis=ssAxis[0L];
|
|
XCurveSegment cv(eAxis, LS_FINITE);
|
|
ads_real nDrt=cv.Direction(ptLoc);
|
|
if (cv.Is(CURVE_LINE)) {
|
|
ads_real nDrtRev=CT_std_angle(nDrt+PI);
|
|
XSector sec(nDrt, nDrtRev);
|
|
nRes = *sec.NearAngle(0.0);
|
|
}
|
|
} else if (len>1){
|
|
Entity eAxis1=ssAxis[0L];
|
|
Entity eAxis2=ssAxis[1L];
|
|
XCurveSegment cv1(eAxis1, LS_FINITE), cv2(eAxis2, LS_FINITE);
|
|
nRes=GetXDirection1(cv1,cv2,ptLoc);// [1/11/2008 nsh]
|
|
}
|
|
}
|
|
return nRes;
|
|
}
|
|
|
|
// add by xlc on 07/04/24
|
|
// 获得轴线的交点
|
|
//modified by nsh --------------------------------------------------------------------
|
|
void GetAxisInt(PickSet &ssAxis, AcGePoint3dArray &points,Array<ads_real> &aixDir)
|
|
{
|
|
long lCount=ssAxis.Length();//轴线数
|
|
if (lCount<2)
|
|
return ;
|
|
|
|
AcDb::Intersect intType=AcDb::kOnBothOperands;//不延长
|
|
for(long i=0L; i<lCount-1; i++) {
|
|
int SubPoint=points.length();// [1/11/2008 nsh]
|
|
Entity ent1=ssAxis[i];
|
|
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbCurve, pEnt1);
|
|
if (!pEnt1)
|
|
continue;
|
|
for(long j=i+1; j<lCount; j++) {
|
|
Entity ent2=ssAxis[j];
|
|
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbCurve, pEnt2);
|
|
if (!pEnt2)
|
|
continue;
|
|
|
|
//modify by xlc on 090605 轴网对柱子的影响(转角不一致)
|
|
// pEnt1->intersectWith(pEnt2, intType, points);
|
|
// // [1/11/2008 nsh]
|
|
// //----------------------------begin-----------------------------
|
|
// int pl=points.length();
|
|
// if (points.length()>SubPoint)
|
|
// {
|
|
// XCurveSegment cv1(ent1,LS_FINITE);
|
|
// XCurveSegment cv2(ent2,LS_FINITE);
|
|
// XPoint TempPoint=points[points.length()-1];
|
|
// ads_real DirAction=GetXDirection1(cv1,cv2,TempPoint);
|
|
// aixDir.AddTail(DirAction);
|
|
// SubPoint=points.length();
|
|
// }
|
|
// //-----------------------------end------------------------------
|
|
AcGePoint3dArray ptArray;
|
|
pEnt1->intersectWith(pEnt2, intType, ptArray);
|
|
|
|
for(int k=0;k<ptArray.length();k++)
|
|
{
|
|
XCurveSegment cv1(ent1,LS_FINITE);
|
|
XCurveSegment cv2(ent2,LS_FINITE);
|
|
XPoint TempPoint=ptArray[k];
|
|
ads_real DirAction=GetXDirection1(cv1,cv2,TempPoint);
|
|
points.append(TempPoint);
|
|
aixDir.AddTail(DirAction);
|
|
}
|
|
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// 插入一柱子到模型空间,并把穿过的墙断为两段
|
|
// Update New: 加入判据, 避免当墙的端点位于柱子内部时, 进行打断产生无效短墙
|
|
int InsertColumn(const XPoly2D &idStyle, TColumnData::TColumnMaterial mater, const XPoint &ptLoc,
|
|
double nHeight, TColumnData::TSectionShape nUsage, CString sT20Mat)
|
|
{
|
|
XPoint ptLow, ptUp;
|
|
idStyle.GetExtend(ptLow, ptUp);
|
|
PickSet ssColu(SS_FREE);
|
|
|
|
//modify by lgy 20120110 柱子插入时如果存在其他柱子，插入柱子并没有跟其他柱子相交仍不能插入
|
|
//if (GetSafeSelection(ssColu, 1, ptLow, ptUp, _T("TCH_COLUMN"))==Acad::eOk && !!ssColu && ssColu.Length()>0) {
|
|
// adsout << _T("\n同一位置已经有其他柱子!");
|
|
// return RTERROR; //同一位置已经有其他柱子
|
|
//}
|
|
XPoly2D polyTemp;
|
|
if (GetSafeSelection(ssColu, 1, ptLow, ptUp, _T("TCH_COLUMN"))==Acad::eOk)
|
|
{
|
|
Entity ent;
|
|
//循环打开实体集判断外包装框是否相交如果相交则返回
|
|
for (long i = 0L; i < ssColu.Length(); i++)
|
|
{
|
|
ent = ssColu[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbColumn, pColumn);
|
|
if (!pColumn)
|
|
{
|
|
continue;
|
|
}
|
|
pColumn->GetOutline(polyTemp);
|
|
DList<XPoly2D> lstPoly2D;
|
|
TchSubExport::Union(polyTemp, idStyle, lstPoly2D); // 求交集
|
|
if (lstPoly2D.Length() == 0)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
adsout << _T("\n同一位置已经有其他柱子!");
|
|
return FALSE; //同一位置已经有其他柱子
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
|
|
XPoly2D polyColu(idStyle);
|
|
|
|
TDbColumn *pColumn=new TDbColumn();
|
|
pColumn->SetLayerHatch2d(InitLayer(LAY_HATCH, FALSE));
|
|
|
|
// add by xly on 110407 设置柱子的保温层
|
|
pColumn->SetInsulateLayerId(InitLayer(LAY_SURFACE)); // 设置保温图层
|
|
|
|
pColumn->m_ptLocation = ptLoc;
|
|
pColumn->m_nHeight = nHeight;
|
|
pColumn->m_material=mater;
|
|
//T20材料扩展数据
|
|
pColumn->GetSpecialtyData()->SetAt(sKEY_COLUMN_HATCH_PATTERN, sT20Mat);
|
|
//添加默认填充设置
|
|
pColumn->GetSpecialtyData()->SetAt(iKEY_COLUMN_FILLING_COLOR, 256);
|
|
pColumn->GetSpecialtyData()->SetAt(dKEY_COLUMN_FILLING_DENSITY, pColumn->GetPScale());
|
|
|
|
pColumn->SetOutlinePoly(polyColu);
|
|
pColumn->SetSectionShape(nUsage);
|
|
pColumn->AddToMSpace(Adesk::kTrue);
|
|
|
|
PickSet ssWall(SS_FREE);
|
|
if (GetSafeSelection(ssWall, 1, ptLow, ptUp, _T("TCH_WALL,TCH_CURTAIN_WALL"))==RTNORM) {
|
|
long nssLen=ssWall.Length();
|
|
for(long i=0; i<nssLen; i++) {
|
|
Entity ent=ssWall[i];
|
|
XDbObject obj(ent, AcDb::kForWrite);
|
|
if (!obj) continue;
|
|
TDbWall *pWall=TDbWall::cast(obj.m_pObject);
|
|
if (pWall && pWall->BreakAt(ptLoc, AcDbObjectId(), &polyColu)==Adesk::kTrue) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return RTNORM;
|
|
}
|
|
|
|
void PolyColuArg(TColumnData::TSectionShape nUsage)
|
|
{
|
|
RBList mask(RTDXF0, _T("POLYLINE,LWPOLYLINE"), NULL);
|
|
PickSet ss(SS_FREE);
|
|
if (SelectEntities(_T("\n请选择封闭的多段线<退出>:"), ss, mask)==RTNORM) {
|
|
int nRet;
|
|
int nMater=2;
|
|
LAB_REINPUT:
|
|
adsout << _T("\n柱子材料:[钢筋砼(0)/混凝土(1)/砖(2)/耐火砖(3)/石材(4)/毛石(5)/金属(6)]<2>: ");
|
|
INITGET_BEG(RSG_NONEG, _T("0 1 2 3 4 5 6"));
|
|
nRet = ads_getint(_T(""), &nMater);
|
|
INITGET_END();
|
|
|
|
if (nRet==RTNORM || nRet==RTNONE) {
|
|
if (nMater>6) {
|
|
adsout << _T("\n请正确输入!");
|
|
goto LAB_REINPUT;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
//新旧材料转换
|
|
switch(nMater)
|
|
{
|
|
case 0:
|
|
{
|
|
nMater = 2;
|
|
sNewCloumMater = g_NewMaterArray[0];
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
nMater = 2;
|
|
sNewCloumMater = g_NewMaterArray[1];
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
nMater = 0;
|
|
sNewCloumMater = g_NewMaterArray[2];
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
nMater = 0;
|
|
sNewCloumMater = g_NewMaterArray[3];
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
nMater = 1;
|
|
sNewCloumMater = g_NewMaterArray[4];
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
nMater = 1;
|
|
sNewCloumMater = g_NewMaterArray[5];
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
nMater = 3;
|
|
sNewCloumMater = g_NewMaterArray[6];
|
|
}
|
|
break;
|
|
}
|
|
|
|
long lCount=ss.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent=ss[i];
|
|
XPoly2D poly(ent);
|
|
poly.SetFlag(1);
|
|
poly.Compress();
|
|
if (poly.Length()<2)
|
|
continue;
|
|
|
|
XPoint ptCen;
|
|
poly.Center(ptCen);
|
|
if (InsertColumn(poly, g_materArray[nMater],ptCen, CFG_LHeight, nUsage, sNewCloumMater)==RTNORM)
|
|
ent.Delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////
|
|
// Command: POLY转柱子
|
|
void PolyColu()
|
|
{
|
|
PolyColuArg(TColumnData::kPoly);
|
|
}
|
|
|
|
|
|
|
|
|
|
// Command:编辑柱
|
|
int EditColumn(AcDbObjectId idColu)
|
|
{
|
|
XPushVar<int> cmdecho(_T("CMDECHO"), 0);
|
|
CColumnDlg dlg(acedGetAcadFrame());
|
|
OPENOBJ_BEGIN(idColu, AcDb::kForRead, TDbColumn, pColu);
|
|
ASSERT(pColu);
|
|
if (!dlg.Obj2Dlg(pColu)) {
|
|
adsout << _T("\n非标准柱子类型不能使用对象编辑！");
|
|
return RTNORM;
|
|
}
|
|
|
|
// 问题描述:在双击编辑异形柱时,首先弹出构件库
|
|
// 解决方法:添加标记是否是编辑状态的成员变量
|
|
// Add by Zyu on 100412
|
|
dlg.m_bIsEdit = true;
|
|
|
|
CAcModuleResourceOverride vTemp;
|
|
if (dlg.DoModal()==IDOK) {
|
|
if (pColu->upgradeOpen()==Acad::eOk) {
|
|
pColu->assertWriteEnabled();
|
|
dlg.UpdateObject(pColu);
|
|
|
|
//modified by whl
|
|
ads_matrix mat;
|
|
if (dlg.bAxisExist)
|
|
{
|
|
XPoint newOffset(_tstof(dlg.m_csXOffset),_tstof(dlg.m_csYOffset));
|
|
XPoint vt=newOffset-dlg.oldOffset;//新偏移减去旧偏移
|
|
XPoint().GetRotationMatrix(dlg.m_xDir,mat);//校正到轴网坐标
|
|
vt.TransformBy(mat);
|
|
XPoint().GetMoveMatrix(vt, mat);
|
|
pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
}
|
|
//新相对转角减去旧相对转角
|
|
double nRot=_tstof(dlg.m_csRotation)*PI/180-pColu->GetRotation()+dlg.m_xDir;
|
|
if (pColu->GetSectionShape()==TColumnData::kPoly)
|
|
nRot=dlg.m_xDir;
|
|
pColu->GetLocation().GetRotationMatrix(nRot, mat);
|
|
pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
|
|
pColu->downgradeOpen();
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
return RTNORM;
|
|
}
|
|
|
|
|
|
//void AlignColumn()
|
|
//{
|
|
// while(true)
|
|
// {
|
|
// XPoint SidePt;
|
|
// int nOldOsnap=g_nOsnapType;
|
|
// DocSetWallOsnapType(1);
|
|
// Entity ent;
|
|
// RBList mask(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL"), NULL);
|
|
// XPoint ptPick;
|
|
// int nRetCode=RTNORM;
|
|
// if ((nRetCode=SelectEntity1(_T("\n请点取墙边<退出>: "), ent, ptPick, mask))!=RTNORM) {
|
|
// DocSetWallOsnapType(nOldOsnap);
|
|
// return;
|
|
// }
|
|
// DocSetWallOsnapType(nOldOsnap);
|
|
// ptPick=Ucs2Wcs(ptPick);
|
|
//
|
|
// XCurveSegment cvResult;
|
|
// OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
// if (!pWall)
|
|
// return;
|
|
//
|
|
// XCurveSegment lCurve, rCurve, selCurve;
|
|
// pWall->GetSideCurve(lCurve, rCurve);
|
|
// XCurveSegment seg=pWall->OffsetGeomCenter();
|
|
// int nSide=seg.OnWhichSide(ptPick);
|
|
// if (nSide==OFFSET_LEFT)
|
|
// cvResult=lCurve;
|
|
// else
|
|
// cvResult=rCurve;
|
|
// cvResult.SetElevation(0.0);
|
|
// OPENOBJ_END();
|
|
//
|
|
// cvResult.flag = LS_INFINITE;
|
|
//
|
|
// RBList mask1(RTDXF0, _T("TCH_COLUMN"), NULL);
|
|
// while(true)
|
|
// {
|
|
// PickSet ss;
|
|
// if (cvResult.Is(CURVE_LINE))//直墙时可以多选
|
|
// {
|
|
// int nRet;
|
|
// INITGET_BEG(0,_T("S Q"));
|
|
// nRet=SelectEntity1(_T("\n请点取柱边或 [同时对齐多个柱子(S)/重新选墙边(Q)]<退出>: "), ent, ptPick, mask1);
|
|
// INITGET_END();
|
|
// if (nRet==RTKWORD)
|
|
// {
|
|
// TCHAR buf[256];
|
|
// acedGetInput(buf);
|
|
// if (buf[0]==_T('S'))
|
|
// {
|
|
// if (SelectEntities(_T("\n选择对齐方式相同的多个柱子<退出>:"),ss,mask1)!=RTNORM)
|
|
// return;
|
|
// if (SelectEntity1(_T("\n请点取柱边<退出>: "), ent, ptPick, mask1)!=RTNORM)
|
|
// return;
|
|
// ss+=ent;
|
|
// }
|
|
// else
|
|
// break;
|
|
// }
|
|
// else if (nRet==RTNORM)
|
|
// ss+=ent;
|
|
// else
|
|
// return;
|
|
// }
|
|
// else
|
|
// {
|
|
// if (SelectEntity1(_T("\n请点取柱边<退出>: "), ent, ptPick, mask1)!=RTNORM)
|
|
// return;
|
|
// ss+=ent;
|
|
// }
|
|
//
|
|
// if (ss.Length()<1)
|
|
// return;
|
|
//
|
|
// ptPick=Ucs2Wcs(ptPick);
|
|
// XPoint ptDest;
|
|
// if (cvResult.ProjectToMe(ptPick, ptDest)==RTNORM) {
|
|
// ads_matrix mat;
|
|
// ptPick.GetMoveMatrix(ptDest, mat);
|
|
// for(long i=0;i<ss.Length();i++)
|
|
// {
|
|
// Entity ent=ss[i];
|
|
// OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbColumn, pColu);
|
|
// if (pColu)
|
|
// pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
// OPENOBJ_END();
|
|
// }
|
|
//
|
|
// TArchCmdReactor::UpdateCorners();
|
|
// TArchCmdReactor::ResetAll();
|
|
// }
|
|
// }
|
|
// }
|
|
//}
|
|
//modfied by whl on 060117
|
|
void AlignColumn()
|
|
{
|
|
while(true)
|
|
{
|
|
XPoint SidePt;
|
|
int nOldOsnap=g_nOsnapType;
|
|
DocSetWallOsnapType(1);
|
|
Entity ent;
|
|
RBList mask(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL"), NULL);
|
|
XPoint ptPick;
|
|
int nRetCode=RTNORM;
|
|
if ((nRetCode=SelectEntity1(_T("\n请点取墙边<退出>: "), ent, ptPick, mask))!=RTNORM) {
|
|
DocSetWallOsnapType(nOldOsnap);
|
|
return;
|
|
}
|
|
DocSetWallOsnapType(nOldOsnap);
|
|
ptPick=Ucs2Wcs(ptPick);
|
|
|
|
XCurveSegment cvResult;
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
if (!pWall)
|
|
return;
|
|
|
|
XCurveSegment lCurve, rCurve, selCurve;
|
|
pWall->GetSideCurve(lCurve, rCurve);
|
|
XCurveSegment seg=pWall->OffsetGeomCenter();
|
|
int nSide=seg.OnWhichSide(ptPick);
|
|
if (nSide==OFFSET_LEFT)
|
|
cvResult=lCurve;
|
|
else
|
|
cvResult=rCurve;
|
|
cvResult.SetElevation(0.0);
|
|
OPENOBJ_END();
|
|
|
|
cvResult.SetLineFlag(LS_INFINITE);
|
|
|
|
RBList mask1(RTDXF0, _T("TCH_COLUMN"), NULL);
|
|
while(true)
|
|
{
|
|
PickSet ss;
|
|
if (cvResult.Is(CURVE_LINE))//直墙时可以多选
|
|
{
|
|
if (SelectEntities(_T("\n选择对齐方式相同的多个柱子<退出>:"),ss,mask1)!=RTNORM)
|
|
return;
|
|
if (SelectEntity1(_T("\n请点取柱边<退出>: "), ent, ptPick, mask1)!=RTNORM)
|
|
return;
|
|
ss+=ent;
|
|
}
|
|
else
|
|
{
|
|
if (SelectEntity1(_T("\n请点取柱边<退出>: "), ent, ptPick, mask1)!=RTNORM)
|
|
return;
|
|
ss+=ent;
|
|
}
|
|
|
|
if (ss.Length()<1)
|
|
return;
|
|
|
|
ptPick=Ucs2Wcs(ptPick);
|
|
XPoint ptDest;
|
|
if (cvResult.ProjectToMe(ptPick, ptDest)==RTNORM)
|
|
{
|
|
ads_matrix mat;
|
|
ptPick.GetMoveMatrix(ptDest, mat);
|
|
for(long i=0;i<ss.Length();i++)
|
|
{
|
|
Entity ent=ss[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbColumn, pColu);
|
|
if (pColu)
|
|
pColu->transformBy(AsAcGeMatrix3d(mat));
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
|
|
if (cvResult.Is(CURVE_LINE))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//add by xlc on 070423
|
|
TDbColumnJig::TDbColumnJig(TDbColumn *m_pEnt,CColumnDlg *dlg):m_column(m_pEnt),m_dlg(dlg)
|
|
{
|
|
m_bRot = FALSE;
|
|
}
|
|
TDbColumnJig::~TDbColumnJig()
|
|
{
|
|
|
|
}
|
|
void TDbColumnJig::SetPrompt(const TCHAR *m_pTemp)
|
|
{
|
|
m_pszPrompt = m_pTemp;
|
|
acutPrintf(m_pTemp);
|
|
}
|
|
int TDbColumnJig::GetRetCode() const
|
|
{
|
|
int ret = m_nRetCode;
|
|
if (ret == AcEdJig::kCancel)
|
|
ret = RTCAN;
|
|
else if (ret == AcEdJig::kNull)
|
|
ret = RTNONE;
|
|
else if (ret == AcEdJig::kNormal)
|
|
ret = RTNORM;
|
|
else
|
|
{
|
|
ret = RTKWORD;
|
|
}
|
|
return ret;
|
|
}
|
|
int TDbColumnJig::doIt()
|
|
{
|
|
if (m_bRot) //旋转
|
|
{
|
|
m_nRetCode = drag();
|
|
}
|
|
else
|
|
{
|
|
INITGET_BEG(0,m_pszKeyword);
|
|
m_nRetCode = drag();
|
|
INITGET_END();
|
|
}
|
|
|
|
int nRet = GetRetCode();
|
|
return nRet;
|
|
}
|
|
void TDbColumnJig::SetKeyword(const TCHAR *pszKeyword)
|
|
{
|
|
m_pszKeyword = pszKeyword;
|
|
}
|
|
Adesk::Boolean TDbColumnJig::update()
|
|
{
|
|
RBList rbMask=AxisMask();
|
|
// [1/14/2008 nsh]
|
|
extern GEOAPI double g_distZero;
|
|
XPushMemVar<double> vTemp(g_distZero,100);
|
|
ads_real nLimX, nLimY;
|
|
m_dlg->GetInsertExtend(nLimX, nLimY);
|
|
|
|
// 问题描述:如果所要添加柱子的位置处，轴线存在两个相隔很近的交点，且柱子添加后
|
|
// 两个交点都位于被覆盖的范围内时，柱子的位置捕捉会出现不准确。
|
|
// 解决方法:去掉设置插入点为附近的轴交点的操作,但仍使用该交点的柱子方向
|
|
// 注意:由于此处原来是采用的上华自己的对象捕捉,所以去掉之后可能会有不可预知的影响!
|
|
// 修改人,修改时间:Zyu modify on 100414
|
|
// Begin
|
|
TADSGePoint3d ptTemp = m_ptPoint;
|
|
// XOsnap(m_ptPoint, OS_INT, rbMask, max(nLimX, nLimY)/2.0);
|
|
XOsnap(ptTemp, OS_INT, rbMask, max(nLimX, nLimY)/2.0);
|
|
//nAxisXDrt=GetAxisXDirection(m_ptPoint,&m_axisDrt,&m_ptIntArray);// [1/8/2008 nsh]
|
|
nAxisXDrt = GetAxisXDirection(ptTemp, &m_axisDrt, &m_ptIntArray);
|
|
// End
|
|
|
|
ads_matrix mat;
|
|
m_ptPoint.GetRotationMatrix(nAxisXDrt, mat);
|
|
|
|
//插入位置
|
|
XPoint ptLoc=m_ptPoint+XPoint(_tstof(m_dlg->m_csXOffset), _tstof(m_dlg->m_csYOffset));
|
|
ptLoc.TransformBy(mat);
|
|
ptLoc.GetRotationMatrix(nAxisXDrt, mat);
|
|
|
|
m_column->SetLocation(ptLoc);
|
|
|
|
XPoly2D poly2d(1); //柱子外形
|
|
//m_dlg->GetOutlinePoly(ptLoc,poly2d);
|
|
GetOutlinePoly(ptLoc, poly2d);
|
|
m_column->SetOutlinePoly(poly2d);
|
|
m_dlg->UpdateObject(m_column);
|
|
m_column->transformBy(AsAcGeMatrix3d(mat));
|
|
return Adesk::kTrue;
|
|
}
|
|
BOOL TDbColumnJig::GetOutlinePoly(XPoint& ptPick, XPoly2D &poly) const
|
|
{
|
|
TColumnData::TSectionShape shape=g_coluShapeArray[m_dlg->m_iColuType];
|
|
//if (shape==TColumnData::kPoly)
|
|
// return FALSE;
|
|
double nSizeX=_tstof(m_dlg->m_csXSize);
|
|
double nSizeY=_tstof(m_dlg->m_csYSize);
|
|
|
|
//modify by xlc on 090520参数错误时切换柱子类型时不起作用
|
|
// if (nSizeX<_DIST_SNAP || nSizeY<_DIST_SNAP)
|
|
// return FALSE;
|
|
if (shape== TColumnData::kRect)
|
|
{
|
|
if (nSizeX<_DIST_SNAP || nSizeY<_DIST_SNAP)
|
|
return FALSE;
|
|
}
|
|
else if (shape==TColumnData::kPoly) //XSize和YSize对异型柱无效
|
|
{
|
|
}
|
|
else //YSize对圆和多边形无效
|
|
{
|
|
if (nSizeX<_DIST_SNAP)
|
|
return FALSE;
|
|
}
|
|
|
|
poly.Reset();
|
|
poly.SetFlag(1);
|
|
|
|
ads_matrix mat;
|
|
ptPick.GetRotationMatrix(_tstof(m_dlg->m_csRotation)*PI/180, mat);
|
|
if (shape == TColumnData::kRect)
|
|
{
|
|
XRectAngle rectangle1(ptPick, nSizeX, nSizeY);
|
|
rectangle1.AsPoly2D(poly);
|
|
poly.TransUCS(mat);
|
|
}
|
|
else if (shape == TColumnData::kCircle)
|
|
{
|
|
XCircle circle(ptPick,nSizeX/2);
|
|
XCurveSegment seg;
|
|
seg = circle;
|
|
seg.AsPoly2D(poly);
|
|
}
|
|
else if (shape==TColumnData::kPoly)
|
|
{
|
|
if (m_dlg->m_polyOutline.Length()<1)
|
|
return FALSE;
|
|
poly=m_dlg->m_polyOutline;
|
|
if (m_dlg->m_bModeless)
|
|
XPoint().GetRotationMatrix(_tstof(m_dlg->m_csRotation)*PI/180,mat);
|
|
else
|
|
XPoint().GetRotationMatrix(_tstof(m_dlg->m_csRotation)*PI/180-m_dlg->m_xDir,mat);
|
|
poly.TransUCS(mat);
|
|
XPoint().GetMoveMatrix(ptPick,mat);
|
|
poly.TransUCS(mat);
|
|
}
|
|
else
|
|
{
|
|
int nNumSides=3;
|
|
|
|
switch(shape)
|
|
{
|
|
case TColumnData::kStd3:
|
|
nNumSides=3;
|
|
break;
|
|
case TColumnData::kStd5:
|
|
nNumSides=5;
|
|
break;
|
|
case TColumnData::kStd6:
|
|
nNumSides=6;
|
|
break;
|
|
case TColumnData::kStd8:
|
|
nNumSides=8;
|
|
break;
|
|
case TColumnData::kStd12:
|
|
nNumSides=12;
|
|
break;
|
|
}
|
|
double circumRadius = nSizeX*0.5/cos(PI/2-PI/nNumSides);
|
|
XPoint vertex;
|
|
double increment,base;
|
|
|
|
|
|
increment = 2.0 * PI / nNumSides;
|
|
base = CT_std_angle(-increment/2.0+1.5*PI+_tstof(m_dlg->m_csRotation)*PI/180);
|
|
|
|
for (int i = 0; i < nNumSides ; i++)
|
|
{
|
|
vertex.x = circumRadius * cos(increment*i+base);
|
|
vertex.y = circumRadius * sin(increment*i+base);
|
|
poly.AppendNode((ptPick+vertex));
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
AcEdJig::DragStatus TDbColumnJig::sampler()
|
|
{
|
|
DragStatus stat;
|
|
setUserInputControls((UserInputControls)
|
|
(AcEdJig::kNullResponseAccepted));
|
|
|
|
if (m_bRot) //旋转
|
|
{
|
|
m_pszPrompt = _T("\n旋转角度:");
|
|
double angle = 0; //旋转角度
|
|
XPoint loc=m_column->GetLocation();
|
|
DragStatus res = acquireAngle(angle,m_ptPoint);
|
|
if (res == kNormal)
|
|
{
|
|
static double temp;
|
|
if (fabs(angle - temp) > 1e-6)
|
|
temp = angle;
|
|
else
|
|
return AcEdJig::kNoChange;
|
|
|
|
double rot = _tstof(m_dlg->m_csRotation);
|
|
double xOffset = _tstof(m_dlg->m_csXOffset);
|
|
double yOffset = _tstof(m_dlg->m_csYOffset);
|
|
double r=sqrt(xOffset*xOffset+yOffset*yOffset);
|
|
AcGePoint3d ptTem(xOffset,yOffset,0);
|
|
AcGeVector3d vec = ptTem- AcGePoint3d(0,0,0);
|
|
vec.rotateBy(-rot*PI/180,AcGeVector3d::kZAxis);
|
|
AcGePoint3d ptOffSet;
|
|
ptOffSet.x = vec.x;
|
|
ptOffSet.y = vec.y;
|
|
loc = m_ptPoint + (XPoint)ptOffSet;
|
|
//modify by xlc on 090301
|
|
rot = (angle)* 180.0 / PI+m_dStartAngle;
|
|
// xOffset = r * cos(rot * PI/180.0)*(-1.0);
|
|
// yOffset = r * sin(rot * PI/180.0)*(-1.0);
|
|
if (rot >= 360)
|
|
{
|
|
rot -= 360;
|
|
}
|
|
else if (rot <= -360)
|
|
{
|
|
rot += 360;
|
|
}
|
|
ads_matrix mat;
|
|
m_ptPoint.GetRotationMatrix(Wcs2Ucs(angle), mat);
|
|
loc=m_ptRot;
|
|
loc.TransformBy(AsAcGeMatrix3d(mat));
|
|
|
|
XPoint pt=/*Wcs2Ucs*/(m_ptPoint);
|
|
XPoint pt3=Wcs2Ucs(loc);
|
|
xOffset=loc.x-pt.x;
|
|
yOffset=loc.y-pt.y;
|
|
|
|
//add by xlc on 090224
|
|
if (fabs(xOffset)<_DIST_SNAP)
|
|
xOffset = 0;
|
|
if (fabs(yOffset)<_DIST_SNAP)
|
|
yOffset = 0;
|
|
if (fabs(rot)<_DIST_SNAP)
|
|
rot = 0;
|
|
m_dlg->m_csRotation.Format(_T("%.f"),rot);
|
|
m_dlg->m_strColumAngle.Format(_T("%.f"),rot);
|
|
m_dlg->m_csXOffset.Format(_T("%.2f"),xOffset);
|
|
m_dlg->m_csYOffset.Format(_T("%.2f"),yOffset);
|
|
m_dlg->SetDlgItemText(IDC_ROTATION,m_dlg->m_csRotation);
|
|
m_dlg->SetDlgItemText(IDC_XOFFSET,m_dlg->m_csXOffset);
|
|
m_dlg->SetDlgItemText(IDC_YOFFSET,m_dlg->m_csYOffset);
|
|
m_dlg->UpdateImage();
|
|
}
|
|
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
if (m_pszKeyword)
|
|
setKeywordList(m_pszKeyword);
|
|
|
|
stat = acquirePoint(m_point);
|
|
m_ptPoint=XPoint(m_point);
|
|
if (stat==AcEdJig::kNormal)
|
|
{
|
|
static XPoint PointTemp;
|
|
if (PointTemp!=m_ptPoint)
|
|
PointTemp=m_ptPoint;
|
|
else
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
AcDbEntity* TDbColumnJig::entity() const
|
|
{
|
|
return (AcDbEntity *)(m_column);
|
|
}
|
|
|
|
ads_real TDbColumnJig::GetAxisXDirect(XPoint point)
|
|
{
|
|
ads_real nAxisXDrt = 0;
|
|
long pos = m_ptIntArray.Find(point);
|
|
|
|
if (pos != -1)//轴网交点位置
|
|
{
|
|
nAxisXDrt = m_axisDrt[pos];
|
|
}
|
|
return nAxisXDrt;
|
|
}
|