开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > CAD > 查看源码
CAD2006View.cpp
资源名称：CAD2006.rar　[点击查看]
上传用户：ckg1000
上传日期：2013-01-26
资源大小：630k
文件大小：42k
源码类别：

CAD

开发平台：

Visual C++

CAD2006View.cpp：源码内容
  1. // CAD2006View.cpp : implementation of the CCAD2006View class
  2. //
  4. #include "stdafx.h"
  5. #include "CAD2006.h"
  6. #include "MainFrm.h"
  8. #include "CAD2006Doc.h"
  9. #include "CAD2006View.h"
  10. #include "shape.h"
  11. #include "Line1.h"
  12. #include "Trigon.h"
  13. #include "Polygon.h"
  14. #include "Circle.h"
  15. #include "Rect.h"
  16. #include "ellipse.h"
  18. #ifdef _DEBUG
  19. #define new DEBUG_NEW
  20. #undef THIS_FILE
  21. static char THIS_FILE[] = __FILE__;
  22. #endif
  23. extern enum SHAPE;
  24. static CString m_allshapepoint;
  25. CArray<CRect,CRect> m_rectarray;
  26. CArray<CRect,CRect> m_textarray;
  27. CString m_array;               //1 line,2 linedown,3 rect,4 trigon,5 polygon,6 circle,7 ellipse
  28. CArray<CPoint,CPoint> m_linearray;
  29. CArray<CPoint,CPoint> m_linedownarray;
  30. CArray<CPoint,CPoint> m_circlearray;
  31. CArray<CPoint,CPoint> m_ellipsearray;
  32. CArray<CPoint,CPoint> m_rectanglearray;
  33. CArray<CPoint,CPoint> m_trigonarray;
  34. CArray<CPoint,CPoint> m_polygonarray;
  35. CArray<POINT *,POINT *> m_polygonarraypoint;
  36. int shapeindex = 0;
  37. enum SelectStatus{NoSelect,YesSelect} selectstatus;   //选定状态
  38. enum MirrorStatus{NoMirror,YesMirror} mirrorstatus;   //镜像状态
  39. static bool bln = true;
  40. static bool blnselecttrigon = true;
  41. static bool blnfirst = true;     //打开
  42. CRect selectrect;
  43. int index;
  44. int count = 0;
  45. bool blnselect = true;
  46. bool blnfrist = true;   //只初始化一次
  48. /////////////////////////////////////////////////////////////////////////////
  49. // CCAD2006View
  51. IMPLEMENT_DYNCREATE(CCAD2006View, CView)
  53. BEGIN_MESSAGE_MAP(CCAD2006View, CView)
  54. //{{AFX_MSG_MAP(CCAD2006View)
  55. ON_WM_MOUSEMOVE()
  56. ON_WM_SETCURSOR()
  57. ON_WM_LBUTTONDOWN()
  58. ON_WM_RBUTTONDOWN()
  59. ON_WM_KEYDOWN()
  60. ON_WM_LBUTTONUP()
  61. ON_COMMAND(ID_FILE_SAVE, OnFileSave)
  62. ON_WM_KILLFOCUS()
  63. ON_WM_MOUSEWHEEL()
  64. ON_WM_ERASEBKGND()
  65. ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
  66. //}}AFX_MSG_MAP
  67. // Standard printing commands
  68. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  69. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  70. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  71. END_MESSAGE_MAP()
  73. /////////////////////////////////////////////////////////////////////////////
  74. // CCAD2006View construction/destruction
  76. CCAD2006View::CCAD2006View()
  77. {
  78. // TODO: add construction code here
  79. this->m_openclose = close;
  80. this->m_state = first;
  81. }
  83. CCAD2006View::~CCAD2006View()
  84. {
  85. }
  87. BOOL CCAD2006View::PreCreateWindow(CREATESTRUCT& cs)
  88. {
  89. // TODO: Modify the Window class or styles here by modifying
  90. //  the CREATESTRUCT cs
  92. return CView::PreCreateWindow(cs);
  93. }
  95. /////////////////////////////////////////////////////////////////////////////
  96. // CCAD2006View drawing
  98. void CCAD2006View::OnDraw(CDC* pDC)
  99. {
  100. CCAD2006Doc* pDoc = GetDocument();
  101. ASSERT_VALID(pDoc);
  102. // TODO: add draw code for native data herestatic HCURSOR hcur = NULL;
  103. /* if( !blnfirst )
  104. {
  105. this->ShowShape(m_allshapepoint);
  106. }*/
  107. /* RECT rect;
  108. ::AfxGetApp()->m_pMainWnd->GetClientRect(&rect);
  109. ::AfxGetApp()->GetMainWnd()->GetClientRect(&rect);
  110. ::AfxGetApp()->GetMainWnd()->InvalidateRect(&rect,false);*/
  111. }
  113. /////////////////////////////////////////////////////////////////////////////
  114. // CCAD2006View printing
  116. BOOL CCAD2006View::OnPreparePrinting(CPrintInfo* pInfo)
  117. {
  118. // default preparation
  119. return DoPreparePrinting(pInfo);
  120. }
  122. void CCAD2006View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  123. {
  124. // TODO: add extra initialization before printing
  125. }
  127. void CCAD2006View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  128. {
  129. // TODO: add cleanup after printing
  130. }
  132. /////////////////////////////////////////////////////////////////////////////
  133. // CCAD2006View diagnostics
  135. #ifdef _DEBUG
  136. void CCAD2006View::AssertValid() const
  137. {
  138. CView::AssertValid();
  139. }
  141. void CCAD2006View::Dump(CDumpContext& dc) const
  142. {
  143. CView::Dump(dc);
  144. }
  146. CCAD2006Doc* CCAD2006View::GetDocument() // non-debug version is inline
  147. {
  148. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CCAD2006Doc)));
  149. return (CCAD2006Doc*)m_pDocument;
  150. }
  151. #endif //_DEBUG
  153. /////////////////////////////////////////////////////////////////////////////
  154. // CCAD2006View message handlers
  156. BOOL CCAD2006View::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  157. {
  158. /*******************设置相应的鼠标光标******************************/
  159. CCAD2006Doc* pDoc = GetDocument();
  160. static HCURSOR hcur = NULL;
  161. switch( pDoc->m_shape )        //形状工具
  162. {
  163. case line:
  164. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_LINE);
  165. break;
  166. case linedown:
  167. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_LINE);
  168. break;
  169. case lineangle:
  170. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_LINE);
  171. break;
  172. case trigon:
  173. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_TRIGON);
  174. break;
  175. case circle:
  176. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_RECT);
  177. break;
  178. case ellipse:
  179. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_RECT);
  180. break;
  181. case circlemater:
  182. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_RECT);
  183. break;
  184. case rect:
  185. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_RECT);
  186. break;
  187. case polygon:
  188. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_RECT);
  189. break;
  190. case font:
  191. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ARROW);
  192. break;
  193. }
  194. switch( pDoc->m_tool )        //图形工具
  195. {
  196. case arrow:
  197. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ARROW);
  198. break;
  199. case draw:
  200. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ARROW);
  201. break;
  202. case fill:
  203. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ARROW);
  204. break;
  205. case move:
  206. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ARROW);
  207. break;
  208. case zoom:
  209. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ARROW);
  210. break;
  211. case msl:
  212. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ARROW);
  213. break;
  214. case eddy:
  215. hcur = ::AfxGetApp()->LoadCursor(IDC_CURSOR_ROTATE);
  216. break;
  217. }
  218. ::SetCursor(hcur);
  219. return 0;
  220. }
  222. void CCAD2006View::OnMouseMove(UINT nFlags, CPoint point) 
  223. {
  224. // TODO: Add your message handler code here and/or call default
  225. CCAD2006Doc* pDoc = GetDocument();
  226. CDC *pDC = GetDC();
  227. /*******************************************/
  228. /*****************镜像工具***********************/
  229. if( pDoc->m_tool == msl )
  230. {
  231. switch( pDoc->m_shape )
  232. {
  233. case rect:
  234. {
  235. if(mirrorstatus == YesMirror)
  236. {
  237. pDoc->m_shapetool->Mirror(pDC,point);
  238. }
  239. break;
  240. }
  241. case trigon:
  242. {
  243. if(mirrorstatus == YesMirror)
  244. {
  245. pDoc->m_shapetool->Mirror(pDC,point);
  246. }
  247. break;
  248. }
  249. case polygon:
  250. {
  251. if(mirrorstatus == YesMirror)
  252. {
  253. pDoc->m_shapetool->Mirror(pDC,point);
  254. }
  255. break;
  256. }
  257. case circle:
  258. {
  259. if(mirrorstatus == YesMirror)
  260. {
  261. pDoc->m_shapetool->Mirror(pDC,point);
  262. }
  263. break;
  264. }
  265. case line:
  266. {
  267. if(mirrorstatus == YesMirror)
  268. {
  269. pDoc->m_shapetool->Mirror(pDC,point);
  270. }
  271. break;
  272. }
  273. }
  274. }
  276. /*******************缩放工具********************/
  277. if( pDoc->m_tool == zoom )
  278. {
  279. switch( pDoc->m_shape )
  280. {
  281. case trigon:
  282. {
  283. if(selectstatus == YesSelect)
  284. {
  285. pDoc->m_shapetool->Update(pDC); //去小圈再动
  286. pDoc->m_shapetool->Zoom(pDC,point);
  287. }
  288. break;
  289. }
  290. case polygon:
  291. {
  292. if(selectstatus == YesSelect)
  293. {
  294. pDoc->m_shapetool->Update(pDC); //去小圈再动
  295. pDoc->m_shapetool->Zoom(pDC,point);
  296. }
  297. break;
  298. }
  299. case rect:
  300. {
  301. if(selectstatus == YesSelect)
  302. {
  303. pDoc->m_shapetool->Update(pDC); //去小圈再动
  304. pDoc->m_shapetool->Zoom(pDC,point);
  305. }
  306. break;
  307. }
  308. case circle:
  309. {
  310. if(selectstatus == YesSelect)
  311. {
  312. //pDoc->m_shapetool->Update(pDC); //去小圈再动
  313. pDoc->m_shapetool->Zoom(pDC,point);
  314. }
  315. break;
  316. }
  317. case ellipse:
  318. {
  319. if(selectstatus == YesSelect)
  320. {
  321. //pDoc->m_shapetool->Update(pDC); //去小圈再动
  322. pDoc->m_shapetool->Zoom(pDC,point);
  323. }
  324. break;
  325. }
  326. case line:
  327. {
  328. if(selectstatus == YesSelect)
  329. {
  330. //pDoc->m_shapetool->Update(pDC); //去小圈再动
  331. pDoc->m_shapetool->Zoom(pDC,point);
  332. }
  333. break;
  334. }
  335. }
  336. }
  337. /********************画图形****************************/
  338. if( this->m_openclose == open )
  339. {
  340. switch( pDoc->m_shape )
  341. {
  342. case rect:
  343. {
  344. pDoc->m_shapetool->Onmousemove(pDC,point);
  345. this->m_state = second;
  346. break;
  347. }
  348. case line:
  349. {
  350. pDoc->m_shapetool->Onmousemove(pDC,point);
  351. this->m_state = second;
  352. break;
  353. }
  354. case linedown:
  355. {
  356. pDoc->m_shapetool->Onmousemove(pDC,point);
  357. //this->m_state = second;
  358. break;
  359. }
  360. case trigon:
  361. {
  362. pDoc->m_shapetool->Onmousemove(pDC,point);
  363. //this->m_state = second;
  364. break;
  365. }
  366. case polygon:
  367. {
  368. pDoc->m_shapetool->Onmousemove(pDC,point);
  369. this->m_state = second;
  370. break;
  371. }
  372. case circle:
  373. {
  374. pDoc->m_shapetool->Onmousemove(pDC,point);
  375. this->m_state = second;
  376. break;
  377. }
  378. case ellipse:
  379. {
  380. pDoc->m_shapetool->Onmousemove(pDC,point);
  381. this->m_state = second;
  382. break;
  383. }
  384. }
  385. }
  386. /*******************图形移动***********************************/
  387. if( pDoc->m_tool == move )
  388. {
  389. switch( pDoc->m_shape )
  390. {
  391. case line:
  392. {
  393. if(selectstatus == YesSelect)
  394. {
  395. pDoc->m_shapetool->Update(pDC); //去小圈再动
  396. pDoc->m_shapetool->Move(pDC,point);
  397. }
  398. break;
  399. }
  400. case trigon:
  401. {
  402. if(selectstatus == YesSelect)
  403. {
  404. pDoc->m_shapetool->Update(pDC); //去小圈再动
  405. pDoc->m_shapetool->Move(pDC,point);
  406. }
  407. break;
  408. }
  409. case polygon:
  410. {
  411. if(selectstatus == YesSelect)
  412. {
  413. pDoc->m_shapetool->Update(pDC); //去小圈再动
  414. pDoc->m_shapetool->Move(pDC,point);
  415. }
  416. break;
  417. }
  418. case rect:
  419. {
  420. if(selectstatus == YesSelect)
  421. {
  422. pDoc->m_shapetool->Update(pDC); //去小圈再动
  423. pDoc->m_shapetool->Move(pDC,point);
  424. }
  425. break;
  426. }
  427. case circle :
  428. {
  429. if(selectstatus == YesSelect)
  430. {
  431. // pDoc->m_shapetool->Update(pDC);
  432. pDoc->m_shapetool->Move(pDC,point);
  433. }
  434. break;
  435. }
  436. case ellipse:
  437. {
  438. if(selectstatus == YesSelect)
  439. {
  440. // pDoc->m_shapetool->Update(pDC);
  441. pDoc->m_shapetool->Move(pDC,point);
  442. }
  443. break;
  444. }
  445. }
  446. }
  447. /************************字体移动***********************************/
  448. /* if( pDoc->m_tool == move && pDoc->m_shape == font && nFlags == MK_LBUTTON )
  449. {
  450. CPoint m_point;
  451. m_point.x = point.x ;
  452. m_point.y = point.y - 32;
  453. m_point.x = abs(m_point.x - m_fontselect.x);
  454. m_point.y = abs(m_point.y - m_fontselect.y);
  455. //pDoc->m_text.TextMove(pDC,point,index,selectrect);
  456. }*/
  458. /***********  坐标计算   *********/
  459. CMainFrame *pWnd = (CMainFrame *)::AfxGetMainWnd();
  460. pWnd->m_wndStatusBar.SetPaneInfo(2,ID_SEPARATOR,SBPS_NORMAL,45);
  461. CString MouseInfo;
  462. MouseInfo.Format("%002d,%002d",point.x,point.y);
  463. pWnd->m_wndStatusBar.SetPaneText(2,MouseInfo);
  464. CView::OnMouseMove(nFlags, point);
  465. }
  467. void CCAD2006View::OnLButtonDown(UINT nFlags, CPoint point) 
  468. {
  469. CCAD2006Doc* pDoc = GetDocument();
  470. CDC *pDC = GetDC();
  471. /********************旋转工具****************************/
  472. if( pDoc->m_tool == eddy )
  473. {
  474. switch( pDoc->m_shape )
  475. {
  476. case trigon:
  477. {
  478. if(selectstatus == YesSelect) 
  479. {
  480. pDoc->m_shapetool->Rotate(pDC,point);      //转30度
  481. this->m_openclose = close;
  482. }
  483. break;
  484. }
  485. case polygon:
  486. {
  487. if(selectstatus == YesSelect) 
  488. {
  489. pDoc->m_shapetool->Rotate(pDC,point);      //转30度
  490. this->m_openclose = close;
  491. }
  492. break;
  493. }
  494. case line:
  495. {
  496. if(selectstatus == YesSelect) 
  497. {
  498. pDoc->m_shapetool->Rotate(pDC,point);      //转30度
  499. this->m_openclose = close;
  500. }
  501. break;
  502. }
  503. }
  504. }
  505. /*****************镜像工具***********************/
  506. if( pDoc->m_tool == msl )
  507. {
  508. switch( pDoc->m_shape )
  509. {
  510. case rect:
  511. {
  512. if(selectstatus == YesSelect) 
  513. {
  514. mirrorstatus = YesMirror;
  515. pDoc->m_shapetool->OnMirLBtnDn(pDC,point);
  516. }
  517. break;
  518. }
  519. case trigon:
  520. {
  521. if(selectstatus == YesSelect) 
  522. {
  523. mirrorstatus = YesMirror;
  524. pDoc->m_shapetool->OnMirLBtnDn(pDC,point);
  525. }
  526. break;
  527. }
  528. case polygon:
  529. {
  530. if(selectstatus == YesSelect) 
  531. {
  532. mirrorstatus = YesMirror;
  533. pDoc->m_shapetool->OnMirLBtnDn(pDC,point);
  534. }
  535. break;
  536. }
  537. case circle:
  538. {
  539. if(selectstatus == YesSelect) 
  540. {
  541. mirrorstatus = YesMirror;
  542. pDoc->m_shapetool->OnMirLBtnDn(pDC,point);
  543. }
  544. break;
  545. }
  546. case line:
  547. {
  548. if(selectstatus == YesSelect) 
  549. {
  550. mirrorstatus = YesMirror;
  551. pDoc->m_shapetool->OnMirLBtnDn(pDC,point);
  552. }
  553. break;
  554. }
  555. }
  556. }
  557. /**************************缩放工具***********************************/
  558. if( pDoc->m_tool == zoom )
  559. {
  560. if( this->ZoomTrigonSelect(point) )
  561. {
  562. blnselecttrigon = false;
  563. selectstatus = YesSelect;
  564. this->m_openclose = close;
  565. }
  566. else if( this->ZoomPolygonSelect(point) )
  567. {
  568. blnselecttrigon = false;
  569. this->m_openclose = close;
  570. selectstatus = YesSelect;
  571. }
  572. else if( this->RectSelect(point) )
  573. {
  574. blnselecttrigon = false;
  575. this->m_openclose = close;
  576. selectstatus = YesSelect;
  577. }
  578. else if( this->CircleSelect(point) )
  579. {
  580. blnselecttrigon = false;
  581. this->m_openclose = close;
  582. selectstatus = YesSelect;
  583. }
  584. else if( this->EllipseSelect(point) )
  585. {
  586. blnselecttrigon = false;
  587. this->m_openclose = close;
  588. selectstatus = YesSelect;
  589. }
  590. else if( this->ZoomLineSelect(point) )
  591. {
  592. blnselecttrigon = false;
  593. this->m_openclose = close;
  594. selectstatus = YesSelect;
  595. }
  596. }
  597. /*****************选中工具******************/
  598. if( pDoc->m_tool == select )
  599. {
  600. for( int i = 0; i < m_array.GetLength(); i++ )
  601. {
  602. switch( m_array.operator [](i) )
  603. {
  604. case '1':
  605. {
  606. if(this->LineSelect(point))
  607. {
  608. selectstatus = YesSelect;
  609. pDoc->m_shape = line;
  610. blnselecttrigon = false;
  611. blnselect = false;    //删除
  612. }
  613. break;
  614. }
  615. case '2':
  616. {
  617. //(CLine *)pDoc->m_shapetool->Select(pDC,point);
  618. break;
  619. }
  620. case '3':
  621. {
  622. if(RectSelect(point))
  623. {
  624. selectstatus = YesSelect;
  625. pDoc->m_shape = rect;
  626. blnselecttrigon = false;
  627. blnselect = false;    //删除
  628. }
  629. break;
  630. }
  631. case '4':
  632. {
  633. if(TrigonSelect(point))
  634. {
  635. selectstatus = YesSelect;
  636. pDoc->m_shape = trigon;
  637. blnselecttrigon = false;
  638. blnselect = false;    //删除
  639. }
  640. break;
  641. }
  642. case '5':
  643. {
  644. if(this->PolygonSelect(point))
  645. {
  646. selectstatus = YesSelect;
  647. pDoc->m_shape = polygon;
  648. blnselecttrigon = false;
  649. blnselect = false;    //删除
  650. }
  651. break;
  652. }
  653. case '6':
  654. {
  655. //(CCircle *)pDoc->m_shapetool->Select(pDC,point);
  656. if(this->CircleSelect(point))
  657. {
  658. pDoc->m_shape = circle;
  659. blnselecttrigon = false;
  660. selectstatus = YesSelect;
  661. blnselect = false;    //删除
  662. }
  663. break;
  664. }
  665. case '7':
  666. {
  667. //(CCircle *)pDoc->m_shapetool->Select(pDC,point);
  668. if(this->EllipseSelect(point))
  669. {
  670. pDoc->m_shape = ellipse;
  671. blnselecttrigon = false;
  672. selectstatus = YesSelect;
  673. blnselect = false;    //删除
  674. }
  675. break;
  676. }
  677. }
  678. }
  679. }
  680. /**********************画图工具绘画***************************/
  681. if( this->m_state == first && pDoc->m_tool != select && pDoc->m_tool != move && 
  682. pDoc->m_tool != zoom && pDoc->m_tool != msl && pDoc->m_tool != eddy )
  683. {
  684. switch( pDoc->m_shape )
  685. {
  686. case rect:
  687. {
  688. this->m_openclose = open;
  689. pDoc->m_shapetool = new CRectangle;
  690. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  691. pDoc->m_shapearray.Add(((CObject*)pDoc->m_shapetool));
  692. m_rectanglearray.Add(pDoc->m_shapetool->GetPosBegin());
  693. m_array.Insert(m_array.GetLength(),"3");
  694. break;
  695. }
  696. case trigon:
  697. {
  698. this->m_openclose = open;
  699. if( blnfrist )
  700. {
  701. pDoc->m_shapetool = new CTrigon;
  702. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  703. pDoc->m_shapearray.Add(((CObject*)pDoc->m_shapetool));
  704. m_trigonarray.Add(pDoc->m_shapetool->GetPosBegin());
  705. m_array.Insert(m_array.GetLength(),"4");
  706. count++;
  707. blnfrist = false;
  708. }
  709. else
  710. {
  711. if( count == 1 )
  712. {
  713. m_trigonarray.Add(pDoc->m_shapetool->GetPosCenter());
  714. }
  715. else
  716. {
  717. m_trigonarray.Add(pDoc->m_shapetool->GetPosEnd());
  718. }
  719. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  720. count++;
  721. }
  722. break;
  723. }
  724. case line:
  725. {
  726. this->m_openclose = open;
  727. pDoc->m_shapetool = new CLine;
  728. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  729. pDoc->m_shapearray.Add(((CObject*)pDoc->m_shapetool));
  730. m_linearray.Add(pDoc->m_shapetool->GetPosBegin());
  731. m_array.Insert(m_array.GetLength(),"1");
  732. break;
  733. }
  734. case linedown:
  735. {
  736. this->m_openclose = open;
  737. pDoc->m_shapetool = new CLine;
  738. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  739. pDoc->m_shapearray.Add(((CObject*)pDoc->m_shapetool));
  740. m_linedownarray.Add(pDoc->m_shapetool->GetPosBegin());
  741. m_array.Insert(m_array.GetLength(),"2");
  742. break;
  743. }
  744. case polygon:
  745. {
  746. this->m_openclose = open;
  747. pDoc->m_shapetool = new CPolygon;
  748. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  749. m_polygonarray.Add(pDoc->m_shapetool->GetPosBegin());
  750. m_array.Insert(m_array.GetLength(),"5");
  751. break;
  752. }
  753. case circle:
  754. {
  755. this->m_openclose = open;
  756. pDoc->m_shapetool = new CCircle;
  757. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  758. m_circlearray.Add(pDoc->m_shapetool->GetPosBegin());
  759. m_array.Insert(m_array.GetLength(),"6");
  760. break;
  761. }
  762. case ellipse:
  763. {
  764. this->m_openclose = open;
  765. pDoc->m_shapetool = new CEllipse;
  766. pDoc->m_shapetool->OnLbuttondown(pDC,point);
  767. m_ellipsearray.Add(pDoc->m_shapetool->GetPosBegin());
  768. m_array.Insert(m_array.GetLength(),"7");
  769. break;
  770. }
  771. }
  772. }
  773. /*******************移动工具************************/
  774. if( pDoc->m_tool == move  )
  775. {
  776. if( blnselecttrigon  == false )
  777. {
  778. selectstatus = YesSelect;
  779. this->m_openclose = close;
  780. }
  781. else if(TrigonSelect(point))
  782. {
  783. blnselecttrigon = false;
  784. selectstatus = YesSelect;
  785. this->m_openclose = close;
  786. }
  787. else if( this->PolygonSelect(point) )
  788. {
  789. blnselecttrigon = false;
  790. this->m_openclose = close;
  791. selectstatus = YesSelect;
  792. }
  793. else if( this->RectSelect(point) )
  794. {
  795. blnselecttrigon = false;
  796. this->m_openclose = close;
  797. selectstatus = YesSelect;
  798. }
  799. else if( this->CircleSelect(point) )
  800. {
  801. blnselecttrigon = false;
  802. this->m_openclose = close;
  803. selectstatus = YesSelect;
  804. }
  805. else if( this->EllipseSelect(point) )
  806. {
  807. blnselecttrigon = false;
  808. this->m_openclose = close;
  809. selectstatus = YesSelect;
  810. }
  811. else if( this->LineSelect(point) )
  812. {
  813. blnselecttrigon = false;
  814. this->m_openclose = close;
  815. selectstatus = YesSelect;
  816. }
  817. }
  819. if( count == 3 )    //三角形
  820. {
  821. blnfrist = true;
  822. this->m_state = second;
  823. count = 0;
  824. }
  825. /*********************存储数据****************************/
  826. if( this->m_state == second )
  827. {
  828. switch( pDoc->m_shape )
  829. {
  830. case line:
  831. {
  832. m_linearray.Add(pDoc->m_shapetool->GetPosEnd());
  833. break;
  834. }
  835. case rect:
  836. {
  837. m_rectanglearray.Add(pDoc->m_shapetool->GetPosEnd());
  838. break;
  839. }
  840. case polygon:
  841. {
  842. m_polygonarray.Add(pDoc->m_shapetool->GetPosEnd());
  843. m_polygonarraypoint.Add(pDoc->m_shapetool->GetPosBorder());
  844. break;
  845. }
  846. case circle:
  847. {
  848. m_circlearray.Add(pDoc->m_shapetool->GetPosEnd());
  849. break;
  850. }
  851. case ellipse:
  852. {
  853. m_ellipsearray.Add(pDoc->m_shapetool->GetPosCenter());
  854. m_ellipsearray.Add(pDoc->m_shapetool->GetPosEnd());
  855. break;
  856. }
  857. }
  858. this->m_openclose = close;
  859. this->m_state = first;
  860. }
  862. /************************字体工具进行写字***********************************/
  863. if( pDoc->m_shape == font )
  864. {
  865. if( bln == true )
  866. {
  867. int m_num = m_rectarray.GetSize();
  868. if( m_num > 0 )
  869. {
  870. CRect rect = m_rectarray.operator [](m_num - 1);
  871. pDoc->m_text.LostTextFouce(pDC,rect);
  872. }
  873. CRect recttext(point.x+55,point.y+60,point.x+140,point.y+80);
  874. m_textarray.Add(recttext);
  875. CRect rectrect(point.x,point.y,point.x+90,point.y+22);
  876. m_rectarray.Add(rectrect);
  877. pDoc->m_text.draw(recttext);
  878. pDoc->m_text.SetTextFouce(pDC,rectrect);
  879. //pDoc->m_text.SetFouceRect(rectrect);
  880. //pDoc->m_text.SetFouceTextRect(rectrect);
  881. bln = false;
  882. }
  883. else
  884. {
  885. CRect rect = m_rectarray.operator [](m_rectarray.GetSize() - 1);
  886. pDoc->m_text.LostTextFouce(pDC,rect);
  887. bln = true;
  888. }
  889. }
  890. /*********************选中字体****************************/
  891. if( pDoc->m_tool == arrow  )
  892. {
  893. if( m_rectarray.GetSize() > 0 )
  894. {
  895. CPoint m_point;
  896. m_point.x = point.x ;
  897. m_point.y = point.y ;
  898. for( int i = 0; i < m_rectarray.GetSize(); i++ )
  899. {
  900. CRect rect = m_rectarray.operator [](i);
  901. if( rect.PtInRect(m_point) )
  902. {
  903. CRect textrect = m_textarray.operator [](i);
  904. selectrect = rect;
  905. index = i;
  906. blnselect = false;  //判断是否被选取
  907. pDoc->m_text.LostTextFouce(pDC,pDoc->m_text.GetFouceText());
  908. pDoc->m_text.SetTextFouce(pDC,rect);
  909. pDoc->m_text.SetFouceRect(rect);     //存取选取的框架的大小
  910. //pDoc->m_text.SetFouceTextRect(textrect);
  911. //pDoc->m_shape = font;
  912. break;
  913. }
  914. else
  915. {
  916. if( !blnselect )
  917. {
  918. pDoc->m_text.LostTextFouce(pDC,pDoc->m_text.GetFouceText());
  919. }
  920. }
  921. }
  922. }
  924. }
  925. CView::OnLButtonDown(nFlags, point);
  926. }
  928. void CCAD2006View::OnRButtonDown(UINT nFlags, CPoint point) 
  929. {
  930. // TODO: Add your message handler code here and/or call default
  931. CCAD2006Doc* pDoc = GetDocument();
  932. CDC *pDC = GetDC();
  933. this->m_openclose = close;
  934. pDoc->m_tool = select;
  935. pDoc->m_shape = shape;
  936. // pDoc->m_text.DeleteText(pDC,1,rect);
  937. CView::OnRButtonDown(nFlags, point);
  938. }
  940. void CCAD2006View::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  941. {
  942. // TODO: Add your message handler code here and/or call default
  943. CCAD2006Doc* pDoc = GetDocument();
  944. CDC *pDC = GetDC();
  945. if( nChar == 46 && blnselect == false )
  946. {
  947. switch( pDoc->m_shape )
  948. {
  949. case rect:
  950. {
  951. // pDoc->m_shapetool = new CRectangle;
  952. pDoc->m_shapetool->Delete(pDC);
  953. m_rectanglearray.RemoveAt(shapeindex,1);
  954. m_rectanglearray.RemoveAt(shapeindex,1);
  955. blnselect = true;
  956. break;
  957. }
  958. case font:
  959. {
  960. //pDoc->m_shapetool = new CRectangle;
  961. pDoc->m_text.DeleteText(pDC,index,selectrect);
  962. m_rectarray.RemoveAt(index);
  963. m_textarray.RemoveAt(index);
  964. blnselect = true;
  965. break;
  966. }
  967. case trigon:
  968. {
  969. // pDoc->m_shapetool = new CTrigon;
  970. pDoc->m_shapetool->Delete(pDC);
  971. m_trigonarray.RemoveAt(shapeindex,1);
  972. m_trigonarray.RemoveAt(shapeindex,1);
  973. m_trigonarray.RemoveAt(shapeindex,1);
  974. blnselect = true;
  975. break;
  976. }
  977. case polygon:
  978. {
  979. // pDoc->m_shapetool = new CPolygon;
  980. pDoc->m_shapetool->Delete(pDC);
  981. m_polygonarray.RemoveAt(shapeindex,1);
  982. m_polygonarray.RemoveAt(shapeindex,1);
  983. m_polygonarraypoint.RemoveAt(shapeindex/2,1);
  984. blnselect = true;
  985. break;
  986. }
  987. case circle:
  988. {
  989. pDoc->m_shapetool->Delete(pDC);
  990. m_circlearray.RemoveAt(shapeindex,1);
  991. m_circlearray.RemoveAt(shapeindex,1);
  992. blnselect = true;
  993. break;
  994. }
  995. case ellipse:
  996. {
  997. pDoc->m_shapetool->Delete(pDC);
  998. m_ellipsearray.RemoveAt(shapeindex,1);
  999. m_ellipsearray.RemoveAt(shapeindex,1);
  1000. blnselect = true;
  1001. break;
  1002. }
  1003. case line:
  1004. {
  1005. pDoc->m_shapetool->Delete(pDC);
  1006. m_linearray.RemoveAt(shapeindex,1);
  1007. m_linearray.RemoveAt(shapeindex,1);
  1008. blnselect = true;
  1009. break;
  1010. }
  1011. }
  1012. switch( pDoc->m_tool )
  1013. {
  1014. case arrow:
  1015. {
  1016. pDoc->m_text.DeleteText(pDC,index,selectrect);
  1017. m_rectarray.RemoveAt(index);
  1018. m_textarray.RemoveAt(index);
  1019. blnselect = true;
  1020. break;
  1021. }
  1022. }
  1023. }
  1025. if( nChar == VK_CONTROL || nChar == 90 )
  1026. {
  1027. int i = pDoc->m_shapearray.GetSize();
  1028. if( i )
  1029. {
  1030. CShape* temp = (CShape*)pDoc->m_shapearray.operator [](i - 1);
  1031. pDoc->m_shapearray.RemoveAt(i - 1);
  1032. delete temp;
  1033. CRect rect;
  1034. this->GetClientRect(&rect);
  1035. pDC->InvertRect(rect);
  1036. pDoc->m_shape = shape;
  1037. pDoc->m_tool = arrow;
  1038. }
  1039. }
  1040. CView::OnKeyDown(nChar, nRepCnt, nFlags);
  1041. }
  1043. void CCAD2006View::OnLButtonUp(UINT nFlags, CPoint point) 
  1044. {
  1045. // TODO: Add your message handler code here and/or call default
  1046. CCAD2006Doc* pDoc = GetDocument();
  1047. CDC *pDC = GetDC();
  1048. /******************旋转工具***************************/
  1049. if( pDoc->m_tool == eddy )
  1050. {
  1051. switch( pDoc->m_shape )
  1052. {
  1053. case trigon:
  1054. {
  1055. //selectstatus = NoSelect;
  1056. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1057. m_trigonarray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1058. m_trigonarray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosCenter();
  1059. m_trigonarray.operator [](shapeindex + 2) = pDoc->m_shapetool->GetPosEnd();
  1060. //pDoc->m_shapetool->Move(pDC,point);
  1061. //delete pDoc->m_shapetool;
  1062. blnselecttrigon = true;
  1063. break;
  1064. }
  1065. case polygon:
  1066. {
  1067. //selectstatus = NoSelect;
  1068. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1069. m_polygonarray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1070. m_polygonarray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1071. m_polygonarraypoint.operator [](shapeindex/2) = pDoc->m_shapetool->GetPosBorder();
  1072. //pDoc->m_shapetool->Move(pDC,point);
  1073. //delete pDoc->m_shapetool;
  1074. blnselecttrigon = true;
  1075. break;
  1076. }
  1077. }
  1078. }
  1079. /*****************镜像工具***********************/
  1080. if( pDoc->m_tool == msl )
  1081. {
  1082. switch( pDoc->m_shape )
  1083. {
  1084. case rect:
  1085. {
  1086. if(mirrorstatus == YesMirror)
  1087. {
  1088. mirrorstatus = NoMirror;
  1089. pDoc->m_shapetool->Update(pDC);
  1090. }
  1091. break;
  1092. }
  1093. case trigon:
  1094. {
  1095. if(mirrorstatus == YesMirror)
  1096. {
  1097. mirrorstatus = NoMirror;
  1098. m_trigonarray.Add(pDoc->m_shapetool->GetPosBegin());
  1099. m_trigonarray.Add(pDoc->m_shapetool->GetPosCenter());
  1100. m_trigonarray.Add(pDoc->m_shapetool->GetPosEnd());
  1101. pDoc->m_shapetool->Update(pDC);
  1102. }
  1103. break;
  1104. }
  1105. case polygon:
  1106. {
  1107. if(mirrorstatus == YesMirror)
  1108. {
  1109. mirrorstatus = NoMirror;
  1110. pDoc->m_shapetool->Update(pDC);
  1111. }
  1112. break;
  1113. }
  1114. case circle:
  1115. {
  1116. if(mirrorstatus == YesMirror)
  1117. {
  1118. m_circlearray.Add(pDoc->m_shapetool->GetPosBegin());
  1119. m_circlearray.Add(pDoc->m_shapetool->GetPosEnd());
  1120. mirrorstatus = NoMirror;
  1121. pDoc->m_shapetool->Update(pDC);
  1122. }
  1123. break;
  1124. }
  1125. case line:
  1126. {
  1127. if(mirrorstatus == YesMirror)
  1128. {
  1129. m_linearray.Add(pDoc->m_shapetool->GetPosBegin());
  1130. m_linearray.Add(pDoc->m_shapetool->GetPosEnd());
  1131. mirrorstatus = NoMirror;
  1132. pDoc->m_shapetool->Update(pDC);
  1133. }
  1134. break;
  1135. }
  1136. }
  1137. }
  1139. /******************拖动工具*******************/
  1140. if( pDoc->m_tool == move && !blnselecttrigon )
  1141. {
  1142. switch( pDoc->m_shape )
  1143. {
  1144. case line:
  1145. {
  1146. selectstatus = NoSelect;
  1147. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1148. m_linearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1149. m_linearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1150. pDoc->m_shapetool->Move(pDC,point);
  1151. blnselecttrigon = true;
  1152. break;
  1153. }
  1154. case trigon:
  1155. {
  1156. selectstatus = NoSelect;
  1157. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1158. m_trigonarray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1159. m_trigonarray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosCenter();
  1160. m_trigonarray.operator [](shapeindex + 2) = pDoc->m_shapetool->GetPosEnd();
  1161. pDoc->m_shapetool->Move(pDC,point);
  1162. //delete pDoc->m_shapetool;
  1163. blnselecttrigon = true;
  1164. break;
  1165. }
  1166. case polygon:
  1167. {
  1168. selectstatus = NoSelect;
  1169. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1170. m_polygonarray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1171. m_polygonarray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1172. m_polygonarraypoint.operator [](shapeindex/2) = pDoc->m_shapetool->GetPosBorder();
  1173. pDoc->m_shapetool->Move(pDC,point);
  1174. //delete pDoc->m_shapetool;
  1175. blnselecttrigon = true;
  1176. break;
  1177. }
  1178. case rect:
  1179. {
  1180. selectstatus = NoSelect;
  1181. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1182. m_rectanglearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1183. m_rectanglearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1184. //pDoc->m_shapetool->Move(pDC,point);
  1185. //delete pDoc->m_shapetool;
  1186. blnselecttrigon = true;
  1187. break;
  1188. }
  1189. case circle:
  1190. {
  1191. selectstatus = NoSelect;
  1192. //pDoc->m_shapetool->Update(pDC); //去小圈再动
  1193. m_circlearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1194. m_circlearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1195. //pDoc->m_shapetool->Move(pDC,point);
  1196. //delete pDoc->m_shapetool;
  1197. blnselecttrigon = true;
  1198. break;
  1199. }
  1200. case ellipse:
  1201. {
  1202. selectstatus = NoSelect;
  1203. //pDoc->m_shapetool->Update(pDC); //去小圈再动
  1204. m_ellipsearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1205. m_ellipsearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosCenter();
  1206. m_ellipsearray.operator [](shapeindex + 2) = pDoc->m_shapetool->GetPosEnd();
  1207. //pDoc->m_shapetool->Move(pDC,point);
  1208. //delete pDoc->m_shapetool;
  1209. blnselecttrigon = true;
  1210. break;
  1211. }
  1212. }
  1213. }
  1214. /*********************缩放工具*************************/
  1215. if( pDoc->m_tool == zoom && !blnselecttrigon )
  1216. {
  1217. switch( pDoc->m_shape )
  1218. {
  1219. case trigon:
  1220. {
  1221. selectstatus = NoSelect;
  1222. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1223. m_trigonarray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1224. m_trigonarray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosCenter();
  1225. m_trigonarray.operator [](shapeindex + 2) = pDoc->m_shapetool->GetPosEnd();
  1226. //delete pDoc->m_shapetool;
  1227. blnselecttrigon = true;
  1228. break;
  1229. }
  1230. case polygon:
  1231. {
  1232. selectstatus = NoSelect;
  1233. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1234. m_polygonarray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1235. m_polygonarray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1236. m_polygonarraypoint.operator [](shapeindex/2) = pDoc->m_shapetool->GetPosBorder();
  1237. //delete pDoc->m_shapetool;
  1238. blnselecttrigon = true;
  1239. break;
  1240. }
  1241. case rect:
  1242. {
  1243. selectstatus = NoSelect;
  1244. pDoc->m_shapetool->Update(pDC); //去小圈再动
  1245. m_rectanglearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1246. m_rectanglearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1247. //delete pDoc->m_shapetool;
  1248. blnselecttrigon = true;
  1249. break;
  1250. }
  1251. case circle:
  1252. {
  1253. selectstatus = NoSelect;
  1254. // pDoc->m_shapetool->Update(pDC); //去小圈再动
  1255. m_circlearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1256. m_circlearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1257. //delete pDoc->m_shapetool;
  1258. blnselecttrigon = true;
  1259. break;
  1260. }
  1261. case ellipse:
  1262. {
  1263. selectstatus = NoSelect;
  1264. // pDoc->m_shapetool->Update(pDC); //去小圈再动
  1265. m_ellipsearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1266. m_ellipsearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosCenter();
  1267. m_ellipsearray.operator [](shapeindex + 2) = pDoc->m_shapetool->GetPosEnd();
  1268. //delete pDoc->m_shapetool;
  1269. blnselecttrigon = true;
  1270. break;
  1271. }
  1272. case line:
  1273. {
  1274. selectstatus = NoSelect;
  1275. // pDoc->m_shapetool->Update(pDC); //去小圈再动
  1276. m_linearray.operator [](shapeindex) = pDoc->m_shapetool->GetPosBegin();
  1277. m_linearray.operator [](shapeindex + 1) = pDoc->m_shapetool->GetPosEnd();
  1278. //delete pDoc->m_shapetool;
  1279. blnselecttrigon = true;
  1280. break;
  1281. }
  1282. }
  1283. }
  1284. CView::OnLButtonUp(nFlags, point);
  1285. }
  1287. bool CCAD2006View::TrigonSelect(CPoint point)
  1288. {
  1289. CCAD2006Doc* pDoc = GetDocument();
  1290. CDC *pDC = GetDC();
  1291. pDoc->m_shapetool = new CTrigon;
  1292. for( int j = 0; j < m_trigonarray.GetSize() ; j+=3 )
  1293. {
  1294. pDoc->m_shapetool->SetPosBegin(m_trigonarray.operator [](j));
  1295. pDoc->m_shapetool->SetPosCenter(m_trigonarray.operator [](j+1));
  1296. pDoc->m_shapetool->SetPosEnd(m_trigonarray.operator [](j+2));
  1298. if(pDoc->m_shapetool->Select(pDC,point))
  1299. {
  1300. shapeindex = j;
  1301. return true;
  1302. }
  1304. }
  1305. delete pDoc->m_shapetool;
  1306. return false;
  1307. }
  1309. bool CCAD2006View::LineSelect(CPoint point)
  1310. {
  1311. CCAD2006Doc* pDoc = GetDocument();
  1312. CDC *pDC = GetDC();
  1313. pDoc->m_shapetool = new CLine;
  1315. for( int j = 0; j < m_linearray.GetSize() ; j+=2 )
  1316. {
  1317. pDoc->m_shapetool->SetPosBegin(m_linearray.operator [](j));
  1318. pDoc->m_shapetool->SetPosEnd(m_linearray.operator [](j+1));
  1319. if((CLine *)pDoc->m_shapetool->Select(pDC,point))
  1320. {
  1321. shapeindex = j;
  1322. return true;
  1323. }
  1324. }
  1325. delete pDoc->m_shapetool;
  1326. return false;
  1327. }
  1329. bool CCAD2006View::CircleSelect(CPoint point)
  1330. {
  1331. CCAD2006Doc* pDoc = GetDocument();
  1332. CDC *pDC = GetDC();
  1333. pDoc->m_shapetool = new CCircle;
  1335. for( int j = 0; j < m_circlearray.GetSize() ; j+=2 )
  1336. {
  1337. pDoc->m_shapetool->SetPosBegin(m_circlearray.operator [](j));
  1338. pDoc->m_shapetool->SetPosEnd(m_circlearray.operator [](j+1));
  1339. if((CCircle *)pDoc->m_shapetool->Select(pDC,point))
  1340. {
  1341. pDoc->m_shape = circle;
  1342. shapeindex = j;
  1343. return true;
  1344. }
  1345. }
  1346. delete pDoc->m_shapetool;
  1347. return false;
  1348. }
  1350. bool CCAD2006View::RectSelect(CPoint point)
  1351. {
  1352. CCAD2006Doc* pDoc = GetDocument();
  1353. CDC *pDC = GetDC();
  1354. pDoc->m_shapetool = new CRectangle;
  1355. for( int j = 0; j < m_rectanglearray.GetSize() ; j+=2 )
  1356. {
  1357. pDoc->m_shapetool->SetPosBegin(m_rectanglearray.operator [](j));
  1358. pDoc->m_shapetool->SetPosEnd(m_rectanglearray.operator [](j+1));
  1359. if((CRectangle *)pDoc->m_shapetool->Select(pDC,point))
  1360. {
  1361. shapeindex = j;
  1362. return true;
  1363. }
  1364. }
  1365. delete pDoc->m_shapetool;
  1366. return false;
  1367. }
  1369. bool CCAD2006View::PolygonSelect(CPoint point)
  1370. {
  1371. CCAD2006Doc* pDoc = GetDocument();
  1372. CDC *pDC = GetDC();
  1373. pDoc->m_shapetool = new CPolygon;
  1374. for( int j = 0,i = 0; j < m_polygonarray.GetSize() ; j+=2,i++ )
  1375. {
  1376. pDoc->m_shapetool->SetPosBegin(m_polygonarray.operator [](j));
  1377. pDoc->m_shapetool->SetPosEnd(m_polygonarray.operator [](j+1));
  1378. pDoc->m_shapetool->SetPosBorder(m_polygonarraypoint.operator [](i));
  1379. if((CPolygon *)pDoc->m_shapetool->Select(pDC,point))
  1380. {
  1381. shapeindex = j;
  1382. return true;
  1383. }
  1384. }
  1385. delete pDoc->m_shapetool;
  1386. return false;
  1387. }
  1389. bool CCAD2006View::EllipseSelect(CPoint point)
  1390. {
  1391. CCAD2006Doc* pDoc = GetDocument();
  1392. CDC *pDC = GetDC();
  1393. pDoc->m_shapetool = new CEllipse;
  1394. for( int j = 0; j < m_ellipsearray.GetSize() ; j+=3 )
  1395. {
  1396. pDoc->m_shapetool->SetPosBegin(m_ellipsearray.operator [](j));
  1397. pDoc->m_shapetool->SetPosCenter(m_ellipsearray.operator [](j+1));
  1398. pDoc->m_shapetool->SetPosEnd(m_ellipsearray.operator [](j+2));
  1400. if((CEllipse *)pDoc->m_shapetool->Select(pDC,point))
  1401. {
  1402. pDoc->m_shape = ellipse;
  1403. shapeindex = j;
  1404. return true;
  1405. }
  1406. }
  1407. delete pDoc->m_shapetool;
  1408. return false;
  1409. }
  1411. bool CCAD2006View::ZoomTrigonSelect(CPoint point)
  1412. {
  1413. CCAD2006Doc* pDoc = GetDocument();
  1414. CDC *pDC = GetDC();
  1415. pDoc->m_shapetool = new CTrigon;
  1416. for( int j = 0; j < m_trigonarray.GetSize() ; j+=3 )
  1417. {
  1418. pDoc->m_shapetool->SetPosBegin(m_trigonarray.operator [](j));
  1419. pDoc->m_shapetool->SetPosCenter(m_trigonarray.operator [](j+1));
  1420. pDoc->m_shapetool->SetPosEnd(m_trigonarray.operator [](j+2));
  1421. if((CTrigon *)pDoc->m_shapetool->SelectOnePt(pDC,point))
  1422. {
  1423. shapeindex = j;
  1424. return true;
  1425. }
  1426. }
  1427. delete pDoc->m_shapetool;
  1428. return false;
  1429. }
  1431. bool CCAD2006View::ZoomPolygonSelect(CPoint point)
  1432. {
  1433. CCAD2006Doc* pDoc = GetDocument();
  1434. CDC *pDC = GetDC();
  1435. pDoc->m_shapetool = new CPolygon;
  1436. for( int j = 0,i = 0; j < m_polygonarray.GetSize() ; j+=2,i++ )
  1437. {
  1438. pDoc->m_shapetool->SetPosBegin(m_polygonarray.operator [](j));
  1439. pDoc->m_shapetool->SetPosEnd(m_polygonarray.operator [](j+1));
  1440. pDoc->m_shapetool->SetPosBorder(m_polygonarraypoint.operator [](i));
  1441. if((CPolygon *)pDoc->m_shapetool->Select(pDC,point))
  1442. {
  1443. shapeindex = j;
  1444. return true;
  1445. }
  1446. }
  1447. delete pDoc->m_shapetool;
  1448. return false;
  1449. }
  1451. bool CCAD2006View::ZoomLineSelect(CPoint point)
  1452. {
  1453. CCAD2006Doc* pDoc = GetDocument();
  1454. CDC *pDC = GetDC();
  1455. pDoc->m_shapetool = new CLine;
  1456. for( int j = 0,i = 0; j < m_linearray.GetSize() ; j+=2,i++ )
  1457. {
  1458. pDoc->m_shapetool->SetPosBegin(m_linearray.operator [](j));
  1459. pDoc->m_shapetool->SetPosEnd(m_linearray.operator [](j+1));
  1460. if((CLine *)pDoc->m_shapetool->SelectOnePt(pDC,point))
  1461. {
  1462. shapeindex = j;
  1463. return true;
  1464. }
  1465. }
  1466. delete pDoc->m_shapetool;
  1467. return false;
  1469. }
  1471. void CCAD2006View::OnFileSave() 
  1472. {
  1473. // TODO: Add your command handler code here
  1474. CFile m_file;
  1475. CString m_str;
  1476. CString m_temp;
  1477. int j = m_linearray.GetSize();
  1478. for( int i = 0; i < m_array.GetLength(); i++ )
  1479. {
  1480. switch( m_array.operator [](i) )
  1481. {
  1482. case '1':
  1483. {
  1484. static int m_line = 0;
  1485. CPoint point1 = m_linearray.operator [](m_line);
  1486. CPoint point2 = m_linearray.operator [](m_line + 1);
  1487. m_temp.Format("*%c,%d,%d,%d,%d",m_array.operator [](i),
  1488. point1.x,point1.y,point2.x,point2.y);
  1489. m_str.Insert(m_str.GetLength(),m_temp);
  1490. m_line += 2;
  1491. break;
  1492. }
  1493. case '2':
  1494. {
  1495. /* static int m_linedown = 0;
  1496. m_temp.Format("%s,%d,%d",m_array.operator [](i),
  1497. m_linedownarray.operator [](m_linedown).x,m_linedownarray.operator [](m_linedown + 1).y)
  1498. m_str.Insert(m_str.GetLength(),m_temp);
  1499. m_linedown += 2;*/
  1500. break;
  1501. }
  1502. case '3':
  1503. {
  1504. static int m_rect = 0;
  1505. m_temp.Format("*%c,%d,%d,%d,%d",m_array.operator [](i),
  1506. m_rectanglearray.operator [](m_rect).x,m_rectanglearray.operator [](m_rect).y,
  1507. m_rectanglearray.operator [](m_rect + 1).x,m_rectanglearray.operator [](m_rect + 1).y);
  1508. m_str.Insert(m_str.GetLength(),m_temp);
  1509. m_rect += 2;
  1510. break;
  1511. }
  1512. case '4':
  1513. {
  1514. static int m_trigon = 0;
  1515. m_temp.Format("*%c,%d,%d,%d,%d,%d,%d",m_array.operator [](i),
  1516. m_trigonarray.operator [](m_trigon).x,m_trigonarray.operator [](m_trigon).y,
  1517. m_trigonarray.operator [](m_trigon + 1).x,m_trigonarray.operator [](m_trigon + 1).y,
  1518. m_trigonarray.operator [](m_trigon + 2).x,m_trigonarray.operator [](m_trigon + 2).y);
  1519. m_str.Insert(m_str.GetLength(),m_temp);
  1520. m_trigon += 3;
  1521. break;
  1522. }
  1523. case '5':
  1524. {
  1525. /* static int m_rect = 0;
  1526. m_temp.Format("%s,%d,%d",m_array.operator [](i),
  1527. m_polygonarray.operator [](m_rect).x,m_polygonarray.operator [](m_rect + 1).y)
  1528. m_str.Insert(m_str.GetLength(),m_temp);
  1529. m_rect += 2;*/
  1530. break;
  1531. }
  1532. case '6':
  1533. {
  1534. static int m_circle = 0;
  1535. m_temp.Format("*%c,%d,%d,%d,%d",m_array.operator [](i),
  1536. m_circlearray.operator [](m_circle).x,m_circlearray.operator [](m_circle).y,
  1537. m_circlearray.operator [](m_circle + 1).x,m_circlearray.operator [](m_circle + 1).y);
  1538. m_str.Insert(m_str.GetLength(),m_temp);
  1539. m_circle += 2;
  1540. break;
  1541. }
  1542. case '7':
  1543. {
  1544. static int m_ellipse = 0;
  1545. m_temp.Format("*%c,%d,%d,%d,%d",m_array.operator [](i),
  1546. m_ellipsearray.operator [](m_ellipse).x,m_ellipsearray.operator [](m_ellipse).y,
  1547. m_ellipsearray.operator [](m_ellipse + 1).x,m_ellipsearray.operator [](m_ellipse + 1).y);
  1548. m_str.Insert(m_str.GetLength(),m_temp);
  1549. m_ellipse += 2;
  1550. break;
  1551. }
  1552. }
  1553. }
  1554. m_file.Open("CAD.txt",CFile::modeCreate | CFile::modeWrite);
  1555. m_file.Write(m_str.operator LPCTSTR(),m_str.GetLength());
  1556. }
  1558. void CCAD2006View::OnFileOpen() 
  1559. {
  1560. // TODO: Add your command handler code here
  1561. CFileDialog m_dialog(true);
  1563. m_dialog.m_ofn.lpstrFilter = "文本文件(*.txt)*.txt所有类型(*.*)*.*";
  1564. CFile m_file;
  1565. if(m_dialog.DoModal() == IDOK )
  1566. {
  1567. m_file.Open(m_dialog.GetFileName(),CFile::modeRead);
  1568. m_file.Read((void *)m_allshapepoint.operator LPCTSTR(),m_file.GetLength());
  1569. }
  1570. ShowShape(m_allshapepoint);
  1571. }
  1573. void CCAD2006View::ShowShape(CString str)
  1574. {
  1575. CCAD2006Doc* pDoc = GetDocument();
  1576. CDC *pDC = GetDC();
  1577. CString m_tempshape;
  1578. CString m_temp;
  1579. CString m_point1,m_point2,m_point3,m_point4,m_point5,m_point6;
  1580. int i = 1;
  1581. int j ;
  1582. m_array = "";
  1583. while( 1 == 1 )
  1584. {
  1585. j = ::AfxExtractSubString(m_tempshape,str.operator LPCTSTR(),i,'*');
  1586. AfxExtractSubString(m_temp,m_tempshape.operator LPCTSTR(),0,',');
  1587. AfxExtractSubString(m_point1,m_tempshape.operator LPCTSTR(),1,',');
  1588. AfxExtractSubString(m_point2,m_tempshape.operator LPCTSTR(),2,',');
  1589. AfxExtractSubString(m_point3,m_tempshape.operator LPCTSTR(),3,',');
  1590. AfxExtractSubString(m_point4,m_tempshape.operator LPCTSTR(),4,',');
  1591. CPoint point1(atoi(m_point1.operator LPCTSTR()),atoi(m_point2.operator LPCTSTR()));
  1592. CPoint point2(atoi(m_point3.operator LPCTSTR()),atoi(m_point4.operator LPCTSTR()));
  1593. if( j == 0 )
  1594. {
  1595. break;
  1596. }
  1597. switch( m_temp.operator [](0) )
  1598. {
  1599. case '1':
  1600. {
  1601. pDC->MoveTo(point1.x,point1.y);
  1602. pDC->LineTo(point2.x,point2.y);
  1603. m_linearray.Add(point1);
  1604. m_linearray.Add(point2);
  1605. m_array.Insert(m_array.GetLength(),'1');
  1606. break;
  1607. }
  1608. case '2':
  1609. {
  1611. break;
  1612. }
  1613. case '3':
  1614. {
  1615. pDC->Rectangle(point1.x,point1.y,point2.x,point2.y);
  1616. m_rectanglearray.Add(point1);
  1617. m_rectanglearray.Add(point2);
  1618. m_array.Insert(m_array.GetLength(),'3');
  1619. break;
  1620. }
  1621. case '4':
  1622. {
  1623. AfxExtractSubString(m_point5,m_tempshape.operator LPCTSTR(),5,',');
  1624. AfxExtractSubString(m_point6,m_tempshape.operator LPCTSTR(),6,',');
  1625. CPoint point3(atoi(m_point5.operator LPCTSTR()),atoi(m_point6.operator LPCTSTR()));
  1626. pDC->MoveTo(point1);
  1627. pDC->LineTo(point2);
  1628. pDC->LineTo(point3);
  1629. pDC->LineTo(point1);
  1630. m_trigonarray.Add(point1);
  1631. m_trigonarray.Add(point2);
  1632. m_trigonarray.Add(point3);
  1633. m_array.Insert(m_array.GetLength(),'4');
  1634. break;
  1635. }
  1636. case '5':
  1637. {
  1639. break;
  1640. }
  1641. case '6':
  1642. {
  1643. pDC->Ellipse(point1.x - point2.x,point1.y - point2.x,point1.x + point2.x,point1.y + point2.x);
  1644. m_circlearray.Add(point1);
  1645. m_circlearray.Add(point2);
  1646. m_array.Insert(m_array.GetLength(),'6');
  1647. break;
  1648. }
  1649. case '7':
  1650. {
  1651. pDC->Ellipse(point2.x,point2.y,point1.x,point1.y);
  1652. m_ellipsearray.Add(point1);
  1653. m_ellipsearray.Add(point2);
  1654. m_array.Insert(m_array.GetLength(),'7');
  1655. break;
  1656. }
  1657. }
  1658. i++;
  1659. }
  1660. }