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

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

绘图程序

开发平台：

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(int style, COLORREF color)
  35. {
  36. LineStyle = style;
  37. PenColor = color;
  38. }
  40. void CManageGraphObject::SetLineStyle(int style)
  41. {
  42. LineStyle = style;
  43. }
  45. void CManageGraphObject::SetPenColor(COLORREF color)
  46. {
  47. PenColor = color;
  48. }
  51. //获取命令堆栈指针
  52. void CManageGraphObject::GetCommandStack(CCommandStack* pStack)
  53. {
  54. pCommandStack = pStack;
  55. }
  57. void CManageGraphObject::GetDC(CClientDC* pClientDC)
  58. {
  59. ASSERT(pClientDC != NULL);
  60. pDC = pClientDC;
  62. }
  64. void CManageGraphObject::Serialize(CArchive& ar)
  65. {
  66. int num;
  67. int index;
  69. CGraphObjectInfo* pLineInfo;
  70. CGraphObjectInfo* pRectInfo;
  71. CGraphObjectInfo* pCircleInfo;
  72. CGraphObjectInfo* pArcInfo;
  74. if(ar.IsStoring())
  75. {
  76. ar << m_LineArray.GetSize() << m_RectArray.GetSize()
  77.    << m_CircleArray.GetSize() << m_ArcArray.GetSize();
  78. }
  79. else
  80. {
  81. ar >> num;
  82. for(index = 0; index < num; index++)
  83. {
  84. pLineInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  85. m_LineInfoArray.Add(pLineInfo);
  86. }
  88. ar >> num;
  89. for(index = 0; index < num; index++)
  90. {
  91. pRectInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  92. m_RectInfoArray.Add(pRectInfo);
  93. }
  95. ar >> num;
  96. for(index = 0; index < num; index++)
  97. {
  98. pCircleInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  99. m_CircleInfoArray.Add(pCircleInfo);
  100. }
  102. ar >> num;
  103. for(index = 0; index < num; index++)
  104. {
  105. pArcInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  106. m_ArcInfoArray.Add(pArcInfo);
  107. }
  109. }
  111. //注意当打开文件时，下面的Serialize()函数会自动创建CMyLine,CMyRect等对象
  112.     m_LineArray.Serialize(ar);
  113. m_RectArray.Serialize(ar);
  114. m_CircleArray.Serialize(ar);
  115. m_ArcArray.Serialize(ar);
  116. }
  117. ///////////////////////////////////////////////////////////////////////////////////////////////
  118. //处理命令
  119. void CManageGraphObject::OnLButtonDown(UINT ID, CPoint point)
  120. {
  121. ASSERT(pDC != NULL);
  122. ASSERT(pCommandStack != NULL);
  124. int ObjectType;
  125. int ObjetcIndex;
  127. switch(ID)
  128. {
  129. case DRAW_SELECT:
  130. SelectObject(pDC, point);
  131.     break;
  133. case DRAW_LINE:
  134. {
  135. LRepeatTimes++;
  136. switch(LRepeatTimes)
  137. {
  138. case 1:
  139. StartPoint = point;
  140. m_DrawGrapObject.SetOnceFlag();
  141. break;
  143. case 2:
  144. EndPoint = point;
  145.         m_DrawGrapObject.DrawLine(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  146.         AddLine(StartPoint, EndPoint, LineStyle, PenColor);
  148.         ObjectType = OBJECT_LINE;
  149.         ObjetcIndex = m_LineArray.GetUpperBound();
  150.         //因为执行一项新操作后，将不再有可以Redo的命令
  151.         pCommandStack->PushCommand(DRAW_LINE, 1, &ObjectType, &ObjetcIndex);
  152.         
  153.         LRepeatTimes--;
  154.         StartPoint = EndPoint;
  155. oldEndPoint = StartPoint;
  156.         break;
  157. }
  158. }
  159. break;
  161.     case DRAW_RECT:
  162. {
  163. LRepeatTimes++;
  164. switch(LRepeatTimes)
  165. {
  166. case 1:
  167. StartPoint = point;
  168. m_DrawGrapObject.SetOnceFlag();
  169. break;
  171. case 2:
  172. EndPoint = point;
  173. m_DrawGrapObject.DrawRect(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  174. AddRect(StartPoint, EndPoint, LineStyle, PenColor);
  176.         ObjectType = OBJECT_RECT;
  177. ObjetcIndex = m_RectArray.GetUpperBound();
  178. pCommandStack->PushCommand(DRAW_RECT, 1, &ObjectType, &ObjetcIndex);
  180.         LRepeatTimes = 0;
  181. break;
  182. }
  183. }
  184. break;
  186.     case DRAW_CIRCLE:
  187. {
  188. LRepeatTimes++;
  189.     switch(LRepeatTimes)
  190. {
  191. case 1:
  192. StartPoint = point;
  193.         m_DrawGrapObject.SetOnceFlag();
  194. break;
  196. case 2:
  197. EndPoint = point;
  198. m_DrawGrapObject.DrawCircle(pDC, StartPoint, EndPoint, LineStyle, PenColor);
  199.         AddCircle(StartPoint, EndPoint, LineStyle, PenColor);
  201.             ObjectType = OBJECT_CIRCLE;
  202.         ObjetcIndex = m_CircleArray.GetUpperBound();
  203.         pCommandStack->PushCommand(DRAW_CIRCLE, 1, &ObjectType, &ObjetcIndex);
  205.         LRepeatTimes = 0;
  206. break;
  207. }
  208. }
  209. break;
  211.     case DRAW_ARC:
  212. {
  213. LRepeatTimes++;
  214.     switch(LRepeatTimes)
  215. {
  216. case 1:
  217. StartPoint = point;
  218. m_DrawGrapObject.SetOnceFlag();
  219.         break;
  221. case 2:
  222. MidPoint = point;
  223. m_DrawGrapObject.SetOnceFlag();
  224. break;
  226. case 3:
  227. EndPoint = point;
  228. m_DrawGrapObject.DrawArc(pDC, StartPoint, MidPoint, EndPoint, 
  229.                      LineStyle, PenColor);
  230. AddArc(StartPoint, MidPoint, EndPoint, LineStyle, PenColor); 
  232.      ObjectType = OBJECT_ARC;
  233. ObjetcIndex = m_ArcArray.GetUpperBound();
  234. pCommandStack->PushCommand(DRAW_ARC, 1, &ObjectType, &ObjetcIndex);
  236. LRepeatTimes = 0;
  237. break;
  238. }
  239. }
  240. break;
  242. case DRAW_TEXT:
  243. break;
  244. }
  245. }
  247. UINT CManageGraphObject::OnRButtonDown(UINT ID, CPoint point)
  248. {
  249. ASSERT(pDC != NULL);
  251. switch(ID)
  252. {
  253. case DRAW_SELECT:
  254. //if(UnselectObject())
  255. //Invalidate();
  256. break;
  258. case DRAW_LINE:
  259. if(LRepeatTimes == 1)
  260. {
  261. m_DrawGrapObject.CancelDrawLine(pDC, StartPoint, EndPoint);
  262.     LRepeatTimes = 0;
  263. }
  264.     else 
  265. {
  266. ID = DRAW_SELECT;
  267. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  268. LRepeatTimes = 0;
  269. }
  270. break;
  272. case DRAW_RECT:
  273. if(LRepeatTimes == 1)
  274. {
  275. m_DrawGrapObject.CancelDrawRect(pDC, StartPoint, EndPoint);
  276. LRepeatTimes = 0;
  277. }
  278. else
  279. {
  280. ID = DRAW_SELECT;
  281. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  282. LRepeatTimes = 0;
  283. }
  284. break;
  286. case DRAW_CIRCLE:
  287. if(LRepeatTimes == 1)
  288. {
  289. m_DrawGrapObject.CancelDrawCircle(pDC, StartPoint, EndPoint);
  290. LRepeatTimes = 0;
  291. }
  292. else
  293. {
  294. ID = DRAW_SELECT;
  295. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  296. LRepeatTimes = 0;
  297. }
  298. break;
  300. case DRAW_ARC:
  301. if(LRepeatTimes > 0)
  302. {
  303. m_DrawGrapObject.CancelDrawArc(pDC, StartPoint, MidPoint, EndPoint, LRepeatTimes);
  304.     LRepeatTimes = 0;
  305. }
  306. else
  307. {
  308. ID = DRAW_SELECT;
  309. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  310. LRepeatTimes = 0;
  311. }
  312. break;
  313. }
  315. return ID;
  316. }
  318. void CManageGraphObject::OnMouseMove(UINT ID, CPoint point)
  319. {
  320. ASSERT(pDC != NULL);
  322. switch(ID)
  323. {
  324. case DRAW_SELECT:
  325. SetCursor(AfxGetApp()->LoadCursor(IDC_SELECTCUR));
  326. break;
  328. case DRAW_LINE:
  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 DRAW_RECT:
  339. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  340. if(LRepeatTimes == 1)
  341. {
  342. EndPoint = point;
  343. m_DrawGrapObject.DrawRectXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  344. oldEndPoint = EndPoint;
  345. }
  346. break;
  348. case DRAW_CIRCLE:
  349. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  350. if(LRepeatTimes == 1)
  351. {
  352. EndPoint = point;
  353. m_DrawGrapObject.DrawCircleXOR(pDC, StartPoint, EndPoint, oldEndPoint);
  354.                 oldEndPoint = EndPoint;
  355. }
  356. break;
  358. case DRAW_ARC:
  359. SetCursor(AfxGetApp()->LoadCursor(IDC_DRAWCUR));
  360. switch(LRepeatTimes)
  361. {
  362. case 1:
  363. MidPoint = point;
  364. m_DrawGrapObject.DrawArcXOR(pDC, StartPoint, MidPoint, oldMidPoint,
  365.                         EndPoint, oldEndPoint, LRepeatTimes);
  366. oldMidPoint = MidPoint;
  367. break;
  369. case 2:
  370. EndPoint = point;
  371. m_DrawGrapObject.DrawArcXOR(pDC, StartPoint, MidPoint, oldMidPoint,
  372.                         EndPoint, oldEndPoint, LRepeatTimes);
  373. oldEndPoint = EndPoint;
  374. break;
  375. }
  376. break;
  377. }
  378. }
  380. void CManageGraphObject::OnScroll(UINT ID)
  381. {
  382. ASSERT(pDC != NULL);
  384. switch(ID)
  385. {
  386. case DRAW_LINE:
  387. if(LRepeatTimes == 1)
  388. {
  389. m_DrawGrapObject.CancelDrawLine(pDC, StartPoint, EndPoint);
  390.                 oldEndPoint = StartPoint;
  391.     EndPoint = StartPoint;
  392. m_DrawGrapObject.SetOnceFlag();
  393. }
  394. break;
  396. case DRAW_RECT:
  397. if(LRepeatTimes == 1)
  398. {
  399. m_DrawGrapObject.CancelDrawRect(pDC, StartPoint, EndPoint);
  400. oldEndPoint = StartPoint;
  401.     EndPoint = StartPoint;
  402. m_DrawGrapObject.SetOnceFlag();
  403. }
  404. break;
  406. case DRAW_CIRCLE:
  407. if(LRepeatTimes == 1)
  408. {
  409. m_DrawGrapObject.CancelDrawCircle(pDC, StartPoint, EndPoint);
  410. oldEndPoint = StartPoint;
  411. EndPoint = StartPoint;
  412. m_DrawGrapObject.SetOnceFlag();
  413. }
  414. break;
  416. case DRAW_ARC:
  417. m_DrawGrapObject.CancelDrawArc(pDC, StartPoint, MidPoint, EndPoint, LRepeatTimes);
  418. if(LRepeatTimes == 1)
  419. {
  420. oldMidPoint = StartPoint;
  421. MidPoint = StartPoint;
  422. }
  423. if(LRepeatTimes == 2)
  424. {
  425. oldEndPoint = StartPoint;
  426. EndPoint = StartPoint;
  427. }
  428.             m_DrawGrapObject.SetOnceFlag();
  429. break;
  430. }
  431.  
  432. }
  434. //实现“撤销”命令
  435. void CManageGraphObject::OnUndo()
  436. {
  437. CCommandStruct* pCommand;
  438. CGraphObjectInfo* pLineInfo;
  439. CGraphObjectInfo* pRectInfo;
  440. CGraphObjectInfo* pCircleInfo;
  441. CGraphObjectInfo* pArcInfo;
  443. pCommand = (CCommandStruct*)pCommandStack->Undo();
  444.     if(pCommand == NULL)
  445. return;
  447.     switch(pCommand->m_command)
  448. {
  449. case DRAW_LINE:
  450. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[0]);
  451.         pLineInfo->m_del = TRUE;
  452. break;
  454. case DRAW_RECT:
  455. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[0]);
  456.         pRectInfo->m_del = TRUE;
  457. break;
  459. case DRAW_CIRCLE:
  460. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[0]);
  461.         pCircleInfo->m_del = TRUE;
  462. break;
  464. case DRAW_ARC:
  465. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[0]);
  466.         pArcInfo->m_del = TRUE;
  467. break;
  469. case CHANGE_DELETE:
  470. for(int index =0; index < pCommand->m_num; index++)
  471. {
  472. switch(pCommand->m_object[index])
  473. {
  474. case OBJECT_LINE:
  475. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[index]);
  476. pLineInfo->m_del = FALSE;
  477. break;
  479. case OBJECT_RECT:
  480. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[index]);
  481. pRectInfo->m_del = FALSE;
  482. break;
  484. case OBJECT_CIRCLE:
  485. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[index]);
  486. pCircleInfo->m_del = FALSE;
  487. break;
  489. case OBJECT_ARC:
  490. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[index]);
  491. pArcInfo->m_del = FALSE;
  492. break;
  493. }
  494. }
  495. break;
  496. }
  498. }
  500. //实现“重做”命令
  501. void CManageGraphObject::OnRedo()
  502. {
  503. CCommandStruct* pCommand;
  504. CGraphObjectInfo* pLineInfo;
  505. CGraphObjectInfo* pRectInfo;
  506. CGraphObjectInfo* pCircleInfo;
  507. CGraphObjectInfo* pArcInfo;
  509. pCommand = (CCommandStruct*)pCommandStack->Redo();
  510. if(pCommand == NULL)
  511. return;
  513.     switch(pCommand->m_command)
  514. {
  515. case DRAW_LINE:
  516. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[0]);
  517.         pLineInfo->m_del = FALSE;
  518. break;
  520. case DRAW_RECT:
  521. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[0]);
  522.         pRectInfo->m_del = FALSE;
  523. break;
  525. case DRAW_CIRCLE:
  526. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[0]);
  527.         pCircleInfo->m_del = FALSE;
  528. break;
  530. case DRAW_ARC:
  531. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[0]);
  532.         pArcInfo->m_del = FALSE;
  533. break;
  535. case CHANGE_DELETE:
  536. for(int index =0; index < pCommand->m_num; index++)
  537. {
  538. switch(pCommand->m_object[index])
  539. {
  540. case OBJECT_LINE:
  541. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pCommand->m_index[index]);
  542. pLineInfo->m_del = TRUE;
  543. break;
  545. case OBJECT_RECT:
  546. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pCommand->m_index[index]);
  547. pRectInfo->m_del = TRUE;
  548. break;
  550. case OBJECT_CIRCLE:
  551. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pCommand->m_index[index]);
  552. pCircleInfo->m_del = TRUE;
  553. break;
  555. case OBJECT_ARC:
  556. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pCommand->m_index[index]);
  557. pArcInfo->m_del = TRUE;
  558. break;
  559. }
  560. }
  561. break;
  562. }
  563. }
  564. //////////////////////////////////////////////////////////////////////////////////////////////
  565. POINT CManageGraphObject::DrawingToLogic(FPOINT fpoint)
  566. {
  567. POINT point;
  568. point.x = long(fpoint.x * Proportion) + EXTRA_WIDTH;
  569. point.y = PageSize.cy - (long)(fpoint.y * Proportion) - EXTRA_HIGTH;
  571. return point;
  572. }
  574. long CManageGraphObject::DrawingToLogic(float fdistance)
  575. {
  576. long distance;
  577. distance = (long)(fdistance * Proportion);
  579. return distance;
  580. }
  582. FPOINT CManageGraphObject::LogicToDrawing(POINT point)
  583. {
  584. FPOINT fpoint;
  585. fpoint.x = (float)(point.x - EXTRA_WIDTH) / Proportion;
  586. fpoint.y = (float)(PageSize.cy - point.y  - EXTRA_HIGTH) / Proportion;
  588. return fpoint;
  589. }
  591. float CManageGraphObject::LogicToDrawing(long distance)
  592. {
  593. float fdistance;
  594. fdistance = (float)distance / Proportion;
  596. return fdistance;
  597. }
  598. ////////////////////////////////////////////////////////////////////////////////////////////////
  599. void CManageGraphObject::RedrawAllObject(CDC* pDC)
  600. {
  601. RedrawLine(pDC);
  602. RedrawRect(pDC);
  603. RedrawCircle(pDC);
  604. RedrawArc(pDC);
  605. }
  607. void CManageGraphObject::SelectObject(CDC* pDC, CPoint point)
  608. {
  609. SelectLine(pDC, point);   
  610. SelectRect(pDC, point);
  611. SelectCircle(pDC, point);
  612. SelectArc(pDC, point);
  613. }
  615. BOOL CManageGraphObject::UnselectObject()
  616. {
  617. BOOL flag = FALSE;
  618. int nIndex;
  620. if(UnselectLine())
  621. flag = TRUE;
  622. if(UnselectRect())
  623. flag = TRUE;
  624. if(UnselectCircle())
  625. flag = TRUE;
  626.     if(UnselectArc())
  627. flag = TRUE;
  628.     
  629. nIndex = m_SelObjInfoArray.GetSize();
  630. while(nIndex--)
  631. delete (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  632.     m_SelObjInfoArray.RemoveAll();
  634. return flag;
  635. }
  637. //////////////////////////////////////////////////////////////////////////////////////////////
  638. void CManageGraphObject::RedrawLine(CDC* pDC)
  639. {
  640. int index;
  641. CMyLine* pLine;
  642. CGraphObjectInfo* pLineInfo;
  644. index = m_LineArray.GetSize();
  645. while(index--)
  646. {
  647. pLine = (CMyLine*)m_LineArray.GetAt(index);
  648. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  650. if(pLineInfo->m_del == TRUE)
  651. continue;
  652. if(pLineInfo->m_selected == TRUE)
  653. {
  654. m_DrawGrapObject.DrawSelLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  655.                          pLine->m_style, pLine->m_color);
  656. continue;
  657. }
  658.         
  659. m_DrawGrapObject.DrawLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  660.                    pLine->m_style, pLine->m_color);
  661.      }
  662. }
  664. void CManageGraphObject::SelectLine(CDC* pDC, CPoint point)
  665. {
  666. int nIndex;
  667. long distance;
  668. CRect rect;
  670. CGraphObjectInfo* pLineInfo;
  671. CSelectedObjectInfo* pSelObjInfo;
  672. CMyLine* pLine; 
  674. for(nIndex = 0; nIndex < m_LineInfoArray.GetSize(); nIndex++)
  675. {
  676. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(nIndex);
  677. if(pLineInfo ->m_del == TRUE || pLineInfo ->m_selected ==TRUE)
  678. continue;
  680. pLine = (CMyLine*)m_LineArray.GetAt(nIndex);
  682. rect.left = DrawingToLogic(pLine->m_start).x;
  683. rect.top = DrawingToLogic(pLine->m_start).y;
  684. rect.right = DrawingToLogic(pLine->m_end).x;
  685. rect.bottom = DrawingToLogic(pLine->m_end).y;
  687. if( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  688.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) )
  689. {
  690. 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) )
  691.        / sqrt( (rect.right - rect.left) * (rect.right - rect.left) + (rect.bottom - rect.top) * (rect.bottom - rect.top) ) );
  693. if(distance <= SELECT_RANGE)
  694. {
  695.            m_DrawGrapObject.DrawSelLine(pDC, DrawingToLogic(pLine->m_start), DrawingToLogic(pLine->m_end),
  696.                          pLine->m_style, pLine->m_color);
  697. pLineInfo->m_selected = TRUE;
  699. pSelObjInfo = new CSelectedObjectInfo(OBJECT_LINE, nIndex);
  700. m_SelObjInfoArray.Add(pSelObjInfo);
  701. }
  702. }
  703. }
  704. }
  706. BOOL CManageGraphObject::UnselectLine()
  707. {
  708. BOOL flag = FALSE;
  709. int nIndex;
  710. CSelectedObjectInfo* pSelObjInfo;
  711. CGraphObjectInfo* pLineInfo;
  712. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  713. {
  714. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  715. if(pSelObjInfo->m_type ==OBJECT_LINE)
  716. {
  717. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pSelObjInfo->m_index);
  718. pLineInfo->m_selected = FALSE;
  719. flag = TRUE;
  720.         }
  721.     }
  722. return flag;
  723. }
  725. void CManageGraphObject::AddLine(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  726. {
  727. FPOINT start;
  728. FPOINT end;
  730. start = LogicToDrawing(SPoint);
  731. end = LogicToDrawing(EPoint);
  733. CMyLine* pMyLine = new CMyLine(start, end, Style, Color);
  734. m_LineArray.Add(pMyLine);
  736. CGraphObjectInfo * pLineInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  737. m_LineInfoArray.Add(pLineInfo);
  738. }
  740. CMyLine* CManageGraphObject::GetLine(int index)
  741. {
  742. if(index < 0 || index > m_LineArray.GetUpperBound())
  743. return 0;
  744. return (CMyLine*)m_LineArray.GetAt(index);
  745. }
  747. void CManageGraphObject::DelAllLine()
  748. {
  749. int index;
  750. index = m_LineArray.GetSize();
  751. while(index--)
  752. delete (CMyLine*)m_LineArray.GetAt(index);
  753. m_LineArray.RemoveAll();
  754.      
  755. index = m_LineInfoArray.GetSize();
  756. while(index--)
  757. delete (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  758. m_LineInfoArray.RemoveAll();
  759. }
  761. //////////////////////////////////////////////////////////////////////////////////////////////
  762. void CManageGraphObject::RedrawRect(CDC* pDC)
  763. {
  764. int index;
  765. CMyRect* pRect;
  766. CGraphObjectInfo* pRectInfo;
  768. index = m_RectArray.GetSize();
  770. //设置不填充状态
  771. pDC->SelectStockObject(NULL_BRUSH);
  772. while(index--)
  773. {
  774. pRect = (CMyRect*)m_RectArray.GetAt(index);
  775. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  777. if(pRectInfo->m_del == TRUE)
  778. continue;
  779. if(pRectInfo->m_selected == TRUE)
  780. {
  781. m_DrawGrapObject.DrawSelRect(pDC, DrawingToLogic(pRect->m_start), DrawingToLogic(pRect->m_end),
  782.                          pRect->m_style, pRect->m_color);
  783. continue;
  784. }
  786. m_DrawGrapObject.DrawRect(pDC, DrawingToLogic(pRect->m_start), DrawingToLogic(pRect->m_end),
  787.                    pRect->m_style, pRect->m_color);
  788.       
  789. }
  790. }
  792. void CManageGraphObject::SelectRect(CDC* pDC, CPoint point)
  793. {
  794. int nIndex;
  795. CRect rect;
  797. CGraphObjectInfo* pRectInfo;
  798. CSelectedObjectInfo* pSelObjInfo;
  799. CMyRect* pRect; 
  801. for(nIndex = 0; nIndex < m_RectInfoArray.GetSize(); nIndex++)
  802. {
  803. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(nIndex);
  804. if(pRectInfo ->m_del == TRUE || pRectInfo ->m_selected ==TRUE)
  805. continue;
  807. pRect = (CMyRect*)m_RectArray.GetAt(nIndex);
  809. rect.left = DrawingToLogic(pRect->m_start).x;
  810. rect.top = DrawingToLogic(pRect->m_start).y;
  811. rect.right = DrawingToLogic(pRect->m_end).x;
  812. rect.bottom = DrawingToLogic(pRect->m_end).y;
  814. if( ( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  815.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) ) &&
  816. ( (point.x <= min(rect.left, rect.right) + SELECT_RANGE) || (point.x >= max(rect.left, rect.right) - SELECT_RANGE) ||
  817.             (point.y <= min(rect.top, rect.bottom) + SELECT_RANGE) || (point.y >= max(rect.top, rect.bottom) - SELECT_RANGE) ) ) 
  819. {
  820. m_DrawGrapObject.DrawSelRect(pDC, rect.TopLeft(), rect.BottomRight(), 
  821.                          pRect->m_style, pRect->m_color);
  823. pRectInfo->m_selected = TRUE;
  825. pSelObjInfo = new CSelectedObjectInfo(OBJECT_RECT, nIndex);
  826. m_SelObjInfoArray.Add(pSelObjInfo);
  827. }
  828. }
  830. }
  832. BOOL CManageGraphObject::UnselectRect()
  833. {
  834. BOOL flag = FALSE;
  835. int nIndex;
  836. CSelectedObjectInfo* pSelObjInfo;
  837. CGraphObjectInfo* pRectInfo;
  838. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  839. {
  840. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  841. if(pSelObjInfo->m_type ==OBJECT_RECT)
  842. {
  843. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pSelObjInfo->m_index);
  844. pRectInfo->m_selected = FALSE;
  845. flag = TRUE;
  846.         }
  847.     }
  848. return flag;
  849. }
  851. void CManageGraphObject::AddRect(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  852. {
  853. FPOINT start;
  854. FPOINT end;
  856. start = LogicToDrawing(SPoint);
  857. end = LogicToDrawing(EPoint);
  858.     
  859. CMyRect* pMyRect = new CMyRect(start, end, Style, Color);
  860. m_RectArray.Add(pMyRect);
  862. CGraphObjectInfo * pRectInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  863. m_RectInfoArray.Add(pRectInfo);
  864. }
  866. CMyRect* CManageGraphObject::GetRect(int index)
  867. {
  868. if(index < 0 || index > m_RectArray.GetUpperBound())
  869. return 0;
  870. return (CMyRect*)m_RectArray.GetAt(index);
  871. }
  873. void CManageGraphObject::DelAllRect()
  874. {
  875. int index;
  877. index = m_RectArray.GetSize();
  878. while(index--)
  879. delete (CMyRect*)m_RectArray.GetAt(index);
  880. m_RectArray.RemoveAll();
  882. index = m_RectInfoArray.GetSize();
  883. while(index--)
  884. delete (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  885. m_RectInfoArray.RemoveAll();
  886. }
  888. //////////////////////////////////////////////////////////////////////////////////////////////
  889. void CManageGraphObject::RedrawCircle(CDC* pDC)
  890. {
  891. int index;
  892. CMyCircle* pCircle;
  893. CGraphObjectInfo* pCircleInfo;
  895. index = m_CircleArray.GetSize();
  897. //设置不填充状态
  898. pDC->SelectStockObject(NULL_BRUSH);
  899. while(index--)
  900. {
  901. pCircle = (CMyCircle*)m_CircleArray.GetAt(index);
  902. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  904. if(pCircleInfo->m_del == TRUE)
  905. continue;
  906. if(pCircleInfo->m_selected == TRUE)
  907. {
  908. m_DrawGrapObject.DrawSelCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius), 
  909.                            pCircle->m_style, pCircle->m_color);
  910. continue;
  911. }
  913. m_DrawGrapObject.DrawCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius),
  914.                          pCircle->m_style, pCircle->m_color);
  915.    }
  916. }
  919. void CManageGraphObject::SelectCircle(CDC* pDC, CPoint point)
  920. {
  921. int nIndex;
  922. POINT origin;
  923. long r;
  924. long distance;
  926. CGraphObjectInfo* pCircleInfo;
  927. CSelectedObjectInfo* pSelObjInfo;
  928. CMyCircle* pCircle; 
  930. for(nIndex = 0; nIndex < m_CircleInfoArray.GetSize(); nIndex++)
  931. {
  932. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(nIndex);
  933. if(pCircleInfo ->m_del == TRUE || pCircleInfo ->m_selected ==TRUE)
  934. continue;
  936. pCircle = (CMyCircle*)m_CircleArray.GetAt(nIndex);
  938. origin = DrawingToLogic(pCircle->m_origin);
  939. r = DrawingToLogic(pCircle->m_radius);
  941. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  943. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  944. {
  945. m_DrawGrapObject.DrawSelCircle(pDC, DrawingToLogic(pCircle->m_origin), DrawingToLogic(pCircle->m_radius),
  946.                            pCircle->m_style, pCircle->m_color);
  948. pCircleInfo->m_selected = TRUE;
  950. pSelObjInfo = new CSelectedObjectInfo(OBJECT_CIRCLE, nIndex);
  951. m_SelObjInfoArray.Add(pSelObjInfo);
  952. }
  953. }
  955. }
  957. BOOL CManageGraphObject::UnselectCircle()
  958. {
  959. BOOL flag = FALSE;
  960. int nIndex;
  961. CSelectedObjectInfo* pSelObjInfo;
  962. CGraphObjectInfo* pCircleInfo;
  963. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  964. {
  965. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  966. if(pSelObjInfo->m_type ==OBJECT_CIRCLE)
  967. {
  968. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pSelObjInfo->m_index);
  969. pCircleInfo->m_selected = FALSE;
  970. flag = TRUE;
  971.         }
  972.     }
  973. return flag;
  974. }
  976. void CManageGraphObject::AddCircle(POINT SPoint, POINT EPoint, int Style, COLORREF Color)
  977. {
  978. FPOINT start;
  979. FPOINT end;
  980. float r;
  982. start = LogicToDrawing(SPoint);
  983. end = LogicToDrawing(EPoint);
  984. r = (float)sqrt(pow(start.x - end.x, 2) + pow(start.y - end.y, 2));
  986. CMyCircle* pMyCircle = new CMyCircle(start, r, Style, Color);
  987. m_CircleArray.Add(pMyCircle);
  989. CGraphObjectInfo* pCircleInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  990. m_CircleInfoArray.Add(pCircleInfo);
  991. }
  993. CMyCircle* CManageGraphObject::GetCircle(int index)
  994. {
  995. if(index < 0 || index > m_CircleArray.GetUpperBound())
  996. return 0;
  997. return (CMyCircle*)m_CircleArray.GetAt(index);
  998. }
  1000. void CManageGraphObject::DelAllCircle()
  1001. {
  1002. int index;
  1004. index = m_CircleArray.GetSize();
  1005. while(index--)
  1006. delete (CMyCircle*)m_CircleArray.GetAt(index);
  1007. m_CircleArray.RemoveAll();
  1009. index = m_CircleInfoArray.GetSize();
  1010. while(index--)
  1011. delete (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  1012. m_CircleInfoArray.RemoveAll();
  1013. }
  1015. //////////////////////////////////////////////////////////////////////////////////////////////
  1016. void CManageGraphObject::RedrawArc(CDC* pDC)
  1017. {
  1018. int index;
  1019. CMyArc* pArc;
  1020. CGraphObjectInfo* pArcInfo;
  1022. index = m_ArcArray.GetSize();
  1024. //设置不填充状态
  1025. pDC->SelectStockObject(NULL_BRUSH);
  1026. while(index--)
  1027. {
  1028. pArc = (CMyArc*)m_ArcArray.GetAt(index);
  1029. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1031. if(pArcInfo->m_del == TRUE)
  1032. continue;
  1033. if(pArcInfo->m_selected == TRUE)
  1034. {
  1035. m_DrawGrapObject.DrawSelArc(pDC, DrawingToLogic(pArc->m_origin), DrawingToLogic(pArc->m_start), 
  1036.                         DrawingToLogic(pArc->m_end),
  1037. DrawingToLogic(pArc->m_radius), LineStyle, PenColor);
  1038. continue;
  1039. }
  1040.          
  1042. m_DrawGrapObject.DrawArc(pDC, DrawingToLogic(pArc->m_origin),
  1043.                      DrawingToLogic(pArc->m_start), DrawingToLogic(pArc->m_end),
  1044.                                  DrawingToLogic(pArc->m_radius), pArc->m_style, pArc->m_color);
  1045. }
  1046. }
  1049. void CManageGraphObject::SelectArc(CDC* pDC, CPoint point)
  1050. {
  1051. int nIndex;
  1053. POINT origin;
  1054. long r;
  1055. long distance;
  1057. CPoint start;
  1058. CPoint end;
  1060. CGraphObjectInfo* pArcInfo;
  1061. CSelectedObjectInfo* pSelObjInfo;
  1062. CMyArc* pArc; 
  1064. for(nIndex = 0; nIndex < m_ArcInfoArray.GetSize(); nIndex++)
  1065. {
  1066. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(nIndex);
  1067. if(pArcInfo ->m_del == TRUE || pArcInfo ->m_selected ==TRUE)
  1068. continue;
  1070. pArc = (CMyArc*)m_ArcArray.GetAt(nIndex);
  1072. origin = DrawingToLogic(pArc->m_origin);
  1073. start = DrawingToLogic(pArc->m_start);
  1074. end = DrawingToLogic(pArc->m_end);
  1075. r = DrawingToLogic(pArc->m_radius);
  1077. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  1079. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  1080. {
  1081. m_DrawGrapObject.DrawSelArc(pDC, origin, start, end, r, pArc->m_style, pArc->m_color);
  1083. pArcInfo->m_selected = TRUE;
  1084. pSelObjInfo = new CSelectedObjectInfo(OBJECT_ARC, nIndex);
  1085. m_SelObjInfoArray.Add(pSelObjInfo);
  1086. }
  1087. }
  1088. }
  1090. BOOL CManageGraphObject::UnselectArc()
  1091. {
  1092. BOOL flag = FALSE;
  1093. int nIndex;
  1094. CSelectedObjectInfo* pSelObjInfo;
  1095. CGraphObjectInfo* pArcInfo;
  1096. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1097. {
  1098. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1099. if(pSelObjInfo->m_type ==OBJECT_ARC)
  1100. {
  1101. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pSelObjInfo->m_index);
  1102. pArcInfo->m_selected = FALSE;
  1103. flag = TRUE;
  1104.         }
  1105.     }
  1106. return flag;
  1107. }
  1110. void CManageGraphObject::AddArc(POINT SPoint, POINT MPoint, POINT EPoint, int Style, COLORREF Color)
  1111. {
  1112. long x1, y1, x2, y2;
  1114. double originX;
  1115. double originY;
  1116. double k1;
  1117. double k2;
  1118. double mid1X;
  1119. double mid1Y;
  1120. double mid2X;
  1121. double mid2Y;
  1123. POINT OPoint;
  1124. long Radius;
  1126. CMyArc* pMyArc;
  1128. if(SPoint.y == MPoint.y)
  1129. k1 = 1000000.0;
  1130. else 
  1131. k1 = (- (double)(SPoint.x - MPoint.x) / (double)(SPoint.y - MPoint.y));
  1133. if(EPoint.y == MPoint.y)
  1134. k2 = 1000000.0;
  1135. else 
  1136. k2 =  (- (double)(EPoint.x - MPoint.x) / (double)(EPoint.y - MPoint.y));
  1138. mid1X = (double)(SPoint.x + MPoint.x) / 2.0;
  1139. mid1Y = (double)(SPoint.y + MPoint.y) / 2.0;
  1141. mid2X = (double)(EPoint.x + MPoint.x) / 2.0;
  1142. mid2Y = (double)(EPoint.y + MPoint.y) / 2.0;
  1144. if(k1 == k2)
  1145. return;
  1147. if(k1 == 1000000.0)
  1148. {
  1149. originX = mid1X;
  1150. originY = k2 * (originX - mid2X) + mid2Y;
  1151. }
  1152. else
  1153. if(k2 == 1000000.0)
  1154. {
  1155. originX = mid2X;
  1156. originY = k1 * (originX - mid1X) + mid1Y;
  1157. }
  1158. else
  1159. {
  1160. originX = ((k2 * mid2X - k1 * mid1X) - (mid2Y - mid1Y)) / (k2 - k1);
  1161. originY = k2 * (originX - mid2X) + mid2Y;
  1162. }
  1164. Radius = (long)sqrt(pow((double)(originX - SPoint.x), 2) + pow((double)(originY - SPoint.y), 2));
  1166. OPoint.x = (long)originX;
  1167. OPoint.y = (long)originY ;
  1169. x1 = MidPoint.x - SPoint.x;
  1170. y1 = MPoint.y - SPoint.y;
  1172. x2 = EPoint.x - SPoint.x;
  1173. y2 = EPoint.y - SPoint.y;
  1175. if(x1*y2 - x2*y1 < 0)
  1176. pMyArc = new CMyArc(LogicToDrawing(OPoint), LogicToDrawing(SPoint), 
  1177.                     LogicToDrawing(EPoint), LogicToDrawing(Radius), 
  1178. LineStyle, PenColor);
  1179. else
  1180. pMyArc = new CMyArc(LogicToDrawing(OPoint), LogicToDrawing(EPoint), 
  1181.                     LogicToDrawing(SPoint), LogicToDrawing(Radius), 
  1182. LineStyle, PenColor);
  1184. m_ArcArray.Add(pMyArc);
  1186. CGraphObjectInfo* pArcInfo = new CGraphObjectInfo(0, FALSE, FALSE);
  1187. m_ArcInfoArray.Add(pArcInfo);
  1188. }
  1191. CMyArc* CManageGraphObject::GetArc(int index)
  1192. {
  1193. if(index < 0 || index > m_ArcArray.GetUpperBound())
  1194. return 0;
  1195. return (CMyArc*)m_ArcArray.GetAt(index);
  1196. }
  1198. void CManageGraphObject::DelAllArc()
  1199. {
  1200. int index;
  1202. index = m_ArcArray.GetSize();
  1203. while(index--)
  1204. delete (CMyArc*)m_ArcArray.GetAt(index);
  1205. m_ArcArray.RemoveAll();
  1207. index = m_ArcInfoArray.GetSize();
  1208. while(index--)
  1209. delete (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1210. m_ArcInfoArray.RemoveAll();
  1211. }