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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
Circle.cpp
资源名称：44757463.rar　[点击查看]
上传用户：lj3531212
上传日期：2007-06-18
资源大小：346k
文件大小：18k
源码类别：

绘图程序

开发平台：

Visual C++

Circle.cpp：源码内容
  1. // Circle.cpp: implementation of the CCircle class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "GraphSoft.h"
  7. #include "Circle.h"
  9. #include "GlobalFunction.h"
  10. #include "math.h"
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  17. ///////////////////////////////////
  18. IMPLEMENT_SERIAL( CCircle, CShape, 0 )
  19. //////////////////////////////////////////////////////////////////////
  20. // Construction/Destruction
  21. //////////////////////////////////////////////////////////////////////
  22. ///////////////////////////////////////////////////////////////////////
  23. CCircle::CCircle():CShape()
  24. {
  25.  m_flRadiusTemp=m_flRadius=0;
  26.  m_flCenterxTemp=m_flCenterx=0;
  27.  m_flCenteryTemp=m_flCentery=0;
  28. }
  29. CCircle::CCircle(COLORREF color,int penWidth,float angle):CShape(color,penWidth,angle)
  30. {
  31. m_flRadiusTemp=m_flRadius=0;
  32. m_flCenterxTemp=m_flCenterx=0;
  33. m_flCenteryTemp=m_flCentery=0;
  34. }
  35. CCircle::CCircle(CCircle * const pCircle):CShape(pCircle)
  36. {
  37. m_flRadius=pCircle->m_flRadius;
  38. m_flCenterx=pCircle->m_flCenterx;
  39. m_flCentery=pCircle->m_flCentery;
  40. //
  41. m_flRadiusTemp=pCircle->m_flRadiusTemp;
  42. m_flCenterxTemp=pCircle->m_flCenterxTemp;
  43. m_flCenteryTemp=pCircle->m_flCenteryTemp;
  44. }
  45. CCircle::~CCircle()
  46. {
  47. }
  48. ////////////////////////////////////////////////////////////////////////// 
  49. void CCircle::Serialize( CArchive& ar)
  50. {
  51. CShape::Serialize( ar ) ;
  52. if ( ar.IsLoading() ){  
  53. ar>>m_flRadius;
  54. ar>>m_flCenterx;
  55. ar>>m_flCentery;
  56. //temp
  57. m_flRadiusTemp=m_flRadius;
  58. m_flCenterxTemp=m_flCenterx;
  59. m_flCenteryTemp=m_flCentery;
  60. } else {
  61. ar<<m_flRadius;
  62. ar<<m_flCenterx;
  63. ar<<m_flCentery;  
  64. }
  65. return ;
  66. }
  67. ////////////////////////////////////////////////////////////////////////
  68. void CCircle::Draw(CDC *pDC,COLORREF color,COLORREF fillColor,int penWidth)
  69. {
  70. CPen pen,*poldPen;
  71. CPoint ptCenter(m_flCenterxTemp,m_flCenteryTemp);
  72.     
  73. pen.CreatePen(PS_SOLID,1, fillColor);    
  75. poldPen=pDC->SelectObject(&pen);
  76. if(m_nFillStyle==_shape_solid_fill){
  77. FillBreCircle(pDC,ptCenter,m_flRadiusTemp,penWidth);
  78. }
  79. pen.DeleteObject();
  80. pen.CreatePen(PS_SOLID,penWidth, color);  
  81. pDC->SelectObject(&pen);      
  82. //CBrush brush ;
  83. //brush.CreateSolidBrush(::GetSysColor(COLOR_3DFACE)) ;
  84. //CBrush* pOldBrush = (CBrush*) pDC->SelectObject(&brush);
  85. BreCircle(pDC,ptCenter,m_flRadiusTemp,color,penWidth);
  87. if(GetDrawPointsFlag()==1){
  88. DrawPoints(pDC,color);
  89. }
  91. pDC->SelectObject(poldPen);  
  92. //pDC->SelectObject(pOldBrush);
  94. }
  95. ///////////////////////////////////////////
  96. void CCircle::DrawPointsCutTo(CDC *pDC,COLORREF color,CFlRect m_rectFrom,CRect m_rectTo)
  97. {
  98. if(!IsInRect(m_rectFrom)){
  99. return;
  100. }
  101. //得到移动扩缩后的关键数据
  102. float  flCx,flCy,flR;
  103. //移动
  104. float stepx=m_rectTo.left-m_rectFrom.left;
  105. float stepy=m_rectTo.top-m_rectFrom.top;
  106. flCx=m_flCenterxTemp+stepx;
  107. flCy=m_flCenteryTemp+stepy;
  108. flR=m_flRadiusTemp;
  109. //扩缩
  110. float cx,cy,flScale;
  111. cx=m_rectTo.left;
  112. cy=m_rectTo.top;  
  113. if(m_rectFrom.Width()<0.01){
  114. m_rectFrom.right=m_rectFrom.left +1;
  115. }
  116. if(m_rectFrom.Height()<0.01){
  117. m_rectFrom.bottom=m_rectFrom.top +1;
  118. }
  119. flScale=(float)m_rectTo.Width()/m_rectFrom.Width();
  120. // flScale=min((float)m_rectTo.Width()/m_rectFrom.Width(),(float)m_rectTo.Height()/m_rectFrom.Height());
  121. flR=flR*flScale;
  122. flCx=(flCx-cx)*flScale+cx;
  123. flCy=(flCy-cy)*flScale+cy;
  125. CPen pen,*poldPen;
  126.     pen.CreatePen(PS_SOLID,1, color);
  127. poldPen=pDC->SelectObject(&pen);
  128. {
  129. pDC->MoveTo(flCx,flCy-1-GetPenWidth());
  130. pDC->LineTo(flCx,flCy+2+GetPenWidth());
  131. pDC->MoveTo(flCx-1-GetPenWidth(),flCy);
  132. pDC->LineTo(flCx+2+GetPenWidth(),flCy);
  133. }
  135. pDC->SelectObject(poldPen);      
  136. return;
  137. }
  138. void CCircle::DrawPoints(CDC *pDC,COLORREF color)
  139. {
  140. CPen pen,*poldPen;
  141.     pen.CreatePen(PS_SOLID,1, color);
  142. poldPen=pDC->SelectObject(&pen);
  143. {
  144. pDC->MoveTo(m_flCenterxTemp,m_flCenteryTemp-1-GetPenWidth());
  145. pDC->LineTo(m_flCenterxTemp,m_flCenteryTemp+2+GetPenWidth());
  146. pDC->MoveTo(m_flCenterxTemp-1-GetPenWidth(),m_flCenteryTemp);
  147. pDC->LineTo(m_flCenterxTemp+2+GetPenWidth(),m_flCenteryTemp);
  148. }  
  149. pDC->SelectObject(poldPen);      
  150. return;
  151. }
  152. ///////////////////////////////
  153. void CCircle::DrawCutToRect(CDC *pDC,COLORREF color,COLORREF fillColor,int penWidth,CFlRect m_rectFrom,CRect m_rectTo)
  154. {
  155. // if(!IsInRect(m_rectFrom)){
  156. // return;
  157. // }
  158. //得到移动扩缩后的关键数据
  159. float  flCx,flCy,flR;
  160. //移动
  161. float stepx=m_rectTo.left-m_rectFrom.left;
  162. float stepy=m_rectTo.top-m_rectFrom.top;
  163. flCx=m_flCenterxTemp+stepx;
  164. flCy=m_flCenteryTemp+stepy;
  165. flR=m_flRadiusTemp;
  166. //扩缩
  167. float cx,cy,flScale;
  168. cx=m_rectTo.left;
  169. cy=m_rectTo.top;  
  170. if(m_rectFrom.Width()<0.01){
  171. m_rectFrom.right=m_rectFrom.left +1;
  172. }
  173. if(m_rectFrom.Height()<0.01){
  174. m_rectFrom.bottom=m_rectFrom.top +1;
  175. }
  176. flScale=(float)m_rectTo.Width()/m_rectFrom.Width();
  177. // flScale=min((float)m_rectTo.Width()/m_rectFrom.Width(),(float)m_rectTo.Height()/m_rectFrom.Height());
  178. flR=flR*flScale;
  179. flCx=(flCx-cx)*flScale+cx;
  180. flCy=(flCy-cy)*flScale+cy;
  182. //Draw
  183. CPen pen,*poldPen;
  184. CPoint ptCenter(flCx,flCy);    
  185. pen.CreatePen(PS_SOLID,1, fillColor);    
  186. poldPen=pDC->SelectObject(&pen);
  187. if(m_nFillStyle==_shape_solid_fill){
  188. FillBreCircle(pDC,ptCenter,flR,penWidth);
  189. }
  190. pen.DeleteObject();
  191. pen.CreatePen(PS_SOLID,penWidth, color);  
  192. pDC->SelectObject(&pen);    
  193. BreCircle(pDC,ptCenter,flR,color,penWidth);
  195. if(GetDrawPointsFlag()==1){
  196. DrawPointsCutTo(pDC,color,m_rectFrom,m_rectTo);
  197. }
  199. pDC->SelectObject(poldPen);
  200. }
  201. //
  202. void CCircle::BreCircle(CDC *pDC,CPoint m_pCenter,int nRadius,COLORREF color,int nPenWidth)
  203. {
  204. int x,y,xc,yc,r,di,i;    
  205. xc=m_pCenter.x;
  206. yc=m_pCenter.y;
  207. x=xc+nRadius;
  208. y=yc;
  209. r=nRadius;
  211. x=0;
  212. y=r;
  213. di=3-2*r;
  214. float flX[8],flY[8];
  215. flX[0]=xc+x;
  216. flX[1]=xc+x;
  217. flX[2]=xc-x;
  218. flX[3]=xc-x;
  219. flX[4]=xc+y;
  220. flX[5]=xc+y;
  221. flX[6]=xc-y;
  222. flX[7]=xc-y;
  223. flY[0]=yc+y;
  224. flY[1]=yc-y;
  225. flY[2]=yc+y;
  226. flY[3]=yc-y;
  227. flY[4]=yc+x;
  228. flY[5]=yc-x;
  229. flY[6]=yc+x;
  230. flY[7]=yc-x;
  231. i=0;
  232. while(x<=y)
  233. {
  234. i++;
  235. // for(i=0;i<nPenWidth;i++)
  236. if(i==5)
  237. {   pDC->MoveTo(flX[0],flY[0]);
  238. pDC->LineTo(xc+x,yc+y);
  239. pDC->MoveTo(flX[1],flY[1]);
  240. pDC->LineTo(xc+x,yc-y);
  241. pDC->MoveTo(flX[2],flY[2]);
  242. pDC->LineTo(xc-x,yc+y);
  243. pDC->MoveTo(flX[3],flY[3]);
  244. pDC->LineTo(xc-x,yc-y);
  245. pDC->MoveTo(flX[4],flY[4]);
  246. pDC->LineTo(xc+y,yc+x);
  247. pDC->MoveTo(flX[5],flY[5]);
  248. pDC->LineTo(xc+y,yc-x);
  249. pDC->MoveTo(flX[6],flY[6]);
  250. pDC->LineTo(xc-y,yc+x);
  251. pDC->MoveTo(flX[7],flY[7]);
  252. pDC->LineTo(xc-y,yc-x);
  254. flX[0]=xc+x;
  255. flX[1]=xc+x;
  256. flX[2]=xc-x;
  257. flX[3]=xc-x;
  258. flX[4]=xc+y;
  259. flX[5]=xc+y;
  260. flX[6]=xc-y;
  261. flX[7]=xc-y;
  262. flY[0]=yc+y;
  263. flY[1]=yc-y;
  264. flY[2]=yc+y;
  265. flY[3]=yc-y;
  266. flY[4]=yc+x;
  267. flY[5]=yc-x;
  268. flY[6]=yc+x;
  269. flY[7]=yc-x;
  270. i=0;
  271. }
  272. if(di<0)
  273. {
  274. di+=4*x+6;
  275. }
  276. else
  277. {
  278. di+=4*(x-y)+10;
  279. y--;
  280. }
  281. x++;
  282. }
  283. pDC->MoveTo(flX[0],flY[0]);
  284. pDC->LineTo(xc+x,yc+y);
  285. pDC->MoveTo(flX[1],flY[1]);
  286. pDC->LineTo(xc+x,yc-y);
  287. pDC->MoveTo(flX[2],flY[2]);
  288. pDC->LineTo(xc-x,yc+y);
  289. pDC->MoveTo(flX[3],flY[3]);
  290. pDC->LineTo(xc-x,yc-y);
  291. pDC->MoveTo(flX[4],flY[4]);
  292. pDC->LineTo(xc+y,yc+x);
  293. pDC->MoveTo(flX[5],flY[5]);
  294. pDC->LineTo(xc+y,yc-x);
  295. pDC->MoveTo(flX[6],flY[6]);
  296. pDC->LineTo(xc-y,yc+x);
  297. pDC->MoveTo(flX[7],flY[7]);
  298. pDC->LineTo(xc-y,yc-x);
  300. }
  301. ///////////
  302. void CCircle::FillBreCircle(CDC *pDC,CPoint ptCenter,int flRadius,int penWidth)
  303. {
  304. int x,y,xc,yc,r,di,i;    
  305. xc=ptCenter.x;
  306. yc=ptCenter.y;
  307. x=xc+flRadius;
  308. y=yc;
  309. r=flRadius;
  310. x=0;
  311. y=r;
  312. di=3-2*r;
  314. while(x<=y)
  315. {
  316. pDC->MoveTo(xc+x,yc+y);
  317.         pDC->LineTo(xc+x,yc-y);
  318.     pDC->MoveTo(xc+y,yc+x);
  319. pDC->LineTo(xc+y,yc-x);
  320. pDC->MoveTo(xc-x,yc+y);
  321.         pDC->LineTo(xc-x,yc-y);
  322. pDC->MoveTo(xc-y,yc+x);
  323. pDC->LineTo(xc-y,yc-x);
  325. if(di<0)
  326. {
  327. di+=4*x+6;
  328. }
  329. else
  330. {
  331. di+=4*(x-y)+10;
  332. y-=1;
  333. }
  334. x+=1;
  335. }
  336. }
  337. ////////////////////////////////////////////////////////////////////////////
  338. ////////////////////////////////////////////////////////////////////////////
  339. void CCircle::RefreshData(bool bRefresh)
  340. {
  341. if(bRefresh){
  343. m_flRadius=m_flRadiusTemp;
  344. m_flCenterx=m_flCenterxTemp;
  345. m_flCentery=m_flCenteryTemp;
  347. m_bModified=FALSE;
  348. m_ptMagnifyCenterTemp=CPoint(0,0);
  349. m_flScaleTemp=1;
  350. m_ptRotateCenterTemp=CPoint(0,0);
  351. m_flAngleTemp=0;
  352. }
  353. }
  355. void CCircle::CreatGraph(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY,int nPenWidth,COLORREF color,COLORREF fillColor,SHAPE_FILLSTYLE nStyle)
  356. {
  357. if(flArrayX.GetSize()<2){
  358. return;
  359. }
  360. CShape::CreatGraph(flArrayX,flArrayY,nPenWidth,color,fillColor,nStyle);
  361. m_flRadiusTemp=m_flRadius=GetDistance(flArrayX.GetAt(0),flArrayY.GetAt(0),flArrayX.GetAt(1),flArrayY.GetAt(1));
  362. m_flCenterx=m_flCenterxTemp=flArrayX.GetAt(0);
  363. m_flCentery=m_flCenteryTemp=flArrayY.GetAt(0);
  364. TRACE("m_flRadius=%fn",m_flRadius);
  365. return;
  366. }
  367. void CCircle::CreatGraph(CArray<CPoint,CPoint>& ptArray,int nPenWidth,COLORREF color,COLORREF fillColor,SHAPE_FILLSTYLE nStyle)
  368. {
  369. if(ptArray.GetSize()<2){
  370. return;
  371. }
  372. CShape::CreatGraph(ptArray,nPenWidth,color,fillColor,nStyle);
  373. m_flRadiusTemp=m_flRadius=GetDistance(ptArray.GetAt(0),ptArray.GetAt(1));
  374. m_flCenterx=m_flCenterxTemp=((CPoint)ptArray.GetAt(0)).x;
  375. m_flCentery=m_flCenteryTemp=((CPoint)ptArray.GetAt(0)).y;
  377. return;
  378. }
  379. //   特殊化处理，第二个点x值保存半径长度
  380. void CCircle::SetPtData(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY)
  381. {
  382. m_flCenterx=m_flCenterxTemp=((float)flArrayX.GetAt(0));
  383. m_flCentery=m_flCenteryTemp=((float)flArrayY.GetAt(0));
  384. m_flRadius=m_flRadiusTemp=flArrayX.GetAt(1);    
  385. }
  386. //   特殊化处理，第二个点x值保存半径长度
  387. void CCircle::GetPtData(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY)
  388. {
  389. flArrayX.RemoveAll();
  390. flArrayY.RemoveAll();
  392. flArrayX.Add(m_flCenterxTemp);
  393. flArrayX.Add(m_flRadiusTemp);
  395. flArrayY.Add(m_flCenteryTemp);
  396. flArrayY.Add(m_flRadiusTemp);
  397. }
  398. CShape* CCircle::GetCopy()
  399. {
  400. CShape* pGraph=new CCircle(this);
  401. return pGraph;  
  402. }
  403. ////////////////////////////////////////////////////////////////////////////
  404. ////////////////////////////////////////////////////////////////////////////
  405. void CCircle::Move(CDC *pDC,float stepx,float stepy)
  406. {
  407. RefreshData(m_bModified);
  408. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  410. m_flCenterx+=stepx;
  411. m_flCentery+=stepy;
  413. //temp
  414. m_flCenterxTemp+=stepx;
  415. m_flCenteryTemp+=stepy;
  416. }
  417. void CCircle::PartMove(CDC *pDC,float PrevX,float PrevY,float CurX,float CurY)
  418. {
  419. RefreshData(m_bModified);
  421.     if(m_nSelectPtNum==1){
  422. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  423. m_flRadiusTemp=GetDistance(CurX,CurY,m_flCenterxTemp,m_flCenteryTemp);
  424. m_flRadius=m_flRadiusTemp; 
  425. m_flRadiusTemp=GetDistance(CurX,CurY,m_flCenterxTemp,m_flCenteryTemp);
  426. m_flRadius=m_flRadiusTemp; 
  427. // CShape::Draw(pDC);
  428.     }else if(m_nSelectPtNum==0){
  429. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  430. m_flCenterxTemp=CurX;
  431. m_flCenteryTemp=CurY;
  432. m_flCenterx=CurX;
  433. m_flCentery=CurY;
  434. // CShape::Draw(pDC);
  435.     }
  436. }
  437. void CCircle::Rotate(CDC *pDC,float CX,float CY,float flAngle)
  438. {
  440. if(m_flScaleTemp!=1){
  441. RefreshData(TRUE);
  442. }
  444. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  446. m_ptRotateCenterTemp=CPoint(CX,CY);
  447. m_flAngleTemp=flAngle;
  448. m_bModified=TRUE;
  450. m_flCenterxTemp=((m_flCenterx-CX)*cos(flAngle)-(m_flCentery-CY)*sin(flAngle))+CX;
  451. m_flCenteryTemp=((m_flCentery-CY)*cos(flAngle)+(m_flCenterx-CX)*sin(flAngle))+CY;
  452. }
  453. void CCircle::Magnify(CDC *pDC,float CX,float CY,float flScale)
  454. {
  456. if(m_flAngleTemp!=0){
  457. RefreshData(TRUE);
  458. }
  459. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));  
  460. m_ptMagnifyCenterTemp=CPoint(CX,CY);
  461. m_flScaleTemp=flScale;
  462. m_bModified=TRUE;
  464. m_flCenterxTemp=(m_flCenterx-CX)*flScale+CX;
  465. m_flCenteryTemp=(m_flCentery-CY)*flScale+CY;
  466. m_flRadiusTemp=m_flRadius*flScale;
  467. }
  468. void CCircle::TopToBottom(CDC* pDC,CRect rect)
  469. {
  470. RefreshData(m_bModified);
  471. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  473. m_flCenteryTemp=rect.top/1000.0+rect.bottom/1000.0-m_flCenteryTemp;
  474. m_flCentery=rect.top/1000.0+rect.bottom/1000.0-m_flCentery;
  477. // CShape::Draw(pDC);
  478. }
  480. void CCircle::LeftToRight(CDC* pDC,CRect rect)
  481. {
  482. RefreshData(m_bModified);
  483. // CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  485. m_flCenterxTemp=rect.left/1000.0+rect.right/1000.0-m_flCenterxTemp;
  486. m_flCenterx=rect.left/1000.0+rect.right/1000.0-m_flCenterx;
  488. // CShape::Draw(pDC);
  489. } 
  490. ///
  491. ////////////////////////////////////////////////////////////////////////////
  492. ////////////////////////////////////////////////////////////////////////////
  493. int CCircle::IsInRect(CRect rect)
  494. {
  495. int nRltVal=0;
  496. CPoint ptRectLT=rect.TopLeft();
  497. CPoint ptRectRB=rect.BottomRight();
  498. CPoint ptRectLB,ptRectRT;
  499. ptRectLB.x=rect.left;
  500. ptRectLB.y=rect.bottom;
  501. ptRectRT.x=rect.right;
  502. ptRectRT.y=rect.top;
  504. CPoint ptCircleCenter(m_flCenterxTemp,m_flCenteryTemp);
  505.     
  506. //求四条矩形边是否有和圆相交/在圆内
  507. float flX[4][2],flY[4][2];
  508. flY[0][0]=rect.top;
  509. flY[1][0]=rect.bottom;
  510. flY[0][1]=rect.top;
  511. flY[1][1]=rect.bottom;
  512. if(rect.left>m_flCenterxTemp){
  513. flX[0][0]=rect.left;
  514. flX[1][0]=rect.left;
  515. flX[0][1]=rect.right;
  516. flX[1][1]=rect.right;
  517. }else if(rect.right<m_flCenterxTemp) {
  518. flX[0][0]=rect.right;
  519. flX[1][0]=rect.right;
  520. flX[0][1]=rect.left;
  521. flX[1][1]=rect.left;
  522. }else{
  523. flX[0][0]=m_flCenterxTemp;
  524. flX[1][0]=m_flCenterxTemp;
  525. if(m_flCenterxTemp-rect.left > rect.right-m_flCenterxTemp){
  526. flX[0][1]=rect.left;
  527. flX[1][1]=rect.left;
  528. }else{
  529. flX[0][1]=rect.right;
  530. flX[1][1]=rect.right;
  531. }
  532. }
  533. flX[2][0]=rect.left;
  534. flX[3][0]=rect.right;
  535. flX[2][1]=rect.left;
  536. flX[3][1]=rect.right;
  537. if(rect.top>m_flCenteryTemp){
  538. flY[2][0]=rect.top;
  539. flY[3][0]=rect.top;
  540. flY[2][1]=rect.bottom;
  541. flY[3][1]=rect.bottom;
  542. }else if(rect.bottom<m_flCenteryTemp) {
  543. flY[2][0]=rect.bottom;
  544. flY[3][0]=rect.bottom;
  545. flY[2][1]=rect.top;
  546. flY[3][1]=rect.top;
  547. }else{
  548. flY[2][0]=m_flCenteryTemp;
  549. flY[3][0]=m_flCenteryTemp;
  550. if(m_flCenteryTemp-rect.top > rect.bottom-m_flCenteryTemp){
  551. flX[2][1]=rect.top;
  552. flX[3][1]=rect.top;
  553. }else{
  554. flX[2][1]=rect.bottom;
  555. flX[3][1]=rect.bottom;
  556. }
  557. }
  558. int flag=0;
  559. if(GetDistance(flX[0][0],flY[0][0],m_flCenterxTemp,m_flCenteryTemp)<=m_flRadiusTemp){
  560. if(GetDistance(flX[0][1],flY[0][1],m_flCenterxTemp,m_flCenteryTemp)>m_flRadiusTemp){
  561. nRltVal|=1;//cut
  562. }else{
  563. nRltVal|=2;
  564. }
  565. }else{
  566. flag++;
  567. }
  568. if(GetDistance(flX[1][0],flY[1][0],m_flCenterxTemp,m_flCenteryTemp)<=m_flRadiusTemp){
  569. if(GetDistance(flX[1][1],flY[1][1],m_flCenterxTemp,m_flCenteryTemp)>m_flRadiusTemp){
  570. nRltVal|=1;//cut
  571. }else{
  572. nRltVal|=2;
  573. }
  574. }else{
  575. flag++;
  576. }
  577. if(GetDistance(flX[2][0],flY[2][0],m_flCenterxTemp,m_flCenteryTemp)<=m_flRadiusTemp){
  578. if(GetDistance(flX[2][1],flY[2][1],m_flCenterxTemp,m_flCenteryTemp)>m_flRadiusTemp){
  579. nRltVal|=1;//cut
  580. }else{
  581. nRltVal|=2;
  582. }
  583. }else{
  584. flag++;
  585. }
  586. if(GetDistance(flX[3][0],flY[3][0],m_flCenterxTemp,m_flCenteryTemp)<=m_flRadiusTemp){
  587. if(GetDistance(flX[3][1],flY[3][1],m_flCenterxTemp,m_flCenteryTemp)>m_flRadiusTemp){
  588. nRltVal|=1;//cut
  589. }else{
  590. nRltVal|=2;
  591. }
  592. }else{
  593. flag++;
  594. }
  595. if(nRltVal==3){
  596. nRltVal=1;
  597. }
  598. if(nRltVal==2&&m_nFillStyle==_shape_none_fill){
  599. nRltVal=0;
  600. }
  601. if(flag==4&&rect.PtInRect(ptCircleCenter)){
  602. nRltVal=2;
  603. }
  604. return nRltVal;
  605. }
  606. CRect CCircle::GetBoundaryRect()
  607. {
  608. CRect rect;
  610. rect.left=1000*(m_flCenterxTemp-m_flRadiusTemp);
  611. rect.right=1000*(m_flCenterxTemp+m_flRadiusTemp);
  612. rect.top=1000*(m_flCenteryTemp-m_flRadiusTemp);
  613. rect.bottom=1000*(m_flCenteryTemp+m_flRadiusTemp);
  615. return rect;
  616. }
  617. CPoint CCircle::GetCenterPoint()
  618. {
  619. CPoint ptCenter(m_flCenterxTemp,m_flCenteryTemp);
  620. return ptCenter;
  621. }
  622. int CCircle::IsPointinRegion(POINT point)
  623. {
  624. CPoint ptCenter(m_flCenterxTemp,m_flCenteryTemp);
  625. if(GetDistance(ptCenter,point)>m_flRadiusTemp)
  626. return 0;
  627. return 1;
  628. }
  629. //////
  630. int CCircle::GetPtState(float flx,float fly,float flRate)
  631. {
  632. CPoint ptCenter(m_flCenterxTemp,m_flCenteryTemp);
  633. if(fabs(GetDistance(m_flCenterxTemp,m_flCenteryTemp,flx,fly)-m_flRadiusTemp) <= 3.0*flRate)
  634. {
  635. m_nSelectPtNum=1;
  636. return 1;
  637. }
  638. if(IsPtInRect(m_flCenterxTemp-3*flRate,m_flCenteryTemp-3*flRate,m_flCenterxTemp+3*flRate,m_flCenteryTemp+3*flRate,flx,fly)){
  639. m_nSelectPtNum=0;
  640. return 1;
  641. }
  642. m_nSelectPtNum=-1;
  643. return 0;
  644. }
  646. //////////////////////////////////////////////////////////////////////
  647. // MODULE   :ExPort
  648. // ABSTRACT :Export to a txt file
  649. // FUNCTION :File->Export...
  650. // NOTE     :
  651. // RETURN   :
  652. // ARGUMENTS:
  653. //              I/O           TYPE      NAME       EXPLANATION
  654. //               O            FILE*    outStream    Out put File
  655. // CREATE   :  FNST)handwolf  2004-4-14
  656. // UPDATE   :  
  657. //          : 
  658. //////////////////////////////////////////////////////////////////////
  660. void CCircle::ExPort(FILE* outStream)//增加导出txt功能时用
  661. {
  662. fprintf(outStream, " CCircle n");
  663. CShape::ExPort(outStream);
  664. fprintf( outStream, " %f %f %f n",m_flRadius,m_flCenterx,m_flCentery);
  665. }
  667. //////////////////////////////////////////////////////////////////////
  668. // MODULE   :ImPort
  669. // ABSTRACT :ImPort from a txt file
  670. // FUNCTION :File->ImPort...
  671. // NOTE     :
  672. // RETURN   :
  673. // ARGUMENTS:
  674. //              I/O           TYPE      NAME       EXPLANATION
  675. //               I            FILE*    inStream    in put File
  676. // CREATE   :  FNST)handwolf  2004-4-14
  677. // UPDATE   :  
  678. //          : 
  679. //////////////////////////////////////////////////////////////////////
  680. void CCircle::ImPort(FILE* inStream)
  681. {
  682. CShape::ImPort(inStream);
  683.     fscanf(inStream, "%f %f %f",&m_flRadius,&m_flCenterx,&m_flCentery);
  684.     m_flRadiusTemp=m_flRadius;
  685. m_flCenterxTemp=m_flCenterx;
  686. m_flCenteryTemp=m_flCentery;
  687. }
  688. CString CCircle::GetNameString()
  689. {
  690. CString str;
  691. str.LoadString(IDS_CIRCLE);
  692. return str;
  693. }
  694. //////////////////////////////////////////////////////////////////////
  695. //End of File////////////////
  696. ////////////////////////////////////////////////////////////////////////////
  697. ////////////////////////////////////////////////////////////////////////////