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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
CEllipse.cpp
资源名称：完整的基本图形绘制系统.rar　[点击查看]
上传用户：qiye66671
上传日期：2009-12-10
资源大小：182k
文件大小：15k
源码类别：

绘图程序

开发平台：

C/C++

CEllipse.cpp：源码内容
  1. #include "stdafx.h"
  2. #include"CEllipse.h"
  3. #include"EastDrawView.h"
  4. IMPLEMENT_SERIAL(CEllipse,CUnit,1)
  5. void CEllipse::DrawStatic(CDC*pDC)
  6. {  
  7.   CPen m_pen;
  8.   CBrush m_brush;
  9.   int oldDrawingMode=pDC->SetROP2(this->m_DrawingMode);
  10.   m_pen.CreatePen(m_PenStyle,m_PenWidth,m_PenColor);
  11.   CPen* pen=(CPen*)pDC->SelectObject(&m_pen);
  12.   LOGBRUSH brushlog;
  13.   brushlog.lbColor=m_BrushColor;
  14.   brushlog.lbHatch=m_BrushHatch;
  15.   brushlog.lbStyle=m_BrushStyle;
  16.   m_brush.CreateBrushIndirect(&brushlog);
  17.   SetBrushOrg(pDC,&m_brush);
  18.   CBrush*brush=(CBrush*)pDC->SelectObject(&m_brush);
  19.  
  20.  int OldBkMode=pDC->SetBkMode(m_BkMode);
  21.  COLORREF OldColor=pDC->SetBkColor(m_BackgroundColor);
  22.  
  23.  ellipseMidpoint(pDC,m_CenterPoint.x,m_CenterPoint.y,this->m_Xr,this->m_Yr);
  24.  pDC->SelectObject(brush);
  25.  pDC->SelectObject(pen);
  26.  pDC->SetBkMode(OldBkMode);
  27.  pDC->SetBkColor(OldColor);
  28.  pDC->SetROP2(oldDrawingMode);
  30. }
  32. void CEllipse::Serialize(CArchive &ar)
  33. {
  34. CUnit::Serialize(ar);
  35.     if(ar.IsStoring())
  36. {
  37.   ar<<m_BrushStyle<<m_BkMode<<m_BrushHatch<<m_BrushColor;
  38.   ar<<m_Sin<<m_Cos;
  39.   ar<<m_Xr<<m_Yr;
  40.   ar<<m_CenterPoint;
  41. }
  42. else
  43. {
  44.   ar>>m_BrushStyle>>m_BkMode>>m_BrushHatch>>m_BrushColor;
  45.   ar>>m_Sin>>m_Cos;
  46.   ar>>m_Xr>>m_Yr;
  47.   ar>>m_CenterPoint;
  48. }
  50. }
  51. BOOL CEllipse::IsInRgn(CPoint point)
  52. {
  53.     
  54. double vh[3][3]={m_Cos,-m_Sin,m_CenterPoint.x*(1-m_Cos)+m_CenterPoint.y*m_Sin,
  55.                m_Sin, m_Cos,m_CenterPoint.y*(1-m_Cos)-m_CenterPoint.x*m_Sin,
  56.    0,0,1
  57.                   };       
  58.   
  59.      
  60.        
  61.   double xy[3];
  62.   CPoint point1=CPoint(m_CenterPoint.x-m_Xr,m_CenterPoint.y+m_Yr);
  63.   CPoint point2=CPoint(m_CenterPoint.x+m_Xr,m_CenterPoint.y+m_Yr);
  64.   CPoint point3=CPoint(m_CenterPoint.x+m_Xr,m_CenterPoint.y-m_Yr);
  65.   CPoint point4=CPoint(m_CenterPoint.x-m_Xr,m_CenterPoint.y-m_Yr);
  66.   CPoint point11=CPoint(m_CenterPoint.x-m_Xr/1.2,m_CenterPoint.y+m_Yr/1.2);
  67.   CPoint point22=CPoint(m_CenterPoint.x+m_Xr/1.2,m_CenterPoint.y+m_Yr/1.2);
  68.   CPoint point33=CPoint(m_CenterPoint.x+m_Xr/1.2,m_CenterPoint.y-m_Yr/1.2);
  69.   CPoint point44=CPoint(m_CenterPoint.x-m_Xr/1.2,m_CenterPoint.y-m_Yr/1.2);
  70.    
  71.   CPoint pointList1[]={point1,point2,point3,point4};
  72.   CPoint pointList2[]={point11,point22,point33,point44};
  73.   
  74.   for(int i=0;i<4;i++)
  75.   {
  76.   xy[0]=pointList1[i].x;
  77.   xy[1]=pointList1[i].y;
  78.   xy[2]=1;
  79.   pointList1[i].x=vh[0][0]*xy[0]+vh[0][1]*xy[1]+vh[0][2]*xy[2];
  80.   pointList1[i].y=vh[1][0]*xy[0]+vh[1][1]*xy[1]+vh[1][2]*xy[2];
  81.   
  82.   xy[0]=pointList2[i].x;
  83.   xy[1]=pointList2[i].y;
  84.   xy[2]=1;
  85.   pointList2[i].x=vh[0][0]*xy[0]+vh[0][1]*xy[1]+vh[0][2]*xy[2];
  86.   pointList2[i].y=vh[1][0]*xy[0]+vh[1][1]*xy[1]+vh[1][2]*xy[2];
  87.   }
  89.   CRgn rgn1;
  90.   rgn1.CreatePolygonRgn(pointList1,4,ALTERNATE);
  91.   CRgn rgn2;
  92.   rgn2.CreatePolygonRgn(pointList2,4,ALTERNATE);
  93.   if(rgn1.PtInRegion(point)&&!rgn2.PtInRegion(point))
  94.   return true;
  95.   
  96.   return false;
  98. }
  99. int CEllipse::IsOnMarginPoint(CPoint point)
  100. {
  102.       CRect rect;
  103.   for(int i=0;i<5;i++)
  104.   {
  105.   rect=CRect(this->m_MarginPoint[i],this->m_MarginPoint[i]);
  106.   rect.InflateRect(4,4);
  107.       if(rect.PtInRect(point))
  108.   {   
  109.   m_FoundPoint=this->m_MarginPoint[i];
  110.   return i+1;
  111.   }
  112.    }
  113. return 0;
  114.  }
  116. void CEllipse::ellipseMidpoint(CDC*pDC,int xCenter, int yCenter, int Rx, int Ry)
  117. {
  119. int Rx2=Rx*Rx;
  120. int Ry2=Ry*Ry;
  121. int twoRx2=2*Rx2;
  122. int twoRy2=2*Ry2;
  123. int p;
  124. int x=0;
  125. int y=Ry;
  126. int px=0;
  127. int py=twoRx2*y;
  128. ellipsePlotPoints(pDC,xCenter,yCenter,x,y);
  129. p=ROUND(Ry2-(Rx2*Ry)+(0.25*Rx2));
  130. while(px<py)
  131. {
  132. x++;
  133. px+=twoRy2;
  134. if(p<0)
  135. p+=Ry2+px;
  136. else
  137. {
  138. y--;
  139. py-=twoRx2;
  140. p+=Ry2+px-py;
  141. }
  142. ellipsePlotPoints(pDC,xCenter,yCenter,x,y);
  143. }
  144. p=ROUND(Ry2*(x+0.5)*(x+0.5)+Rx2*(y-1)*(y-1)-Rx2*Ry2);
  145. while(y>0)
  146. {
  147. y--;
  148. py-=twoRx2;
  149. if(p>0)
  150. p+=Rx2-py;
  151. else
  152. {
  153. x++;
  154. px+=twoRy2;
  155. p+=Rx2-py+px;
  156. }
  157. ellipsePlotPoints(pDC,xCenter,yCenter,x,y);
  158. }
  159. }
  161. void CEllipse::ellipsePlotPoints(CDC*pDC,int xCenter, int yCenter, int x, int y)
  162. {
  163.  /* CPen m_pen;
  164.   CBrush m_brush;
  165.   int oldDrawingMode=pDC->SetROP2(this->m_DrawingMode);
  166.   m_pen.CreatePen(m_PenStyle,m_PenWidth,m_PenColor);
  167.   CPen* pen=(CPen*)pDC->SelectObject(&m_pen);
  168.   LOGBRUSH brushlog;
  169.   brushlog.lbColor=m_BrushColor;
  170.   brushlog.lbHatch=m_BrushHatch;
  171.   brushlog.lbStyle=m_BrushStyle;
  173.   m_brush.CreateBrushIndirect(&brushlog);
  174.  
  175.   CBrush*brush=(CBrush*)pDC->SelectObject(&m_brush);
  176.  
  177.  int OldBkMode=pDC->SetBkMode(m_BkMode);
  178.  COLORREF OldColor=pDC->SetBkColor(m_BackgroundColor);
  179. */
  180. PdcSetPixel(pDC,xCenter+x,yCenter+y,m_PenColor);
  181. PdcSetPixel(pDC,xCenter-x,yCenter+y,m_PenColor);
  182. PdcSetPixel(pDC,xCenter+x,yCenter-y,m_PenColor);
  183. PdcSetPixel(pDC,xCenter-x,yCenter-y,m_PenColor);
  184. /*
  185.  pDC->SelectObject(brush);
  186.  pDC->SelectObject(pen);
  187.  pDC->SetBkMode(OldBkMode);
  188.  pDC->SetBkColor(OldColor);
  189.  pDC->SetROP2(oldDrawingMode);
  190.  */
  191. }
  193. float CEllipse::ComputSloap(CPoint firstPoint, CPoint secondPoint)
  194. {
  195.     m_SecondPoint=secondPoint;
  196. double sloap;
  197. if(firstPoint.x==secondPoint.x)
  198. {
  199.   sloap=9999999999999.0;
  200. }
  201. else
  202. {
  203. sloap=double((firstPoint.y-secondPoint.y))/double((firstPoint.x-secondPoint.x));
  204. }
  205.    
  206.   if(sloap<0)
  207.    {
  208.    m_Cos=fabs(sloap/sqrt(sloap*sloap+1.0));
  209.    m_Sin=1.0/sqrt(sloap*sloap+1.0);
  210.    }
  211.    else
  212.    {
  213.    m_Cos=fabs(sloap/sqrt(sloap*sloap+1.0));
  214.    m_Sin=-1.0/sqrt(sloap*sloap+1.0);
  215.    }
  217.   
  218.    return 0;
  219. }
  221. void CEllipse::PdcSetPixel(CDC *pDC, int xCenter, int yCenter, COLORREF m_PenColor)
  222. {
  223.       //xCenter+x,yCenter+y
  224.   
  225. double vh[3][3]={m_Cos,-m_Sin,m_CenterPoint.x*(1-m_Cos)+m_CenterPoint.y*m_Sin,
  226.                m_Sin, m_Cos,m_CenterPoint.y*(1-m_Cos)-m_CenterPoint.x*m_Sin,
  227.    0,0,1
  228.                   };       
  229.   
  230.       double xy[3]={xCenter,yCenter,1};
  231.   double x[3]={0,0,0};
  232.  
  233.   x[0]=vh[0][0]*xy[0]+vh[0][1]*xy[1]+vh[0][2]*xy[2];
  234.   x[1]=vh[1][0]*xy[0]+vh[1][1]*xy[1]+vh[1][2]*xy[2];
  235.    if(x[0]-int(x[0])>=0.5)
  236.   x[0]+=1;
  237.   if(x[1]-int(x[1])>=0.5)
  238.   x[1]+=1;
  239.   
  240.     for(int i=0;i<this->m_PenWidth;i++)
  241.   pDC->SetPixel(x[0]+i,x[1]-i,m_PenColor);
  242.   
  243.  
  244.    
  245.   //pDC->LineTo(x[0],x[1]);
  246.   // pDC->LineTo(x[0]+1,x[1]-1);
  247.   
  248.   
  249. }
  251. int CEllipse::ComputRadiusX(CPoint firstPoint,CPoint secondPoint)
  252. {
  253.  m_Xr=sqrt((firstPoint.x-secondPoint.x)*(firstPoint.x-secondPoint.x)+(firstPoint.y-secondPoint.y)*(firstPoint.y-secondPoint.y));
  254.  return 0;
  255. }
  257. int CEllipse::ComputRadiusY(CPoint firstPoint,CPoint secondPoint)
  258. {
  259.   m_Yr=sqrt((firstPoint.x-secondPoint.x)*(firstPoint.x-secondPoint.x)+(firstPoint.y-secondPoint.y)*(firstPoint.y-secondPoint.y));
  260.   return 0;
  261. }
  265. void CEllipse::ShowMovingLine(CDC*pDC,CPoint firstPoint, CPoint secondPoint)
  266. {
  267. CPen m_pen;
  268. m_pen.CreatePen(PS_SOLID,1,RGB(0,0,255));
  269. CPen *OldPen=pDC->SelectObject(&m_pen);
  270. pDC->MoveTo(firstPoint);
  271. pDC->LineTo(secondPoint);
  272. pDC->SelectObject(OldPen);
  274. }
  276. void CEllipse::ComputeOffSet()
  277. {
  278. double vh[3][3]={m_Cos,-m_Sin,m_CenterPoint.x*(1-m_Cos)+m_CenterPoint.y*m_Sin,
  279.                m_Sin, m_Cos,m_CenterPoint.y*(1-m_Cos)-m_CenterPoint.x*m_Sin,
  280.    0,0,1
  281.             };       
  282.   
  283.       double xy1[3]={m_CenterPoint.x,m_CenterPoint.y,1};
  284.   m_OffSetX=vh[0][0]*xy1[0]+vh[0][1]*xy1[1]+vh[0][2]*xy1[2];
  285.   m_OffSetY=vh[1][0]*xy1[0]+vh[1][1]*xy1[1]+vh[1][2]*xy1[2];
  286.   
  288. }
  290. void CEllipse::ShowSelectPoint(CDC *pDC)
  291. {
  292.  double vh[3][3]={m_Cos,-m_Sin,m_CenterPoint.x*(1-m_Cos)+m_CenterPoint.y*m_Sin,
  293.                m_Sin, m_Cos,m_CenterPoint.y*(1-m_Cos)-m_CenterPoint.x*m_Sin,
  294.    0,0,1
  295.                   };       
  296.   
  297.       double xy1[3]={-m_Xr+this->m_CenterPoint.x,this->m_CenterPoint.y,1};
  298.   this->m_MarginPoint[0].x=vh[0][0]*xy1[0]+vh[0][1]*xy1[1]+vh[0][2]*xy1[2];
  299.   this->m_MarginPoint[0].y=vh[1][0]*xy1[0]+vh[1][1]*xy1[1]+vh[1][2]*xy1[2];
  300.       
  301.   double xy2[3]={this->m_CenterPoint.x,this->m_CenterPoint.y-m_Yr,1};
  302.       this->m_MarginPoint[1].x=vh[0][0]*xy2[0]+vh[0][1]*xy2[1]+vh[0][2]*xy2[2];
  303.   this->m_MarginPoint[1].y=vh[1][0]*xy2[0]+vh[1][1]*xy2[1]+vh[1][2]*xy2[2]; 
  305.   double xy3[3]={this->m_CenterPoint.x+m_Xr,this->m_CenterPoint.y,1};
  306.   this->m_MarginPoint[2].x=vh[0][0]*xy3[0]+vh[0][1]*xy3[1]+vh[0][2]*xy3[2];
  307.   this->m_MarginPoint[2].y=vh[1][0]*xy3[0]+vh[1][1]*xy3[1]+vh[1][2]*xy3[2];
  308.    
  309.   double xy4[3]={this->m_CenterPoint.x,m_Yr+this->m_CenterPoint.y,1};
  310.       this->m_MarginPoint[3].x=vh[0][0]*xy4[0]+vh[0][1]*xy4[1]+vh[0][2]*xy4[2];
  311.   this->m_MarginPoint[3].y=vh[1][0]*xy4[0]+vh[1][1]*xy4[1]+vh[1][2]*xy4[2];
  313.   double xy5[3]={this->m_CenterPoint.x,this->m_CenterPoint.y,1};
  314.       this->m_MarginPoint[4].x=vh[0][0]*xy5[0]+vh[0][1]*xy5[1]+vh[0][2]*xy5[2];
  315.   this->m_MarginPoint[4].y=vh[1][0]*xy5[0]+vh[1][1]*xy5[1]+vh[1][2]*xy5[2];
  318. CBrush brush;
  319. brush.CreateSolidBrush(RGB(0,0,255));
  320. CPen m_pen;
  321. m_pen.CreatePen(PS_SOLID,1,RGB(0,0,255));
  322. CPen *OldPen=pDC->SelectObject(&m_pen);
  323. int oldBkMode=pDC->SetBkMode(OPAQUE); 
  324. CBrush *OldBrush=pDC->SelectObject(&brush);
  325. int oldDrawingMode=pDC->SetROP2(R2_NOTXORPEN);
  326.  CRect rect;
  327.  for(int i=0;i<4;i++)
  328.  {
  329.   rect.SetRect(this->m_MarginPoint[i],this->m_MarginPoint[i]);
  330.   rect.InflateRect(3,3);
  331.   pDC->Rectangle(rect);
  332.  }
  333.  pDC->SelectObject(OldBrush);
  334.  brush.DeleteObject();
  335.  brush.CreateSolidBrush(RGB(255,0,0));
  336.  pDC->SelectObject(&brush);
  337.   rect.SetRect(this->m_MarginPoint[4],this->m_MarginPoint[4]);
  338.   rect.InflateRect(3,3);
  339.   pDC->Rectangle(rect);
  340. pDC->SelectObject(OldPen);
  341. pDC->SetBkMode(oldBkMode); 
  342. pDC->SelectObject(OldBrush);
  343. pDC->SetROP2(oldDrawingMode);
  344. }
  346. CRect CEllipse::GetBoundingRect()
  347. {
  348. double vh[3][3]={m_Cos,-m_Sin,m_CenterPoint.x*(1-m_Cos)+m_CenterPoint.y*m_Sin,
  349.                m_Sin, m_Cos,m_CenterPoint.y*(1-m_Cos)-m_CenterPoint.x*m_Sin,
  350.    0,0,1
  351.                   };       
  352.   
  353.       double xy1[3]={-m_Xr+this->m_CenterPoint.x,this->m_CenterPoint.y-m_Yr,1};
  354.   int left=vh[0][0]*xy1[0]+vh[0][1]*xy1[1]+vh[0][2]*xy1[2];
  355.   int top=vh[1][0]*xy1[0]+vh[1][1]*xy1[1]+vh[1][2]*xy1[2];
  356.       
  357.   double xy2[3]={this->m_CenterPoint.x+m_Xr,this->m_CenterPoint.y-m_Yr,1};
  358.       int left2=vh[0][0]*xy2[0]+vh[0][1]*xy2[1]+vh[0][2]*xy2[2];
  359.   int top2=vh[1][0]*xy2[0]+vh[1][1]*xy2[1]+vh[1][2]*xy2[2]; 
  361.   double xy3[3]={this->m_CenterPoint.x+m_Xr,this->m_CenterPoint.y+m_Yr,1};
  362.   int right=vh[0][0]*xy3[0]+vh[0][1]*xy3[1]+vh[0][2]*xy3[2];
  363.   int bottom=vh[1][0]*xy3[0]+vh[1][1]*xy3[1]+vh[1][2]*xy3[2];
  364.    
  365.   double xy4[3]={this->m_CenterPoint.x-m_Xr,m_Yr+this->m_CenterPoint.y,1};
  366.       int right2=vh[0][0]*xy4[0]+vh[0][1]*xy4[1]+vh[0][2]*xy4[2];
  367.   int bottom2=vh[1][0]*xy4[0]+vh[1][1]*xy4[1]+vh[1][2]*xy4[2];
  371.      
  372.  int miny=min(min(top,top2),min(bottom,bottom2));
  373.  int minx=min(min(right,right2),min(left,left2));
  374.  int maxy=max(max(top,top2),max(bottom,bottom2));
  375.  int maxx=max(max(right,right2),max(left,left2));
  377.   m_BoundingRect.left=minx;
  378.   m_BoundingRect.top=miny;
  379.   m_BoundingRect.right=maxx;
  380.   m_BoundingRect.bottom=maxy;
  381.   
  382.   return this->m_BoundingRect;
  383.   
  385. }
  387. void CEllipse::DrawActive(CDC *pDC,CPoint point)
  388. {
  389.   CPen m_pen;
  390.   CBrush m_brush;
  391.  
  392.   m_pen.CreatePen(m_PenStyle,m_PenWidth,m_PenColor);
  393.   CPen* pen=(CPen*)pDC->SelectObject(&m_pen);
  394.   LOGBRUSH brushlog;
  395.   brushlog.lbColor=m_BrushColor;
  396.   brushlog.lbHatch=m_BrushHatch;
  397.   brushlog.lbStyle=m_BrushStyle;
  398.   m_brush.CreateBrushIndirect(&brushlog);
  399.   SetBrushOrg(pDC,&m_brush);
  400.   CBrush*brush=(CBrush*)pDC->SelectObject(&m_brush);
  401.  
  402.  int OldBkMode=pDC->SetBkMode(m_BkMode);
  403.  COLORREF OldColor=pDC->SetBkColor(m_BackgroundColor);
  404.  
  405.  ellipseMidpoint(pDC,m_CenterPoint.x,m_CenterPoint.y,this->m_Xr,this->m_Yr);
  406.  pDC->SelectObject(brush);
  407.  pDC->SelectObject(pen);
  408.  pDC->SetBkMode(OldBkMode);
  409.  pDC->SetBkColor(OldColor);
  410.  
  411. }
  413. void CEllipse::OnLButtonDown(CDC *pDC, CEastDrawView *pView, CPoint point)
  414. {
  415.    if(m_HaveFindFirst)
  416. {
  417.     pView->L_iPointCount=IsOnMarginPoint(point);
  418. if(pView->L_iPointCount!=0)
  419. {
  420. pView->m_bHaveFindSecond=true;
  421.         pView->m_CurrentDrawTool=Ellipse_Tool;
  422.         pView->m_CurrentDrawStatus=Change_Status;
  423.   
  424. switch(pView->L_iPointCount)
  425. {
  426.    case 1:
  427.    pView->m_FirstPoint=m_SecondPoint;
  428.    pView->m_SecondPoint=m_FirstPoint;
  429.    break;
  431.    case 2:
  432.    pView->m_FirstPoint=m_FirstPoint;
  433.    pView->m_SecondPoint=m_SecondPoint;
  434.    break;
  435.    
  436.    case 3:
  437.    pView->m_FirstPoint=m_FirstPoint;
  438.    pView->m_SecondPoint=m_SecondPoint;
  439.    break;
  441.    case 4:
  442.    pView->m_FirstPoint=m_SecondPoint;
  443.    pView->m_SecondPoint=m_FirstPoint;
  444.    break;
  446.    case 5:
  447.    pView->m_FirstPoint=m_FirstPoint;
  448.    pView->m_SecondPoint=m_SecondPoint;
  449.        pView->m_CurrentDrawTool=Ellipse_Tool;
  450.        pView->m_CurrentDrawStatus=Drag_Status;
  451.   break;
  452. }
  453.  }//******if(L_iPointCount!=0)
  454. }//**********if(L_pEllipse->m_HaveFindFirst)
  455.   
  456.      if(!pView->m_bHaveFindSecond&&IsInRgn(point))
  457.  {
  458.    if(!m_HaveFindFirst)
  459.    {
  460.     m_HaveFindFirst=true;
  461. pView->m_bHaveFindFirst=true;
  462.     ShowSelectPoint(pDC);
  463.    }
  464.    else
  465.    {
  466.     m_HaveFindFirst=false;
  467. pView->m_bHaveFindFirst=true;
  468. ShowSelectPoint(pDC);
  469.    }
  470.  }
  471.  
  472.    if(pView->m_bHaveFindSecond)
  473. {   
  474.         pView->m_pCurrentUnit=this;
  475. m_DrawingMode=pDC->GetROP2();
  476.         DrawStatic(pDC);
  477. DrawOldReferencePoint(pDC,m_FoundPoint);
  478.     ShowSelectPoint(pDC);
  479.     }
  480.   
  481. }
  483.  void CEllipse::OnMouseMove(CDC *pDC, CEastDrawView *pView, CPoint point)
  484. {
  485.     if(pView->m_CurrentDrawStatus==Drag_Status)
  486. {
  487.        if(!m_IsCirCu)
  488.    m_CenterPoint.Offset((pView->m_SecondPoint.x-pView->m_FirstPoint.x),(pView->m_SecondPoint.y-pView->m_FirstPoint.y)); 
  489.    if(m_IsCirCu)
  490.    ComputSloap(m_CenterPoint,point);
  491. }
  492. else
  493.   {
  494.       //pDC->SetROP2(R2_NOTXORPEN);
  495.  if(pView->m_LBDownTimes==2&&pView->m_CurrentDrawStatus!=Change_Status)
  496.   {
  497.  
  498.   ShowMovingLine(pDC,m_CenterPoint,point);
  499.   ellipseMidpoint(pDC,m_CenterPoint.x,m_CenterPoint.y,m_Xr,m_Yr);
  500.       ComputRadiusX(m_CenterPoint,point);
  501.   //m_DrawingMode=pDC->GetROP2();
  502.   pView->m_SecondPoint=point;
  503.   ellipseMidpoint(pDC,m_CenterPoint.x,m_CenterPoint.y,m_Xr,m_Yr);
  504.   ShowMovingLine(pDC,m_CenterPoint,point);
  505.  }
  506.  if(pView->m_CurrentDrawStatus==Change_Status)
  507.  {
  508.  
  509.  ellipseMidpoint(pDC,m_CenterPoint.x,m_CenterPoint.y,m_Xr,m_Yr);
  510.  
  511.     ShowMovingLine(pDC,m_CenterPoint,pView->m_SecondPoint);
  513.       pView->m_SecondPoint=point;
  514.   if(pView->L_iPointCount==1||pView->L_iPointCount==3)
  515.   ComputRadiusX(m_CenterPoint,point);
  516.   if(pView->L_iPointCount==2||pView->L_iPointCount==4)
  517.           ComputRadiusY(m_CenterPoint,point);
  518.   
  519.   //m_DrawingMode=pDC->GetROP2();
  520.   ShowMovingLine(pDC,m_CenterPoint,point);
  521.   
  522.   
  523.       ellipseMidpoint(pDC,m_CenterPoint.x,m_CenterPoint.y,m_Xr,m_Yr);
  524.   }
  525.  
  526.  if(pView->m_LBDownTimes==1&&pView->m_CurrentDrawStatus!=Change_Status)
  527.  {
  528.           
  529.   ShowMovingLine(pDC,pView->m_FirstPoint,pView->m_SecondPoint);
  530.   pView->m_SecondPoint=point;
  531.   ShowMovingLine(pDC,pView->m_FirstPoint,point);
  532.  }
  534.   }
  535. }
  537. void CEllipse::OnMenuitemCirCu(CDC *pDC, CEastDrawView *pView)
  538. {
  539.   m_IsCirCu=!m_IsCirCu;
  540. }
  542. CEllipse::CEllipse()
  543. {
  544. CUnit::Initial();
  545. m_IsCirCu=false;
  546. }
  550. void CEllipse::OnContextMenu(CWnd *pWnd, CPoint point)
  551. {
  552. CEastDrawView*pView=(CEastDrawView*)pWnd;
  553. if(pView->m_CurrentDrawStatus==Drag_Status)
  554. {
  555. CMenu menuTextEdit;
  556. menuTextEdit.LoadMenu(IDR_MENU_Canvas_Edit);
  557. menuTextEdit.CheckMenuItem(ID_CirCu,m_IsCirCu?MF_CHECKED:MF_UNCHECKED);
  558. menuTextEdit.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN,point.x,point.y,pWnd);
  559. }
  560. }