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

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

绘图程序

开发平台：

Visual C++

MyDraw.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "math.h"
  3. #include "MyDraw.h"
  4. #include "MyDefine.h"
  7. ///////////////////////////////////////////////////////////////////////////////////////////////
  8. //被选择图形对象信息
  9. CSelectedObjectInfo::CSelectedObjectInfo(int type, int index)
  10. {
  11. m_type = type;
  12. m_index = index;
  13. }
  14. ///////////////////////////////////////////////////////////////////////////////////////////////
  15. IMPLEMENT_DYNCREATE(COperateObject, CObject)
  17. COperateObject::COperateObject()
  18. {
  19. Proportion = 1.0;
  20. }
  22. COperateObject::~COperateObject()
  23. {
  24. DelAllLine();
  25. DelAllRect();
  26. DelAllCircle();
  27. DelAllArc();
  28. }
  30. void COperateObject::Intialize(COLORREF pcolor, int lstyle)
  31. {
  32. PenColor = pcolor;
  33. LineStyle = lstyle;
  34. }
  36. void COperateObject::SetPageSize(SIZE size)
  37. {
  38. PageSize.cx = size.cx;
  39. PageSize.cy = size.cy;
  40. }
  42. void COperateObject::Serialize(CArchive& ar)
  43. {
  44. int num;
  45. int index;
  47. CGraphObjectInfo* pLineInfo;
  48. CGraphObjectInfo* pRectInfo;
  49. CGraphObjectInfo* pCircleInfo;
  50. CGraphObjectInfo* pArcInfo;
  52. if(ar.IsStoring())
  53. {
  54. ar << m_LineArray.GetSize() << m_RectArray.GetSize()
  55.    << m_CircleArray.GetSize() << m_ArcArray.GetSize();
  56. }
  57. else
  58. {
  59. ar >> num;
  60. for(index = 0; index < num; index++)
  61. {
  62. pLineInfo = new CGraphObjectInfo(FALSE, FALSE);
  63. m_LineInfoArray.Add(pLineInfo);
  64. }
  66. ar >> num;
  67. for(index = 0; index < num; index++)
  68. {
  69. pRectInfo = new CGraphObjectInfo(FALSE, FALSE);
  70. m_RectInfoArray.Add(pRectInfo);
  71. }
  73. ar >> num;
  74. for(index = 0; index < num; index++)
  75. {
  76. pCircleInfo = new CGraphObjectInfo(FALSE, FALSE);
  77. m_CircleInfoArray.Add(pCircleInfo);
  78. }
  80. ar >> num;
  81. for(index = 0; index < num; index++)
  82. {
  83. pArcInfo = new CGraphObjectInfo(FALSE, FALSE);
  84. m_ArcInfoArray.Add(pArcInfo);
  85. }
  87. }
  89. //注意当打开文件时，下面的Serialize()函数会自动创建CMyLine,CMyRect等对象
  90.     m_LineArray.Serialize(ar);
  91. m_RectArray.Serialize(ar);
  92. m_CircleArray.Serialize(ar);
  93. m_ArcArray.Serialize(ar);
  94. }
  95. ////////////////////////////////////////////////////////////////////////////////////////////////
  96. void COperateObject::RedrawAllObject(CDC* pDC)
  97. {
  98. RedrawLine(pDC);
  99. RedrawRect(pDC);
  100. RedrawCircle(pDC);
  101. RedrawArc(pDC);
  102. }
  104. void COperateObject::SelectObject(CDC* pDC, CPoint point)
  105. {
  106. SelectLine(pDC, point);   
  107. SelectRect(pDC, point);
  108. SelectCircle(pDC, point);
  109. SelectArc(pDC, point);
  110. }
  112. BOOL COperateObject::UnselectObject()
  113. {
  114. BOOL flag = FALSE;
  115. int nIndex;
  117. if(UnselectLine())
  118. flag = TRUE;
  119. if(UnselectRect())
  120. flag = TRUE;
  121. if(UnselectCircle())
  122. flag = TRUE;
  123.     if(UnselectArc())
  124. flag = TRUE;
  125.     
  126. nIndex = m_SelObjInfoArray.GetSize();
  127. while(nIndex--)
  128. delete (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  129.     m_SelObjInfoArray.RemoveAll();
  131. return flag;
  132. }
  133. //////////////////////////////////////////////////////////////////////////////////////////////
  134. //operate line
  135. void COperateObject::DrawLineA(CDC* pDC)
  136. {
  137. //基于CDC
  138. pDC->SetROP2(R2_NOT);
  140. pDC->MoveTo(StartPoint);
  141. pDC->LineTo(oldEndPoint);
  142. pDC->MoveTo(StartPoint);
  143. pDC->LineTo(EndPoint);
  145. oldEndPoint = EndPoint;
  146. pDC->SetROP2(R2_COPYPEN);
  147. }
  150. void COperateObject::DrawLineB(CDC* pDC)
  151. {
  152. //基于CDC
  153. CPen Pen;
  154. CPen* OldPen;
  156. Pen.CreatePen(LineStyle, 1, PenColor);
  157. OldPen = pDC->SelectObject(&Pen);
  158. pDC->SetROP2(R2_COPYPEN);
  159. pDC->MoveTo(StartPoint);
  160. pDC->LineTo(EndPoint);
  162. pDC->SelectObject(OldPen);
  163. }
  165. void COperateObject::DrawSelLine(CDC* pDC, CMyLine * pLine)
  166. {
  167. CPen* Pen;
  168. CPen* OldPen;
  169. CPoint start;
  170. CPoint end;
  171. CPoint middle;
  172. RECT rect;
  174. Pen = new CPen(PS_DOT, 1, pLine->m_color);
  175. OldPen = pDC->SelectObject(Pen);
  177. start.x = (long)(pLine->m_startX * Proportion) + EXTRA_WIDTH;
  178. start.y = PageSize.cy - (long)(pLine->m_startY * Proportion) - EXTRA_HIGTH;
  179.     end.x = (long)(pLine->m_endX * Proportion) + EXTRA_WIDTH;
  180. end.y = PageSize.cy - (long)(pLine->m_endY * Proportion) - EXTRA_HIGTH;
  182. pDC->MoveTo(start);
  183. pDC->LineTo(end);
  184. pDC->SelectObject(OldPen);
  185. delete Pen;
  187. Pen = new CPen(PS_SOLID, 1, RGB(0, 0, 255));
  188. OldPen = pDC->SelectObject(Pen);
  189. pDC->SelectStockObject(NULL_BRUSH);
  191. rect.left = start.x - SEL_RECT_WIDTH;
  192. rect.top = start.y - SEL_RECT_WIDTH;
  193. rect.right = start.x + SEL_RECT_WIDTH + 1;
  194. rect.bottom = start.y + SEL_RECT_WIDTH + 1;
  195.     pDC->Rectangle(&rect);
  197. middle.x = (start.x + end.x) / 2;
  198. middle.y = (start.y + end.y) / 2;
  199. rect.left = middle.x - SEL_RECT_WIDTH;
  200. rect.top = middle.y - SEL_RECT_WIDTH;
  201. rect.right = middle.x + SEL_RECT_WIDTH + 1;
  202. rect.bottom = middle.y + SEL_RECT_WIDTH + 1;
  203.     pDC->Rectangle(&rect);
  205. rect.left = end.x - SEL_RECT_WIDTH;
  206. rect.top = end.y - SEL_RECT_WIDTH;
  207. rect.right = end.x + SEL_RECT_WIDTH + 1;
  208. rect.bottom = end.y + SEL_RECT_WIDTH + 1;
  209.     pDC->Rectangle(&rect);
  211.     pDC->SelectObject(OldPen);
  212. pDC->SetROP2(R2_COPYPEN);
  213. delete Pen;
  214. }
  216. void COperateObject::RedrawLine(CDC* pDC)
  217. {
  218. CPen *Pen;
  219. CPen* OldPen;
  220. int index;
  221. CMyLine* pLine;
  222. CGraphObjectInfo* pLineInfo;
  224. index = m_LineArray.GetSize();
  225. while(index--)
  226. {
  227. pLine = (CMyLine*)m_LineArray.GetAt(index);
  228. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  230. if(pLineInfo->m_del == TRUE)
  231. continue;
  232. if(pLineInfo->m_selected == TRUE)
  233. {
  234. DrawSelLine(pDC, pLine);
  235. continue;
  236. }
  238.         Pen = new CPen(pLine->m_style, 1, pLine->m_color);
  239. OldPen = pDC->SelectObject(Pen);
  241. pDC->MoveTo((long)(pLine->m_startX * Proportion) + EXTRA_WIDTH, 
  242. PageSize.cy - (long)(pLine->m_startY * Proportion) - EXTRA_HIGTH);
  243. pDC->LineTo((long)(pLine->m_endX * Proportion) + EXTRA_WIDTH,
  244. PageSize.cy - (long)(pLine->m_endY * Proportion) - EXTRA_HIGTH);
  245. //注意以下两句顺序不可颠倒
  246. pDC->SelectObject(OldPen);
  247. delete Pen;
  248. }
  249. }
  251. void COperateObject::CancelDrawLine(CDC* pDC)
  252. {
  253. pDC->SetROP2(R2_NOT);
  255. pDC->MoveTo(StartPoint);
  256. pDC->LineTo(oldEndPoint);
  257.     
  258. pDC->SetROP2(R2_COPYPEN);
  259. }
  261. void COperateObject::SelectLine(CDC* pDC, CPoint point)
  262. {
  263. int nIndex;
  264. long distance;
  265. RECT rect;
  267. CGraphObjectInfo* pLineInfo;
  268. CSelectedObjectInfo* pSelObjInfo;
  269. CMyLine* pLine; 
  271. for(nIndex = 0; nIndex < m_LineInfoArray.GetSize(); nIndex++)
  272. {
  273. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(nIndex);
  274. if(pLineInfo ->m_del == TRUE || pLineInfo ->m_selected ==TRUE)
  275. continue;
  277. pLine = (CMyLine*)m_LineArray.GetAt(nIndex);
  279. rect.left = (long)(pLine->m_startX * Proportion) + EXTRA_WIDTH;
  280. rect.top = PageSize.cy - (long)(pLine->m_startY * Proportion) - EXTRA_HIGTH;
  281. rect.right = (long)(pLine->m_endX * Proportion) + EXTRA_WIDTH;
  282. rect.bottom = PageSize.cy - (long)(pLine->m_endY * Proportion) - EXTRA_HIGTH;
  284. if( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  285.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) )
  286. {
  287. 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) )
  288.        / sqrt( (rect.right - rect.left) * (rect.right - rect.left) + (rect.bottom - rect.top) * (rect.bottom - rect.top) ) );
  290. if(distance <= SELECT_RANGE)
  291. {
  292. DrawSelLine(pDC, pLine);
  293. pLineInfo->m_selected = TRUE;
  295. pSelObjInfo = new CSelectedObjectInfo(OBJ_LINE, nIndex);
  296. m_SelObjInfoArray.Add(pSelObjInfo);
  297. }
  298. }
  299. }
  300. }
  302. BOOL COperateObject::UnselectLine()
  303. {
  304. BOOL flag = FALSE;
  305. int nIndex;
  306. CSelectedObjectInfo* pSelObjInfo;
  307. CGraphObjectInfo* pLineInfo;
  308. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  309. {
  310. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  311. if(pSelObjInfo->m_type ==OBJ_LINE)
  312. {
  313. pLineInfo = (CGraphObjectInfo*)m_LineInfoArray.GetAt(pSelObjInfo->m_index);
  314. pLineInfo->m_selected = FALSE;
  315. flag = TRUE;
  316.         }
  317.     }
  318. return flag;
  319. }
  321. void COperateObject::AddLine()
  322. {
  323. float startx;
  324. float starty;
  325. float endx;
  326. float endy;
  328. startx = (StartPoint.x - EXTRA_WIDTH) / Proportion;
  329. starty = (PageSize.cy - StartPoint.y  - EXTRA_HIGTH) / Proportion;
  331. endx = (EndPoint.x - EXTRA_WIDTH) / Proportion;
  332. endy = (PageSize.cy - EndPoint.y - EXTRA_HIGTH) / Proportion;
  334. CMyLine* pMyLine = new CMyLine(startx, starty, endx, endy, LineStyle, PenColor);
  335. m_LineArray.Add(pMyLine);
  337. CGraphObjectInfo * pLineInfo = new CGraphObjectInfo(FALSE, FALSE);
  338. m_LineInfoArray.Add(pLineInfo);
  339. }
  341. CMyLine* COperateObject::GetLine(int index)
  342. {
  343. if(index < 0 || index > m_LineArray.GetUpperBound())
  344. return 0;
  345. return (CMyLine*)m_LineArray.GetAt(index);
  346. }
  348. void COperateObject::DelAllLine()
  349. {
  350. int index;
  351. index = m_LineArray.GetSize();
  352. while(index--)
  353. delete (CMyLine*)m_LineArray.GetAt(index);
  354. m_LineArray.RemoveAll();
  355.      
  356. index = m_LineInfoArray.GetSize();
  357. while(index--)
  358. delete (CGraphObjectInfo*)m_LineInfoArray.GetAt(index);
  359. m_LineInfoArray.RemoveAll();
  360. }
  362. ///////////////////////////////////////////////////////////////////////////////////////////////
  363. //operate rectangle
  364. void COperateObject::DrawRectA(CDC* pDC)
  365. {
  366. //基于CDC
  367. pDC->SetROP2(R2_NOT);
  368. //设置不填充状态
  369. pDC->SelectStockObject(NULL_BRUSH);
  371. CRect rect;
  372. rect.left = StartPoint.x;
  373. rect.top = StartPoint.y;
  374. rect.right = oldEndPoint.x;
  375. rect.bottom = oldEndPoint.y;
  376. rect.NormalizeRect();
  377. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom +1);
  379. rect.left = StartPoint.x;
  380. rect.top = StartPoint.y;
  381. rect.right = EndPoint.x;
  382. rect.bottom = EndPoint.y;
  383. rect.NormalizeRect();
  384. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  386. oldEndPoint = EndPoint;
  387. pDC->SetROP2(R2_COPYPEN);
  388. }
  390. void COperateObject::DrawRectB(CDC* pDC)
  391. {
  392. //基于CDC
  393. CPen Pen;
  394. CPen* OldPen;
  396. CRect rect;
  397. rect.left = StartPoint.x;
  398. rect.top = StartPoint.y;
  399. rect.right = EndPoint.x;
  400. rect.bottom = EndPoint.y;
  401. rect.NormalizeRect();
  403. Pen.CreatePen(LineStyle, 1, PenColor);
  404. OldPen = pDC->SelectObject(&Pen);
  405. //设置不填充状态
  406. pDC->SelectStockObject(NULL_BRUSH);
  407. pDC->SetROP2(R2_COPYPEN);
  408. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  409. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  410. pDC->SelectObject(OldPen);
  411. }
  413. void COperateObject::CancelDrawRect(CDC* pDC)
  414. {
  415. pDC->SetROP2(R2_NOT);
  416. pDC->SelectStockObject(NULL_BRUSH);
  418. CRect rect;
  419. rect.left = StartPoint.x;
  420. rect.top = StartPoint.y;
  421. rect.right = EndPoint.x;
  422. rect.bottom = EndPoint.y;
  423. rect.NormalizeRect();
  424. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  425. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  427. pDC->SetROP2(R2_COPYPEN);
  428. }
  430. void COperateObject::RedrawRect(CDC* pDC)
  431. {
  432. CPen *Pen;
  433. CPen* OldPen;
  434. int index;
  435. CRect rect;
  436. CMyRect* pRect;
  437. CGraphObjectInfo* pRectInfo;
  439. index = m_RectArray.GetSize();
  441. //设置不填充状态
  442. pDC->SelectStockObject(NULL_BRUSH);
  443. while(index--)
  444. {
  445. pRect = (CMyRect*)m_RectArray.GetAt(index);
  446. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  448. if(pRectInfo->m_del == TRUE)
  449. continue;
  450. if(pRectInfo->m_selected == TRUE)
  451. {
  452. DrawSelRect(pDC, pRect);
  453. continue;
  454. }
  456.         Pen = new CPen(pRect->m_style, 1, pRect->m_color);
  457. OldPen = pDC->SelectObject(Pen);
  459.         rect.left = (long)(pRect->m_startX * Proportion) + EXTRA_WIDTH;
  460. rect.right = (long)(pRect->m_endX * Proportion) + EXTRA_WIDTH;
  461.     rect.top = PageSize.cy - (long)(pRect->m_startY * Proportion) - EXTRA_HIGTH;
  462.         rect.bottom = PageSize.cy - (long)(pRect->m_endY * Proportion) - EXTRA_HIGTH;
  463. rect.NormalizeRect();
  465. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  466. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  468. //注意以下两句顺序不可颠倒
  469. pDC->SelectObject(OldPen);
  470. delete Pen;
  471. }
  472. }
  474. void COperateObject::DrawSelRect(CDC* pDC, CMyRect* pRect)
  475. {
  476. CPen *Pen;
  477. CPen* OldPen;
  478. CRect rect;
  480.     CPoint mid;
  482. //设置不填充状态
  483. pDC->SelectStockObject(NULL_BRUSH);
  484. Pen = new CPen(PS_DOT, 1, pRect->m_color);
  485. OldPen = pDC->SelectObject(Pen);
  487.     rect.left = (long)(pRect->m_startX * Proportion) + EXTRA_WIDTH;
  488. rect.right = (long)(pRect->m_endX * Proportion) + EXTRA_WIDTH;
  489.     rect.top = PageSize.cy - (long)(pRect->m_startY * Proportion) - EXTRA_HIGTH;
  490.     rect.bottom = PageSize.cy - (long)(pRect->m_endY * Proportion) - EXTRA_HIGTH;
  491. rect.NormalizeRect();
  492. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  493. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  494. pDC->SelectObject(OldPen);
  495. delete Pen;
  497. Pen = new CPen(PS_SOLID, 1, RGB(0, 0, 255));
  498. OldPen = pDC->SelectObject(Pen);
  500.     pDC->Rectangle(rect.left - SEL_RECT_WIDTH, rect.top - SEL_RECT_WIDTH,
  501.            rect.left + SEL_RECT_WIDTH + 1, rect.top + SEL_RECT_WIDTH + 1);
  502. pDC->Rectangle(rect.left - SEL_RECT_WIDTH, rect.bottom - SEL_RECT_WIDTH,
  503.            rect.left + SEL_RECT_WIDTH + 1, rect.bottom + SEL_RECT_WIDTH + 1);
  504. pDC->Rectangle(rect.right - SEL_RECT_WIDTH, rect.top - SEL_RECT_WIDTH,
  505.            rect.right + SEL_RECT_WIDTH + 1, rect.top + SEL_RECT_WIDTH + 1);
  506. pDC->Rectangle(rect.right - SEL_RECT_WIDTH, rect.bottom - SEL_RECT_WIDTH,
  507.            rect.right + SEL_RECT_WIDTH + 1, rect.bottom + SEL_RECT_WIDTH + 1);
  509. mid.x = (rect.left + rect.right) / 2;
  510. mid.y = rect.top;
  511. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  512.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  514. mid.x = (rect.left + rect.right) / 2;
  515. mid.y = rect.bottom;
  516. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  517.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  520. mid.x = rect.left;
  521. mid.y = (rect.top + rect.bottom) / 2;
  522. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  523.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  525. mid.x = rect.right;
  526. mid.y = (rect.top + rect.bottom) / 2;
  527. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  528.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  530. //注意以下两句顺序不可颠倒
  531. pDC->SelectObject(OldPen);
  532. delete Pen;
  533. }
  535. void COperateObject::SelectRect(CDC* pDC, CPoint point)
  536. {
  537. int nIndex;
  538. RECT rect;
  540. CGraphObjectInfo* pRectInfo;
  541. CSelectedObjectInfo* pSelObjInfo;
  542. CMyRect* pRect; 
  544. for(nIndex = 0; nIndex < m_RectInfoArray.GetSize(); nIndex++)
  545. {
  546. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(nIndex);
  547. if(pRectInfo ->m_del == TRUE || pRectInfo ->m_selected ==TRUE)
  548. continue;
  550. pRect = (CMyRect*)m_RectArray.GetAt(nIndex);
  552. rect.left = (long)(pRect->m_startX * Proportion) + EXTRA_WIDTH;
  553. rect.top = PageSize.cy - (long)(pRect->m_startY * Proportion) - EXTRA_HIGTH;
  554. rect.right = (long)(pRect->m_endX * Proportion) + EXTRA_WIDTH;
  555. rect.bottom = PageSize.cy - (long)(pRect->m_endY * Proportion) - EXTRA_HIGTH;
  557. if( ( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  558.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) ) &&
  559. ( (point.x <= min(rect.left, rect.right) + SELECT_RANGE) || (point.x >= max(rect.left, rect.right) - SELECT_RANGE) ||
  560.             (point.y <= min(rect.top, rect.bottom) + SELECT_RANGE) || (point.y >= max(rect.top, rect.bottom) - SELECT_RANGE) ) ) 
  562. {
  563. DrawSelRect(pDC, pRect);
  564. pRectInfo->m_selected = TRUE;
  566. pSelObjInfo = new CSelectedObjectInfo(OBJ_RECT, nIndex);
  567. m_SelObjInfoArray.Add(pSelObjInfo);
  568. }
  569. }
  571. }
  573. BOOL COperateObject::UnselectRect()
  574. {
  575. BOOL flag = FALSE;
  576. int nIndex;
  577. CSelectedObjectInfo* pSelObjInfo;
  578. CGraphObjectInfo* pRectInfo;
  579. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  580. {
  581. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  582. if(pSelObjInfo->m_type ==OBJ_RECT)
  583. {
  584. pRectInfo = (CGraphObjectInfo*)m_RectInfoArray.GetAt(pSelObjInfo->m_index);
  585. pRectInfo->m_selected = FALSE;
  586. flag = TRUE;
  587.         }
  588.     }
  589. return flag;
  590. }
  592. void COperateObject::AddRect()
  593. {
  594. float startx;
  595. float starty;
  596. float endx;
  597. float endy;
  598. CRect rect;
  599.     
  600. rect.left = StartPoint.x - EXTRA_WIDTH;
  601. rect.top =  PageSize.cy - StartPoint.y  - EXTRA_HIGTH;
  602. rect.right = EndPoint.x - EXTRA_WIDTH;
  603. rect.bottom = PageSize.cy - EndPoint.y - EXTRA_HIGTH;
  604. rect.NormalizeRect();
  606. startx = (float)rect.left / Proportion;
  607. starty = (float)rect.top / Proportion;
  608. endx = (float)rect.right / Proportion;
  609. endy = (float)rect.bottom / Proportion;
  611. CMyRect* pMyRect = new CMyRect(startx, starty, endx, endy, LineStyle, PenColor);
  612. m_RectArray.Add(pMyRect);
  614. CGraphObjectInfo * pRectInfo = new CGraphObjectInfo(FALSE, FALSE);
  615. m_RectInfoArray.Add(pRectInfo);
  616. }
  618. CMyRect* COperateObject::GetRect(int index)
  619. {
  620. if(index < 0 || index > m_RectArray.GetUpperBound())
  621. return 0;
  622. return (CMyRect*)m_RectArray.GetAt(index);
  623. }
  625. void COperateObject::DelAllRect()
  626. {
  627. int index;
  629. index = m_RectArray.GetSize();
  630. while(index--)
  631. delete (CMyRect*)m_RectArray.GetAt(index);
  632. m_RectArray.RemoveAll();
  634. index = m_RectInfoArray.GetSize();
  635. while(index--)
  636. delete (CGraphObjectInfo*)m_RectInfoArray.GetAt(index);
  637. m_RectInfoArray.RemoveAll();
  638. }
  639. //////////////////////////////////////////////////////////////////////////////////////////////
  640. void COperateObject::DrawCircleA(CDC* pDC)
  641. {
  642. //基于CDC
  643. pDC->SetROP2(R2_NOT);
  644. //设置不填充状态
  645. pDC->SelectStockObject(NULL_BRUSH);
  647. pDC->MoveTo(StartPoint.x, StartPoint.y);
  648. pDC->LineTo(oldEndPoint.x, oldEndPoint.y);
  649. pDC->MoveTo(StartPoint.x, StartPoint.y);
  650. pDC->LineTo(EndPoint.x, EndPoint.y);
  652. RECT rect;
  653. rect.left = StartPoint.x - Radius;
  654. rect.top = StartPoint.y - Radius;
  655. rect.right = StartPoint.x + Radius;
  656. rect.bottom = StartPoint.y + Radius;
  657. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  659. Radius = (long)sqrt(pow((float)(StartPoint.x - EndPoint.x), 2) + pow((float)(StartPoint.y - EndPoint.y), 2));
  660. rect.left = StartPoint.x - Radius;
  661. rect.top = StartPoint.y - Radius;
  662. rect.right = StartPoint.x + Radius;
  663. rect.bottom = StartPoint.y + Radius;
  664. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  666. oldEndPoint = EndPoint;
  667. pDC->SetROP2(R2_COPYPEN);
  668. }
  670. void COperateObject::DrawCircleB(CDC* pDC)
  671. {
  672. //基于CDC
  673. CPen Pen;
  674. CPen* OldPen;
  675. RECT rect;
  677. //设置不填充状态
  678. pDC->SelectStockObject(NULL_BRUSH);
  680. //注意先擦除原有的未设置线形、颜色的圆
  681. pDC->SetROP2(R2_NOT);
  682. pDC->MoveTo(StartPoint.x, StartPoint.y);
  683. pDC->LineTo(EndPoint.x, EndPoint.y);
  684. rect.left = StartPoint.x - Radius;
  685. rect.top = StartPoint.y - Radius;
  686. rect.right = StartPoint.x + Radius;
  687. rect.bottom = StartPoint.y + Radius;
  688. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  690. pDC->SetROP2(R2_COPYPEN);
  691. Pen.CreatePen(LineStyle, 1, PenColor);
  692. OldPen = pDC->SelectObject(&Pen);
  693. rect.left = StartPoint.x - Radius;
  694. rect.top = StartPoint.y - Radius;
  695. rect.right = StartPoint.x + Radius;
  696. rect.bottom = StartPoint.y + Radius;
  697. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  699. oldEndPoint = EndPoint;
  700. pDC->SelectObject(OldPen);
  701. }
  703. void COperateObject::CancelDrawCircle(CDC* pDC)
  704. {
  705. //基于CDC
  706. pDC->SetROP2(R2_NOT);
  707. //设置不填充状态
  708. pDC->SelectStockObject(NULL_BRUSH);
  710. pDC->MoveTo(StartPoint.x, StartPoint.y);
  711. pDC->LineTo(EndPoint.x, EndPoint.y);
  713. RECT rect;
  714. rect.left = (StartPoint.x) - Radius;
  715. rect.top = (StartPoint.y) - Radius;
  716. rect.right = (StartPoint.x) + Radius;
  717. rect.bottom = (StartPoint.y) + Radius;
  718. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  720. pDC->SetROP2(R2_COPYPEN);
  721. }
  723. void COperateObject::RedrawCircle(CDC* pDC)
  724. {
  725. CPen *Pen;
  726. CPen* OldPen;
  727. CPoint origin;
  728. long r;
  729. RECT rect;
  730. int index;
  731. CMyCircle* pCircle;
  732. CGraphObjectInfo* pCircleInfo;
  734. index = m_CircleArray.GetSize();
  736. //设置不填充状态
  737. pDC->SelectStockObject(NULL_BRUSH);
  738. while(index--)
  739. {
  740. pCircle = (CMyCircle*)m_CircleArray.GetAt(index);
  741. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  743. if(pCircleInfo->m_del == TRUE)
  744. continue;
  745. if(pCircleInfo->m_selected == TRUE)
  746. {
  747. DrawSelCircle(pDC, pCircle);
  748. continue;
  749. }
  751.         Pen = new CPen(pCircle->m_style, 1, pCircle->m_color);
  752. OldPen = pDC->SelectObject(Pen);
  754. origin.x = (long)(pCircle->m_originX * Proportion) + EXTRA_WIDTH;
  755. origin.y = PageSize.cy - (long)(pCircle->m_originY * Proportion) - EXTRA_HIGTH;
  756. r = (long)(pCircle->m_radius * Proportion);
  758. rect.left = origin.x - r;
  759. rect.top = origin.y - r;
  760. rect.right = origin.x + r;
  761. rect.bottom = origin.y + r;
  762. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  764. //注意以下两句顺序不可颠倒
  765. pDC->SelectObject(OldPen);
  766. delete Pen;
  767. }
  768. }
  770. void COperateObject::DrawSelCircle(CDC* pDC, CMyCircle* pCircle)
  771. {
  772. CPen *Pen;
  773. CPen* OldPen;
  774. RECT rect;
  775. long r;
  776. CPoint origin;
  777. CPoint mid;
  779. //设置不填充状态
  780. pDC->SelectStockObject(NULL_BRUSH);
  783. origin.x = (long)(pCircle->m_originX * Proportion) + EXTRA_WIDTH;
  784. origin.y = PageSize.cy - (long)(pCircle->m_originY * Proportion) - EXTRA_HIGTH;
  785. r = (long)(pCircle->m_radius * Proportion);
  787. rect.left = origin.x - r;
  788. rect.top = origin.y - r;
  789. rect.right = origin.x + r;
  790. rect.bottom = origin.y + r;
  792. //用异或擦除原有的圆
  793. Pen = new CPen(pCircle->m_style, 1, pCircle->m_color);
  794. OldPen = pDC->SelectObject(Pen);
  795. pDC->SetROP2(R2_NOT);
  796. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  797. pDC->SelectObject(OldPen);
  798. delete Pen;
  800. //重画线形为点线的圆
  801. Pen = new CPen(PS_DOT, 1, pCircle->m_color);
  802. OldPen = pDC->SelectObject(Pen);
  803. pDC->SetROP2(R2_COPYPEN);
  804. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  805. pDC->SelectObject(OldPen);
  806. delete Pen;
  809. Pen = new CPen(PS_SOLID, 1, RGB(0, 0, 255));
  810. OldPen = pDC->SelectObject(Pen);
  811. pDC->Rectangle(origin.x - SEL_RECT_WIDTH, origin.y - SEL_RECT_WIDTH,
  812.            origin.x + SEL_RECT_WIDTH + 1, origin.y + SEL_RECT_WIDTH + 1);
  813. pDC->Rectangle(origin.x - SEL_RECT_WIDTH, origin.y - r - SEL_RECT_WIDTH ,
  814.            origin.x + SEL_RECT_WIDTH + 1, origin.y - r + SEL_RECT_WIDTH + 1);
  815. pDC->Rectangle(origin.x - SEL_RECT_WIDTH, origin.y + r - SEL_RECT_WIDTH,
  816.            origin.x + SEL_RECT_WIDTH + 1, origin.y + r + SEL_RECT_WIDTH + 1);
  817.     pDC->Rectangle(origin.x - r - SEL_RECT_WIDTH, origin.y - SEL_RECT_WIDTH,
  818.            origin.x - r + SEL_RECT_WIDTH + 1, origin.y + SEL_RECT_WIDTH + 1);
  819. pDC->Rectangle(origin.x + r  - SEL_RECT_WIDTH, origin.y - SEL_RECT_WIDTH,
  820.            origin.x + r + SEL_RECT_WIDTH + 1, origin.y + SEL_RECT_WIDTH + 1);
  821. //注意以下两句顺序不可颠倒
  822. OldPen = pDC->SelectObject(Pen);
  823. pDC->SelectObject(OldPen);
  824. delete Pen;
  825. }
  826. void COperateObject::SelectCircle(CDC* pDC, CPoint point)
  827. {
  828. int nIndex;
  829. CPoint origin;
  830. long r;
  831. long distance;
  833. CGraphObjectInfo* pCircleInfo;
  834. CSelectedObjectInfo* pSelObjInfo;
  835. CMyCircle* pCircle; 
  837. for(nIndex = 0; nIndex < m_CircleInfoArray.GetSize(); nIndex++)
  838. {
  839. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(nIndex);
  840. if(pCircleInfo ->m_del == TRUE || pCircleInfo ->m_selected ==TRUE)
  841. continue;
  843. pCircle = (CMyCircle*)m_CircleArray.GetAt(nIndex);
  845. origin.x = (long)(pCircle->m_originX * Proportion) + EXTRA_WIDTH;
  846. origin.y = PageSize.cy - (long)(pCircle->m_originY * Proportion) - EXTRA_HIGTH;
  847. r = (long)(pCircle->m_radius * Proportion);
  849. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  851. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  852. {
  853. DrawSelCircle(pDC, pCircle);
  854. pCircleInfo->m_selected = TRUE;
  856. pSelObjInfo = new CSelectedObjectInfo(OBJ_CIRCLE, nIndex);
  857. m_SelObjInfoArray.Add(pSelObjInfo);
  858. }
  859. }
  861. }
  863. BOOL COperateObject::UnselectCircle()
  864. {
  865. BOOL flag = FALSE;
  866. int nIndex;
  867. CSelectedObjectInfo* pSelObjInfo;
  868. CGraphObjectInfo* pCircleInfo;
  869. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  870. {
  871. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  872. if(pSelObjInfo->m_type ==OBJ_CIRCLE)
  873. {
  874. pCircleInfo = (CGraphObjectInfo*)m_CircleInfoArray.GetAt(pSelObjInfo->m_index);
  875. pCircleInfo->m_selected = FALSE;
  876. flag = TRUE;
  877.         }
  878.     }
  879. return flag;
  880. }
  883. void COperateObject::AddCircle()
  884. {
  885. float startx;
  886. float starty;
  887. float r;
  889. startx = (StartPoint.x - EXTRA_WIDTH) / Proportion;
  890. starty = (PageSize.cy - StartPoint.y  - EXTRA_HIGTH) / Proportion;
  891. r = Radius / Proportion;
  893. CMyCircle* pMyCircle = new CMyCircle(startx, starty, r, LineStyle, PenColor);
  894. m_CircleArray.Add(pMyCircle);
  896. CGraphObjectInfo* pCircleInfo = new CGraphObjectInfo(FALSE, FALSE);
  897. m_CircleInfoArray.Add(pCircleInfo);
  898. }
  900. CMyCircle* COperateObject::GetCircle(int index)
  901. {
  902. if(index < 0 || index > m_CircleArray.GetUpperBound())
  903. return 0;
  904. return (CMyCircle*)m_CircleArray.GetAt(index);
  905. }
  907. void COperateObject::DelAllCircle()
  908. {
  909. int index;
  911. index = m_CircleArray.GetSize();
  912. while(index--)
  913. delete (CMyCircle*)m_CircleArray.GetAt(index);
  914. m_CircleArray.RemoveAll();
  916. index = m_CircleInfoArray.GetSize();
  917. while(index--)
  918. delete (CGraphObjectInfo*)m_CircleInfoArray.GetAt(index);
  919. m_CircleInfoArray.RemoveAll();
  920. }
  921. //////////////////////////////////////////////////////////////////////////////////////////////
  922. void COperateObject::DrawArcA(CDC* pDC, int times)
  923. {
  924. static int flag;
  925. double originX;
  926. double originY;
  927. double k1;
  928. double k2;
  930. double mid1X;
  931. double mid1Y;
  932. double mid2X;
  933. double mid2Y;
  935. long x1, y1, x2, y2;
  937. //基于CDC
  938. pDC->SetROP2(R2_NOT);
  939. //设置不填充状态
  940. pDC->SelectStockObject(NULL_BRUSH);
  942.     switch(times)
  943. {
  944. case 1:
  945. pDC->MoveTo(StartPoint.x, StartPoint.y);
  946. pDC->LineTo(oldMidPoint.x, oldMidPoint.y);
  947. pDC->MoveTo(StartPoint.x, StartPoint.y);
  948. pDC->LineTo(MidPoint.x, MidPoint.y);
  950. flag = 1;
  952.         oldMidPoint = MidPoint;
  953. break;
  955. case 2:
  956. RECT rect;
  957. if(flag == 1)
  958. {
  959. pDC->MoveTo(StartPoint.x, StartPoint.y);
  960. pDC->LineTo(MidPoint.x, MidPoint.y);
  961. flag = 0;
  962. }
  964. if(OriginPoint.x != -1000 && OriginPoint.y != -1000)
  965. {
  966. rect.left = OriginPoint.x - Radius;
  967. rect.top = OriginPoint.y - Radius;
  968. rect.right = OriginPoint.x + Radius;
  969. rect.bottom = OriginPoint.y + Radius;
  971. x1 = MidPoint.x - StartPoint.x;
  972. y1 = MidPoint.y - StartPoint.y;
  974. x2 = oldEndPoint.x - StartPoint.x;
  975. y2 = oldEndPoint.y - StartPoint.y;
  977. if(x1*y2 - x2*y1 < 0)
  978. pDC->Arc(&rect, StartPoint, oldEndPoint);
  979. else
  980. pDC->Arc(&rect, oldEndPoint, StartPoint);
  981. }
  983. if(StartPoint.y == MidPoint.y)
  984. k1 = 1000000.0;
  985. else 
  986. k1 = (- (double)(StartPoint.x - MidPoint.x) / (double)(StartPoint.y - MidPoint.y));
  988. if(EndPoint.y == MidPoint.y)
  989. k2 = 1000000.0;
  990. else 
  991. k2 =  (- (double)(EndPoint.x - MidPoint.x) / (double)(EndPoint.y - MidPoint.y));
  993. mid1X = (double)(StartPoint.x + MidPoint.x) / 2.0;
  994. mid1Y = (double)(StartPoint.y + MidPoint.y) / 2.0;
  996. mid2X = (double)(EndPoint.x + MidPoint.x) / 2.0;
  997. mid2Y = (double)(EndPoint.y + MidPoint.y) / 2.0;
  999. if(k1 == k2)
  1000. {
  1001. OriginPoint.x = -1000;
  1002. OriginPoint.y = -1000;
  1003. }
  1004. else
  1005. {
  1006. if(k1 == 1000000.0)
  1007. {
  1008. originX = mid1X;
  1009. originY = k2 * (originX - mid2X) + mid2Y;
  1010. }
  1011. else
  1012. if(k2 == 1000000.0)
  1013. {
  1014. originX = mid2X;
  1015. originY = k1 * (originX - mid1X) + mid1Y;
  1016. }
  1017. else
  1018. {
  1019. originX = ((k2 * mid2X - k1 * mid1X) - (mid2Y - mid1Y)) / (k2 - k1);
  1020. originY = k2 * (originX - mid2X) + mid2Y;
  1021. }
  1023. Radius = (long)sqrt(pow((double)(originX - StartPoint.x), 2) + pow((double)(originY - StartPoint.y), 2));
  1025. OriginPoint.x = (long)originX;
  1026. OriginPoint.y = (long)originY ;
  1027. rect.left = OriginPoint.x - Radius;
  1028. rect.top = OriginPoint.y - Radius;
  1029. rect.right = OriginPoint.x + Radius;
  1030. rect.bottom = OriginPoint.y + Radius;
  1032. x1 = MidPoint.x - StartPoint.x;
  1033. y1 = MidPoint.y - StartPoint.y;
  1035. x2 = EndPoint.x - StartPoint.x;
  1036. y2 = EndPoint.y - StartPoint.y;
  1038. //判断优弧
  1039. if(x1*y2 - x2*y1 < 0)
  1040. pDC->Arc(&rect, StartPoint, EndPoint);
  1041. else
  1042. pDC->Arc(&rect, EndPoint, StartPoint);
  1044.      oldEndPoint = EndPoint;
  1045. }
  1046. break;
  1047. }
  1049. pDC->SetROP2(R2_COPYPEN);
  1050. }
  1052. void COperateObject::DrawArcB(CDC* pDC)
  1053. {
  1054. CPen* Pen;
  1055. CPen* OldPen;
  1056. RECT rect;
  1057. long x1, y1, x2, y2;
  1059. //设置不填充状态
  1060. pDC->SelectStockObject(NULL_BRUSH);
  1062. rect.left = OriginPoint.x - Radius;
  1063. rect.top = OriginPoint.y - Radius;
  1064. rect.right = OriginPoint.x + Radius;
  1065. rect.bottom = OriginPoint.y + Radius;
  1067.     Pen = new CPen(LineStyle, 1, PenColor);
  1068. OldPen = pDC->SelectObject(Pen);
  1070. x1 = MidPoint.x - StartPoint.x;
  1071. y1 = MidPoint.y - StartPoint.y;
  1073. x2 = EndPoint.x - StartPoint.x;
  1074. y2 = EndPoint.y - StartPoint.y;
  1076.     if(x1*y2 - x2*y1 < 0)
  1077. pDC->Arc(&rect, StartPoint, EndPoint);
  1078. else
  1079. pDC->Arc(&rect, EndPoint, StartPoint);
  1081. pDC->SelectObject(OldPen);
  1082.     delete Pen; 
  1083. }
  1085. void COperateObject::CancelDrawArc(CDC* pDC, int times)
  1086. {
  1087. long x1, y1, x2, y2;
  1088. //设置不填充状态
  1089. pDC->SetROP2(R2_NOT);
  1090. pDC->SelectStockObject(NULL_BRUSH);
  1091.     switch(times)
  1092. {
  1093. case 1:
  1094. pDC->MoveTo(StartPoint.x, StartPoint.y);
  1095. pDC->LineTo(MidPoint.x, MidPoint.y);
  1096. break;
  1098. case 2:
  1099. RECT rect;
  1100. if(OriginPoint.x != -1000 && OriginPoint.y != -1000)
  1101. {
  1102. rect.left = OriginPoint.x - Radius;
  1103. rect.top = OriginPoint.y - Radius;
  1104. rect.right = OriginPoint.x + Radius;
  1105. rect.bottom = OriginPoint.y + Radius;
  1107. x1 = MidPoint.x - StartPoint.x;
  1108. y1 = MidPoint.y - StartPoint.y;
  1110. x2 = EndPoint.x - StartPoint.x;
  1111. y2 = EndPoint.y - StartPoint.y;
  1113. if(x1*y2 - x2*y1 < 0)
  1114. pDC->Arc(&rect, StartPoint, EndPoint);
  1115. else
  1116. pDC->Arc(&rect, EndPoint, StartPoint);
  1117. }
  1118. break;
  1119. }
  1121. pDC->SetROP2(R2_COPYPEN);
  1122. }
  1124. void COperateObject::RedrawArc(CDC* pDC)
  1125. {
  1126. CPen *Pen;
  1127. CPen* OldPen;
  1128. CPoint origin;
  1129. CPoint start;
  1130. CPoint end;
  1131. long r;
  1132. RECT rect;
  1133. int index;
  1134. CMyArc* pArc;
  1135. CGraphObjectInfo* pArcInfo;
  1137. index = m_ArcArray.GetSize();
  1139. //设置不填充状态
  1140. pDC->SelectStockObject(NULL_BRUSH);
  1141. while(index--)
  1142. {
  1143. pArc = (CMyArc*)m_ArcArray.GetAt(index);
  1144. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1146. if(pArcInfo->m_del == TRUE)
  1147. continue;
  1148. if(pArcInfo->m_selected == TRUE)
  1149. {
  1150. DrawSelArc(pDC, pArc);
  1151. continue;
  1152. }
  1154.         Pen = new CPen(pArc->m_style, 1, pArc->m_color);
  1155. OldPen = pDC->SelectObject(Pen);
  1157. origin.x = (long)(pArc->m_originX * Proportion) + EXTRA_WIDTH;
  1158. origin.y = PageSize.cy - (long)(pArc->m_originY * Proportion) - EXTRA_HIGTH;
  1159. start.x = (long)(pArc->m_startX * Proportion) + EXTRA_WIDTH;
  1160. start.y = PageSize.cy - (long)(pArc->m_startY * Proportion) - EXTRA_HIGTH;
  1161. end.x = (long)(pArc->m_endX * Proportion) + EXTRA_WIDTH;
  1162. end.y = PageSize.cy - (long)(pArc->m_endY * Proportion) - EXTRA_HIGTH;
  1164. r = (long)(pArc->m_radius * Proportion);
  1166. rect.left = origin.x - r;
  1167. rect.top = origin.y - r;
  1168. rect.right = origin.x + r;
  1169. rect.bottom = origin.y + r;
  1171. pDC->Arc(&rect, start, end);
  1173. //注意以下两句顺序不可颠倒
  1174. pDC->SelectObject(OldPen);
  1175. delete Pen;
  1176. }
  1177. }
  1179. void COperateObject::DrawSelArc(CDC* pDC, CMyArc* pArc)
  1180. {
  1181. CPen *Pen;
  1182. CPen* OldPen;
  1183. RECT rect;
  1184. long r;
  1185. CPoint origin;
  1186. CPoint start;
  1187. CPoint end;
  1189. //设置不填充状态
  1190. pDC->SelectStockObject(NULL_BRUSH);
  1192. origin.x = (long)(pArc->m_originX * Proportion) + EXTRA_WIDTH;
  1193. origin.y = PageSize.cy - (long)(pArc->m_originY * Proportion) - EXTRA_HIGTH;
  1194. start.x = (long)(pArc->m_startX * Proportion) + EXTRA_WIDTH;
  1195. start.y = PageSize.cy - (long)(pArc->m_startY * Proportion) - EXTRA_HIGTH;
  1196. end.x = (long)(pArc->m_endX * Proportion) + EXTRA_WIDTH;
  1197. end.y = PageSize.cy - (long)(pArc->m_endY * Proportion) - EXTRA_HIGTH;
  1198. r = (long)(pArc->m_radius * Proportion);
  1200. rect.left = origin.x - r;
  1201. rect.top = origin.y - r;
  1202. rect.right = origin.x + r;
  1203. rect.bottom = origin.y + r;
  1205. //重画线形为点线的圆弧
  1206. Pen = new CPen(PS_DOT, 1, pArc->m_color);
  1207. OldPen = pDC->SelectObject(Pen);
  1208. pDC->SetROP2(R2_COPYPEN);
  1209. pDC->Arc(&rect, start, end);
  1210. pDC->SelectObject(OldPen);
  1211. delete Pen;
  1214. Pen = new CPen(PS_SOLID, 1, RGB(0, 0, 255));
  1215. OldPen = pDC->SelectObject(Pen);
  1216. pDC->Rectangle(start.x - SEL_RECT_WIDTH, start.y - SEL_RECT_WIDTH ,
  1217.            start.x + SEL_RECT_WIDTH + 1, start.y + SEL_RECT_WIDTH + 1);
  1218. pDC->Rectangle(end.x - SEL_RECT_WIDTH, end.y - SEL_RECT_WIDTH,
  1219.            end.x + SEL_RECT_WIDTH + 1, end.y + SEL_RECT_WIDTH + 1);
  1220. //注意以下两句顺序不可颠倒
  1221. OldPen = pDC->SelectObject(Pen);
  1222. pDC->SelectObject(OldPen);
  1223. delete Pen;
  1224. }
  1226. void COperateObject::SelectArc(CDC* pDC, CPoint point)
  1227. {
  1228. long x1, y1, x2, y2;
  1229. int nIndex;
  1231. CPoint origin;
  1232. long r;
  1233. long distance;
  1235. CPoint start;
  1236. CPoint end;
  1238. CGraphObjectInfo* pArcInfo;
  1239. CSelectedObjectInfo* pSelObjInfo;
  1240. CMyArc* pArc; 
  1242. for(nIndex = 0; nIndex < m_ArcInfoArray.GetSize(); nIndex++)
  1243. {
  1244. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(nIndex);
  1245. if(pArcInfo ->m_del == TRUE || pArcInfo ->m_selected ==TRUE)
  1246. continue;
  1248. pArc = (CMyArc*)m_ArcArray.GetAt(nIndex);
  1250. origin.x = (long)(pArc->m_originX * Proportion) + EXTRA_WIDTH;
  1251. origin.y = PageSize.cy - (long)(pArc->m_originY * Proportion) - EXTRA_HIGTH;
  1252. start.x = (long)(pArc->m_startX * Proportion) + EXTRA_WIDTH;
  1253. start.y = PageSize.cy - (long)(pArc->m_startY * Proportion) - EXTRA_HIGTH;
  1254. end.x = (long)(pArc->m_endX * Proportion) + EXTRA_WIDTH;
  1255. end.y = PageSize.cy - (long)(pArc->m_endY * Proportion) - EXTRA_HIGTH;
  1256. r = (long)(pArc->m_radius * Proportion);
  1258. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  1260. if(distance >= r + SELECT_RANGE || distance <= r - SELECT_RANGE)
  1261. continue;
  1263. x1 = point.x - start.x;
  1264. y1 = point.y - start.y;
  1265. x2 = end.x - start.x;
  1266. y2 = end.y - start.y;
  1268. if(x1 * y2 - x2 * y1 < 0)
  1269. {
  1270. DrawSelArc(pDC, pArc);
  1271. pArcInfo->m_selected = TRUE;
  1272. pSelObjInfo = new CSelectedObjectInfo(OBJ_ARC, nIndex);
  1273. m_SelObjInfoArray.Add(pSelObjInfo);
  1274. }
  1276. }
  1277. }
  1279. BOOL COperateObject::UnselectArc()
  1280. {
  1281. BOOL flag = FALSE;
  1282. int nIndex;
  1283. CSelectedObjectInfo* pSelObjInfo;
  1284. CGraphObjectInfo* pArcInfo;
  1285. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1286. {
  1287. pSelObjInfo = (CSelectedObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1288. if(pSelObjInfo->m_type ==OBJ_ARC)
  1289. {
  1290. pArcInfo = (CGraphObjectInfo*)m_ArcInfoArray.GetAt(pSelObjInfo->m_index);
  1291. pArcInfo->m_selected = FALSE;
  1292. flag = TRUE;
  1293.         }
  1294.     }
  1295. return flag;
  1296. }
  1299. void COperateObject::AddArc()
  1300. {
  1301. long x1, y1, x2, y2;
  1302. float originx;
  1303. float originy;
  1305. float startx;
  1306. float starty;
  1307. float endx;
  1308. float endy;
  1309. float r;
  1311. CMyArc* pMyArc;
  1313. originx = (OriginPoint.x - EXTRA_WIDTH) / Proportion;
  1314. originy = (PageSize.cy - OriginPoint.y  - EXTRA_HIGTH) / Proportion;
  1316. startx = (StartPoint.x - EXTRA_WIDTH) / Proportion;
  1317. starty = (PageSize.cy - StartPoint.y  - EXTRA_HIGTH) / Proportion;
  1318.     endx = (EndPoint.x - EXTRA_WIDTH) / Proportion;
  1319. endy = (PageSize.cy - EndPoint.y  - EXTRA_HIGTH) / Proportion;
  1321. r = Radius / Proportion;
  1323. x1 = MidPoint.x - StartPoint.x;
  1324. y1 = MidPoint.y - StartPoint.y;
  1326. x2 = EndPoint.x - StartPoint.x;
  1327. y2 = EndPoint.y - StartPoint.y;
  1329. if(x1*y2 - x2*y1 < 0)
  1330. pMyArc = new CMyArc(originx, originy, startx, starty, endx, endy, r, LineStyle, PenColor);
  1331. else
  1332. pMyArc = new CMyArc(originx, originy, endx, endy, startx, starty, r, LineStyle, PenColor);
  1334. m_ArcArray.Add(pMyArc);
  1336. CGraphObjectInfo* pArcInfo = new CGraphObjectInfo(FALSE, FALSE);
  1337. m_ArcInfoArray.Add(pArcInfo);
  1338. }
  1341. CMyArc* COperateObject::GetArc(int index)
  1342. {
  1343. if(index < 0 || index > m_ArcArray.GetUpperBound())
  1344. return 0;
  1345. return (CMyArc*)m_ArcArray.GetAt(index);
  1346. }
  1348. void COperateObject::DelAllArc()
  1349. {
  1350. int index;
  1352. index = m_ArcArray.GetSize();
  1353. while(index--)
  1354. delete (CMyArc*)m_ArcArray.GetAt(index);
  1355. m_ArcArray.RemoveAll();
  1357. index = m_ArcInfoArray.GetSize();
  1358. while(index--)
  1359. delete (CGraphObjectInfo*)m_ArcInfoArray.GetAt(index);
  1360. m_ArcInfoArray.RemoveAll();
  1361. }