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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
MyManageGraphObj.cpp
资源名称：MiniCAD_ALL.zip　[点击查看]
上传用户：netltd
上传日期：2013-02-12
资源大小：7234k
文件大小：42k
源码类别：

绘图程序

开发平台：

Visual C++

MyManageGraphObj.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "MyManageGraphObj.h"
  3. #include "math.h"
  4. #include "MyDefine.h"
  5. #include "resource.h"
  7. //被选择图形对象信息
  8. CSelectedObjectInfo::CSelectedObjectInfo(int type, int index)
  9. {
  10. m_type = type;
  11. m_index = index;
  12. }
  14. ///////////////////////////////////////////////////////////////////////////////////////////////
  15. IMPLEMENT_DYNCREATE(CManageGraphObject, CObject)
  17. CManageGraphObject::CManageGraphObject()
  18. {
  19. Proportion = 1.0;
  21. LRepeatTimes = 0;
  22. RRepeatTimes = 0;
  23. }
  25. CManageGraphObject::~CManageGraphObject()
  26. {
  27. DelAllLine();
  28. DelAllRect();
  29. DelAllCircle();
  30. DelAllArc();
  31. }
  34. void CManageGraphObject::Initialize(SIZE size, int style, COLORREF color)
  35. {
  36. LogicSize = size;
  37. LineStyle = style;
  38. PenColor = color;
  40. GetObjectRange();
  41. }
  43. void CManageGraphObject::SetLogicSize(SIZE size)
  44. {
  45. LogicSize.cx = size.cx;
  46. LogicSize.cy = size.cy;
  47. }
  49. void CManageGraphObject::SetLineStyle(int style)
  50. {
  51. LineStyle = style;
  52. }
  54. void CManageGraphObject::SetPenColor(COLORREF color)
  55. {
  56. PenColor = color;
  57. }
  60. //获取命令堆栈指针
  61. void CManageGraphObject::GetCommandStack(CCommandStack* pStack)
  62. {
  63. pCommandStack = pStack;
  64. }
  66. void CManageGraphObject::SetCurrentLayerName(CString layername)
  67. {
  68. CurrentLayerName = layername;
  69. }
  71. void CManageGraphObject::GetDC(CDC* pClientDC)
  72. {
  73. ASSERT(pClientDC != NULL);
  74. pDC = pClientDC;
  76. }
  78. void CManageGraphObject::GetView(CView* view)
  79. {
  80. ASSERT(view != NULL);
  81. pView = view;
  82. }
  84. void CManageGraphObject::GetManageFileLayer(CManageFileLayer* pManage)
  85. {
  86. pManageLayer = pManage;
  87. }
  90. void CManageGraphObject::Serialize(CArchive& ar)
  91. {
  92. int index;
  94. CMyLine*      pLine;
  95. CMyRect*      pRect;
  96. CMyCircle*    pCircle;
  97. CMyArc*       pArc;
  99. CGraphObjectInfo* pLineInfo;
  100. CGraphObjectInfo* pRectInfo;
  101. CGraphObjectInfo* pCircleInfo;
  102. CGraphObjectInfo* pArcInfo;
  104. if(ar.IsStoring())
  105. {
  106. m_LineArray.Serialize(ar);
  107. m_RectArray.Serialize(ar);
  108. m_CircleArray.Serialize(ar);
  109. m_ArcArray.Serialize(ar);
  110. }
  111. else
  112. {
  113. //注意当打开文件时，下面的Serialize()函数会自动创建CMyLine,CMyRect等对象
  114. m_LineArray.Serialize(ar);
  115. m_RectArray.Serialize(ar);
  116. m_CircleArray.Serialize(ar);
  117. m_ArcArray.Serialize(ar);
  118.     
  119. //注意创建CGraphObjectInfo对象
  120. for(index = 0; index < m_LineArray.GetSize(); index++)
  121. {
  122. pLine = GetLine(index);
  123. pLineInfo = new CGraphObjectInfo();
  124. m_LineInfoArray.Add(pLineInfo);
  125. }
  127. for(index = 0; index < m_RectArray.GetSize(); index++)
  128. {
  129. pRect = GetRect(index);
  130. pRectInfo = new CGraphObjectInfo();
  131. m_RectInfoArray.Add(pRectInfo);
  132. }
  134. for(index = 0; index < m_CircleArray.GetSize(); index++)
  135. {
  136. pCircle = GetCircle(index);
  137. pCircleInfo = new CGraphObjectInfo();
  138. m_CircleInfoArray.Add(pCircleInfo);
  139. }
  141. for(index = 0; index < m_ArcArray.GetSize(); index++)
  142. {
  143. pArc = GetArc(index);
  144. pArcInfo = new CGraphObjectInfo();
  145. m_ArcInfoArray.Add(pArcInfo);
  146. }
  148. }
  149. }
  150. ///////////////////////////////////////////////////////////////////////////////////////////////
  151. //处理命令
  152. void CManageGraphObject::OnLButtonDown(UINT ID, CPoint point)
  153. {
  154. ASSERT(pDC != NULL);
  155. ASSERT(pCommandStack != NULL);
  157. UINT msg = MESSAGE_LBUTTONDOWN;
  159. switch(ID)
  160. {
  161. case DRAW_SELECT:
  162. SelectObject(pDC, point);
  163.     break;
  165. case DRAW_LINE:
  166. OnDrawLine(msg, point);
  167. break;
  169.     case DRAW_RECT:
  170. OnDrawRect(msg, point);
  171. break;
  173.     case DRAW_CIRCLE:
  174.             OnDrawCircle(msg, point);
  175. break;
  177.     case DRAW_ARC:
  178. OnDrawArc(msg, point);
  179. break;
  181. case DRAW_TEXT:
  182. break;
  184. case MODIFY_DELETE:
  185. break;
  186. }
  187. }
  189. UINT CManageGraphObject::OnRButtonDown(UINT ID, CPoint point)
  190. {
  191. ASSERT(pDC != NULL);
  193. UINT msg = MESSAGE_RBUTTONDOWN;
  195. switch(ID)
  196. {
  197. case DRAW_SELECT:
  198. if(UnselectObject())
  199. pView->Invalidate();
  200. break;
  202. case DRAW_LINE:
  203. ID = OnDrawLine(msg, point);
  204. break;
  206. case DRAW_RECT:
  207. ID = OnDrawRect(msg, point);
  208. break;
  210. case DRAW_CIRCLE:
  211. ID = OnDrawCircle(msg, point);
  212. break;
  214. case DRAW_ARC:
  215. ID = OnDrawArc(msg, point);
  216. break;
  217. }
  219. return ID;
  220. }
  222. void CManageGraphObject::OnMouseMove(UINT ID, CPoint point)
  223. {
  224. ASSERT(pDC != NULL);
  226. UINT msg = MESSAGE_MOUSEMOVE;
  228. switch(ID)
  229. {
  230. case DRAW_SELECT:
  231. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  232. break;
  234. case DRAW_LINE:
  235.         OnDrawLine(msg, point); 
  236. break;
  238. case DRAW_RECT:
  239. OnDrawRect(msg, point);
  240. break;
  242. case DRAW_CIRCLE:
  243. OnDrawCircle(msg, point);
  244. break;
  246. case DRAW_ARC:
  247. OnDrawArc(msg, point);
  248. break;
  249. }
  250. }
  252. void CManageGraphObject::OnScroll(UINT ID)
  253. {
  254. ASSERT(pDC != NULL);
  255.     
  256. UINT msg = MESSAGE_SCROLL;
  258. switch(ID)
  259. {
  260. case DRAW_LINE:
  261. OnDrawLine(msg, NULL);
  262. break;
  264. case DRAW_RECT:
  265. OnDrawRect(msg, NULL);
  266. break;
  268. case DRAW_CIRCLE:
  269. OnDrawCircle(msg, NULL);
  270. break;
  272. case DRAW_ARC:
  273. OnDrawArc(msg, NULL);
  274. break;
  275. }
  276.  
  277. }
  279. UINT CManageGraphObject::OnDrawLine(UINT msg, CPoint point)
  280. {
  281. int ObjectType;
  282. int ObjetcIndex;
  283.     
  284. UINT command = DRAW_LINE;
  286. switch(msg)
  287. {
  288. case MESSAGE_LBUTTONDOWN:
  289. LRepeatTimes++;
  290. switch(LRepeatTimes)
  291. {
  292. case 1:
  293. StartPoint = point;
  294. m_DrawGrapObject.SetOnceFlag();
  295. break;
  297. case 2:
  298. EndPoint = point;
  299.         m_DrawGrapObject.DrawLine(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  300.         AddLine(StartPoint, EndPoint, LineStyle, PenColor);
  302.         ObjectType = OBJECT_LINE;
  303.         ObjetcIndex = m_LineArray.GetUpperBound();
  304.         //因为执行一项新操作后，将不再有可以Redo的命令
  305.         pCommandStack->PushCommand(DRAW_LINE, 1, &ObjectType, &ObjetcIndex);
  306.         
  307.         LRepeatTimes--;
  308.         StartPoint = EndPoint;
  309. oldEndPoint = StartPoint;
  310.         break;
  311. }
  312. break;
  314. case MESSAGE_RBUTTONDOWN:
  315. if(LRepeatTimes == 1)
  316. {
  317. m_DrawGrapObject.CancelDrawLine(pDC, StartPoint, EndPoint);
  318. LRepeatTimes = 0;
  319. }
  320. else 
  321. {
  322. command = DRAW_SELECT;
  323. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  324. LRepeatTimes = 0;
  325. }
  326. break;
  328. case MESSAGE_MOUSEMOVE:
  329. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  330. if(LRepeatTimes == 1)
  331. {
  332. EndPoint = point;
  333. m_DrawGrapObject.DrawLineXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  334. oldEndPoint = EndPoint;
  335. }
  336. break;
  338. case MESSAGE_SCROLL:
  339. if(LRepeatTimes == 1)
  340. {
  341. m_DrawGrapObject.CancelDrawLine(pDC, StartPoint, EndPoint);
  342.             oldEndPoint = StartPoint;
  343.     EndPoint = StartPoint;
  344. m_DrawGrapObject.SetOnceFlag();
  345. }
  346. break;
  347. }
  349. return command;
  350. }
  352. UINT CManageGraphObject::OnDrawRect(UINT msg, CPoint point)
  353. {
  354. int ObjectType;
  355. int ObjetcIndex;
  357. UINT command = DRAW_RECT;
  359. switch(msg)
  360. {
  361. case MESSAGE_LBUTTONDOWN:
  362. LRepeatTimes++;
  363. switch(LRepeatTimes)
  364. {
  365. case 1:
  366. StartPoint = point;
  367. m_DrawGrapObject.SetOnceFlag();
  368. break;
  370. case 2:
  371. EndPoint = point;
  372. m_DrawGrapObject.DrawRect(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  373. AddRect(StartPoint, EndPoint, LineStyle, PenColor);
  375.     ObjectType = OBJECT_RECT;
  376. ObjetcIndex = m_RectArray.GetUpperBound();
  377. pCommandStack->PushCommand(DRAW_RECT, 1, &ObjectType, &ObjetcIndex);
  379.     LRepeatTimes = 0;
  380. break;
  381. }
  382. break;
  384. case MESSAGE_RBUTTONDOWN:
  385. if(LRepeatTimes == 1)
  386. {
  387. m_DrawGrapObject.CancelDrawRect(pDC, StartPoint, EndPoint);
  388. LRepeatTimes = 0;
  389. }
  390. else
  391. {
  392. command = DRAW_SELECT;
  393. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  394. LRepeatTimes = 0;
  395. }
  396. break;
  398. case MESSAGE_MOUSEMOVE:
  399. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  400. if(LRepeatTimes == 1)
  401. {
  402. EndPoint = point;
  403. m_DrawGrapObject.DrawRectXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  404. oldEndPoint = EndPoint;
  405. }
  406. break;
  408. case MESSAGE_SCROLL:
  409. if(LRepeatTimes == 1)
  410. {
  411. m_DrawGrapObject.CancelDrawRect(pDC, StartPoint, EndPoint);
  412. oldEndPoint = StartPoint;
  413.     EndPoint = StartPoint;
  414. m_DrawGrapObject.SetOnceFlag();
  415. }
  416. break;
  417. }
  419. return command;
  420. }
  422. UINT CManageGraphObject::OnDrawCircle(UINT msg, CPoint point)
  423. {
  424. int ObjectType;
  425. int ObjetcIndex;
  427. UINT command = DRAW_CIRCLE;
  429. switch(msg)
  430. {
  431. case MESSAGE_LBUTTONDOWN:
  432. LRepeatTimes++;
  433.     switch(LRepeatTimes)
  434. {
  435. case 1:
  436. StartPoint = point;
  437.     m_DrawGrapObject.SetOnceFlag();
  438. break;
  440. case 2:
  441. EndPoint = point;
  442.     m_DrawGrapObject.DrawCircle(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  443. AddCircle(StartPoint, EndPoint, LineStyle, PenColor);
  445. ObjectType = OBJECT_CIRCLE;
  446. ObjetcIndex = m_CircleArray.GetUpperBound();
  447. pCommandStack->PushCommand(DRAW_CIRCLE, 1, &ObjectType, &ObjetcIndex);
  449. LRepeatTimes = 0;
  450. break;
  451. }
  452. break;
  454. case MESSAGE_RBUTTONDOWN:
  455. if(LRepeatTimes == 1)
  456. {
  457. m_DrawGrapObject.CancelDrawCircle(pDC, StartPoint, EndPoint);
  458. LRepeatTimes = 0;
  459. }
  460. else
  461. {
  462. command = DRAW_SELECT;
  463. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  464. LRepeatTimes = 0;
  465. }
  466. break;
  468. case MESSAGE_MOUSEMOVE:
  469. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  470. if(LRepeatTimes == 1)
  471. {
  472. EndPoint = point;
  473. m_DrawGrapObject.DrawCircleXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  474.             oldEndPoint = EndPoint;
  475. }
  476. break;
  478. case MESSAGE_SCROLL:
  479. if(LRepeatTimes == 1)
  480. {
  481. m_DrawGrapObject.CancelDrawCircle(pDC, StartPoint, EndPoint);
  482. oldEndPoint = StartPoint;
  483. EndPoint = StartPoint;
  484. m_DrawGrapObject.SetOnceFlag();
  485. }
  486. break;
  487. }
  489. return command;
  490. }
  492. UINT CManageGraphObject::OnDrawArc(UINT msg, CPoint point)
  493. {
  494. int ObjectType;
  495. int ObjetcIndex;
  497. UINT command = DRAW_ARC;
  499. switch(msg)
  500. {
  501. case MESSAGE_LBUTTONDOWN:
  502. LRepeatTimes++;
  503. switch(LRepeatTimes)
  504. {
  505. case 1:
  506. StartPoint = point;
  507. m_DrawGrapObject.SetOnceFlag();
  508.     break;
  510. case 2:
  511. MidPoint = point;
  512. m_DrawGrapObject.SetOnceFlag();
  513. break;
  515. case 3:
  516. EndPoint = point;
  517. m_DrawGrapObject.DrawArc(pDC, StartPoint, MidPoint, EndPoint, 
  518.                      LineStyle, PenColor);
  519. AddArc(StartPoint, MidPoint, EndPoint, LineStyle, PenColor); 
  521.      ObjectType = OBJECT_ARC;
  522. ObjetcIndex = m_ArcArray.GetUpperBound();
  523. pCommandStack->PushCommand(DRAW_ARC, 1, &ObjectType, &ObjetcIndex);
  525. LRepeatTimes = 0;
  526. break;
  527. }
  528. break;
  530. case MESSAGE_RBUTTONDOWN:
  531. if(LRepeatTimes > 0)
  532. {
  533. m_DrawGrapObject.CancelDrawArc(pDC, StartPoint, MidPoint, EndPoint, LRepeatTimes);
  534. LRepeatTimes = 0;
  535. }
  536. else
  537. {
  538. command = DRAW_SELECT;
  539. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  540. LRepeatTimes = 0;
  541. }
  542. break;
  544. case MESSAGE_MOUSEMOVE:
  545. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  546. switch(LRepeatTimes)
  547. {
  548. case 1:
  549. MidPoint = point;
  550. m_DrawGrapObject.DrawArcXOR(pDC, StartPoint, MidPoint, oldMidPoint,
  551.                         EndPoint, oldEndPoint, LRepeatTimes);
  552. oldMidPoint = MidPoint;
  553. break;
  555. case 2:
  556. EndPoint = point;
  557. m_DrawGrapObject.DrawArcXOR(pDC, StartPoint, MidPoint, oldMidPoint,
  558.                         EndPoint, oldEndPoint, LRepeatTimes);
  559. oldEndPoint = EndPoint;
  560. break;
  561. }
  562. break;
  564. case MESSAGE_SCROLL:
  565. m_DrawGrapObject.CancelDrawArc(pDC, StartPoint, MidPoint, EndPoint, LRepeatTimes);
  566. if(LRepeatTimes == 1)
  567. {
  568. oldMidPoint = StartPoint;
  569. MidPoint = StartPoint;
  570. }
  571. if(LRepeatTimes == 2)
  572. {
  573. oldEndPoint = StartPoint;
  574. EndPoint = StartPoint;
  575. }
  576.         m_DrawGrapObject.SetOnceFlag();
  577. break;
  578. }
  580. return command;
  581. }
  583. UINT CManageGraphObject::OnModifyDelete()
  584. {
  585. int* pObjectType;
  586. int* pObjetcIndex;
  588. int nIndex;
  589. int num;
  591. CGraphObjectInfo* pLineInfo;
  592. CGraphObjectInfo* pRectInfo;
  593. CGraphObjectInfo* pCircleInfo;
  594. CGraphObjectInfo* pArcInfo;
  596. CSelectedObjectInfo* pSelObjectInfo;
  598. num = m_SelObjInfoArray.GetSize();
  600. //如果没有图形对象被选中则返回
  601. if(num == 0)
  602. {
  603. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR1));
  604. return DRAW_SELECT;
  605. }
  607. pObjectType = new int[num];
  608. pObjetcIndex = new int[num];
  610. for(nIndex = 0; nIndex < num; nIndex++)
  611. {
  612. pSelObjectInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  613. switch(pSelObjectInfo->m_type)
  614. {
  615. case OBJECT_LINE:
  616. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pSelObjectInfo->m_index);
  617. pLineInfo->m_del = TRUE;
  619. pObjectType[nIndex] = OBJECT_LINE;
  620. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  621. break;
  623. case OBJECT_RECT:
  624. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pSelObjectInfo->m_index);
  625. pRectInfo->m_del = TRUE;
  627. pObjectType[nIndex] = OBJECT_RECT;
  628. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  629. break;
  631. case OBJECT_CIRCLE:
  632. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pSelObjectInfo->m_index);
  633. pCircleInfo->m_del = TRUE;
  635. pObjectType[nIndex] = OBJECT_CIRCLE;
  636. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  637. break;
  639. case OBJECT_ARC:
  640. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pSelObjectInfo->m_index);
  641. pArcInfo->m_del = TRUE;
  643. pObjectType[nIndex] = OBJECT_ARC;
  644. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  645. break;
  646. }
  647. }
  649. pCommandStack->PushCommand(MODIFY_DELETE, num, pObjectType, pObjetcIndex);
  650.     UnselectObject();
  651. pView->Invalidate();
  653. delete pObjectType;
  654. delete pObjetcIndex;
  656.     return DRAW_SELECT;
  657. }
  659. //实现“撤销”命令
  660. void CManageGraphObject::OnUndo()
  661. {
  662. CCommandStruct* pCommand;
  663. CGraphObjectInfo* pLineInfo;
  664. CGraphObjectInfo* pRectInfo;
  665. CGraphObjectInfo* pCircleInfo;
  666. CGraphObjectInfo* pArcInfo;
  668. pCommand = (CCommandStruct*)pCommandStack->Undo();
  669.     if(pCommand == NULL)
  670. return;
  672.     switch(pCommand->m_command)
  673. {
  674. case DRAW_LINE:
  675. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[0]);
  676.         pLineInfo->m_del = TRUE;
  677. break;
  679. case DRAW_RECT:
  680. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[0]);
  681.         pRectInfo->m_del = TRUE;
  682. break;
  684. case DRAW_CIRCLE:
  685. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[0]);
  686.         pCircleInfo->m_del = TRUE;
  687. break;
  689. case DRAW_ARC:
  690. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[0]);
  691.         pArcInfo->m_del = TRUE;
  692. break;
  694. case MODIFY_DELETE:
  695. for(int index =0; index < pCommand->m_num; index++)
  696. {
  697. switch(pCommand->m_object[index])
  698. {
  699. case OBJECT_LINE:
  700. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[index]);
  701. pLineInfo->m_del = FALSE;
  702. break;
  704. case OBJECT_RECT:
  705. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[index]);
  706. pRectInfo->m_del = FALSE;
  707. break;
  709. case OBJECT_CIRCLE:
  710. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[index]);
  711. pCircleInfo->m_del = FALSE;
  712. break;
  714. case OBJECT_ARC:
  715. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[index]);
  716. pArcInfo->m_del = FALSE;
  717. break;
  718. }
  719. }
  720. break;
  721. }
  723. }
  725. //实现“重做”命令
  726. void CManageGraphObject::OnRedo()
  727. {
  728. CCommandStruct* pCommand;
  729. CGraphObjectInfo* pLineInfo;
  730. CGraphObjectInfo* pRectInfo;
  731. CGraphObjectInfo* pCircleInfo;
  732. CGraphObjectInfo* pArcInfo;
  734. pCommand = (CCommandStruct*)pCommandStack->Redo();
  735. if(pCommand == NULL)
  736. return;
  738.     switch(pCommand->m_command)
  739. {
  740. case DRAW_LINE:
  741. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[0]);
  742.         pLineInfo->m_del = FALSE;
  743. break;
  745. case DRAW_RECT:
  746. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[0]);
  747.         pRectInfo->m_del = FALSE;
  748. break;
  750. case DRAW_CIRCLE:
  751. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[0]);
  752.         pCircleInfo->m_del = FALSE;
  753. break;
  755. case DRAW_ARC:
  756. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[0]);
  757.         pArcInfo->m_del = FALSE;
  758. break;
  760. case MODIFY_DELETE:
  761. for(int index =0; index < pCommand->m_num; index++)
  762. {
  763. switch(pCommand->m_object[index])
  764. {
  765. case OBJECT_LINE:
  766. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[index]);
  767. pLineInfo->m_del = TRUE;
  768. break;
  770. case OBJECT_RECT:
  771. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[index]);
  772. pRectInfo->m_del = TRUE;
  773. break;
  775. case OBJECT_CIRCLE:
  776. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[index]);
  777. pCircleInfo->m_del = TRUE;
  778. break;
  780. case OBJECT_ARC:
  781. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[index]);
  782. pArcInfo->m_del = TRUE;
  783. break;
  784. }
  785. }
  786. break;
  787. }
  788. }
  789. //////////////////////////////////////////////////////////////////////////////////////////////
  790. POINT CManageGraphObject::DrawingToLogic(FPOINT fpoint)
  791. {
  792. POINT point;
  793. point.x = long(fpoint.x * Proportion) + EXTRA_WIDTH;
  794. point.y = LogicSize.cy - (long)(fpoint.y * Proportion) - EXTRA_HIGTH;
  796. return point;
  797. }
  799. long CManageGraphObject::DrawingToLogic(float fdistance)
  800. {
  801. long distance;
  802. distance = (long)(fdistance * Proportion);
  804. return distance;
  805. }
  807. FPOINT CManageGraphObject::LogicToDrawing(POINT point)
  808. {
  809. FPOINT fpoint;
  810. fpoint.x = (float)(point.x - EXTRA_WIDTH) / Proportion;
  811. fpoint.y = (float)(LogicSize.cy - point.y  - EXTRA_HIGTH) / Proportion;
  813. return fpoint;
  814. }
  816. float CManageGraphObject::LogicToDrawing(long distance)
  817. {
  818. float fdistance;
  819. fdistance = (float)distance / Proportion;
  821. return fdistance;
  822. }
  824. void CManageGraphObject::GetObjectRange()
  825. {
  826. int index;
  828. // int n;
  829. CMyLine*      pLine;
  830. CMyRect*      pRect;
  831. CMyCircle*    pCircle;
  832. CMyArc*       pArc;
  834. CGraphObjectInfo* pLineInfo;
  835. CGraphObjectInfo* pRectInfo;
  836. CGraphObjectInfo* pCircleInfo;
  837. CGraphObjectInfo* pArcInfo;
  839. // n = m_LineArray.GetSize();
  840. // n = m_LineInfoArray.GetSize();
  841. for(index = 0; index < m_LineInfoArray.GetSize(); index++)
  842. {
  844. pLine = GetLine(index);
  845. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  846. pLineInfo->Initialize(GetLineRange(2, pLine), FALSE, FALSE);
  847. }
  849. for(index = 0; index < m_RectInfoArray.GetSize(); index++)
  850. {
  851. pRect = GetRect(index);
  852. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  853. pRectInfo->Initialize(GetRectRange(2, pRect), FALSE, FALSE);
  854. }
  856. for(index = 0; index < m_CircleInfoArray.GetSize(); index++)
  857. {
  858. pCircle = GetCircle(index);
  859. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  860. pCircleInfo->Initialize(GetCircleRange(2, pCircle), FALSE, FALSE);
  861. }
  863. for(index = 0; index < m_ArcInfoArray.GetSize(); index++)
  864. {
  865. pArc = GetArc(index);
  866. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  867. pArcInfo->Initialize(GetArcRange(2, pArc), FALSE, FALSE);
  868. }
  870. }
  872. void CManageGraphObject::SetEffectRect(CRect rect)
  873. {
  874. EffectRect = rect;
  875. }
  877. CRect CManageGraphObject::GetLogicClientRect()
  878. {
  879. CRect rect;
  880. ASSERT(pView != NULL);
  881. ASSERT(pDC != NULL);
  882. pView->GetClientRect(&rect);
  883. pDC->DPtoLP(&rect);
  884. return rect;
  885. }
  887. BOOL CManageGraphObject::IsInLogicClientRect(CRect rect)
  888. {
  889. CRect clientrect = GetLogicClientRect();
  890. CRect temp = clientrect & rect;
  891. if(temp.IsRectEmpty())
  892. return FALSE;
  893. else 
  894. return TRUE;
  895. }
  898. CRect CManageGraphObject::GetRedrawRect(CRect effectRect, CRect clientRect)
  899. {
  900. CRect rect;
  901.     rect = effectRect & clientRect;
  902. return rect;
  903. }
  906. BOOL CManageGraphObject::IsRedraw(CRect redrawRect, CRect objRect)
  907. {
  908. CRect rect;
  909.     
  910. rect = redrawRect & objRect;
  911. if(rect.IsRectEmpty())
  912. return FALSE;
  913. else 
  914. return TRUE;
  915. }
  916. ////////////////////////////////////////////////////////////////////////////////////////////////
  917. void CManageGraphObject::RedrawAllObject(CDC* pDC)
  918. {
  919. LogicClientRect = GetLogicClientRect();
  920. RedrawLine(pDC);
  921. RedrawRect(pDC);
  922. RedrawCircle(pDC);
  923. RedrawArc(pDC);
  924. }
  926. void CManageGraphObject::SelectObject(CDC* pDC, CPoint point)
  927. {
  928. SelectLine(pDC, point);   
  929. SelectRect(pDC, point);
  930. SelectCircle(pDC, point);
  931. SelectArc(pDC, point);
  932. }
  934. BOOL CManageGraphObject::UnselectObject()
  935. {
  936. BOOL flag = FALSE;
  937. int nIndex;
  939. if(UnselectLine())
  940. flag = TRUE;
  941. if(UnselectRect())
  942. flag = TRUE;
  943. if(UnselectCircle())
  944. flag = TRUE;
  945.     if(UnselectArc())
  946. flag = TRUE;
  947.     
  948. nIndex = m_SelObjInfoArray.GetSize();
  949. while(nIndex--)
  950. delete (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  951.     m_SelObjInfoArray.RemoveAll();
  953. return flag;
  954. }
  956. //////////////////////////////////////////////////////////////////////////////////////////////
  957. CRect CManageGraphObject::GetLineRange(long ExtraRange, CMyLine* pLine)
  958. {
  959. CRect rect;
  960. POINT start;
  961. POINT end;
  963. start = DrawingToLogic(pLine->m_start);
  964. end = DrawingToLogic(pLine->m_end);
  966. rect.left = start.x;
  967. rect.top = start.y;
  968. rect.right = end.x;
  969. rect.bottom = end.y;
  970. //注意必须对矩形规格化
  971. rect.NormalizeRect();
  973. rect.left -= ExtraRange;
  974. rect.top -= ExtraRange;
  975. rect.right += ExtraRange;
  976. rect.bottom += ExtraRange;
  978. return rect;
  979. }
  982. void CManageGraphObject::RedrawLine(CDC* pDC)
  983. {
  984. int index;
  985. CRect rect;
  987. CMyLine* pLine;
  988. CGraphObjectInfo* pLineInfo;
  990. index = m_LineArray.GetSize();
  991. while(index--)
  992. {
  993. pLine = (CMyLine*)m_LineArray.GetAt(index);
  994. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  996. //判断图形对象所在层是否被隐藏
  997. CFileLayer* pLayer = pManageLayer->GetLayer(pLine->m_layer);
  998. if(!pLayer->IsShow())
  999. continue;
  1001. //判断直线对象是否需要重画
  1002. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pLineInfo->m_rect))
  1003. continue;
  1005. if(pLineInfo->m_del == TRUE)
  1006. continue;
  1007. if(pLineInfo->m_selected == TRUE)
  1008. {
  1009. m_DrawGrapObject.DrawSelLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  1010.                          pLine->m_style, pLine->m_color);
  1011. continue;
  1012. }
  1013.         
  1014. m_DrawGrapObject.DrawLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  1015.                    pLine->m_style, pLine->m_color);
  1016.      }
  1017. }
  1019. void CManageGraphObject::SelectLine(CDC* pDC, CPoint point)
  1020. {
  1021. int nIndex;
  1022. long distance;
  1023. CRect rect;
  1025. CGraphObjectInfo* pLineInfo;
  1026. CSelectedObjectInfo* pSelObjInfo;
  1027. CMyLine* pLine; 
  1029. for(nIndex = 0; nIndex < m_LineInfoArray.GetSize(); nIndex++)
  1030. {
  1031. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(nIndex);
  1032. pLine = (CMyLine*)m_LineArray.GetAt(nIndex);
  1034. //判断图形对象所在层是否被隐藏
  1035. CFileLayer* pLayer = pManageLayer->GetLayer(pLine->m_layer);
  1036. if(!pLayer->IsShow())
  1037. continue;
  1039. if(pLineInfo ->m_del == TRUE || pLineInfo ->m_selected ==TRUE)
  1040. continue;
  1041.         
  1042. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1043. CRect region = pLineInfo->m_rect;
  1044. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1045.         if(!region.PtInRect(point))
  1046. continue;
  1048. rect.left = DrawingToLogic(pLine->m_start).x;
  1049. rect.top = DrawingToLogic(pLine->m_start).y;
  1050. rect.right = DrawingToLogic(pLine->m_end).x;
  1051. rect.bottom = DrawingToLogic(pLine->m_end).y;
  1053. if( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  1054.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) )
  1055. {
  1056. distance = (long)( abs( (rect.bottom - rect.top) * point.x - (rect.right - rect.left) * point.y + rect.top * (rect.right - rect.left) - rect.left * (rect.bottom - rect.top) )
  1057.        / sqrt( (rect.right - rect.left) * (rect.right - rect.left) + (rect.bottom - rect.top) * (rect.bottom - rect.top) ) );
  1059. if(distance <= SELECT_RANGE)
  1060. {
  1061.            m_DrawGrapObject.DrawSelLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  1062.                          pLine->m_style, pLine->m_color);
  1063. pLineInfo->m_selected = TRUE;
  1065. pSelObjInfo = new CSelectedObjectInfo(OBJECT_LINE, nIndex);
  1066. m_SelObjInfoArray.Add(pSelObjInfo);
  1067. }
  1068. }
  1069. }
  1070. }
  1072. BOOL CManageGraphObject::UnselectLine()
  1073. {
  1074. BOOL flag = FALSE;
  1075. int nIndex;
  1076. CSelectedObjectInfo* pSelObjInfo;
  1077. CGraphObjectInfo* pLineInfo;
  1078. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1079. {
  1080. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1081. if(pSelObjInfo->m_type ==OBJECT_LINE)
  1082. {
  1083. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pSelObjInfo->m_index);
  1084. pLineInfo->m_selected = FALSE;
  1085. flag = TRUE;
  1086.         }
  1087.     }
  1088. return flag;
  1089. }
  1091. void CManageGraphObject::AddLine(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  1092. {
  1093. FPOINT start;
  1094. FPOINT end;
  1096. start = LogicToDrawing(SPoint);
  1097. end = LogicToDrawing(EPoint);
  1099. CMyLine* pLine = new CMyLine(CurrentLayerName, start, end, Style, Color);
  1100. m_LineArray.Add(pLine);
  1102. CGraphObjectInfo* pLineInfo = new CGraphObjectInfo(GetLineRange(0, pLine), FALSE, FALSE);
  1103. m_LineInfoArray.Add(pLineInfo);
  1104. }
  1106. CMyLine* CManageGraphObject::GetLine(int index)
  1107. {
  1108. ASSERT(index >= 0 && index <= m_LineArray.GetUpperBound());
  1109. return (CMyLine*)m_LineArray.GetAt(index);
  1110. }
  1112. void CManageGraphObject::DelLine(int index)
  1113. {
  1114. ASSERT(index >= 0 && index <= m_LineArray.GetUpperBound());
  1116. delete (CMyLine*)m_LineArray.GetAt(index);
  1117. m_LineArray.RemoveAt(index);
  1119. delete (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  1120. m_LineInfoArray.RemoveAt(index);
  1121. }
  1125. void CManageGraphObject::DelAllLine()
  1126. {
  1127. int index;
  1128. index = m_LineArray.GetSize();
  1129. while(index--)
  1130. delete (CMyLine*)m_LineArray.GetAt(index);
  1131. m_LineArray.RemoveAll();
  1132.      
  1133. index = m_LineInfoArray.GetSize();
  1134. while(index--)
  1135. delete (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  1136. m_LineInfoArray.RemoveAll();
  1137. }
  1139. //////////////////////////////////////////////////////////////////////////////////////////////
  1140. CRect CManageGraphObject::GetRectRange(long ExtraRange, CMyRect* pRect)
  1141. {
  1142. CRect rect;
  1143. POINT start;
  1144. POINT end;
  1146. start = DrawingToLogic(pRect->m_start);
  1147. end = DrawingToLogic(pRect->m_end);
  1148. rect.left = start.x;
  1149. rect.top = start.y;
  1150. rect.right = end.x;
  1151. rect.bottom = end.y;
  1152. //注意必须对矩形规格化
  1153. rect.NormalizeRect();
  1155. rect.left -= ExtraRange;
  1156. rect.top -= ExtraRange;
  1157. rect.right += ExtraRange;
  1158. rect.bottom += ExtraRange;
  1159. return rect;
  1160. }
  1163. void CManageGraphObject::RedrawRect(CDC* pDC)
  1164. {
  1165. int index;
  1166. CMyRect* pRect;
  1167. CGraphObjectInfo* pRectInfo;
  1169. index = m_RectArray.GetSize();
  1171. //设置不填充状态
  1172. pDC->SelectStockObject(NULL_BRUSH);
  1173. while(index--)
  1174. {
  1175. pRect = (CMyRect*)m_RectArray.GetAt(index);
  1176. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  1178. //判断图形对象所在层是否被隐藏
  1179. CFileLayer* pLayer = pManageLayer->GetLayer(pRect->m_layer);
  1180. if(!pLayer->IsShow())
  1181. continue;
  1183. //判断矩形对象是否需要重画
  1184. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pRectInfo->m_rect))
  1185. continue;
  1187. if(pRectInfo->m_del == TRUE)
  1188. continue;
  1189. if(pRectInfo->m_selected == TRUE)
  1190. {
  1191. m_DrawGrapObject.DrawSelRect(pDC, DrawingToLogic(pRect->m_start), DrawingToLogic(pRect->m_end),
  1192.                          pRect->m_style, pRect->m_color);
  1193. continue;
  1194. }
  1196. m_DrawGrapObject.DrawRect(pDC, DrawingToLogic(pRect->m_start), DrawingToLogic(pRect->m_end),
  1197.                    pRect->m_style, pRect->m_color);
  1198.       
  1199. }
  1200. }
  1202. void CManageGraphObject::SelectRect(CDC* pDC, CPoint point)
  1203. {
  1204. int nIndex;
  1205. CRect rect;
  1207. CGraphObjectInfo* pRectInfo;
  1208. CSelectedObjectInfo* pSelObjInfo;
  1209. CMyRect* pRect; 
  1211. for(nIndex = 0; nIndex < m_RectInfoArray.GetSize(); nIndex++)
  1212. {
  1213. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(nIndex);
  1214. pRect = (CMyRect*)m_RectArray.GetAt(nIndex);
  1216. //判断图形对象所在层是否被隐藏
  1217. CFileLayer* pLayer = pManageLayer->GetLayer(pRect->m_layer);
  1218. if(!pLayer->IsShow())
  1219. continue;
  1221. if(pRectInfo ->m_del == TRUE || pRectInfo ->m_selected ==TRUE)
  1222. continue;
  1224. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1225. CRect region = pRectInfo->m_rect;
  1226. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1227.         if(!region.PtInRect(point))
  1228. continue;
  1230. rect.left = DrawingToLogic(pRect->m_start).x;
  1231. rect.top = DrawingToLogic(pRect->m_start).y;
  1232. rect.right = DrawingToLogic(pRect->m_end).x;
  1233. rect.bottom = DrawingToLogic(pRect->m_end).y;
  1235. if( ( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  1236.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) ) &&
  1237. ( (point.x <= min(rect.left, rect.right) + SELECT_RANGE) || (point.x >= max(rect.left, rect.right) - SELECT_RANGE) ||
  1238.             (point.y <= min(rect.top, rect.bottom) + SELECT_RANGE) || (point.y >= max(rect.top, rect.bottom) - SELECT_RANGE) ) ) 
  1240. {
  1241. m_DrawGrapObject.DrawSelRect(pDC, rect.TopLeft(), rect.BottomRight(), 
  1242.                          pRect->m_style, pRect->m_color);
  1244. pRectInfo->m_selected = TRUE;
  1246. pSelObjInfo = new CSelectedObjectInfo(OBJECT_RECT, nIndex);
  1247. m_SelObjInfoArray.Add(pSelObjInfo);
  1248. }
  1249. }
  1251. }
  1253. BOOL CManageGraphObject::UnselectRect()
  1254. {
  1255. BOOL flag = FALSE;
  1256. int nIndex;
  1257. CSelectedObjectInfo* pSelObjInfo;
  1258. CGraphObjectInfo* pRectInfo;
  1259. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1260. {
  1261. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1262. if(pSelObjInfo->m_type ==OBJECT_RECT)
  1263. {
  1264. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pSelObjInfo->m_index);
  1265. pRectInfo->m_selected = FALSE;
  1266. flag = TRUE;
  1267.         }
  1268.     }
  1269. return flag;
  1270. }
  1272. void CManageGraphObject::AddRect(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  1273. {
  1274. FPOINT start;
  1275. FPOINT end;
  1277. start = LogicToDrawing(SPoint);
  1278. end = LogicToDrawing(EPoint);
  1279.     
  1280. CMyRect* pRect = new CMyRect(CurrentLayerName, start, end, Style, Color);
  1281. m_RectArray.Add(pRect);
  1283. CGraphObjectInfo * pRectInfo = new CGraphObjectInfo(GetRectRange(0, pRect), FALSE, FALSE);
  1284. m_RectInfoArray.Add(pRectInfo);
  1285. }
  1287. CMyRect* CManageGraphObject::GetRect(int index)
  1288. {
  1289. ASSERT(index >= 0 && index <= m_RectArray.GetUpperBound());
  1290. return (CMyRect*)m_RectArray.GetAt(index);
  1291. }
  1293. void CManageGraphObject::DelRect(int index)
  1294. {
  1295. ASSERT(index >= 0 && index <= m_RectArray.GetUpperBound());
  1297. delete (CMyRect*)m_RectArray.GetAt(index);
  1298. m_RectArray.RemoveAt(index);
  1300. delete (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  1301. m_RectInfoArray.RemoveAt(index);
  1302. }
  1304. void CManageGraphObject::DelAllRect()
  1305. {
  1306. int index;
  1308. index = m_RectArray.GetSize();
  1309. while(index--)
  1310. delete (CMyRect*)m_RectArray.GetAt(index);
  1311. m_RectArray.RemoveAll();
  1313. index = m_RectInfoArray.GetSize();
  1314. while(index--)
  1315. delete (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  1316. m_RectInfoArray.RemoveAll();
  1317. }
  1319. //////////////////////////////////////////////////////////////////////////////////////////////
  1320. CRect CManageGraphObject::GetCircleRange(long ExtraRange, CMyCircle* pCircle)
  1321. {
  1322. CRect rect;
  1323. POINT origin;
  1324. long Radius;
  1326. origin = DrawingToLogic(pCircle->m_origin);
  1327. Radius = DrawingToLogic(pCircle->m_radius);
  1328. rect.left = origin.x - Radius - ExtraRange;
  1329. rect.top = origin.y - Radius - ExtraRange;
  1330. rect.right = origin.x + Radius + ExtraRange;
  1331. rect.bottom = origin.y + Radius + ExtraRange;
  1332. rect.NormalizeRect();
  1333. return rect;
  1334. }
  1337. void CManageGraphObject::RedrawCircle(CDC* pDC)
  1338. {
  1339. int index;
  1340. CMyCircle* pCircle;
  1341. CGraphObjectInfo* pCircleInfo;
  1343. index = m_CircleArray.GetSize();
  1345. //设置不填充状态
  1346. pDC->SelectStockObject(NULL_BRUSH);
  1347. while(index--)
  1348. {
  1349. pCircle = (CMyCircle*)m_CircleArray.GetAt(index);
  1350. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  1352. //判断图形对象所在层是否被隐藏
  1353. CFileLayer* pLayer = pManageLayer->GetLayer(pCircle->m_layer);
  1354. if(!pLayer->IsShow())
  1355. continue;
  1357. //判断圆对象是否需要重画
  1358. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pCircleInfo->m_rect))
  1359. continue;
  1361. if(pCircleInfo->m_del == TRUE)
  1362. continue;
  1363. if(pCircleInfo->m_selected == TRUE)
  1364. {
  1365. m_DrawGrapObject.DrawSelCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius), 
  1366.                            pCircle->m_style, pCircle->m_color);
  1367. continue;
  1368. }
  1370. m_DrawGrapObject.DrawCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius),
  1371.                          pCircle->m_style, pCircle->m_color);
  1372.    }
  1373. }
  1376. void CManageGraphObject::SelectCircle(CDC* pDC, CPoint point)
  1377. {
  1378. int nIndex;
  1379. POINT origin;
  1380. long r;
  1381. long distance;
  1383. CGraphObjectInfo* pCircleInfo;
  1384. CSelectedObjectInfo* pSelObjInfo;
  1385. CMyCircle* pCircle; 
  1387. for(nIndex = 0; nIndex < m_CircleInfoArray.GetSize(); nIndex++)
  1388. {
  1389. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(nIndex);
  1390. pCircle = (CMyCircle*)m_CircleArray.GetAt(nIndex);
  1392. //判断图形对象所在层是否被隐藏
  1393. CFileLayer* pLayer = pManageLayer->GetLayer(pCircle->m_layer);
  1394. if(!pLayer->IsShow())
  1395. continue;
  1397. if(pCircleInfo ->m_del == TRUE || pCircleInfo ->m_selected ==TRUE)
  1398. continue;
  1400. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1401. CRect region = pCircleInfo->m_rect;
  1402. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1403.         if(!region.PtInRect(point))
  1404. continue;
  1406. origin = DrawingToLogic(pCircle->m_origin);
  1407. r = DrawingToLogic(pCircle->m_radius);
  1409. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  1411. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  1412. {
  1413. m_DrawGrapObject.DrawSelCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius),
  1414.                            pCircle->m_style, pCircle->m_color);
  1416. pCircleInfo->m_selected = TRUE;
  1418. pSelObjInfo = new CSelectedObjectInfo(OBJECT_CIRCLE, nIndex);
  1419. m_SelObjInfoArray.Add(pSelObjInfo);
  1420. }
  1421. }
  1423. }
  1425. BOOL CManageGraphObject::UnselectCircle()
  1426. {
  1427. BOOL flag = FALSE;
  1428. int nIndex;
  1429. CSelectedObjectInfo* pSelObjInfo;
  1430. CGraphObjectInfo* pCircleInfo;
  1431. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1432. {
  1433. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1434. if(pSelObjInfo->m_type ==OBJECT_CIRCLE)
  1435. {
  1436. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pSelObjInfo->m_index);
  1437. pCircleInfo->m_selected = FALSE;
  1438. flag = TRUE;
  1439.         }
  1440.     }
  1441. return flag;
  1442. }
  1444. void CManageGraphObject::AddCircle(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  1445. {
  1446. FPOINT start;
  1447. FPOINT end;
  1448. float r;
  1450. start = LogicToDrawing(SPoint);
  1451. end = LogicToDrawing(EPoint);
  1452. r = (float)sqrt(pow(start.x - end.x, 2) + pow(start.y - end.y, 2));
  1454. CMyCircle* pCircle = new CMyCircle(CurrentLayerName, start, r, Style, Color);
  1455. m_CircleArray.Add(pCircle);
  1456. CGraphObjectInfo* pCircleInfo = new CGraphObjectInfo(GetCircleRange(0, pCircle), FALSE, FALSE);
  1457. m_CircleInfoArray.Add(pCircleInfo);
  1458. }
  1460. CMyCircle* CManageGraphObject::GetCircle(int index)
  1461. {
  1462. ASSERT(index >= 0 && index <= m_CircleArray.GetUpperBound());
  1463. return (CMyCircle*)m_CircleArray.GetAt(index);
  1464. }
  1466. void CManageGraphObject::DelCircle(int index)
  1467. {
  1468. ASSERT(index >= 0 && index <= m_CircleArray.GetUpperBound());
  1470. delete (CMyCircle*)m_CircleArray.GetAt(index);
  1471. m_CircleArray.RemoveAt(index);
  1473. delete (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  1474. m_CircleInfoArray.RemoveAt(index);
  1475. }
  1477. void CManageGraphObject::DelAllCircle()
  1478. {
  1479. int index;
  1481. index = m_CircleArray.GetSize();
  1482. while(index--)
  1483. delete (CMyCircle*)m_CircleArray.GetAt(index);
  1484. m_CircleArray.RemoveAll();
  1486. index = m_CircleInfoArray.GetSize();
  1487. while(index--)
  1488. delete (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  1489. m_CircleInfoArray.RemoveAll();
  1490. }
  1492. //////////////////////////////////////////////////////////////////////////////////////////////
  1493. CRect CManageGraphObject::GetArcRange(long ExtraRange, CMyArc* pArc)
  1494. {
  1495. CRect rect;
  1496. POINT origin;
  1497. long Radius;
  1499. origin = DrawingToLogic(pArc->m_origin);
  1500. Radius = DrawingToLogic(pArc->m_radius);
  1501. rect.left = origin.x - Radius - ExtraRange;
  1502. rect.top = origin.y - Radius - ExtraRange;
  1503. rect.right = origin.x + Radius + ExtraRange;
  1504. rect.bottom = origin.y + Radius + ExtraRange;
  1505. rect.NormalizeRect();
  1506. return rect;
  1507. }
  1509. void CManageGraphObject::RedrawArc(CDC* pDC)
  1510. {
  1511. int index;
  1512. CMyArc* pArc;
  1513. CGraphObjectInfo* pArcInfo;
  1515. index = m_ArcArray.GetSize();
  1517. //设置不填充状态
  1518. pDC->SelectStockObject(NULL_BRUSH);
  1519. while(index--)
  1520. {
  1521. pArc = (CMyArc*)m_ArcArray.GetAt(index);
  1522. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1524. //判断图形对象所在层是否被隐藏
  1525. CFileLayer* pLayer = pManageLayer->GetLayer(pArc->m_layer);
  1526. if(!pLayer->IsShow())
  1527. continue;
  1529. //判断圆弧对象是否需要重画
  1530. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pArcInfo->m_rect))
  1531. continue;
  1533. if(pArcInfo->m_del == TRUE)
  1534. continue;
  1535. if(pArcInfo->m_selected == TRUE)
  1536. {
  1537. m_DrawGrapObject.DrawSelArc(pDC, DrawingToLogic(pArc->m_origin), DrawingToLogic(pArc->m_start), 
  1538.                         DrawingToLogic(pArc->m_end),
  1539. DrawingToLogic(pArc->m_radius), LineStyle, PenColor);
  1540. continue;
  1541. }
  1542.          
  1544. m_DrawGrapObject.DrawArc(pDC, DrawingToLogic(pArc->m_origin),
  1545.                      DrawingToLogic(pArc->m_start), DrawingToLogic(pArc->m_end),
  1546.                                  DrawingToLogic(pArc->m_radius), pArc->m_style, pArc->m_color);
  1547. }
  1548. }
  1551. void CManageGraphObject::SelectArc(CDC* pDC, CPoint point)
  1552. {
  1553. int nIndex;
  1555. POINT origin;
  1556. long r;
  1557. long distance;
  1559. CPoint start;
  1560. CPoint end;
  1562. CGraphObjectInfo* pArcInfo;
  1563. CSelectedObjectInfo* pSelObjInfo;
  1564. CMyArc* pArc; 
  1566. for(nIndex = 0; nIndex < m_ArcInfoArray.GetSize(); nIndex++)
  1567. {
  1568. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(nIndex);
  1569. pArc = (CMyArc*)m_ArcArray.GetAt(nIndex);
  1571. //判断图形对象所在层是否被隐藏
  1572. CFileLayer* pLayer = pManageLayer->GetLayer(pArc->m_layer);
  1573. if(!pLayer->IsShow())
  1574. continue;
  1576. if(pArcInfo ->m_del == TRUE || pArcInfo ->m_selected ==TRUE)
  1577. continue;
  1579. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1580. CRect region = pArcInfo->m_rect;
  1581. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1582.         if(!region.PtInRect(point))
  1583. continue;
  1585. origin = DrawingToLogic(pArc->m_origin);
  1586. start = DrawingToLogic(pArc->m_start);
  1587. end = DrawingToLogic(pArc->m_end);
  1588. r = DrawingToLogic(pArc->m_radius);
  1590. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  1592. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  1593. {
  1594. m_DrawGrapObject.DrawSelArc(pDC, origin, start, end, r, pArc->m_style, pArc->m_color);
  1596. pArcInfo->m_selected = TRUE;
  1597. pSelObjInfo = new CSelectedObjectInfo(OBJECT_ARC, nIndex);
  1598. m_SelObjInfoArray.Add(pSelObjInfo);
  1599. }
  1600. }
  1601. }
  1603. BOOL CManageGraphObject::UnselectArc()
  1604. {
  1605. BOOL flag = FALSE;
  1606. int nIndex;
  1607. CSelectedObjectInfo* pSelObjInfo;
  1608. CGraphObjectInfo* pArcInfo;
  1609. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1610. {
  1611. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1612. if(pSelObjInfo->m_type ==OBJECT_ARC)
  1613. {
  1614. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pSelObjInfo->m_index);
  1615. pArcInfo->m_selected = FALSE;
  1616. flag = TRUE;
  1617.         }
  1618.     }
  1619. return flag;
  1620. }
  1623. void CManageGraphObject::AddArc(POINT SPoint, POINT MPoint, POINT EPoint, int Style, COLORREF Color)
  1624. {
  1625. long x1, y1, x2, y2;
  1627. double originX;
  1628. double originY;
  1629. double k1;
  1630. double k2;
  1631. double mid1X;
  1632. double mid1Y;
  1633. double mid2X;
  1634. double mid2Y;
  1636. POINT OPoint;
  1637. long Radius;
  1639. CMyArc* pArc;
  1641. if(SPoint.y == MPoint.y)
  1642. k1 = 1000000.0;
  1643. else 
  1644. k1 = (- (double)(SPoint.x - MPoint.x) / (double)(SPoint.y - MPoint.y));
  1646. if(EPoint.y == MPoint.y)
  1647. k2 = 1000000.0;
  1648. else 
  1649. k2 =  (- (double)(EPoint.x - MPoint.x) / (double)(EPoint.y - MPoint.y));
  1651. mid1X = (double)(SPoint.x + MPoint.x) / 2.0;
  1652. mid1Y = (double)(SPoint.y + MPoint.y) / 2.0;
  1654. mid2X = (double)(EPoint.x + MPoint.x) / 2.0;
  1655. mid2Y = (double)(EPoint.y + MPoint.y) / 2.0;
  1657. if(k1 == k2)
  1658. return;
  1660. if(k1 == 1000000.0)
  1661. {
  1662. originX = mid1X;
  1663. originY = k2 * (originX - mid2X) + mid2Y;
  1664. }
  1665. else
  1666. if(k2 == 1000000.0)
  1667. {
  1668. originX = mid2X;
  1669. originY = k1 * (originX - mid1X) + mid1Y;
  1670. }
  1671. else
  1672. {
  1673. originX = ((k2 * mid2X - k1 * mid1X) - (mid2Y - mid1Y)) / (k2 - k1);
  1674. originY = k2 * (originX - mid2X) + mid2Y;
  1675. }
  1677. Radius = (long)sqrt(pow((double)(originX - SPoint.x), 2) + pow((double)(originY - SPoint.y), 2));
  1679. OPoint.x = (long)originX;
  1680. OPoint.y = (long)originY ;
  1682. x1 = MidPoint.x - SPoint.x;
  1683. y1 = MPoint.y - SPoint.y;
  1685. x2 = EPoint.x - SPoint.x;
  1686. y2 = EPoint.y - SPoint.y;
  1688. if(x1*y2 - x2*y1 < 0)
  1689. pArc = new CMyArc(CurrentLayerName, LogicToDrawing(OPoint),
  1690.                   LogicToDrawing(SPoint), LogicToDrawing(EPoint), 
  1691.   LogicToDrawing(Radius), LineStyle, PenColor);
  1692. else
  1693. pArc = new CMyArc(CurrentLayerName, LogicToDrawing(OPoint), 
  1694.                   LogicToDrawing(EPoint), LogicToDrawing(SPoint), 
  1695.   LogicToDrawing(Radius), LineStyle, PenColor);
  1697. m_ArcArray.Add(pArc);
  1699. CGraphObjectInfo* pArcInfo = new CGraphObjectInfo(GetArcRange(0, pArc), FALSE, FALSE);
  1700. m_ArcInfoArray.Add(pArcInfo);
  1701. }
  1704. CMyArc* CManageGraphObject::GetArc(int index)
  1705. {
  1706. ASSERT(index >= 0 && index <= m_ArcArray.GetUpperBound());
  1707. return (CMyArc*)m_ArcArray.GetAt(index);
  1708. }
  1710. void CManageGraphObject::DelArc(int index)
  1711. {
  1712. ASSERT(index >= 0 && index <= m_ArcArray.GetUpperBound());
  1714. delete (CMyArc*)m_ArcArray.GetAt(index);
  1715. m_ArcArray.RemoveAt(index);
  1717. delete (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1718. m_ArcInfoArray.RemoveAt(index);
  1719. }
  1721. void CManageGraphObject::DelAllArc()
  1722. {
  1723. int index;
  1725. index = m_ArcArray.GetSize();
  1726. while(index--)
  1727. delete (CMyArc*)m_ArcArray.GetAt(index);
  1728. m_ArcArray.RemoveAll();
  1730. index = m_ArcInfoArray.GetSize();
  1731. while(index--)
  1732. delete (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1733. m_ArcInfoArray.RemoveAll();
  1734. }