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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
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. LogicViewSize = size;
  37. LineStyle = style;
  38. PenColor = color;
  40. GetObjectRange();
  41. }
  43. void CManageGraphObject::SetLogicViewSize(SIZE size)
  44. {
  45. LogicViewSize.cx = size.cx;
  46. LogicViewSize.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. OnModifyDelete(msg, point);
  186. break;
  187. }
  188. }
  190. UINT CManageGraphObject::OnRButtonDown(UINT ID, CPoint point)
  191. {
  192. ASSERT(pDC != NULL);
  194. UINT msg = MESSAGE_RBUTTONDOWN;
  196. switch(ID)
  197. {
  198. case DRAW_SELECT:
  199. if(UnselectObject())
  200. pView->Invalidate();
  201. break;
  203. case DRAW_LINE:
  204. ID = OnDrawLine(msg, point);
  205. break;
  207. case DRAW_RECT:
  208. ID = OnDrawRect(msg, point);
  209. break;
  211. case DRAW_CIRCLE:
  212. ID = OnDrawCircle(msg, point);
  213. break;
  215. case DRAW_ARC:
  216. ID = OnDrawArc(msg, point);
  217. break;
  219. case MODIFY_DELETE:
  220. ID = OnModifyDelete(msg, point);
  221. break;
  222. }
  224. return ID;
  225. }
  227. void CManageGraphObject::OnMouseMove(UINT ID, CPoint point)
  228. {
  229. ASSERT(pDC != NULL);
  231. UINT msg = MESSAGE_MOUSEMOVE;
  233. switch(ID)
  234. {
  235. case DRAW_SELECT:
  236. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  237. break;
  239. case DRAW_LINE:
  240.         OnDrawLine(msg, point); 
  241. break;
  243. case DRAW_RECT:
  244. OnDrawRect(msg, point);
  245. break;
  247. case DRAW_CIRCLE:
  248. OnDrawCircle(msg, point);
  249. break;
  251. case DRAW_ARC:
  252. OnDrawArc(msg, point);
  253. break;
  255. case MODIFY_DELETE:
  256. OnModifyDelete(msg, point);
  257. break;
  258. }
  259. }
  261. void CManageGraphObject::OnScroll(UINT ID)
  262. {
  263. ASSERT(pDC != NULL);
  264.     
  265. UINT msg = MESSAGE_SCROLL;
  267. switch(ID)
  268. {
  269. case DRAW_LINE:
  270. OnDrawLine(msg, NULL);
  271. break;
  273. case DRAW_RECT:
  274. OnDrawRect(msg, NULL);
  275. break;
  277. case DRAW_CIRCLE:
  278. OnDrawCircle(msg, NULL);
  279. break;
  281. case DRAW_ARC:
  282. OnDrawArc(msg, NULL);
  283. break;
  284. }
  285.  
  286. }
  288. UINT CManageGraphObject::OnDrawLine(UINT msg, CPoint point)
  289. {
  290. int ObjectType;
  291. int ObjetcIndex;
  292.     
  293. UINT command = DRAW_LINE;
  295. switch(msg)
  296. {
  297. case MESSAGE_LBUTTONDOWN:
  298. LRepeatTimes++;
  299. switch(LRepeatTimes)
  300. {
  301. case 1:
  302. StartPoint = point;
  303. m_DrawGrapObject.SetOnceFlag();
  304. break;
  306. case 2:
  307. EndPoint = point;
  308.         m_DrawGrapObject.DrawLine(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  309.         AddLine(StartPoint, EndPoint, LineStyle, PenColor);
  311.         ObjectType = OBJECT_LINE;
  312.         ObjetcIndex = m_LineArray.GetUpperBound();
  313.         //因为执行一项新操作后，将不再有可以Redo的命令
  314.         pCommandStack->PushCommand(DRAW_LINE, 1, &ObjectType, &ObjetcIndex);
  315.         
  316.         LRepeatTimes--;
  317.         StartPoint = EndPoint;
  318. oldEndPoint = StartPoint;
  319.         break;
  320. }
  321. break;
  323. case MESSAGE_RBUTTONDOWN:
  324. if(LRepeatTimes == 1)
  325. {
  326. m_DrawGrapObject.CancelDrawLine(pDC, StartPoint, EndPoint);
  327. LRepeatTimes = 0;
  328. }
  329. else 
  330. {
  331. command = DRAW_SELECT;
  332. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  333. LRepeatTimes = 0;
  334. }
  335. break;
  337. case MESSAGE_MOUSEMOVE:
  338. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  339. if(LRepeatTimes == 1)
  340. {
  341. EndPoint = point;
  342. m_DrawGrapObject.DrawLineXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  343. oldEndPoint = EndPoint;
  344. }
  345. break;
  347. case MESSAGE_SCROLL:
  348. if(LRepeatTimes == 1)
  349. {
  350. m_DrawGrapObject.CancelDrawLine(pDC, StartPoint, EndPoint);
  351.             oldEndPoint = StartPoint;
  352.     EndPoint = StartPoint;
  353. m_DrawGrapObject.SetOnceFlag();
  354. }
  355. break;
  356. }
  358. return command;
  359. }
  361. UINT CManageGraphObject::OnDrawRect(UINT msg, CPoint point)
  362. {
  363. int ObjectType;
  364. int ObjetcIndex;
  366. UINT command = DRAW_RECT;
  368. switch(msg)
  369. {
  370. case MESSAGE_LBUTTONDOWN:
  371. LRepeatTimes++;
  372. switch(LRepeatTimes)
  373. {
  374. case 1:
  375. StartPoint = point;
  376. m_DrawGrapObject.SetOnceFlag();
  377. break;
  379. case 2:
  380. EndPoint = point;
  381. m_DrawGrapObject.DrawRect(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  382. AddRect(StartPoint, EndPoint, LineStyle, PenColor);
  384.     ObjectType = OBJECT_RECT;
  385. ObjetcIndex = m_RectArray.GetUpperBound();
  386. pCommandStack->PushCommand(DRAW_RECT, 1, &ObjectType, &ObjetcIndex);
  388.     LRepeatTimes = 0;
  389. break;
  390. }
  391. break;
  393. case MESSAGE_RBUTTONDOWN:
  394. if(LRepeatTimes == 1)
  395. {
  396. m_DrawGrapObject.CancelDrawRect(pDC, StartPoint, EndPoint);
  397. LRepeatTimes = 0;
  398. }
  399. else
  400. {
  401. command = DRAW_SELECT;
  402. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  403. LRepeatTimes = 0;
  404. }
  405. break;
  407. case MESSAGE_MOUSEMOVE:
  408. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  409. if(LRepeatTimes == 1)
  410. {
  411. EndPoint = point;
  412. m_DrawGrapObject.DrawRectXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  413. oldEndPoint = EndPoint;
  414. }
  415. break;
  417. case MESSAGE_SCROLL:
  418. if(LRepeatTimes == 1)
  419. {
  420. m_DrawGrapObject.CancelDrawRect(pDC, StartPoint, EndPoint);
  421. oldEndPoint = StartPoint;
  422.     EndPoint = StartPoint;
  423. m_DrawGrapObject.SetOnceFlag();
  424. }
  425. break;
  426. }
  428. return command;
  429. }
  431. UINT CManageGraphObject::OnDrawCircle(UINT msg, CPoint point)
  432. {
  433. int ObjectType;
  434. int ObjetcIndex;
  436. UINT command = DRAW_CIRCLE;
  438. switch(msg)
  439. {
  440. case MESSAGE_LBUTTONDOWN:
  441. LRepeatTimes++;
  442.     switch(LRepeatTimes)
  443. {
  444. case 1:
  445. StartPoint = point;
  446.     m_DrawGrapObject.SetOnceFlag();
  447. break;
  449. case 2:
  450. EndPoint = point;
  451.     m_DrawGrapObject.DrawCircle(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  452. AddCircle(StartPoint, EndPoint, LineStyle, PenColor);
  454. ObjectType = OBJECT_CIRCLE;
  455. ObjetcIndex = m_CircleArray.GetUpperBound();
  456. pCommandStack->PushCommand(DRAW_CIRCLE, 1, &ObjectType, &ObjetcIndex);
  458. LRepeatTimes = 0;
  459. break;
  460. }
  461. break;
  463. case MESSAGE_RBUTTONDOWN:
  464. if(LRepeatTimes == 1)
  465. {
  466. m_DrawGrapObject.CancelDrawCircle(pDC, StartPoint, EndPoint);
  467. LRepeatTimes = 0;
  468. }
  469. else
  470. {
  471. command = DRAW_SELECT;
  472. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  473. LRepeatTimes = 0;
  474. }
  475. break;
  477. case MESSAGE_MOUSEMOVE:
  478. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  479. if(LRepeatTimes == 1)
  480. {
  481. EndPoint = point;
  482. m_DrawGrapObject.DrawCircleXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  483.             oldEndPoint = EndPoint;
  484. }
  485. break;
  487. case MESSAGE_SCROLL:
  488. if(LRepeatTimes == 1)
  489. {
  490. m_DrawGrapObject.CancelDrawCircle(pDC, StartPoint, EndPoint);
  491. oldEndPoint = StartPoint;
  492. EndPoint = StartPoint;
  493. m_DrawGrapObject.SetOnceFlag();
  494. }
  495. break;
  496. }
  498. return command;
  499. }
  501. UINT CManageGraphObject::OnDrawArc(UINT msg, CPoint point)
  502. {
  503. int ObjectType;
  504. int ObjetcIndex;
  506. UINT command = DRAW_ARC;
  508. switch(msg)
  509. {
  510. case MESSAGE_LBUTTONDOWN:
  511. LRepeatTimes++;
  512. switch(LRepeatTimes)
  513. {
  514. case 1:
  515. StartPoint = point;
  516. m_DrawGrapObject.SetOnceFlag();
  517.     break;
  519. case 2:
  520. MidPoint = point;
  521. m_DrawGrapObject.SetOnceFlag();
  522. break;
  524. case 3:
  525. EndPoint = point;
  526. m_DrawGrapObject.DrawArc(pDC, StartPoint, MidPoint, EndPoint, 
  527.                      LineStyle, PenColor);
  528. AddArc(StartPoint, MidPoint, EndPoint, LineStyle, PenColor); 
  530.      ObjectType = OBJECT_ARC;
  531. ObjetcIndex = m_ArcArray.GetUpperBound();
  532. pCommandStack->PushCommand(DRAW_ARC, 1, &ObjectType, &ObjetcIndex);
  534. LRepeatTimes = 0;
  535. break;
  536. }
  537. break;
  539. case MESSAGE_RBUTTONDOWN:
  540. if(LRepeatTimes > 0)
  541. {
  542. m_DrawGrapObject.CancelDrawArc(pDC, StartPoint, MidPoint, EndPoint, LRepeatTimes);
  543. LRepeatTimes = 0;
  544. }
  545. else
  546. {
  547. command = DRAW_SELECT;
  548. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  549. LRepeatTimes = 0;
  550. }
  551. break;
  553. case MESSAGE_MOUSEMOVE:
  554. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  555. switch(LRepeatTimes)
  556. {
  557. case 1:
  558. MidPoint = point;
  559. m_DrawGrapObject.DrawArcXOR(pDC, StartPoint, MidPoint, oldMidPoint,
  560.                         EndPoint, oldEndPoint, LRepeatTimes);
  561. oldMidPoint = MidPoint;
  562. break;
  564. case 2:
  565. EndPoint = point;
  566. m_DrawGrapObject.DrawArcXOR(pDC, StartPoint, MidPoint, oldMidPoint,
  567.                         EndPoint, oldEndPoint, LRepeatTimes);
  568. oldEndPoint = EndPoint;
  569. break;
  570. }
  571. break;
  573. case MESSAGE_SCROLL:
  574. m_DrawGrapObject.CancelDrawArc(pDC, StartPoint, MidPoint, EndPoint, LRepeatTimes);
  575. if(LRepeatTimes == 1)
  576. {
  577. oldMidPoint = StartPoint;
  578. MidPoint = StartPoint;
  579. }
  580. if(LRepeatTimes == 2)
  581. {
  582. oldEndPoint = StartPoint;
  583. EndPoint = StartPoint;
  584. }
  585.         m_DrawGrapObject.SetOnceFlag();
  586. break;
  587. }
  589. return command;
  590. }
  592. UINT CManageGraphObject::OnModifyDelete(UINT msg, CPoint point)
  593. {
  594. int* pObjectType;
  595. int* pObjetcIndex;
  597. int nIndex;
  598. int num;
  600. CGraphObjectInfo* pLineInfo;
  601. CGraphObjectInfo* pRectInfo;
  602. CGraphObjectInfo* pCircleInfo;
  603. CGraphObjectInfo* pArcInfo;
  605. CSelectedObjectInfo* pSelObjectInfo;
  607. switch(msg)
  608. {
  609. case MESSAGE_LBUTTONDOWN:
  610. SelectObject(pDC, point);
  611. break;
  613.     case MESSAGE_MOUSEMOVE:
  614. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR1));
  615. break;
  617. case NULL:
  618. case MESSAGE_RBUTTONDOWN:
  619. num = m_SelObjInfoArray.GetSize();
  621. //如果没有图形对象被选中则返回
  622. if(num == 0)
  623. {
  624. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR1));
  625. return MODIFY_DELETE;
  626. }
  628. pObjectType = new int[num];
  629. pObjetcIndex = new int[num];
  631. for(nIndex = 0; nIndex < num; nIndex++)
  632. {
  633. pSelObjectInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  634. switch(pSelObjectInfo->m_type)
  635. {
  636. case OBJECT_LINE:
  637. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pSelObjectInfo->m_index);
  638. pLineInfo->m_del = TRUE;
  640. pObjectType[nIndex] = OBJECT_LINE;
  641. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  642. break;
  644. case OBJECT_RECT:
  645. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pSelObjectInfo->m_index);
  646. pRectInfo->m_del = TRUE;
  648. pObjectType[nIndex] = OBJECT_RECT;
  649. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  650. break;
  652. case OBJECT_CIRCLE:
  653. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pSelObjectInfo->m_index);
  654. pCircleInfo->m_del = TRUE;
  656. pObjectType[nIndex] = OBJECT_CIRCLE;
  657. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  658. break;
  660. case OBJECT_ARC:
  661. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pSelObjectInfo->m_index);
  662. pArcInfo->m_del = TRUE;
  664. pObjectType[nIndex] = OBJECT_ARC;
  665. pObjetcIndex[nIndex] = pSelObjectInfo->m_index;
  666. break;
  667. }
  668. }
  670. pCommandStack->PushCommand(MODIFY_DELETE, num, pObjectType, pObjetcIndex);
  671. UnselectObject();
  672. pView->Invalidate();
  674. delete pObjectType;
  675. delete pObjetcIndex;
  676. return DRAW_SELECT;
  677. }
  679.     return MODIFY_DELETE;
  680. }
  682. //实现“撤销”命令
  683. void CManageGraphObject::OnUndo()
  684. {
  685. CCommandStruct* pCommand;
  686. CGraphObjectInfo* pLineInfo;
  687. CGraphObjectInfo* pRectInfo;
  688. CGraphObjectInfo* pCircleInfo;
  689. CGraphObjectInfo* pArcInfo;
  691. pCommand = (CCommandStruct*)pCommandStack->Undo();
  692.     if(pCommand == NULL)
  693. return;
  695.     switch(pCommand->m_command)
  696. {
  697. case DRAW_LINE:
  698. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[0]);
  699.         pLineInfo->m_del = TRUE;
  700. break;
  702. case DRAW_RECT:
  703. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[0]);
  704.         pRectInfo->m_del = TRUE;
  705. break;
  707. case DRAW_CIRCLE:
  708. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[0]);
  709.         pCircleInfo->m_del = TRUE;
  710. break;
  712. case DRAW_ARC:
  713. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[0]);
  714.         pArcInfo->m_del = TRUE;
  715. break;
  717. case MODIFY_DELETE:
  718. for(int index =0; index < pCommand->m_num; index++)
  719. {
  720. switch(pCommand->m_object[index])
  721. {
  722. case OBJECT_LINE:
  723. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[index]);
  724. pLineInfo->m_del = FALSE;
  725. break;
  727. case OBJECT_RECT:
  728. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[index]);
  729. pRectInfo->m_del = FALSE;
  730. break;
  732. case OBJECT_CIRCLE:
  733. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[index]);
  734. pCircleInfo->m_del = FALSE;
  735. break;
  737. case OBJECT_ARC:
  738. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[index]);
  739. pArcInfo->m_del = FALSE;
  740. break;
  741. }
  742. }
  743. break;
  744. }
  746. }
  748. //实现“重做”命令
  749. void CManageGraphObject::OnRedo()
  750. {
  751. CCommandStruct* pCommand;
  752. CGraphObjectInfo* pLineInfo;
  753. CGraphObjectInfo* pRectInfo;
  754. CGraphObjectInfo* pCircleInfo;
  755. CGraphObjectInfo* pArcInfo;
  757. pCommand = (CCommandStruct*)pCommandStack->Redo();
  758. if(pCommand == NULL)
  759. return;
  761.     switch(pCommand->m_command)
  762. {
  763. case DRAW_LINE:
  764. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[0]);
  765.         pLineInfo->m_del = FALSE;
  766. break;
  768. case DRAW_RECT:
  769. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[0]);
  770.         pRectInfo->m_del = FALSE;
  771. break;
  773. case DRAW_CIRCLE:
  774. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[0]);
  775.         pCircleInfo->m_del = FALSE;
  776. break;
  778. case DRAW_ARC:
  779. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[0]);
  780.         pArcInfo->m_del = FALSE;
  781. break;
  783. case MODIFY_DELETE:
  784. for(int index =0; index < pCommand->m_num; index++)
  785. {
  786. switch(pCommand->m_object[index])
  787. {
  788. case OBJECT_LINE:
  789. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[index]);
  790. pLineInfo->m_del = TRUE;
  791. break;
  793. case OBJECT_RECT:
  794. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[index]);
  795. pRectInfo->m_del = TRUE;
  796. break;
  798. case OBJECT_CIRCLE:
  799. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[index]);
  800. pCircleInfo->m_del = TRUE;
  801. break;
  803. case OBJECT_ARC:
  804. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[index]);
  805. pArcInfo->m_del = TRUE;
  806. break;
  807. }
  808. }
  809. break;
  810. }
  811. }
  812. //////////////////////////////////////////////////////////////////////////////////////////////
  813. POINT CManageGraphObject::DrawingToLogic(FPOINT fpoint)
  814. {
  815. POINT point;
  816. point.x = long(fpoint.x * Proportion) + EXTRA_WIDTH;
  817. point.y = LogicViewSize.cy - (long)(fpoint.y * Proportion) - EXTRA_HIGTH;
  819. return point;
  820. }
  822. long CManageGraphObject::DrawingToLogic(float fdistance)
  823. {
  824. long distance;
  825. distance = (long)(fdistance * Proportion);
  827. return distance;
  828. }
  830. FPOINT CManageGraphObject::LogicToDrawing(POINT point)
  831. {
  832. FPOINT fpoint;
  833. fpoint.x = (float)(point.x - EXTRA_WIDTH) / Proportion;
  834. fpoint.y = (float)(LogicViewSize.cy - point.y  - EXTRA_HIGTH) / Proportion;
  836. return fpoint;
  837. }
  839. float CManageGraphObject::LogicToDrawing(long distance)
  840. {
  841. float fdistance;
  842. fdistance = (float)distance / Proportion;
  844. return fdistance;
  845. }
  847. void CManageGraphObject::GetObjectRange()
  848. {
  849. int index;
  851. // int n;
  852. CMyLine*      pLine;
  853. CMyRect*      pRect;
  854. CMyCircle*    pCircle;
  855. CMyArc*       pArc;
  857. CGraphObjectInfo* pLineInfo;
  858. CGraphObjectInfo* pRectInfo;
  859. CGraphObjectInfo* pCircleInfo;
  860. CGraphObjectInfo* pArcInfo;
  862. // n = m_LineArray.GetSize();
  863. // n = m_LineInfoArray.GetSize();
  864. for(index = 0; index < m_LineInfoArray.GetSize(); index++)
  865. {
  867. pLine = GetLine(index);
  868. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  869. pLineInfo->Initialize(GetLineRange(2, pLine), FALSE, FALSE);
  870. }
  872. for(index = 0; index < m_RectInfoArray.GetSize(); index++)
  873. {
  874. pRect = GetRect(index);
  875. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  876. pRectInfo->Initialize(GetRectRange(2, pRect), FALSE, FALSE);
  877. }
  879. for(index = 0; index < m_CircleInfoArray.GetSize(); index++)
  880. {
  881. pCircle = GetCircle(index);
  882. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  883. pCircleInfo->Initialize(GetCircleRange(2, pCircle), FALSE, FALSE);
  884. }
  886. for(index = 0; index < m_ArcInfoArray.GetSize(); index++)
  887. {
  888. pArc = GetArc(index);
  889. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  890. pArcInfo->Initialize(GetArcRange(2, pArc), FALSE, FALSE);
  891. }
  893. }
  895. void CManageGraphObject::SetEffectRect(CRect rect)
  896. {
  897. EffectRect = rect;
  898. }
  900. CRect CManageGraphObject::GetLogicClientRect()
  901. {
  902. CRect rect;
  903. ASSERT(pView != NULL);
  904. ASSERT(pDC != NULL);
  905. pView->GetClientRect(&rect);
  906. pDC->DPtoLP(&rect);
  907. return rect;
  908. }
  910. BOOL CManageGraphObject::IsInLogicClientRect(CRect rect)
  911. {
  912. CRect clientrect = GetLogicClientRect();
  913. CRect temp = clientrect & rect;
  914. if(temp.IsRectEmpty())
  915. return FALSE;
  916. else 
  917. return TRUE;
  918. }
  921. CRect CManageGraphObject::GetRedrawRect(CRect effectRect, CRect clientRect)
  922. {
  923. CRect rect;
  924.     rect = effectRect & clientRect;
  925. return rect;
  926. }
  929. BOOL CManageGraphObject::IsRedraw(CRect redrawRect, CRect objRect)
  930. {
  931. CRect rect;
  932.     
  933. rect = redrawRect & objRect;
  934. if(rect.IsRectEmpty())
  935. return FALSE;
  936. else 
  937. return TRUE;
  938. }
  939. ////////////////////////////////////////////////////////////////////////////////////////////////
  940. void CManageGraphObject::RedrawAllObject(CDC* pDC)
  941. {
  942. LogicClientRect = GetLogicClientRect();
  943. RedrawLine(pDC);
  944. RedrawRect(pDC);
  945. RedrawCircle(pDC);
  946. RedrawArc(pDC);
  947. }
  949. void CManageGraphObject::SelectObject(CDC* pDC, CPoint point)
  950. {
  951. SelectLine(pDC, point);   
  952. SelectRect(pDC, point);
  953. SelectCircle(pDC, point);
  954. SelectArc(pDC, point);
  955. }
  957. BOOL CManageGraphObject::UnselectObject()
  958. {
  959. BOOL flag = FALSE;
  960. int nIndex;
  962. if(UnselectLine())
  963. flag = TRUE;
  964. if(UnselectRect())
  965. flag = TRUE;
  966. if(UnselectCircle())
  967. flag = TRUE;
  968.     if(UnselectArc())
  969. flag = TRUE;
  970.     
  971. nIndex = m_SelObjInfoArray.GetSize();
  972. while(nIndex--)
  973. delete (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  974.     m_SelObjInfoArray.RemoveAll();
  976. return flag;
  977. }
  979. //////////////////////////////////////////////////////////////////////////////////////////////
  980. CRect CManageGraphObject::GetLineRange(long ExtraRange, CMyLine* pLine)
  981. {
  982. CRect rect;
  983. POINT start;
  984. POINT end;
  986. start = DrawingToLogic(pLine->m_start);
  987. end = DrawingToLogic(pLine->m_end);
  989. rect.left = start.x;
  990. rect.top = start.y;
  991. rect.right = end.x;
  992. rect.bottom = end.y;
  993. //注意必须对矩形规格化
  994. rect.NormalizeRect();
  996. rect.left -= ExtraRange;
  997. rect.top -= ExtraRange;
  998. rect.right += ExtraRange;
  999. rect.bottom += ExtraRange;
  1001. return rect;
  1002. }
  1005. void CManageGraphObject::RedrawLine(CDC* pDC)
  1006. {
  1007. int index;
  1008. CRect rect;
  1010. CMyLine* pLine;
  1011. CGraphObjectInfo* pLineInfo;
  1013. index = m_LineArray.GetSize();
  1014. while(index--)
  1015. {
  1016. pLine = (CMyLine*)m_LineArray.GetAt(index);
  1017. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  1019. //判断图形对象所在层是否被隐藏
  1020. CFileLayer* pLayer = pManageLayer->GetLayer(pLine->m_layer);
  1021. if(!pLayer->IsShow())
  1022. continue;
  1024. //判断直线对象是否需要重画
  1025. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pLineInfo->m_rect))
  1026. continue;
  1028. if(pLineInfo->m_del == TRUE)
  1029. continue;
  1030. if(pLineInfo->m_selected == TRUE)
  1031. {
  1032. m_DrawGrapObject.DrawSelLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  1033.                          pLine->m_style, pLine->m_color);
  1034. continue;
  1035. }
  1036.         
  1037. m_DrawGrapObject.DrawLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  1038.                    pLine->m_style, pLine->m_color);
  1039.      }
  1040. }
  1042. void CManageGraphObject::SelectLine(CDC* pDC, CPoint point)
  1043. {
  1044. int nIndex;
  1045. long distance;
  1046. CRect rect;
  1048. CGraphObjectInfo* pLineInfo;
  1049. CSelectedObjectInfo* pSelObjInfo;
  1050. CMyLine* pLine; 
  1052. for(nIndex = 0; nIndex < m_LineInfoArray.GetSize(); nIndex++)
  1053. {
  1054. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(nIndex);
  1055. pLine = (CMyLine*)m_LineArray.GetAt(nIndex);
  1057. //判断图形对象所在层是否被隐藏
  1058. CFileLayer* pLayer = pManageLayer->GetLayer(pLine->m_layer);
  1059. if(!pLayer->IsShow())
  1060. continue;
  1062. if(pLineInfo ->m_del == TRUE || pLineInfo ->m_selected ==TRUE)
  1063. continue;
  1064.         
  1065. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1066. CRect region = pLineInfo->m_rect;
  1067. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1068.         if(!region.PtInRect(point))
  1069. continue;
  1071. rect.left = DrawingToLogic(pLine->m_start).x;
  1072. rect.top = DrawingToLogic(pLine->m_start).y;
  1073. rect.right = DrawingToLogic(pLine->m_end).x;
  1074. rect.bottom = DrawingToLogic(pLine->m_end).y;
  1076. if( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  1077.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) )
  1078. {
  1079. 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) )
  1080.        / sqrt( (rect.right - rect.left) * (rect.right - rect.left) + (rect.bottom - rect.top) * (rect.bottom - rect.top) ) );
  1082. if(distance <= SELECT_RANGE)
  1083. {
  1084.            m_DrawGrapObject.DrawSelLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  1085.                          pLine->m_style, pLine->m_color);
  1086. pLineInfo->m_selected = TRUE;
  1088. pSelObjInfo = new CSelectedObjectInfo(OBJECT_LINE, nIndex);
  1089. m_SelObjInfoArray.Add(pSelObjInfo);
  1090. }
  1091. }
  1092. }
  1093. }
  1095. BOOL CManageGraphObject::UnselectLine()
  1096. {
  1097. BOOL flag = FALSE;
  1098. int nIndex;
  1099. CSelectedObjectInfo* pSelObjInfo;
  1100. CGraphObjectInfo* pLineInfo;
  1101. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1102. {
  1103. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1104. if(pSelObjInfo->m_type ==OBJECT_LINE)
  1105. {
  1106. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pSelObjInfo->m_index);
  1107. pLineInfo->m_selected = FALSE;
  1108. flag = TRUE;
  1109.         }
  1110.     }
  1111. return flag;
  1112. }
  1114. void CManageGraphObject::AddLine(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  1115. {
  1116. FPOINT start;
  1117. FPOINT end;
  1119. start = LogicToDrawing(SPoint);
  1120. end = LogicToDrawing(EPoint);
  1122. CMyLine* pLine = new CMyLine(CurrentLayerName, start, end, Style, Color);
  1123. m_LineArray.Add(pLine);
  1125. CGraphObjectInfo* pLineInfo = new CGraphObjectInfo(GetLineRange(0, pLine), FALSE, FALSE);
  1126. m_LineInfoArray.Add(pLineInfo);
  1127. }
  1129. CMyLine* CManageGraphObject::GetLine(int index)
  1130. {
  1131. ASSERT(index >= 0 && index <= m_LineArray.GetUpperBound());
  1132. return (CMyLine*)m_LineArray.GetAt(index);
  1133. }
  1135. void CManageGraphObject::DelLine(int index)
  1136. {
  1137. ASSERT(index >= 0 && index <= m_LineArray.GetUpperBound());
  1139. delete (CMyLine*)m_LineArray.GetAt(index);
  1140. m_LineArray.RemoveAt(index);
  1142. delete (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  1143. m_LineInfoArray.RemoveAt(index);
  1144. }
  1148. void CManageGraphObject::DelAllLine()
  1149. {
  1150. int index;
  1151. index = m_LineArray.GetSize();
  1152. while(index--)
  1153. delete (CMyLine*)m_LineArray.GetAt(index);
  1154. m_LineArray.RemoveAll();
  1155.      
  1156. index = m_LineInfoArray.GetSize();
  1157. while(index--)
  1158. delete (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  1159. m_LineInfoArray.RemoveAll();
  1160. }
  1162. //////////////////////////////////////////////////////////////////////////////////////////////
  1163. CRect CManageGraphObject::GetRectRange(long ExtraRange, CMyRect* pRect)
  1164. {
  1165. CRect rect;
  1166. POINT start;
  1167. POINT end;
  1169. start = DrawingToLogic(pRect->m_start);
  1170. end = DrawingToLogic(pRect->m_end);
  1171. rect.left = start.x;
  1172. rect.top = start.y;
  1173. rect.right = end.x;
  1174. rect.bottom = end.y;
  1175. //注意必须对矩形规格化
  1176. rect.NormalizeRect();
  1178. rect.left -= ExtraRange;
  1179. rect.top -= ExtraRange;
  1180. rect.right += ExtraRange;
  1181. rect.bottom += ExtraRange;
  1182. return rect;
  1183. }
  1186. void CManageGraphObject::RedrawRect(CDC* pDC)
  1187. {
  1188. int index;
  1189. CMyRect* pRect;
  1190. CGraphObjectInfo* pRectInfo;
  1192. index = m_RectArray.GetSize();
  1194. //设置不填充状态
  1195. pDC->SelectStockObject(NULL_BRUSH);
  1196. while(index--)
  1197. {
  1198. pRect = (CMyRect*)m_RectArray.GetAt(index);
  1199. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  1201. //判断图形对象所在层是否被隐藏
  1202. CFileLayer* pLayer = pManageLayer->GetLayer(pRect->m_layer);
  1203. if(!pLayer->IsShow())
  1204. continue;
  1206. //判断矩形对象是否需要重画
  1207. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pRectInfo->m_rect))
  1208. continue;
  1210. if(pRectInfo->m_del == TRUE)
  1211. continue;
  1212. if(pRectInfo->m_selected == TRUE)
  1213. {
  1214. m_DrawGrapObject.DrawSelRect(pDC, DrawingToLogic(pRect->m_start), DrawingToLogic(pRect->m_end),
  1215.                          pRect->m_style, pRect->m_color);
  1216. continue;
  1217. }
  1219. m_DrawGrapObject.DrawRect(pDC, DrawingToLogic(pRect->m_start), DrawingToLogic(pRect->m_end),
  1220.                    pRect->m_style, pRect->m_color);
  1221.       
  1222. }
  1223. }
  1225. void CManageGraphObject::SelectRect(CDC* pDC, CPoint point)
  1226. {
  1227. int nIndex;
  1228. CRect rect;
  1230. CGraphObjectInfo* pRectInfo;
  1231. CSelectedObjectInfo* pSelObjInfo;
  1232. CMyRect* pRect; 
  1234. for(nIndex = 0; nIndex < m_RectInfoArray.GetSize(); nIndex++)
  1235. {
  1236. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(nIndex);
  1237. pRect = (CMyRect*)m_RectArray.GetAt(nIndex);
  1239. //判断图形对象所在层是否被隐藏
  1240. CFileLayer* pLayer = pManageLayer->GetLayer(pRect->m_layer);
  1241. if(!pLayer->IsShow())
  1242. continue;
  1244. if(pRectInfo ->m_del == TRUE || pRectInfo ->m_selected ==TRUE)
  1245. continue;
  1247. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1248. CRect region = pRectInfo->m_rect;
  1249. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1250.         if(!region.PtInRect(point))
  1251. continue;
  1253. rect.left = DrawingToLogic(pRect->m_start).x;
  1254. rect.top = DrawingToLogic(pRect->m_start).y;
  1255. rect.right = DrawingToLogic(pRect->m_end).x;
  1256. rect.bottom = DrawingToLogic(pRect->m_end).y;
  1258. if( ( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  1259.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) ) &&
  1260. ( (point.x <= min(rect.left, rect.right) + SELECT_RANGE) || (point.x >= max(rect.left, rect.right) - SELECT_RANGE) ||
  1261.             (point.y <= min(rect.top, rect.bottom) + SELECT_RANGE) || (point.y >= max(rect.top, rect.bottom) - SELECT_RANGE) ) ) 
  1263. {
  1264. m_DrawGrapObject.DrawSelRect(pDC, rect.TopLeft(), rect.BottomRight(), 
  1265.                          pRect->m_style, pRect->m_color);
  1267. pRectInfo->m_selected = TRUE;
  1269. pSelObjInfo = new CSelectedObjectInfo(OBJECT_RECT, nIndex);
  1270. m_SelObjInfoArray.Add(pSelObjInfo);
  1271. }
  1272. }
  1274. }
  1276. BOOL CManageGraphObject::UnselectRect()
  1277. {
  1278. BOOL flag = FALSE;
  1279. int nIndex;
  1280. CSelectedObjectInfo* pSelObjInfo;
  1281. CGraphObjectInfo* pRectInfo;
  1282. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1283. {
  1284. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1285. if(pSelObjInfo->m_type ==OBJECT_RECT)
  1286. {
  1287. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pSelObjInfo->m_index);
  1288. pRectInfo->m_selected = FALSE;
  1289. flag = TRUE;
  1290.         }
  1291.     }
  1292. return flag;
  1293. }
  1295. void CManageGraphObject::AddRect(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  1296. {
  1297. FPOINT start;
  1298. FPOINT end;
  1300. start = LogicToDrawing(SPoint);
  1301. end = LogicToDrawing(EPoint);
  1302.     
  1303. CMyRect* pRect = new CMyRect(CurrentLayerName, start, end, Style, Color);
  1304. m_RectArray.Add(pRect);
  1306. CGraphObjectInfo * pRectInfo = new CGraphObjectInfo(GetRectRange(0, pRect), FALSE, FALSE);
  1307. m_RectInfoArray.Add(pRectInfo);
  1308. }
  1310. CMyRect* CManageGraphObject::GetRect(int index)
  1311. {
  1312. ASSERT(index >= 0 && index <= m_RectArray.GetUpperBound());
  1313. return (CMyRect*)m_RectArray.GetAt(index);
  1314. }
  1316. void CManageGraphObject::DelRect(int index)
  1317. {
  1318. ASSERT(index >= 0 && index <= m_RectArray.GetUpperBound());
  1320. delete (CMyRect*)m_RectArray.GetAt(index);
  1321. m_RectArray.RemoveAt(index);
  1323. delete (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  1324. m_RectInfoArray.RemoveAt(index);
  1325. }
  1327. void CManageGraphObject::DelAllRect()
  1328. {
  1329. int index;
  1331. index = m_RectArray.GetSize();
  1332. while(index--)
  1333. delete (CMyRect*)m_RectArray.GetAt(index);
  1334. m_RectArray.RemoveAll();
  1336. index = m_RectInfoArray.GetSize();
  1337. while(index--)
  1338. delete (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  1339. m_RectInfoArray.RemoveAll();
  1340. }
  1342. //////////////////////////////////////////////////////////////////////////////////////////////
  1343. CRect CManageGraphObject::GetCircleRange(long ExtraRange, CMyCircle* pCircle)
  1344. {
  1345. CRect rect;
  1346. POINT origin;
  1347. long Radius;
  1349. origin = DrawingToLogic(pCircle->m_origin);
  1350. Radius = DrawingToLogic(pCircle->m_radius);
  1351. rect.left = origin.x - Radius - ExtraRange;
  1352. rect.top = origin.y - Radius - ExtraRange;
  1353. rect.right = origin.x + Radius + ExtraRange;
  1354. rect.bottom = origin.y + Radius + ExtraRange;
  1355. rect.NormalizeRect();
  1356. return rect;
  1357. }
  1360. void CManageGraphObject::RedrawCircle(CDC* pDC)
  1361. {
  1362. int index;
  1363. CMyCircle* pCircle;
  1364. CGraphObjectInfo* pCircleInfo;
  1366. index = m_CircleArray.GetSize();
  1368. //设置不填充状态
  1369. pDC->SelectStockObject(NULL_BRUSH);
  1370. while(index--)
  1371. {
  1372. pCircle = (CMyCircle*)m_CircleArray.GetAt(index);
  1373. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  1375. //判断图形对象所在层是否被隐藏
  1376. CFileLayer* pLayer = pManageLayer->GetLayer(pCircle->m_layer);
  1377. if(!pLayer->IsShow())
  1378. continue;
  1380. //判断圆对象是否需要重画
  1381. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pCircleInfo->m_rect))
  1382. continue;
  1384. if(pCircleInfo->m_del == TRUE)
  1385. continue;
  1386. if(pCircleInfo->m_selected == TRUE)
  1387. {
  1388. m_DrawGrapObject.DrawSelCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius), 
  1389.                            pCircle->m_style, pCircle->m_color);
  1390. continue;
  1391. }
  1393. m_DrawGrapObject.DrawCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius),
  1394.                          pCircle->m_style, pCircle->m_color);
  1395.    }
  1396. }
  1399. void CManageGraphObject::SelectCircle(CDC* pDC, CPoint point)
  1400. {
  1401. int nIndex;
  1402. POINT origin;
  1403. long r;
  1404. long distance;
  1406. CGraphObjectInfo* pCircleInfo;
  1407. CSelectedObjectInfo* pSelObjInfo;
  1408. CMyCircle* pCircle; 
  1410. for(nIndex = 0; nIndex < m_CircleInfoArray.GetSize(); nIndex++)
  1411. {
  1412. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(nIndex);
  1413. pCircle = (CMyCircle*)m_CircleArray.GetAt(nIndex);
  1415. //判断图形对象所在层是否被隐藏
  1416. CFileLayer* pLayer = pManageLayer->GetLayer(pCircle->m_layer);
  1417. if(!pLayer->IsShow())
  1418. continue;
  1420. if(pCircleInfo ->m_del == TRUE || pCircleInfo ->m_selected ==TRUE)
  1421. continue;
  1423. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1424. CRect region = pCircleInfo->m_rect;
  1425. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1426.         if(!region.PtInRect(point))
  1427. continue;
  1429. origin = DrawingToLogic(pCircle->m_origin);
  1430. r = DrawingToLogic(pCircle->m_radius);
  1432. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  1434. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  1435. {
  1436. m_DrawGrapObject.DrawSelCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius),
  1437.                            pCircle->m_style, pCircle->m_color);
  1439. pCircleInfo->m_selected = TRUE;
  1441. pSelObjInfo = new CSelectedObjectInfo(OBJECT_CIRCLE, nIndex);
  1442. m_SelObjInfoArray.Add(pSelObjInfo);
  1443. }
  1444. }
  1446. }
  1448. BOOL CManageGraphObject::UnselectCircle()
  1449. {
  1450. BOOL flag = FALSE;
  1451. int nIndex;
  1452. CSelectedObjectInfo* pSelObjInfo;
  1453. CGraphObjectInfo* pCircleInfo;
  1454. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1455. {
  1456. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1457. if(pSelObjInfo->m_type ==OBJECT_CIRCLE)
  1458. {
  1459. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pSelObjInfo->m_index);
  1460. pCircleInfo->m_selected = FALSE;
  1461. flag = TRUE;
  1462.         }
  1463.     }
  1464. return flag;
  1465. }
  1467. void CManageGraphObject::AddCircle(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  1468. {
  1469. FPOINT start;
  1470. FPOINT end;
  1471. float r;
  1473. start = LogicToDrawing(SPoint);
  1474. end = LogicToDrawing(EPoint);
  1475. r = (float)sqrt(pow(start.x - end.x, 2) + pow(start.y - end.y, 2));
  1477. CMyCircle* pCircle = new CMyCircle(CurrentLayerName, start, r, Style, Color);
  1478. m_CircleArray.Add(pCircle);
  1479. CGraphObjectInfo* pCircleInfo = new CGraphObjectInfo(GetCircleRange(0, pCircle), FALSE, FALSE);
  1480. m_CircleInfoArray.Add(pCircleInfo);
  1481. }
  1483. CMyCircle* CManageGraphObject::GetCircle(int index)
  1484. {
  1485. ASSERT(index >= 0 && index <= m_CircleArray.GetUpperBound());
  1486. return (CMyCircle*)m_CircleArray.GetAt(index);
  1487. }
  1489. void CManageGraphObject::DelCircle(int index)
  1490. {
  1491. ASSERT(index >= 0 && index <= m_CircleArray.GetUpperBound());
  1493. delete (CMyCircle*)m_CircleArray.GetAt(index);
  1494. m_CircleArray.RemoveAt(index);
  1496. delete (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  1497. m_CircleInfoArray.RemoveAt(index);
  1498. }
  1500. void CManageGraphObject::DelAllCircle()
  1501. {
  1502. int index;
  1504. index = m_CircleArray.GetSize();
  1505. while(index--)
  1506. delete (CMyCircle*)m_CircleArray.GetAt(index);
  1507. m_CircleArray.RemoveAll();
  1509. index = m_CircleInfoArray.GetSize();
  1510. while(index--)
  1511. delete (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  1512. m_CircleInfoArray.RemoveAll();
  1513. }
  1515. //////////////////////////////////////////////////////////////////////////////////////////////
  1516. CRect CManageGraphObject::GetArcRange(long ExtraRange, CMyArc* pArc)
  1517. {
  1518. CRect rect;
  1519. POINT origin;
  1520. long Radius;
  1522. origin = DrawingToLogic(pArc->m_origin);
  1523. Radius = DrawingToLogic(pArc->m_radius);
  1524. rect.left = origin.x - Radius - ExtraRange;
  1525. rect.top = origin.y - Radius - ExtraRange;
  1526. rect.right = origin.x + Radius + ExtraRange;
  1527. rect.bottom = origin.y + Radius + ExtraRange;
  1528. rect.NormalizeRect();
  1529. return rect;
  1530. }
  1532. void CManageGraphObject::RedrawArc(CDC* pDC)
  1533. {
  1534. int index;
  1535. CMyArc* pArc;
  1536. CGraphObjectInfo* pArcInfo;
  1538. index = m_ArcArray.GetSize();
  1540. //设置不填充状态
  1541. pDC->SelectStockObject(NULL_BRUSH);
  1542. while(index--)
  1543. {
  1544. pArc = (CMyArc*)m_ArcArray.GetAt(index);
  1545. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1547. //判断图形对象所在层是否被隐藏
  1548. CFileLayer* pLayer = pManageLayer->GetLayer(pArc->m_layer);
  1549. if(!pLayer->IsShow())
  1550. continue;
  1552. //判断圆弧对象是否需要重画
  1553. if(!IsRedraw(GetRedrawRect(EffectRect, LogicClientRect), pArcInfo->m_rect))
  1554. continue;
  1556. if(pArcInfo->m_del == TRUE)
  1557. continue;
  1558. if(pArcInfo->m_selected == TRUE)
  1559. {
  1560. m_DrawGrapObject.DrawSelArc(pDC, DrawingToLogic(pArc->m_origin), DrawingToLogic(pArc->m_start), 
  1561.                         DrawingToLogic(pArc->m_end),
  1562. DrawingToLogic(pArc->m_radius), LineStyle, PenColor);
  1563. continue;
  1564. }
  1565.          
  1567. m_DrawGrapObject.DrawArc(pDC, DrawingToLogic(pArc->m_origin),
  1568.                      DrawingToLogic(pArc->m_start), DrawingToLogic(pArc->m_end),
  1569.                                  DrawingToLogic(pArc->m_radius), pArc->m_style, pArc->m_color);
  1570. }
  1571. }
  1574. void CManageGraphObject::SelectArc(CDC* pDC, CPoint point)
  1575. {
  1576. int nIndex;
  1578. POINT origin;
  1579. long r;
  1580. long distance;
  1582. CPoint start;
  1583. CPoint end;
  1585. CGraphObjectInfo* pArcInfo;
  1586. CSelectedObjectInfo* pSelObjInfo;
  1587. CMyArc* pArc; 
  1589. for(nIndex = 0; nIndex < m_ArcInfoArray.GetSize(); nIndex++)
  1590. {
  1591. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(nIndex);
  1592. pArc = (CMyArc*)m_ArcArray.GetAt(nIndex);
  1594. //判断图形对象所在层是否被隐藏
  1595. CFileLayer* pLayer = pManageLayer->GetLayer(pArc->m_layer);
  1596. if(!pLayer->IsShow())
  1597. continue;
  1599. if(pArcInfo ->m_del == TRUE || pArcInfo ->m_selected ==TRUE)
  1600. continue;
  1602. //判断选取点是否在图形对象所占据的选取逻辑区域内
  1603. CRect region = pArcInfo->m_rect;
  1604. region.InflateRect(SELECT_RANGE, SELECT_RANGE);
  1605.         if(!region.PtInRect(point))
  1606. continue;
  1608. origin = DrawingToLogic(pArc->m_origin);
  1609. start = DrawingToLogic(pArc->m_start);
  1610. end = DrawingToLogic(pArc->m_end);
  1611. r = DrawingToLogic(pArc->m_radius);
  1613. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  1615. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  1616. {
  1617. m_DrawGrapObject.DrawSelArc(pDC, origin, start, end, r, pArc->m_style, pArc->m_color);
  1619. pArcInfo->m_selected = TRUE;
  1620. pSelObjInfo = new CSelectedObjectInfo(OBJECT_ARC, nIndex);
  1621. m_SelObjInfoArray.Add(pSelObjInfo);
  1622. }
  1623. }
  1624. }
  1626. BOOL CManageGraphObject::UnselectArc()
  1627. {
  1628. BOOL flag = FALSE;
  1629. int nIndex;
  1630. CSelectedObjectInfo* pSelObjInfo;
  1631. CGraphObjectInfo* pArcInfo;
  1632. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1633. {
  1634. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1635. if(pSelObjInfo->m_type ==OBJECT_ARC)
  1636. {
  1637. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pSelObjInfo->m_index);
  1638. pArcInfo->m_selected = FALSE;
  1639. flag = TRUE;
  1640.         }
  1641.     }
  1642. return flag;
  1643. }
  1646. void CManageGraphObject::AddArc(POINT SPoint, POINT MPoint, POINT EPoint, int Style, COLORREF Color)
  1647. {
  1648. long x1, y1, x2, y2;
  1650. double originX;
  1651. double originY;
  1652. double k1;
  1653. double k2;
  1654. double mid1X;
  1655. double mid1Y;
  1656. double mid2X;
  1657. double mid2Y;
  1659. POINT OPoint;
  1660. long Radius;
  1662. CMyArc* pArc;
  1664. if(SPoint.y == MPoint.y)
  1665. k1 = 1000000.0;
  1666. else 
  1667. k1 = (- (double)(SPoint.x - MPoint.x) / (double)(SPoint.y - MPoint.y));
  1669. if(EPoint.y == MPoint.y)
  1670. k2 = 1000000.0;
  1671. else 
  1672. k2 =  (- (double)(EPoint.x - MPoint.x) / (double)(EPoint.y - MPoint.y));
  1674. mid1X = (double)(SPoint.x + MPoint.x) / 2.0;
  1675. mid1Y = (double)(SPoint.y + MPoint.y) / 2.0;
  1677. mid2X = (double)(EPoint.x + MPoint.x) / 2.0;
  1678. mid2Y = (double)(EPoint.y + MPoint.y) / 2.0;
  1680. if(k1 == k2)
  1681. return;
  1683. if(k1 == 1000000.0)
  1684. {
  1685. originX = mid1X;
  1686. originY = k2 * (originX - mid2X) + mid2Y;
  1687. }
  1688. else
  1689. if(k2 == 1000000.0)
  1690. {
  1691. originX = mid2X;
  1692. originY = k1 * (originX - mid1X) + mid1Y;
  1693. }
  1694. else
  1695. {
  1696. originX = ((k2 * mid2X - k1 * mid1X) - (mid2Y - mid1Y)) / (k2 - k1);
  1697. originY = k2 * (originX - mid2X) + mid2Y;
  1698. }
  1700. Radius = (long)sqrt(pow((double)(originX - SPoint.x), 2) + pow((double)(originY - SPoint.y), 2));
  1702. OPoint.x = (long)originX;
  1703. OPoint.y = (long)originY ;
  1705. x1 = MidPoint.x - SPoint.x;
  1706. y1 = MPoint.y - SPoint.y;
  1708. x2 = EPoint.x - SPoint.x;
  1709. y2 = EPoint.y - SPoint.y;
  1711. if(x1*y2 - x2*y1 < 0)
  1712. pArc = new CMyArc(CurrentLayerName, LogicToDrawing(OPoint),
  1713.                   LogicToDrawing(SPoint), LogicToDrawing(EPoint), 
  1714.   LogicToDrawing(Radius), LineStyle, PenColor);
  1715. else
  1716. pArc = new CMyArc(CurrentLayerName, LogicToDrawing(OPoint), 
  1717.                   LogicToDrawing(EPoint), LogicToDrawing(SPoint), 
  1718.   LogicToDrawing(Radius), LineStyle, PenColor);
  1720. m_ArcArray.Add(pArc);
  1722. CGraphObjectInfo* pArcInfo = new CGraphObjectInfo(GetArcRange(0, pArc), FALSE, FALSE);
  1723. m_ArcInfoArray.Add(pArcInfo);
  1724. }
  1727. CMyArc* CManageGraphObject::GetArc(int index)
  1728. {
  1729. ASSERT(index >= 0 && index <= m_ArcArray.GetUpperBound());
  1730. return (CMyArc*)m_ArcArray.GetAt(index);
  1731. }
  1733. void CManageGraphObject::DelArc(int index)
  1734. {
  1735. ASSERT(index >= 0 && index <= m_ArcArray.GetUpperBound());
  1737. delete (CMyArc*)m_ArcArray.GetAt(index);
  1738. m_ArcArray.RemoveAt(index);
  1740. delete (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1741. m_ArcInfoArray.RemoveAt(index);
  1742. }
  1744. void CManageGraphObject::DelAllArc()
  1745. {
  1746. int index;
  1748. index = m_ArcArray.GetSize();
  1749. while(index--)
  1750. delete (CMyArc*)m_ArcArray.GetAt(index);
  1751. m_ArcArray.RemoveAll();
  1753. index = m_ArcInfoArray.GetSize();
  1754. while(index--)
  1755. delete (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1756. m_ArcInfoArray.RemoveAll();
  1757. }