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

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

绘图程序

开发平台：

Visual C++

MyDraw.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "math.h"
  3. #include "MyDraw.h"
  4. #include "MyDefine.h"
  6. ///////////////////////////////////////////////////////////////////////////////////////////////
  7. //图形对象信息
  8. CMyObjectInfo::CMyObjectInfo(BOOL del, BOOL selected)
  9. {
  10. m_del = del;  
  11. m_selected = selected;
  12. }
  13. ///////////////////////////////////////////////////////////////////////////////////////////////
  14. //被选择图形对象信息
  15. CMySelObjectInfo::CMySelObjectInfo(int type, int index)
  16. {
  17. m_type = type;
  18. m_index = index;
  19. }
  20. ///////////////////////////////////////////////////////////////////////////////////////////////
  21. IMPLEMENT_DYNCREATE(CMyOperate, CObject)
  23. CMyOperate::CMyOperate()
  24. {
  25. Proportion = 1.0;
  26. }
  28. CMyOperate::~CMyOperate()
  29. {
  30. DelAllLine();
  31. DelAllRect();
  32. DelAllCircle();
  33. DelAllArc();
  34. }
  36. void CMyOperate::Serialize(CArchive& ar)
  37. {
  38. int num;
  39. int index;
  41. CMyObjectInfo* pLineInfo;
  42. CMyObjectInfo* pRectInfo;
  43. CMyObjectInfo* pCircleInfo;
  44. CMyObjectInfo* pArcInfo;
  46. if(ar.IsStoring())
  47. {
  48. ar << m_LineArray.GetSize() << m_RectArray.GetSize()
  49.    << m_CircleArray.GetSize() << m_ArcArray.GetSize();
  50. }
  51. else
  52. {
  53. ar >> num;
  54. for(index = 0; index < num; index++)
  55. {
  56. pLineInfo = new CMyObjectInfo(FALSE, FALSE);
  57. m_LineInfoArray.Add(pLineInfo);
  58. }
  60. ar >> num;
  61. for(index = 0; index < num; index++)
  62. {
  63. pRectInfo = new CMyObjectInfo(FALSE, FALSE);
  64. m_RectInfoArray.Add(pRectInfo);
  65. }
  67. ar >> num;
  68. for(index = 0; index < num; index++)
  69. {
  70. pCircleInfo = new CMyObjectInfo(FALSE, FALSE);
  71. m_CircleInfoArray.Add(pCircleInfo);
  72. }
  74. ar >> num;
  75. for(index = 0; index < num; index++)
  76. {
  77. pArcInfo = new CMyObjectInfo(FALSE, FALSE);
  78. m_ArcInfoArray.Add(pArcInfo);
  79. }
  81. }
  83. //注意当打开文件时，下面的Serialize()函数会自动创建CMyLine,CMyRect等对象
  84.     m_LineArray.Serialize(ar);
  85. m_RectArray.Serialize(ar);
  86. m_CircleArray.Serialize(ar);
  87. m_ArcArray.Serialize(ar);
  88. }
  89. ////////////////////////////////////////////////////////////////////////////////////////////////
  90. void CMyOperate::RedrawAllObject(CDC* pDC)
  91. {
  92. RedrawLine(pDC);
  93. RedrawRect(pDC);
  94. RedrawCircle(pDC);
  95. RedrawArc(pDC);
  96. }
  98. void CMyOperate::SelectObject(CDC* pDC, CPoint point)
  99. {
  100. SelectLine(pDC, point);   
  101. SelectRect(pDC, point);
  102. SelectCircle(pDC, point);
  103. SelectArc(pDC, point);
  104. }
  106. BOOL CMyOperate::UnselectObject()
  107. {
  108. BOOL flag = FALSE;
  109. int nIndex;
  111. if(UnselectLine())
  112. flag = TRUE;
  113. if(UnselectRect())
  114. flag = TRUE;
  115. if(UnselectCircle())
  116. flag = TRUE;
  117.     if(UnselectArc())
  118. flag = TRUE;
  119.     
  120. nIndex = m_SelObjInfoArray.GetSize();
  121. while(nIndex--)
  122. delete (CMySelObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  123.     m_SelObjInfoArray.RemoveAll();
  125. return flag;
  126. }
  127. //////////////////////////////////////////////////////////////////////////////////////////////
  128. //operate line
  129. void CMyOperate::DrawLineA(CDC* pDC)
  130. {
  131. //基于CDC
  132. pDC->SetROP2(R2_NOT);
  134. pDC->MoveTo(StartPoint);
  135. pDC->LineTo(oldEndPoint);
  136. pDC->MoveTo(StartPoint);
  137. pDC->LineTo(EndPoint);
  139. oldEndPoint = EndPoint;
  140. pDC->SetROP2(R2_COPYPEN);
  141. }
  143. void CMyOperate::DrawLineB(CDC* pDC)
  144. {
  145. //基于CDC
  146. pDC->MoveTo(StartPoint.x, StartPoint.y);
  147. pDC->LineTo(EndPoint.x, EndPoint.y);
  148. }
  150. void CMyOperate::DrawLineC(CDC* pDC)
  151. {
  152. //基于CDC
  153. CPen Pen;
  154. CPen* OldPen;
  156. Pen.CreatePen(LineStyle, 1, ForeColor);
  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 CMyOperate::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 = size.cy - (long)(pLine->m_startY * Proportion) - EXTRA_HIGTH;
  179.     end.x = (long)(pLine->m_endX * Proportion) + EXTRA_WIDTH;
  180. end.y = size.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 CMyOperate::RedrawLine(CDC* pDC)
  217. {
  218. CPen *Pen;
  219. CPen* OldPen;
  220. int index;
  221. CMyLine* pLine;
  222. CMyObjectInfo* pLineInfo;
  224. index = m_LineArray.GetSize();
  225. while(index--)
  226. {
  227. pLine = (CMyLine*)m_LineArray.GetAt(index);
  228. pLineInfo = (CMyObjectInfo*)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. size.cy - (long)(pLine->m_startY * Proportion) - EXTRA_HIGTH);
  243. pDC->LineTo((long)(pLine->m_endX * Proportion) + EXTRA_WIDTH,
  244. size.cy - (long)(pLine->m_endY * Proportion) - EXTRA_HIGTH);
  245. //注意以下两句顺序不可颠倒
  246. pDC->SelectObject(OldPen);
  247. delete Pen;
  248. }
  249. }
  251. void CMyOperate::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 CMyOperate::SelectLine(CDC* pDC, CPoint point)
  262. {
  263. int nIndex;
  264. long distance;
  265. RECT rect;
  267. CMyObjectInfo* pLineInfo;
  268. CMySelObjectInfo* pSelObjInfo;
  269. CMyLine* pLine; 
  271. for(nIndex = 0; nIndex < m_LineInfoArray.GetSize(); nIndex++)
  272. {
  273. pLineInfo = (CMyObjectInfo*)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 = size.cy - (long)(pLine->m_startY * Proportion) - EXTRA_HIGTH;
  281. rect.right = (long)(pLine->m_endX * Proportion) + EXTRA_WIDTH;
  282. rect.bottom = size.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 CMySelObjectInfo(OBJ_LINE, nIndex);
  296. m_SelObjInfoArray.Add(pSelObjInfo);
  297. }
  298. }
  299. }
  300. }
  302. BOOL CMyOperate::UnselectLine()
  303. {
  304. BOOL flag = FALSE;
  305. int nIndex;
  306. CMySelObjectInfo* pSelObjInfo;
  307. CMyObjectInfo* pLineInfo;
  308. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  309. {
  310. pSelObjInfo = (CMySelObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  311. if(pSelObjInfo->m_type ==OBJ_LINE)
  312. {
  313. pLineInfo = (CMyObjectInfo*)m_LineInfoArray.GetAt(pSelObjInfo->m_index);
  314. pLineInfo->m_selected = FALSE;
  315. flag = TRUE;
  316.         }
  317.     }
  318. return flag;
  319. }
  321. void CMyOperate::AddLine()
  322. {
  323. float startx;
  324. float starty;
  325. float endx;
  326. float endy;
  328. startx = (StartPoint.x - EXTRA_WIDTH) / Proportion;
  329. starty = (size.cy - StartPoint.y  - EXTRA_HIGTH) / Proportion;
  331. endx = (EndPoint.x - EXTRA_WIDTH) / Proportion;
  332. endy = (size.cy - EndPoint.y - EXTRA_HIGTH) / Proportion;
  334. CMyLine* pMyLine = new CMyLine(startx, starty, endx, endy, LineStyle, ForeColor);
  335. m_LineArray.Add(pMyLine);
  337. CMyObjectInfo * pLineInfo = new CMyObjectInfo(FALSE, FALSE);
  338. m_LineInfoArray.Add(pLineInfo);
  339. }
  341. CMyLine* CMyOperate::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 CMyOperate::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 (CMyObjectInfo*)m_LineInfoArray.GetAt(index);
  359. m_LineInfoArray.RemoveAll();
  360. }
  362. ///////////////////////////////////////////////////////////////////////////////////////////////
  363. //operate rectangle
  364. void CMyOperate::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 CMyOperate::DrawRectB(CDC* pDC)
  391. {
  392. //基于CDC
  393. //设置不填充状态
  394. pDC->SelectStockObject(NULL_BRUSH);
  395. CRect rect;
  396. rect.left = StartPoint.x;
  397. rect.top = StartPoint.y;
  398. rect.right = EndPoint.x;
  399. rect.bottom = EndPoint.y;
  400. rect.NormalizeRect();
  401. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  402. }
  404. void CMyOperate::DrawRectC(CDC* pDC)
  405. {
  406. //基于CDC
  407. CPen Pen;
  408. CPen* OldPen;
  410. CRect rect;
  411. rect.left = StartPoint.x;
  412. rect.top = StartPoint.y;
  413. rect.right = EndPoint.x;
  414. rect.bottom = EndPoint.y;
  415. rect.NormalizeRect();
  417. Pen.CreatePen(LineStyle, 1, ForeColor);
  418. OldPen = pDC->SelectObject(&Pen);
  419. //设置不填充状态
  420. pDC->SelectStockObject(NULL_BRUSH);
  421. pDC->SetROP2(R2_COPYPEN);
  422. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  423. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  424. pDC->SelectObject(OldPen);
  425. }
  427. void CMyOperate::CancelDrawRect(CDC* pDC)
  428. {
  429. pDC->SetROP2(R2_NOT);
  430. pDC->SelectStockObject(NULL_BRUSH);
  432. CRect rect;
  433. rect.left = StartPoint.x;
  434. rect.top = StartPoint.y;
  435. rect.right = EndPoint.x;
  436. rect.bottom = EndPoint.y;
  437. rect.NormalizeRect();
  438. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  439. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  441. pDC->SetROP2(R2_COPYPEN);
  442. }
  444. void CMyOperate::RedrawRect(CDC* pDC)
  445. {
  446. CPen *Pen;
  447. CPen* OldPen;
  448. int index;
  449. CRect rect;
  450. CMyRect* pRect;
  451. CMyObjectInfo* pRectInfo;
  453. index = m_RectArray.GetSize();
  455. //设置不填充状态
  456. pDC->SelectStockObject(NULL_BRUSH);
  457. while(index--)
  458. {
  459. pRect = (CMyRect*)m_RectArray.GetAt(index);
  460. pRectInfo = (CMyObjectInfo*)m_RectInfoArray.GetAt(index);
  462. if(pRectInfo->m_del == TRUE)
  463. continue;
  464. if(pRectInfo->m_selected == TRUE)
  465. {
  466. DrawSelRect(pDC, pRect);
  467. continue;
  468. }
  470.         Pen = new CPen(pRect->m_style, 1, pRect->m_color);
  471. OldPen = pDC->SelectObject(Pen);
  473.         rect.left = (long)(pRect->m_startX * Proportion) + EXTRA_WIDTH;
  474. rect.right = (long)(pRect->m_endX * Proportion) + EXTRA_WIDTH;
  475.     rect.top = size.cy - (long)(pRect->m_startY * Proportion) - EXTRA_HIGTH;
  476.         rect.bottom = size.cy - (long)(pRect->m_endY * Proportion) - EXTRA_HIGTH;
  477. rect.NormalizeRect();
  479. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  480. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  482. //注意以下两句顺序不可颠倒
  483. pDC->SelectObject(OldPen);
  484. delete Pen;
  485. }
  486. }
  488. void CMyOperate::DrawSelRect(CDC* pDC, CMyRect* pRect)
  489. {
  490. CPen *Pen;
  491. CPen* OldPen;
  492. CRect rect;
  494.     CPoint mid;
  496. //设置不填充状态
  497. pDC->SelectStockObject(NULL_BRUSH);
  498. Pen = new CPen(PS_DOT, 1, pRect->m_color);
  499. OldPen = pDC->SelectObject(Pen);
  501.     rect.left = (long)(pRect->m_startX * Proportion) + EXTRA_WIDTH;
  502. rect.right = (long)(pRect->m_endX * Proportion) + EXTRA_WIDTH;
  503.     rect.top = size.cy - (long)(pRect->m_startY * Proportion) - EXTRA_HIGTH;
  504.     rect.bottom = size.cy - (long)(pRect->m_endY * Proportion) - EXTRA_HIGTH;
  505. rect.NormalizeRect();
  506. //注意画矩形时，不包括右下角那一点，所以右下角x,y坐标加1
  507. pDC->Rectangle(rect.left, rect.top, rect.right + 1, rect.bottom + 1);
  508. pDC->SelectObject(OldPen);
  509. delete Pen;
  511. Pen = new CPen(PS_SOLID, 1, RGB(0, 0, 255));
  512. OldPen = pDC->SelectObject(Pen);
  514.     pDC->Rectangle(rect.left - SEL_RECT_WIDTH, rect.top - SEL_RECT_WIDTH,
  515.            rect.left + SEL_RECT_WIDTH + 1, rect.top + SEL_RECT_WIDTH + 1);
  516. pDC->Rectangle(rect.left - SEL_RECT_WIDTH, rect.bottom - SEL_RECT_WIDTH,
  517.            rect.left + SEL_RECT_WIDTH + 1, rect.bottom + SEL_RECT_WIDTH + 1);
  518. pDC->Rectangle(rect.right - SEL_RECT_WIDTH, rect.top - SEL_RECT_WIDTH,
  519.            rect.right + SEL_RECT_WIDTH + 1, rect.top + SEL_RECT_WIDTH + 1);
  520. pDC->Rectangle(rect.right - SEL_RECT_WIDTH, rect.bottom - SEL_RECT_WIDTH,
  521.            rect.right + SEL_RECT_WIDTH + 1, rect.bottom + SEL_RECT_WIDTH + 1);
  523. mid.x = (rect.left + rect.right) / 2;
  524. mid.y = rect.top;
  525. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  526.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  528. mid.x = (rect.left + rect.right) / 2;
  529. mid.y = rect.bottom;
  530. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  531.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  534. mid.x = rect.left;
  535. mid.y = (rect.top + rect.bottom) / 2;
  536. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  537.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  539. mid.x = rect.right;
  540. mid.y = (rect.top + rect.bottom) / 2;
  541. pDC->Rectangle(mid.x - SEL_RECT_WIDTH, mid.y - SEL_RECT_WIDTH,
  542.            mid.x + SEL_RECT_WIDTH + 1, mid.y + SEL_RECT_WIDTH + 1);
  544. //注意以下两句顺序不可颠倒
  545. pDC->SelectObject(OldPen);
  546. delete Pen;
  547. }
  549. void CMyOperate::SelectRect(CDC* pDC, CPoint point)
  550. {
  551. int nIndex;
  552. RECT rect;
  554. CMyObjectInfo* pRectInfo;
  555. CMySelObjectInfo* pSelObjInfo;
  556. CMyRect* pRect; 
  558. for(nIndex = 0; nIndex < m_RectInfoArray.GetSize(); nIndex++)
  559. {
  560. pRectInfo = (CMyObjectInfo*)m_RectInfoArray.GetAt(nIndex);
  561. if(pRectInfo ->m_del == TRUE || pRectInfo ->m_selected ==TRUE)
  562. continue;
  564. pRect = (CMyRect*)m_RectArray.GetAt(nIndex);
  566. rect.left = (long)(pRect->m_startX * Proportion) + EXTRA_WIDTH;
  567. rect.top = size.cy - (long)(pRect->m_startY * Proportion) - EXTRA_HIGTH;
  568. rect.right = (long)(pRect->m_endX * Proportion) + EXTRA_WIDTH;
  569. rect.bottom = size.cy - (long)(pRect->m_endY * Proportion) - EXTRA_HIGTH;
  571. if( ( (point.x >= min(rect.left, rect.right) - SELECT_RANGE) && (point.x <= max(rect.left, rect.right) + SELECT_RANGE) &&
  572.     (point.y >= min(rect.top, rect.bottom) - SELECT_RANGE) && (point.y <= max(rect.top, rect.bottom) + SELECT_RANGE) ) &&
  573. ( (point.x <= min(rect.left, rect.right) + SELECT_RANGE) || (point.x >= max(rect.left, rect.right) - SELECT_RANGE) ||
  574.             (point.y <= min(rect.top, rect.bottom) + SELECT_RANGE) || (point.y >= max(rect.top, rect.bottom) - SELECT_RANGE) ) ) 
  576. {
  577. DrawSelRect(pDC, pRect);
  578. pRectInfo->m_selected = TRUE;
  580. pSelObjInfo = new CMySelObjectInfo(OBJ_RECT, nIndex);
  581. m_SelObjInfoArray.Add(pSelObjInfo);
  582. }
  583. }
  585. }
  587. BOOL CMyOperate::UnselectRect()
  588. {
  589. BOOL flag = FALSE;
  590. int nIndex;
  591. CMySelObjectInfo* pSelObjInfo;
  592. CMyObjectInfo* pRectInfo;
  593. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  594. {
  595. pSelObjInfo = (CMySelObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  596. if(pSelObjInfo->m_type ==OBJ_RECT)
  597. {
  598. pRectInfo = (CMyObjectInfo*)m_RectInfoArray.GetAt(pSelObjInfo->m_index);
  599. pRectInfo->m_selected = FALSE;
  600. flag = TRUE;
  601.         }
  602.     }
  603. return flag;
  604. }
  606. void CMyOperate::AddRect()
  607. {
  608. float startx;
  609. float starty;
  610. float endx;
  611. float endy;
  612. CRect rect;
  613.     
  614. rect.left = StartPoint.x - EXTRA_WIDTH;
  615. rect.top =  size.cy - StartPoint.y  - EXTRA_HIGTH;
  616. rect.right = EndPoint.x - EXTRA_WIDTH;
  617. rect.bottom = size.cy - EndPoint.y - EXTRA_HIGTH;
  618. rect.NormalizeRect();
  620. startx = (float)rect.left / Proportion;
  621. starty = (float)rect.top / Proportion;
  622. endx = (float)rect.right / Proportion;
  623. endy = (float)rect.bottom / Proportion;
  625. CMyRect* pMyRect = new CMyRect(startx, starty, endx, endy, LineStyle, ForeColor);
  626. m_RectArray.Add(pMyRect);
  628. CMyObjectInfo * pRectInfo = new CMyObjectInfo(FALSE, FALSE);
  629. m_RectInfoArray.Add(pRectInfo);
  630. }
  632. CMyRect* CMyOperate::GetRect(int index)
  633. {
  634. if(index < 0 || index > m_RectArray.GetUpperBound())
  635. return 0;
  636. return (CMyRect*)m_RectArray.GetAt(index);
  637. }
  639. void CMyOperate::DelAllRect()
  640. {
  641. int index;
  643. index = m_RectArray.GetSize();
  644. while(index--)
  645. delete (CMyRect*)m_RectArray.GetAt(index);
  646. m_RectArray.RemoveAll();
  648. index = m_RectInfoArray.GetSize();
  649. while(index--)
  650. delete (CMyObjectInfo*)m_RectInfoArray.GetAt(index);
  651. m_RectInfoArray.RemoveAll();
  652. }
  653. //////////////////////////////////////////////////////////////////////////////////////////////
  654. void CMyOperate::DrawCircleA(CDC* pDC)
  655. {
  656. //基于CDC
  657. pDC->SetROP2(R2_NOT);
  658. //设置不填充状态
  659. pDC->SelectStockObject(NULL_BRUSH);
  661. pDC->MoveTo(StartPoint.x, StartPoint.y);
  662. pDC->LineTo(oldEndPoint.x, oldEndPoint.y);
  663. pDC->MoveTo(StartPoint.x, StartPoint.y);
  664. pDC->LineTo(EndPoint.x, EndPoint.y);
  666. RECT rect;
  667. rect.left = StartPoint.x - Radius;
  668. rect.top = StartPoint.y - Radius;
  669. rect.right = StartPoint.x + Radius;
  670. rect.bottom = StartPoint.y + Radius;
  671. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  673. Radius = (long)sqrt(pow((float)(StartPoint.x - EndPoint.x), 2) + pow((float)(StartPoint.y - EndPoint.y), 2));
  674. rect.left = StartPoint.x - Radius;
  675. rect.top = StartPoint.y - Radius;
  676. rect.right = StartPoint.x + Radius;
  677. rect.bottom = StartPoint.y + Radius;
  678. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  680. oldEndPoint = EndPoint;
  681. pDC->SetROP2(R2_COPYPEN);
  682. }
  684. void CMyOperate::DrawCircleB(CDC* pDC)
  685. {
  686. //基于CDC
  687. //设置不填充状态
  688. pDC->SelectStockObject(NULL_BRUSH);
  690. pDC->MoveTo(StartPoint.x , StartPoint.y);
  691. pDC->LineTo(EndPoint.x, EndPoint.y);
  693. RECT rect;
  694. rect.left = StartPoint.x - Radius;
  695. rect.top = StartPoint.y - Radius;
  696. rect.right = StartPoint.x + Radius;
  697. rect.bottom = StartPoint.y + Radius;
  698. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  699. }
  701. void CMyOperate::DrawCircleC(CDC* pDC)
  702. {
  703. //基于CDC
  704. CPen Pen;
  705. CPen* OldPen;
  706. RECT rect;
  708. //设置不填充状态
  709. pDC->SelectStockObject(NULL_BRUSH);
  711. //注意先擦除原有的未设置线形、颜色的圆
  712. pDC->SetROP2(R2_NOT);
  713. pDC->MoveTo(StartPoint.x, StartPoint.y);
  714. pDC->LineTo(EndPoint.x, EndPoint.y);
  715. rect.left = StartPoint.x - Radius;
  716. rect.top = StartPoint.y - Radius;
  717. rect.right = StartPoint.x + Radius;
  718. rect.bottom = StartPoint.y + Radius;
  719. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  721. pDC->SetROP2(R2_COPYPEN);
  722. Pen.CreatePen(LineStyle, 1, ForeColor);
  723. OldPen = pDC->SelectObject(&Pen);
  724. rect.left = StartPoint.x - Radius;
  725. rect.top = StartPoint.y - Radius;
  726. rect.right = StartPoint.x + Radius;
  727. rect.bottom = StartPoint.y + Radius;
  728. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  730. oldEndPoint = EndPoint;
  731. pDC->SelectObject(OldPen);
  732. }
  734. void CMyOperate::CancelDrawCircle(CDC* pDC)
  735. {
  736. //基于CDC
  737. pDC->SetROP2(R2_NOT);
  738. //设置不填充状态
  739. pDC->SelectStockObject(NULL_BRUSH);
  741. pDC->MoveTo(StartPoint.x, StartPoint.y);
  742. pDC->LineTo(EndPoint.x, EndPoint.y);
  744. RECT rect;
  745. rect.left = (StartPoint.x) - Radius;
  746. rect.top = (StartPoint.y) - Radius;
  747. rect.right = (StartPoint.x) + Radius;
  748. rect.bottom = (StartPoint.y) + Radius;
  749. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  751. pDC->SetROP2(R2_COPYPEN);
  752. }
  754. void CMyOperate::RedrawCircle(CDC* pDC)
  755. {
  756. CPen *Pen;
  757. CPen* OldPen;
  758. CPoint origin;
  759. long r;
  760. RECT rect;
  761. int index;
  762. CMyCircle* pCircle;
  763. CMyObjectInfo* pCircleInfo;
  765. index = m_CircleArray.GetSize();
  767. //设置不填充状态
  768. pDC->SelectStockObject(NULL_BRUSH);
  769. while(index--)
  770. {
  771. pCircle = (CMyCircle*)m_CircleArray.GetAt(index);
  772. pCircleInfo = (CMyObjectInfo*)m_CircleInfoArray.GetAt(index);
  774. if(pCircleInfo->m_del == TRUE)
  775. continue;
  776. if(pCircleInfo->m_selected == TRUE)
  777. {
  778. DrawSelCircle(pDC, pCircle);
  779. continue;
  780. }
  782.         Pen = new CPen(pCircle->m_style, 1, pCircle->m_color);
  783. OldPen = pDC->SelectObject(Pen);
  785. origin.x = (long)(pCircle->m_originX * Proportion) + EXTRA_WIDTH;
  786. origin.y = size.cy - (long)(pCircle->m_originY * Proportion) - EXTRA_HIGTH;
  787. r = (long)(pCircle->m_radius * Proportion);
  789. rect.left = origin.x - r;
  790. rect.top = origin.y - r;
  791. rect.right = origin.x + r;
  792. rect.bottom = origin.y + r;
  793. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  795. //注意以下两句顺序不可颠倒
  796. pDC->SelectObject(OldPen);
  797. delete Pen;
  798. }
  799. }
  801. void CMyOperate::DrawSelCircle(CDC* pDC, CMyCircle* pCircle)
  802. {
  803. CPen *Pen;
  804. CPen* OldPen;
  805. RECT rect;
  806. long r;
  807. CPoint origin;
  808. CPoint mid;
  810. //设置不填充状态
  811. pDC->SelectStockObject(NULL_BRUSH);
  814. origin.x = (long)(pCircle->m_originX * Proportion) + EXTRA_WIDTH;
  815. origin.y = size.cy - (long)(pCircle->m_originY * Proportion) - EXTRA_HIGTH;
  816. r = (long)(pCircle->m_radius * Proportion);
  818. rect.left = origin.x - r;
  819. rect.top = origin.y - r;
  820. rect.right = origin.x + r;
  821. rect.bottom = origin.y + r;
  823. //用异或擦除原有的圆
  824. Pen = new CPen(pCircle->m_style, 1, pCircle->m_color);
  825. OldPen = pDC->SelectObject(Pen);
  826. pDC->SetROP2(R2_NOT);
  827. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  828. pDC->SelectObject(OldPen);
  829. delete Pen;
  831. //重画线形为点线的圆
  832. Pen = new CPen(PS_DOT, 1, pCircle->m_color);
  833. OldPen = pDC->SelectObject(Pen);
  834. pDC->SetROP2(R2_COPYPEN);
  835. pDC->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
  836. pDC->SelectObject(OldPen);
  837. delete Pen;
  840. Pen = new CPen(PS_SOLID, 1, RGB(0, 0, 255));
  841. OldPen = pDC->SelectObject(Pen);
  842. pDC->Rectangle(origin.x - SEL_RECT_WIDTH, origin.y - SEL_RECT_WIDTH,
  843.            origin.x + SEL_RECT_WIDTH + 1, origin.y + SEL_RECT_WIDTH + 1);
  844. pDC->Rectangle(origin.x - SEL_RECT_WIDTH, origin.y - r - SEL_RECT_WIDTH ,
  845.            origin.x + SEL_RECT_WIDTH + 1, origin.y - r + SEL_RECT_WIDTH + 1);
  846. pDC->Rectangle(origin.x - SEL_RECT_WIDTH, origin.y + r - SEL_RECT_WIDTH,
  847.            origin.x + SEL_RECT_WIDTH + 1, origin.y + r + SEL_RECT_WIDTH + 1);
  848.     pDC->Rectangle(origin.x - r - SEL_RECT_WIDTH, origin.y - SEL_RECT_WIDTH,
  849.            origin.x - r + SEL_RECT_WIDTH + 1, origin.y + SEL_RECT_WIDTH + 1);
  850. pDC->Rectangle(origin.x + r  - SEL_RECT_WIDTH, origin.y - SEL_RECT_WIDTH,
  851.            origin.x + r + SEL_RECT_WIDTH + 1, origin.y + SEL_RECT_WIDTH + 1);
  852. //注意以下两句顺序不可颠倒
  853. OldPen = pDC->SelectObject(Pen);
  854. pDC->SelectObject(OldPen);
  855. delete Pen;
  856. }
  857. void CMyOperate::SelectCircle(CDC* pDC, CPoint point)
  858. {
  859. int nIndex;
  860. CPoint origin;
  861. long r;
  862. long distance;
  864. CMyObjectInfo* pCircleInfo;
  865. CMySelObjectInfo* pSelObjInfo;
  866. CMyCircle* pCircle; 
  868. for(nIndex = 0; nIndex < m_CircleInfoArray.GetSize(); nIndex++)
  869. {
  870. pCircleInfo = (CMyObjectInfo*)m_CircleInfoArray.GetAt(nIndex);
  871. if(pCircleInfo ->m_del == TRUE || pCircleInfo ->m_selected ==TRUE)
  872. continue;
  874. pCircle = (CMyCircle*)m_CircleArray.GetAt(nIndex);
  876. origin.x = (long)(pCircle->m_originX * Proportion) + EXTRA_WIDTH;
  877. origin.y = size.cy - (long)(pCircle->m_originY * Proportion) - EXTRA_HIGTH;
  878. r = (long)(pCircle->m_radius * Proportion);
  880. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  882. if(distance <= r + SELECT_RANGE && distance >= r - SELECT_RANGE)
  883. {
  884. DrawSelCircle(pDC, pCircle);
  885. pCircleInfo->m_selected = TRUE;
  887. pSelObjInfo = new CMySelObjectInfo(OBJ_CIRCLE, nIndex);
  888. m_SelObjInfoArray.Add(pSelObjInfo);
  889. }
  890. }
  892. }
  894. BOOL CMyOperate::UnselectCircle()
  895. {
  896. BOOL flag = FALSE;
  897. int nIndex;
  898. CMySelObjectInfo* pSelObjInfo;
  899. CMyObjectInfo* pCircleInfo;
  900. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  901. {
  902. pSelObjInfo = (CMySelObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  903. if(pSelObjInfo->m_type ==OBJ_CIRCLE)
  904. {
  905. pCircleInfo = (CMyObjectInfo*)m_CircleInfoArray.GetAt(pSelObjInfo->m_index);
  906. pCircleInfo->m_selected = FALSE;
  907. flag = TRUE;
  908.         }
  909.     }
  910. return flag;
  911. }
  914. void CMyOperate::AddCircle()
  915. {
  916. float startx;
  917. float starty;
  918. float r;
  920. startx = (StartPoint.x - EXTRA_WIDTH) / Proportion;
  921. starty = (size.cy - StartPoint.y  - EXTRA_HIGTH) / Proportion;
  922. r = Radius / Proportion;
  924. CMyCircle* pMyCircle = new CMyCircle(startx, starty, r, LineStyle, ForeColor);
  925. m_CircleArray.Add(pMyCircle);
  927. CMyObjectInfo* pCircleInfo = new CMyObjectInfo(FALSE, FALSE);
  928. m_CircleInfoArray.Add(pCircleInfo);
  929. }
  931. CMyCircle* CMyOperate::GetCircle(int index)
  932. {
  933. if(index < 0 || index > m_CircleArray.GetUpperBound())
  934. return 0;
  935. return (CMyCircle*)m_CircleArray.GetAt(index);
  936. }
  938. void CMyOperate::DelAllCircle()
  939. {
  940. int index;
  942. index = m_CircleArray.GetSize();
  943. while(index--)
  944. delete (CMyCircle*)m_CircleArray.GetAt(index);
  945. m_CircleArray.RemoveAll();
  947. index = m_CircleInfoArray.GetSize();
  948. while(index--)
  949. delete (CMyObjectInfo*)m_CircleInfoArray.GetAt(index);
  950. m_CircleInfoArray.RemoveAll();
  951. }
  952. //////////////////////////////////////////////////////////////////////////////////////////////
  953. void CMyOperate::DrawArcA(CDC* pDC, int times)
  954. {
  955. static flag;
  956. double originX;
  957. double originY;
  958. double k1;
  959. double k2;
  961. double mid1X;
  962. double mid1Y;
  963. double mid2X;
  964. double mid2Y;
  966. long x1, y1, x2, y2;
  968. //基于CDC
  969. pDC->SetROP2(R2_NOT);
  970. //设置不填充状态
  971. pDC->SelectStockObject(NULL_BRUSH);
  973.     switch(times)
  974. {
  975. case 1:
  976. pDC->MoveTo(StartPoint.x, StartPoint.y);
  977. pDC->LineTo(oldMidPoint.x, oldMidPoint.y);
  978. pDC->MoveTo(StartPoint.x, StartPoint.y);
  979. pDC->LineTo(MidPoint.x, MidPoint.y);
  981. flag = 1;
  983.         oldMidPoint = MidPoint;
  984. break;
  986. case 2:
  987. RECT rect;
  988. if(flag == 1)
  989. {
  990. pDC->MoveTo(StartPoint.x, StartPoint.y);
  991. pDC->LineTo(MidPoint.x, MidPoint.y);
  992. flag = 0;
  993. }
  995. if(OriginPoint.x != -1000 && OriginPoint.y != -1000)
  996. {
  997. rect.left = OriginPoint.x - Radius;
  998. rect.top = OriginPoint.y - Radius;
  999. rect.right = OriginPoint.x + Radius;
  1000. rect.bottom = OriginPoint.y + Radius;
  1002. x1 = MidPoint.x - StartPoint.x;
  1003. y1 = MidPoint.y - StartPoint.y;
  1005. x2 = oldEndPoint.x - StartPoint.x;
  1006. y2 = oldEndPoint.y - StartPoint.y;
  1008. if(x1*y2 - x2*y1 < 0)
  1009. pDC->Arc(&rect, StartPoint, oldEndPoint);
  1010. else
  1011. pDC->Arc(&rect, oldEndPoint, StartPoint);
  1012. }
  1014. if(StartPoint.y == MidPoint.y)
  1015. k1 = 1000000.0;
  1016. else 
  1017. k1 = (- (double)(StartPoint.x - MidPoint.x) / (double)(StartPoint.y - MidPoint.y));
  1019. if(EndPoint.y == MidPoint.y)
  1020. k2 = 1000000.0;
  1021. else 
  1022. k2 =  (- (double)(EndPoint.x - MidPoint.x) / (double)(EndPoint.y - MidPoint.y));
  1024. mid1X = (double)(StartPoint.x + MidPoint.x) / 2.0;
  1025. mid1Y = (double)(StartPoint.y + MidPoint.y) / 2.0;
  1027. mid2X = (double)(EndPoint.x + MidPoint.x) / 2.0;
  1028. mid2Y = (double)(EndPoint.y + MidPoint.y) / 2.0;
  1030. if(k1 == k2)
  1031. {
  1032. OriginPoint.x = -1000;
  1033. OriginPoint.y = -1000;
  1034. }
  1035. else
  1036. {
  1037. if(k1 == 1000000.0)
  1038. {
  1039. originX = mid1X;
  1040. originY = k2 * (originX - mid2X) + mid2Y;
  1041. }
  1042. else
  1043. if(k2 == 1000000.0)
  1044. {
  1045. originX = mid2X;
  1046. originY = k1 * (originX - mid1X) + mid1Y;
  1047. }
  1048. else
  1049. {
  1050. originX = ((k2 * mid2X - k1 * mid1X) - (mid2Y - mid1Y)) / (k2 - k1);
  1051. originY = k2 * (originX - mid2X) + mid2Y;
  1052. }
  1054. Radius = (long)sqrt(pow((double)(originX - StartPoint.x), 2) + pow((double)(originY - StartPoint.y), 2));
  1056. OriginPoint.x = (long)originX;
  1057. OriginPoint.y = (long)originY ;
  1058. rect.left = OriginPoint.x - Radius;
  1059. rect.top = OriginPoint.y - Radius;
  1060. rect.right = OriginPoint.x + Radius;
  1061. rect.bottom = OriginPoint.y + Radius;
  1063. x1 = MidPoint.x - StartPoint.x;
  1064. y1 = MidPoint.y - StartPoint.y;
  1066. x2 = EndPoint.x - StartPoint.x;
  1067. y2 = EndPoint.y - StartPoint.y;
  1069. //判断优弧
  1070. if(x1*y2 - x2*y1 < 0)
  1071. pDC->Arc(&rect, StartPoint, EndPoint);
  1072. else
  1073. pDC->Arc(&rect, EndPoint, StartPoint);
  1075.      oldEndPoint = EndPoint;
  1076. }
  1077. break;
  1078. }
  1080. pDC->SetROP2(R2_COPYPEN);
  1081. }
  1083. void CMyOperate::DrawArcB(CDC* pDC, int times)
  1084. {
  1085. long x1, y1, x2, y2;
  1086. //设置不填充状态
  1087. pDC->SelectStockObject(NULL_BRUSH);
  1088.     switch(times)
  1089. {
  1090. case 1:
  1091. pDC->MoveTo(StartPoint.x, StartPoint.y);
  1092. pDC->LineTo(MidPoint.x, MidPoint.y);
  1093. break;
  1095. case 2:
  1096. RECT rect;
  1097. if(OriginPoint.x != -1000 && OriginPoint.y != -1000)
  1098. {
  1099. rect.left = OriginPoint.x - Radius;
  1100. rect.top = OriginPoint.y - Radius;
  1101. rect.right = OriginPoint.x + Radius;
  1102. rect.bottom = OriginPoint.y + Radius;
  1104. x1 = MidPoint.x - StartPoint.x;
  1105. y1 = MidPoint.y - StartPoint.y;
  1106. x2 = EndPoint.x - StartPoint.x;
  1107. y2 = EndPoint.y - StartPoint.y;
  1109. if(x1*y2 - x2*y1 < 0)
  1110. pDC->Arc(&rect, StartPoint, EndPoint);
  1111. else
  1112. pDC->Arc(&rect, EndPoint, StartPoint);
  1113. }
  1114. break;
  1115. }
  1116. }
  1118. void CMyOperate::DrawArcC(CDC* pDC)
  1119. {
  1120. CPen* Pen;
  1121. CPen* OldPen;
  1122. RECT rect;
  1123. long x1, y1, x2, y2;
  1125. //设置不填充状态
  1126. pDC->SelectStockObject(NULL_BRUSH);
  1128. rect.left = OriginPoint.x - Radius;
  1129. rect.top = OriginPoint.y - Radius;
  1130. rect.right = OriginPoint.x + Radius;
  1131. rect.bottom = OriginPoint.y + Radius;
  1133.     Pen = new CPen(LineStyle, 1, ForeColor);
  1134. OldPen = pDC->SelectObject(Pen);
  1136. x1 = MidPoint.x - StartPoint.x;
  1137. y1 = MidPoint.y - StartPoint.y;
  1139. x2 = EndPoint.x - StartPoint.x;
  1140. y2 = EndPoint.y - StartPoint.y;
  1142.     if(x1*y2 - x2*y1 < 0)
  1143. pDC->Arc(&rect, StartPoint, EndPoint);
  1144. else
  1145. pDC->Arc(&rect, EndPoint, StartPoint);
  1147. pDC->SelectObject(OldPen);
  1148.     delete Pen; 
  1149. }
  1151. void CMyOperate::CancelDrawArc(CDC* pDC, int times)
  1152. {
  1153. long x1, y1, x2, y2;
  1154. //设置不填充状态
  1155. pDC->SetROP2(R2_NOT);
  1156. pDC->SelectStockObject(NULL_BRUSH);
  1157.     switch(times)
  1158. {
  1159. case 1:
  1160. pDC->MoveTo(StartPoint.x, StartPoint.y);
  1161. pDC->LineTo(MidPoint.x, MidPoint.y);
  1162. break;
  1164. case 2:
  1165. RECT rect;
  1166. if(OriginPoint.x != -1000 && OriginPoint.y != -1000)
  1167. {
  1168. rect.left = OriginPoint.x - Radius;
  1169. rect.top = OriginPoint.y - Radius;
  1170. rect.right = OriginPoint.x + Radius;
  1171. rect.bottom = OriginPoint.y + Radius;
  1173. x1 = MidPoint.x - StartPoint.x;
  1174. y1 = MidPoint.y - StartPoint.y;
  1176. x2 = EndPoint.x - StartPoint.x;
  1177. y2 = EndPoint.y - StartPoint.y;
  1179. if(x1*y2 - x2*y1 < 0)
  1180. pDC->Arc(&rect, StartPoint, EndPoint);
  1181. else
  1182. pDC->Arc(&rect, EndPoint, StartPoint);
  1183. }
  1184. break;
  1185. }
  1187. pDC->SetROP2(R2_COPYPEN);
  1188. }
  1190. void CMyOperate::RedrawArc(CDC* pDC)
  1191. {
  1192. CPen *Pen;
  1193. CPen* OldPen;
  1194. CPoint origin;
  1195. CPoint start;
  1196. CPoint end;
  1197. long r;
  1198. RECT rect;
  1199. int index;
  1200. CMyArc* pArc;
  1201. CMyObjectInfo* pArcInfo;
  1203. index = m_ArcArray.GetSize();
  1205. //设置不填充状态
  1206. pDC->SelectStockObject(NULL_BRUSH);
  1207. while(index--)
  1208. {
  1209. pArc = (CMyArc*)m_ArcArray.GetAt(index);
  1210. pArcInfo = (CMyObjectInfo*)m_ArcInfoArray.GetAt(index);
  1212. if(pArcInfo->m_del == TRUE)
  1213. continue;
  1214. if(pArcInfo->m_selected == TRUE)
  1215. {
  1216. DrawSelArc(pDC, pArc);
  1217. continue;
  1218. }
  1220.         Pen = new CPen(pArc->m_style, 1, pArc->m_color);
  1221. OldPen = pDC->SelectObject(Pen);
  1223. origin.x = (long)(pArc->m_originX * Proportion) + EXTRA_WIDTH;
  1224. origin.y = size.cy - (long)(pArc->m_originY * Proportion) - EXTRA_HIGTH;
  1225. start.x = (long)(pArc->m_startX * Proportion) + EXTRA_WIDTH;
  1226. start.y = size.cy - (long)(pArc->m_startY * Proportion) - EXTRA_HIGTH;
  1227. end.x = (long)(pArc->m_endX * Proportion) + EXTRA_WIDTH;
  1228. end.y = size.cy - (long)(pArc->m_endY * Proportion) - EXTRA_HIGTH;
  1230. r = (long)(pArc->m_radius * Proportion);
  1232. rect.left = origin.x - r;
  1233. rect.top = origin.y - r;
  1234. rect.right = origin.x + r;
  1235. rect.bottom = origin.y + r;
  1237. pDC->Arc(&rect, start, end);
  1239. //注意以下两句顺序不可颠倒
  1240. pDC->SelectObject(OldPen);
  1241. delete Pen;
  1242. }
  1243. }
  1245. void CMyOperate::DrawSelArc(CDC* pDC, CMyArc* pArc)
  1246. {
  1247. CPen *Pen;
  1248. CPen* OldPen;
  1249. RECT rect;
  1250. long r;
  1251. CPoint origin;
  1252. CPoint start;
  1253. CPoint end;
  1255. //设置不填充状态
  1256. pDC->SelectStockObject(NULL_BRUSH);
  1258. origin.x = (long)(pArc->m_originX * Proportion) + EXTRA_WIDTH;
  1259. origin.y = size.cy - (long)(pArc->m_originY * Proportion) - EXTRA_HIGTH;
  1260. start.x = (long)(pArc->m_startX * Proportion) + EXTRA_WIDTH;
  1261. start.y = size.cy - (long)(pArc->m_startY * Proportion) - EXTRA_HIGTH;
  1262. end.x = (long)(pArc->m_endX * Proportion) + EXTRA_WIDTH;
  1263. end.y = size.cy - (long)(pArc->m_endY * Proportion) - EXTRA_HIGTH;
  1264. r = (long)(pArc->m_radius * Proportion);
  1266. rect.left = origin.x - r;
  1267. rect.top = origin.y - r;
  1268. rect.right = origin.x + r;
  1269. rect.bottom = origin.y + r;
  1271. //重画线形为点线的圆弧
  1272. Pen = new CPen(PS_DOT, 1, pArc->m_color);
  1273. OldPen = pDC->SelectObject(Pen);
  1274. pDC->SetROP2(R2_COPYPEN);
  1275. pDC->Arc(&rect, start, end);
  1276. pDC->SelectObject(OldPen);
  1277. delete Pen;
  1280. Pen = new CPen(PS_SOLID, 1, RGB(0, 0, 255));
  1281. OldPen = pDC->SelectObject(Pen);
  1282. pDC->Rectangle(start.x - SEL_RECT_WIDTH, start.y - SEL_RECT_WIDTH ,
  1283.            start.x + SEL_RECT_WIDTH + 1, start.y + SEL_RECT_WIDTH + 1);
  1284. pDC->Rectangle(end.x - SEL_RECT_WIDTH, end.y - SEL_RECT_WIDTH,
  1285.            end.x + SEL_RECT_WIDTH + 1, end.y + SEL_RECT_WIDTH + 1);
  1286. //注意以下两句顺序不可颠倒
  1287. OldPen = pDC->SelectObject(Pen);
  1288. pDC->SelectObject(OldPen);
  1289. delete Pen;
  1290. }
  1292. void CMyOperate::SelectArc(CDC* pDC, CPoint point)
  1293. {
  1294. long x1, y1, x2, y2;
  1295. int nIndex;
  1297. CPoint origin;
  1298. long r;
  1299. long distance;
  1301. CPoint start;
  1302. CPoint end;
  1304. CMyObjectInfo* pArcInfo;
  1305. CMySelObjectInfo* pSelObjInfo;
  1306. CMyArc* pArc; 
  1308. for(nIndex = 0; nIndex < m_ArcInfoArray.GetSize(); nIndex++)
  1309. {
  1310. pArcInfo = (CMyObjectInfo*)m_ArcInfoArray.GetAt(nIndex);
  1311. if(pArcInfo ->m_del == TRUE || pArcInfo ->m_selected ==TRUE)
  1312. continue;
  1314. pArc = (CMyArc*)m_ArcArray.GetAt(nIndex);
  1316. origin.x = (long)(pArc->m_originX * Proportion) + EXTRA_WIDTH;
  1317. origin.y = size.cy - (long)(pArc->m_originY * Proportion) - EXTRA_HIGTH;
  1318. start.x = (long)(pArc->m_startX * Proportion) + EXTRA_WIDTH;
  1319. start.y = size.cy - (long)(pArc->m_startY * Proportion) - EXTRA_HIGTH;
  1320. end.x = (long)(pArc->m_endX * Proportion) + EXTRA_WIDTH;
  1321. end.y = size.cy - (long)(pArc->m_endY * Proportion) - EXTRA_HIGTH;
  1322. r = (long)(pArc->m_radius * Proportion);
  1324. distance = (long)sqrt( (origin.x - point.x) * (origin.x - point.x) + (origin.y - point.y) * (origin.y - point.y) );
  1326. if(distance >= r + SELECT_RANGE || distance <= r - SELECT_RANGE)
  1327. continue;
  1329. x1 = point.x - start.x;
  1330. y1 = point.y - start.y;
  1331. x2 = end.x - start.x;
  1332. y2 = end.y - start.y;
  1334. if(x1 * y2 - x2 * y1 < 0)
  1335. {
  1336. DrawSelArc(pDC, pArc);
  1337. pArcInfo->m_selected = TRUE;
  1338. pSelObjInfo = new CMySelObjectInfo(OBJ_ARC, nIndex);
  1339. m_SelObjInfoArray.Add(pSelObjInfo);
  1340. }
  1342. }
  1343. }
  1345. BOOL CMyOperate::UnselectArc()
  1346. {
  1347. BOOL flag = FALSE;
  1348. int nIndex;
  1349. CMySelObjectInfo* pSelObjInfo;
  1350. CMyObjectInfo* pArcInfo;
  1351. for(nIndex = 0; nIndex < m_SelObjInfoArray.GetSize(); nIndex++)
  1352. {
  1353. pSelObjInfo = (CMySelObjectInfo*)m_SelObjInfoArray.GetAt(nIndex);
  1354. if(pSelObjInfo->m_type ==OBJ_ARC)
  1355. {
  1356. pArcInfo = (CMyObjectInfo*)m_ArcInfoArray.GetAt(pSelObjInfo->m_index);
  1357. pArcInfo->m_selected = FALSE;
  1358. flag = TRUE;
  1359.         }
  1360.     }
  1361. return flag;
  1362. }
  1365. void CMyOperate::AddArc()
  1366. {
  1367. long x1, y1, x2, y2;
  1368. float originx;
  1369. float originy;
  1371. float startx;
  1372. float starty;
  1373. float endx;
  1374. float endy;
  1375. float r;
  1377. CMyArc* pMyArc;
  1379. originx = (OriginPoint.x - EXTRA_WIDTH) / Proportion;
  1380. originy = (size.cy - OriginPoint.y  - EXTRA_HIGTH) / Proportion;
  1382. startx = (StartPoint.x - EXTRA_WIDTH) / Proportion;
  1383. starty = (size.cy - StartPoint.y  - EXTRA_HIGTH) / Proportion;
  1384.     endx = (EndPoint.x - EXTRA_WIDTH) / Proportion;
  1385. endy = (size.cy - EndPoint.y  - EXTRA_HIGTH) / Proportion;
  1387. r = Radius / Proportion;
  1389. x1 = MidPoint.x - StartPoint.x;
  1390. y1 = MidPoint.y - StartPoint.y;
  1392. x2 = EndPoint.x - StartPoint.x;
  1393. y2 = EndPoint.y - StartPoint.y;
  1395. if(x1*y2 - x2*y1 < 0)
  1396. pMyArc = new CMyArc(originx, originy, startx, starty, endx, endy, r, LineStyle, ForeColor);
  1397. else
  1398. pMyArc = new CMyArc(originx, originy, endx, endy, startx, starty, r, LineStyle, ForeColor);
  1400. m_ArcArray.Add(pMyArc);
  1402. CMyObjectInfo* pArcInfo = new CMyObjectInfo(FALSE, FALSE);
  1403. m_ArcInfoArray.Add(pArcInfo);
  1404. }
  1407. CMyArc* CMyOperate::GetArc(int index)
  1408. {
  1409. if(index < 0 || index > m_ArcArray.GetUpperBound())
  1410. return 0;
  1411. return (CMyArc*)m_ArcArray.GetAt(index);
  1412. }
  1414. void CMyOperate::DelAllArc()
  1415. {
  1416. int index;
  1418. index = m_ArcArray.GetSize();
  1419. while(index--)
  1420. delete (CMyArc*)m_ArcArray.GetAt(index);
  1421. m_ArcArray.RemoveAll();
  1423. index = m_ArcInfoArray.GetSize();
  1424. while(index--)
  1425. delete (CMyObjectInfo*)m_ArcInfoArray.GetAt(index);
  1426. m_ArcInfoArray.RemoveAll();
  1427. }