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

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

绘图程序

开发平台：

Visual C++

Parallelogram.cpp：源码内容
  1. // Parallelogram.cpp: implementation of the CParallelogram class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "GraphSoft.h"
  7. #include "Parallelogram.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( CParallelogram, CShape, 0 )
  19. //////////////////////////////////////////////////////////////////////
  20. // Construction/Destruction
  21. //////////////////////////////////////////////////////////////////////
  23. CParallelogram::CParallelogram():CShape()
  24. {
  25.  m_flFirstxTemp=m_flFirstx=0;
  26.  m_flFirstyTemp=m_flFirsty=0;
  27.  m_flSecondxTemp=m_flSecondx=0;
  28.  m_flSecondyTemp=m_flSecondy=0;
  29.      m_flThirdxTemp=m_flThirdx=0;
  30.  m_flThirdyTemp=m_flThirdy=0;
  32.  m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  33.  m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  34.  m_flForthxTemp=m_flForthx;
  35.  m_flForthyTemp=m_flForthy;
  36. }
  37. ////////////////////////////
  38. CParallelogram::CParallelogram(COLORREF color,int penWidth,float angle):CShape(color,penWidth,angle)
  39. {
  40. m_flFirstxTemp=m_flFirstx=0;
  41. m_flFirstyTemp=m_flFirsty=0;
  42. m_flSecondxTemp=m_flSecondx=0;
  43. m_flSecondyTemp=m_flSecondy=0;
  44. m_flThirdxTemp=m_flThirdx=0;
  45. m_flThirdyTemp=m_flThirdy=0;
  47. m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  48. m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  49. m_flForthxTemp=m_flForthx;
  50. m_flForthyTemp=m_flForthy;
  51. }
  52. //////////////////////////////
  53. CParallelogram::CParallelogram(CParallelogram * const pParallelogram):CShape(pParallelogram)
  54. {
  55. m_flFirstx=pParallelogram->m_flFirstx;
  56. m_flFirsty=pParallelogram->m_flFirsty;
  57. m_flSecondx=pParallelogram->m_flSecondx;
  58. m_flSecondy=pParallelogram->m_flSecondy;
  59. m_flThirdx=pParallelogram->m_flThirdx;
  60. m_flThirdy=pParallelogram->m_flThirdy;
  61.     ////
  62. m_flFirstxTemp=pParallelogram->m_flFirstxTemp;
  63. m_flFirstyTemp=pParallelogram->m_flFirstyTemp;
  64. m_flSecondxTemp=pParallelogram->m_flSecondxTemp;
  65. m_flSecondyTemp=pParallelogram->m_flSecondyTemp;
  66. m_flThirdxTemp=pParallelogram->m_flThirdxTemp;
  67. m_flThirdyTemp=pParallelogram->m_flThirdyTemp;
  69. m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  70. m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  71. m_flForthxTemp=m_flForthx;
  72. m_flForthyTemp=m_flForthy;
  73. }
  75. CParallelogram::~CParallelogram()
  76. {
  77. }
  78. //////////////////////////////////////////////////////////////////////
  80. //////////////////////////////////////////////////////////////////////
  81. //存储
  82. //////////////////////////////////////////////////////////////////////
  83.  void CParallelogram::Serialize( CArchive& ar)
  84.  {
  85.  CShape::Serialize( ar ) ;
  86.  if ( ar.IsLoading() ){  
  87.  ar>>m_flFirstx;
  88.  ar>>m_flFirsty;
  89.  ar>>m_flSecondx;
  90.  ar>>m_flSecondy;
  91.  ar>>m_flThirdx;
  92.  ar>>m_flThirdy;
  93.  //temp
  94.  m_flFirstxTemp=m_flFirstx;
  95.  m_flFirstyTemp=m_flFirsty;
  96.  m_flSecondxTemp=m_flSecondx;
  97.  m_flSecondyTemp=m_flSecondy;
  98.  m_flThirdxTemp=m_flThirdx;
  99.  m_flThirdyTemp=m_flThirdy;
  100.  
  101.  m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  102.  m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  103.  m_flForthxTemp=m_flForthx;
  104.  m_flForthyTemp=m_flForthy;
  105.  } else {
  106.  ar<<m_flFirstx;
  107.  ar<<m_flFirsty;
  108.  ar<<m_flSecondx;
  109.  ar<<m_flSecondy;
  110.  ar<<m_flThirdx;
  111.  ar<<m_flThirdy;  
  112.  }
  113.  return ;
  115.  }
  116.  //////////////////////////////////////////////////////////////////////
  118.  //////////////////////////////////////////////////////////////////////
  119.  //绘画
  120.  //////////////////////////////////////////////////////////////////////
  122.  void CParallelogram::Draw(CDC *pDC,COLORREF color,COLORREF fillColor,int penWidth)
  123.  {  
  124.  CPen pen,*poldPen;  
  125.  pen.CreatePen(PS_SOLID,1, fillColor);
  126.  poldPen=pDC->SelectObject(&pen);
  127.  if(m_nFillStyle==_shape_solid_fill){
  128.  CPoint ptArray[4];
  129.  ptArray[0].x=m_flFirstxTemp;
  130.  ptArray[0].y=m_flFirstyTemp;
  131.  ptArray[1].x=m_flSecondxTemp;
  132.  ptArray[1].y=m_flSecondyTemp;
  133.  ptArray[2].x=m_flThirdxTemp;
  134.  ptArray[2].y=m_flThirdyTemp;
  135.  ptArray[3].x=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  136.  ptArray[3].y=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  137.  AreaFill(pDC,4,ptArray,fillColor);
  138.  }
  139.  pen.DeleteObject();
  140.  pen.CreatePen(PS_SOLID,penWidth,color);  
  141.  pDC->SelectObject(&pen);      
  142.  
  143.  pDC->MoveTo(m_flFirstxTemp,m_flFirstyTemp);
  144.  pDC->LineTo(m_flSecondxTemp,m_flSecondyTemp);
  145.  pDC->LineTo(m_flThirdxTemp,m_flThirdyTemp);
  146. // pDC->LineTo(m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp,m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp);
  147.  pDC->LineTo(m_flForthxTemp,m_flForthyTemp);
  148.  pDC->LineTo(m_flFirstxTemp,m_flFirstyTemp);
  149.  
  150.  if(GetDrawPointsFlag()==1){
  151.  DrawPoints(pDC,color);
  152.  }
  153.  
  154.  pDC->SelectObject(poldPen);  
  156.  }
  157.  ///////////////////////////////////////////
  158.  void CParallelogram::DrawPointsCutTo(CDC *pDC,COLORREF color,CFlRect m_rectFrom,CRect m_rectTo)
  159.  {
  160.  //得到移动扩缩后的关键数据
  161.  float flFirstx,flFirsty,flSecondx,flSecondy,flThirdx,flThirdy,flForthx,flForthy;
  162.  //移动
  163.  
  164.  float stepx=m_rectTo.left-m_rectFrom.left;
  165.  float stepy=m_rectTo.top-m_rectFrom.top;
  166.  flFirstx=m_flFirstxTemp+stepx;
  167.  flFirsty=m_flFirstyTemp+stepy;
  168.  flSecondx=m_flSecondxTemp+stepx;
  169.  flSecondy=m_flSecondyTemp+stepy;
  170.  flThirdx=m_flThirdxTemp+stepx;
  171.  flThirdy=m_flThirdyTemp+stepy;
  172.  flForthx=m_flForthxTemp+stepx;
  173.  flForthy=m_flForthyTemp+stepy;
  174.  //扩缩
  175.  float cx,cy,flScale;
  176.  cx=m_rectTo.left;
  177.  cy=m_rectTo.top;  
  178.  if(m_rectFrom.Width()<0.01){
  179.  m_rectFrom.right=m_rectFrom.left +1;
  180.  }
  181.  if(m_rectFrom.Height()<0.01){
  182.  m_rectFrom.bottom=m_rectFrom.top +1;
  183.  }
  184.  flScale=(float)m_rectTo.Width()/m_rectFrom.Width();
  185.  //flScale=min((float)m_rectTo.Width()/m_rectFrom.Width(),(float)m_rectTo.Height()/m_rectFrom.Height());
  186.  flFirstx=(flFirstx-cx)*flScale+cx;
  187.  flFirsty=(flFirsty-cy)*flScale+cy;
  188.  flSecondx=(flSecondx-cx)*flScale+cx;
  189.  flSecondy=(flSecondy-cy)*flScale+cy;
  190.  flThirdx=(flThirdx-cx)*flScale+cx;
  191.  flThirdy=(flThirdy-cy)*flScale+cy;  
  192.  flForthx=(flForthx-cx)*flScale+cx;
  193.  flForthy=(flForthy-cy)*flScale+cy;
  194.  
  195.  CPen pen,*poldPen;
  196.  pen.CreatePen(PS_SOLID,1, color);
  197.  poldPen=pDC->SelectObject(&pen);
  198.  {
  199.  pDC->MoveTo(flFirstx,flFirsty-1-GetPenWidth());
  200.  pDC->LineTo(flFirstx,flFirsty+2+GetPenWidth());
  201.  pDC->MoveTo(flFirstx-1-GetPenWidth(),flFirsty);
  202.  pDC->LineTo(flFirstx+2+GetPenWidth(),flFirsty);
  203.  
  204.  pDC->MoveTo(flSecondx,flSecondy-1-GetPenWidth());
  205.  pDC->LineTo(flSecondx,flSecondy+2+GetPenWidth());
  206.  pDC->MoveTo(flSecondx-1-GetPenWidth(),flSecondy);
  207.  pDC->LineTo(flSecondx+2+GetPenWidth(),flSecondy);
  208.  
  209.  pDC->MoveTo(flThirdx,flThirdy-1-GetPenWidth());
  210.  pDC->LineTo(flThirdx,flThirdy+2+GetPenWidth());
  211.  pDC->MoveTo(flThirdx-1-GetPenWidth(),flThirdy);
  212.  pDC->LineTo(flThirdx+2+GetPenWidth(),flThirdy);
  213.  
  214.  pDC->MoveTo(flForthx,flForthy-1-GetPenWidth());
  215.  pDC->LineTo(flForthx,flForthy+2+GetPenWidth());
  216.  pDC->MoveTo(flForthx-1-GetPenWidth(),flForthy);
  217.  pDC->LineTo(flForthx+2+GetPenWidth(),flForthy);
  218.  }  
  219.  pDC->SelectObject(poldPen);      
  220.  return;
  221.  }
  222.  void CParallelogram::DrawPoints(CDC *pDC,COLORREF color)
  223.  {
  224.  float flForthx,flForthy;
  225. // flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  226. // flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  227.  flForthx=m_flForthxTemp;
  228.  flForthy=m_flForthyTemp;
  229.  CPen pen,*poldPen;
  230.  pen.CreatePen(PS_SOLID,1, color);
  231.  poldPen=pDC->SelectObject(&pen);
  232.  {
  233.  pDC->MoveTo(m_flFirstxTemp,m_flFirstyTemp-1-GetPenWidth());
  234.  pDC->LineTo(m_flFirstxTemp,m_flFirstyTemp+2+GetPenWidth());
  235.  pDC->MoveTo(m_flFirstxTemp-1-GetPenWidth(),m_flFirstyTemp);
  236.  pDC->LineTo(m_flFirstxTemp+2+GetPenWidth(),m_flFirstyTemp);
  237.  
  238.  pDC->MoveTo(m_flSecondxTemp,m_flSecondyTemp-1-GetPenWidth());
  239.  pDC->LineTo(m_flSecondxTemp,m_flSecondyTemp+2+GetPenWidth());
  240.  pDC->MoveTo(m_flSecondxTemp-1-GetPenWidth(),m_flSecondyTemp);
  241.  pDC->LineTo(m_flSecondxTemp+2+GetPenWidth(),m_flSecondyTemp);
  242.  
  243.  pDC->MoveTo(m_flThirdxTemp,m_flThirdyTemp-1-GetPenWidth());
  244.  pDC->LineTo(m_flThirdxTemp,m_flThirdyTemp+2+GetPenWidth());
  245.  pDC->MoveTo(m_flThirdxTemp-1-GetPenWidth(),m_flThirdyTemp);
  246.  pDC->LineTo(m_flThirdxTemp+2+GetPenWidth(),m_flThirdyTemp);
  247.  
  248.  pDC->MoveTo(flForthx,flForthy-1-GetPenWidth());
  249.  pDC->LineTo(flForthx,flForthy+2+GetPenWidth());
  250.  pDC->MoveTo(flForthx-1-GetPenWidth(),flForthy);
  251.  pDC->LineTo(flForthx+2+GetPenWidth(),flForthy);
  252.  }  
  253.  pDC->SelectObject(poldPen);      
  254.  return;
  255.  }
  256.  ////////////////////////////////////////////
  257.  void CParallelogram::DrawCutToRect(CDC *pDC,COLORREF color,COLORREF fillColor,int penWidth,CFlRect m_rectFrom,CRect m_rectTo)
  258.  {
  259.  // if(!IsInRect(m_rectFrom)){
  260.  // return;
  261.  // }
  262.  //得到移动扩缩后的关键数据
  263.  float flFirstx,flFirsty,flSecondx,flSecondy,flThirdx,flThirdy,flForthx,flForthy;
  264.  //移动
  265.  
  266.  float stepx=m_rectTo.left-m_rectFrom.left;
  267.  float stepy=m_rectTo.top-m_rectFrom.top;
  268.  flFirstx=m_flFirstxTemp+stepx;
  269.  flFirsty=m_flFirstyTemp+stepy;
  270.  flSecondx=m_flSecondxTemp+stepx;
  271.  flSecondy=m_flSecondyTemp+stepy;
  272.  flThirdx=m_flThirdxTemp+stepx;
  273.  flThirdy=m_flThirdyTemp+stepy;
  274.  flForthx=m_flForthxTemp+stepx;
  275.  flForthy=m_flForthyTemp+stepy;
  276.  //扩缩
  277.  float cx,cy,flScale;
  278.  cx=m_rectTo.left;
  279.  cy=m_rectTo.top;  
  280.  if(m_rectFrom.Width()<0.01){
  281.  m_rectFrom.right=m_rectFrom.left +1;
  282.  }
  283.  if(m_rectFrom.Height()<0.01){
  284.  m_rectFrom.bottom=m_rectFrom.top +1;
  285.  }
  286.  flScale=(float)m_rectTo.Width()/m_rectFrom.Width();
  287.  // flScale=min((float)m_rectTo.Width()/m_rectFrom.Width(),(float)m_rectTo.Height()/m_rectFrom.Height());
  288.  flFirstx=(flFirstx-cx)*flScale+cx;
  289.  flFirsty=(flFirsty-cy)*flScale+cy;
  290.  flSecondx=(flSecondx-cx)*flScale+cx;
  291.  flSecondy=(flSecondy-cy)*flScale+cy;
  292.  flThirdx=(flThirdx-cx)*flScale+cx;
  293.  flThirdy=(flThirdy-cy)*flScale+cy;  
  294.  flForthx=(flForthx-cx)*flScale+cx;
  295.  flForthy=(flForthy-cy)*flScale+cy;
  296.  
  297.  CPen pen,*poldPen;  
  298.  pen.CreatePen(PS_SOLID,1, fillColor);
  299.  poldPen=pDC->SelectObject(&pen);  
  300.  
  301.  if(m_nFillStyle==_shape_solid_fill){
  302.  CPoint ptArray[4];
  303.  ptArray[0].x=flFirstx;
  304.  ptArray[0].y=flFirsty;
  305.  ptArray[1].x=flSecondx;
  306.  ptArray[1].y=flSecondy;
  307.  ptArray[2].x=flThirdx;
  308.  ptArray[2].y=flThirdy;
  309.  ptArray[3].x=flForthx;  
  310.  ptArray[3].y=flForthy;
  311.  AreaFill(pDC,4,ptArray,fillColor);
  312.  }
  313.  pen.DeleteObject();
  314.  pen.CreatePen(PS_SOLID,penWidth,color);  
  315.  pDC->SelectObject(&pen);       
  316.  
  317.  pDC->MoveTo(flFirstx,flFirsty);
  318.  pDC->LineTo(flSecondx,flSecondy);
  319.  pDC->LineTo(flThirdx,flThirdy);
  320.  pDC->LineTo(flForthx,flForthy);
  321.  pDC->LineTo(flFirstx,flFirsty);
  322.  
  323.  
  324.  if(GetDrawPointsFlag()==1){
  325.  DrawPointsCutTo(pDC,color,m_rectFrom,m_rectTo);
  326.  }
  327.  
  328.  pDC->SelectObject(poldPen);
  329.  }
  330.  //////////////////////////////////////////////////////////////////////
  331.  //////////////////////////////////////////////////////////////////////
  332.  void CParallelogram::CreatGraph(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY,int nPenWidth,COLORREF color,COLORREF fillColor,SHAPE_FILLSTYLE nStyle)
  333.  {  
  334.  if(flArrayX.GetSize()<3){
  335.  return;
  336.  }
  337.      CShape::CreatGraph(flArrayX,flArrayY,nPenWidth,color,fillColor,nStyle);
  338.  
  339.  m_flFirstxTemp=m_flFirstx=flArrayX.GetAt(0);
  340.  m_flFirstyTemp=m_flFirsty=flArrayY.GetAt(0);
  341.  m_flSecondxTemp=m_flSecondx=flArrayX.GetAt(1);
  342.  m_flSecondyTemp=m_flSecondy=flArrayY.GetAt(1);
  343.  m_flThirdxTemp=m_flThirdx=flArrayX.GetAt(2);
  344.  m_flThirdyTemp=m_flThirdy=flArrayY.GetAt(2);
  345.  
  346.  m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  347.  m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  348.  m_flForthxTemp=m_flForthx;
  349.  m_flForthyTemp=m_flForthy;
  350.  }
  351.  //////////////////////////////////////////////////////////////////////
  352.  void CParallelogram::CreatGraph(CArray<CPoint,CPoint>& ptArray,int nPenWidth,COLORREF color,COLORREF fillColor,SHAPE_FILLSTYLE nStyle)
  353.  {  
  354.  if(ptArray.GetSize()<3){
  355.  return;
  356.  }
  357.      CShape::CreatGraph(ptArray,nPenWidth,color,fillColor,nStyle);
  359.  m_flFirstxTemp=m_flFirstx=((CPoint)ptArray.GetAt(0)).x;
  360.  m_flFirstyTemp=m_flFirsty=((CPoint)ptArray.GetAt(0)).y;
  361.  m_flSecondxTemp=m_flSecondx=((CPoint)ptArray.GetAt(1)).x;
  362.  m_flSecondyTemp=m_flSecondy=((CPoint)ptArray.GetAt(1)).y;
  363.  m_flThirdxTemp=m_flThirdx=((CPoint)ptArray.GetAt(2)).x;
  364.  m_flThirdyTemp=m_flThirdy=((CPoint)ptArray.GetAt(2)).y;
  366.  m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  367.  m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  368.  m_flForthxTemp=m_flForthx;
  369.  m_flForthyTemp=m_flForthy;
  370.  }
  371.  void CParallelogram::SetPtData(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY)
  372.  {
  373.  m_flFirstxTemp=m_flFirstx=flArrayX.GetAt(0);
  374.  m_flFirstyTemp=m_flFirsty=flArrayY.GetAt(0);
  375.  m_flSecondxTemp=m_flSecondx=flArrayX.GetAt(1);
  376.  m_flSecondyTemp=m_flSecondy=flArrayY.GetAt(1);
  377.  m_flThirdxTemp=m_flThirdx=flArrayX.GetAt(2);
  378.  m_flThirdyTemp=m_flThirdy=flArrayY.GetAt(2);
  379.  
  380.  m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  381.  m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  382.  m_flForthxTemp=m_flForthx;
  383.  m_flForthyTemp=m_flForthy;
  384.  }
  385.  void CParallelogram::GetPtData(CArray<float,float>& flArrayX,CArray<float,float>& flArrayY)
  386.  {
  387.  flArrayX.RemoveAll();
  388.  flArrayY.RemoveAll();
  390.  flArrayX.Add(m_flFirstxTemp);
  391.  flArrayX.Add(m_flSecondxTemp);
  392.  flArrayX.Add(m_flThirdxTemp);
  394.  flArrayY.Add(m_flFirstyTemp);
  395.  flArrayY.Add(m_flSecondyTemp);
  396.  flArrayY.Add(m_flThirdyTemp);
  397.  }
  398.  CShape* CParallelogram::GetCopy()
  399.  {
  400.  CShape* pGraph=new CParallelogram(this);
  401.  return pGraph;  
  402.  }
  403. //////////////////////////////////////////////////////////////////////
  405.  //////////////////////////////////////////////////////////////////////
  406.  void CParallelogram::Move(CDC *pDC,float stepx,float stepy)
  407.  {
  408.  RefreshData(m_bModified);
  409. //  CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  410.  m_flFirstx+=stepx;
  411.  m_flFirsty+=stepy;
  412.  m_flSecondx+=stepx;
  413.  m_flSecondy+=stepy;
  414.  m_flThirdx+=stepx;
  415.  m_flThirdy+=stepy;
  417.  //temp
  418.  m_flFirstxTemp+=stepx;
  419.  m_flFirstyTemp+=stepy;
  420.  m_flSecondxTemp+=stepx;
  421.  m_flSecondyTemp+=stepy;
  422.  m_flThirdxTemp+=stepx;
  423.  m_flThirdyTemp+=stepy;
  425.  m_flForthx+=stepx;
  426.  m_flForthy+=stepy;
  427.  m_flForthxTemp=m_flForthx;
  428.  m_flForthyTemp=m_flForthy;
  429.  }
  430.  void CParallelogram::PartMove(CDC *pDC,float PrevX,float PrevY,float CurX,float CurY)
  431.  {    
  432.  if(m_nSelectPtNum>-1){
  433. //  CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  434.  float flX,flY;
  435.  float flDisA,flDisB;  
  436.  switch(m_nSelectPtNum) {
  437.  case 0:
  438.  flX = m_flThirdx;
  439.  flY = m_flThirdy;             
  440.  flDisA=GetDistance(m_flThirdx,m_flThirdy,m_flFirstx,m_flFirsty);
  441.  flDisB=GetDistance(m_flThirdx,m_flThirdy,CurX,CurY);  
  442.  break;
  443.  case 1:
  444.  flX = m_flForthx;
  445.  flY = m_flForthy;             
  446.  flDisA=GetDistance(m_flForthx,m_flForthy,m_flSecondx,m_flSecondy);
  447.  flDisB=GetDistance(m_flForthx,m_flForthy,CurX,CurY);
  448.  break;
  449.  case 2:
  450.  flX = m_flFirstx;
  451.  flY = m_flFirsty;             
  452.  flDisA=GetDistance(m_flFirstx,m_flFirsty,m_flThirdx,m_flThirdy);
  453.  flDisB=GetDistance(m_flFirstx,m_flFirsty,CurX,CurY);
  454.  break;
  455.  case 3:
  456.  flX = m_flSecondx;
  457.  flY = m_flSecondy;             
  458.  flDisA=GetDistance(m_flSecondx,m_flSecondy,m_flForthx,m_flForthy);
  459.  flDisB=GetDistance(m_flSecondx,m_flSecondy,CurX,CurY);
  460.  break;  
  461.  }
  462.  if(flDisA<1){
  463.  flDisA=1;
  464.  }
  465.  Magnify(pDC,flX,flY,flDisB/flDisA);
  466.  //CShape::Draw(pDC);
  467.  }else if(m_nSelectLineNum>-1){
  468. //  CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  469.  float flCut1x,flCut1y,flCut2x,flCut2y;
  470.  float flX1[4],flY1[4],flX2[4],flY2[4];
  471.  switch(m_nSelectLineNum) {
  472.  case 0:
  473.  flX1[0]=m_flForthx;
  474.  flY1[0]=m_flForthy;
  475.  flX1[1]=CurX;
  476.  flY1[1]=CurY;    
  477.  flX1[2] = m_flFirstx;
  478.  flY1[2] = m_flFirsty;
  479.  flX1[3] = m_flSecondx;
  480.  flY1[3] = m_flSecondy;
  481.  flX2[0]=m_flThirdx;
  482.  flY2[0]=m_flThirdy;
  483.  flX2[1]=CurX;
  484.  flY2[1]=CurY;    
  485.  flX2[2] = m_flFirstx;
  486.  flY2[2] = m_flFirsty;
  487.  flX2[3] = m_flSecondx;
  488.  flY2[3] = m_flSecondy;
  490.  if(GetCutPtFrom2Line(flX1,flY1,&flCut1x,&flCut1y) && GetCutPtFrom2Line(flX2,flY2,&flCut2x,&flCut2y)){
  492.  if(fabs(flCut1x-m_flForthx)>=0.01){
  493.  m_flFirstxTemp=(m_flFirstx-m_flForthx)*((float)CurX-flCut1x)/(flCut1x-m_flForthx)+m_flFirstx;
  494.  } 
  495.  if(fabs(flCut1y-m_flForthy)>=0.01){
  496.  m_flFirstyTemp=(m_flFirsty-m_flForthy)*((float)CurY-flCut1y)/(flCut1y-m_flForthy)+m_flFirsty;
  497.  }
  498.  if(fabs(flCut2x-m_flThirdx)>=0.01){
  499. m_flSecondxTemp=(m_flSecondx-m_flThirdx)*((float)CurX-flCut2x)/(flCut2x-m_flThirdx)+m_flSecondx;
  500.  }
  501.  if(fabs(flCut2y-m_flThirdy)>=0.01){
  502.   m_flSecondyTemp=(m_flSecondy-m_flThirdy)*((float)CurY-flCut2y)/(flCut2y-m_flThirdy)+m_flSecondy;
  503.  }
  504.  }
  505.  break;
  506.  case 1:
  507.  flX1[0]=m_flFirstx;
  508.  flY1[0]=m_flFirsty;
  509.  flX1[1]=CurX;
  510.  flY1[1]=CurY;    
  511.  flX1[2] = m_flSecondx;
  512.  flY1[2] = m_flSecondy;
  513.  flX1[3] = m_flThirdx;
  514.  flY1[3] = m_flThirdy;
  515.  flX2[0]=m_flForthx;
  516.  flY2[0]=m_flForthy;
  517.  flX2[1]=CurX;
  518.  flY2[1]=CurY;    
  519.  flX2[2] = flX1[2];
  520.  flY2[2] = flY1[2];
  521.  flX2[3] = flX1[3];
  522.  flY2[3] = flY1[3];
  523.  
  524.  if(GetCutPtFrom2Line(flX1,flY1,&flCut1x,&flCut1y) && GetCutPtFrom2Line(flX2,flY2,&flCut2x,&flCut2y)){
  525.  
  526.  if(fabs(flCut1x-m_flFirstx)>=0.01){
  527.  m_flSecondxTemp=(m_flSecondx-m_flFirstx)*((float)CurX-flCut1x)/(flCut1x-m_flFirstx)+m_flSecondx;
  528.  } 
  529.  if(fabs(flCut1y-m_flFirsty)>=0.01){
  530.      m_flSecondyTemp=(m_flSecondy-m_flFirsty)*((float)CurY-flCut1y)/(flCut1y-m_flFirsty)+m_flSecondy;
  531.  }
  532.  if(fabs(flCut2x-m_flForthx)>=0.01){
  533.  m_flThirdxTemp=(m_flThirdx-m_flForthx)*((float)CurX-flCut2x)/(flCut2x-m_flForthx)+m_flThirdx;
  534.  }
  535.  if(fabs(flCut2y-m_flForthy)>=0.01){
  536.  m_flThirdyTemp=(m_flThirdy-m_flForthy)*((float)CurY-flCut2y)/(flCut2y-m_flForthy)+m_flThirdy;
  537.  }
  538.  }
  539.  break;
  540.  case 2:
  541.  flX1[0]=m_flSecondx;
  542.  flY1[0]=m_flSecondy;
  543.  flX1[1]=CurX;
  544.  flY1[1]=CurY;    
  545.  flX1[2] = m_flThirdx;
  546.  flY1[2] = m_flThirdy;
  547.  flX1[3] = m_flForthx;
  548.  flY1[3] = m_flForthy;
  549.  flX2[0]=m_flFirstx;
  550.  flY2[0]=m_flFirsty;
  551.  flX2[1]=CurX;
  552.  flY2[1]=CurY;    
  553.  flX2[2] = flX1[2];
  554.  flY2[2] = flY1[2];
  555.  flX2[3] = flX1[3];
  556.  flY2[3] = flY1[3];
  557.  if(GetCutPtFrom2Line(flX1,flY1,&flCut1x,&flCut1y) && GetCutPtFrom2Line(flX2,flY2,&flCut2x,&flCut2y)){
  558.  
  559.  if(fabs(flCut1x-m_flSecondx)>=0.01){
  560.  m_flThirdxTemp=(m_flThirdx-m_flSecondx)*((float)CurX-flCut1x)/(flCut1x-m_flSecondx)+m_flThirdx;
  561.  } 
  562.  if(fabs(flCut1y-m_flSecondy)>=0.01){
  563. m_flThirdyTemp=(m_flThirdy-m_flSecondy)*((float)CurY-flCut1y)/(flCut1y-m_flSecondy)+m_flThirdy;
  564.  }
  565.  if(fabs(flCut2x-m_flFirstx)>=0.01){
  566.  m_flForthxTemp=(m_flForthx-m_flFirstx)*((float)CurX-flCut2x)/(flCut2x-m_flFirstx)+m_flForthx;
  567.  }
  568.  if(fabs(flCut2y-m_flFirsty)>=0.01){
  569.  m_flForthyTemp=(m_flForthy-m_flFirsty)*((float)CurY-flCut2y)/(flCut2y-m_flFirsty)+m_flForthy;
  570.  }
  571.  }
  572.  break;
  573.  case 3:
  574.  flX1[0]=m_flThirdx;
  575.  flY1[0]=m_flThirdy;
  576.  flX1[1]=CurX;
  577.  flY1[1]=CurY;    
  578.  flX1[2] = m_flForthx;
  579.  flY1[2] = m_flForthy;
  580.  flX1[3] = m_flFirstx;
  581.  flY1[3] = m_flFirsty;
  582.  flX2[0]=m_flSecondx;
  583.  flY2[0]=m_flSecondy;
  584.  flX2[1]=CurX;
  585.  flY2[1]=CurY;    
  586.  flX2[2] = flX1[2];
  587.  flY2[2] = flY1[2];
  588.  flX2[3] = flX1[3];
  589.  flY2[3] = flY1[3];
  590.  if(GetCutPtFrom2Line(flX1,flY1,&flCut1x,&flCut1y) && GetCutPtFrom2Line(flX2,flY2,&flCut2x,&flCut2y)){
  591.  
  592.  if(fabs(flCut1x-m_flThirdx)>=0.01){
  593.  m_flForthxTemp=(m_flForthx-m_flThirdx)*((float)CurX-flCut1x)/(flCut1x-m_flThirdx)+m_flForthx;
  594.  } 
  595.  if(fabs(flCut1y-m_flThirdy)>=0.01){
  596.  m_flForthyTemp=(m_flForthy-m_flThirdy)*((float)CurY-flCut1y)/(flCut1y-m_flThirdy)+m_flForthy;
  597.  }
  598.  if(fabs(flCut2x-m_flSecondx)>=0.01){
  599.  m_flFirstxTemp=(m_flFirstx-m_flSecondx)*((float)CurX-flCut2x)/(flCut2x-m_flSecondx)+m_flFirstx;
  600.  }
  601.  if(fabs(flCut2y-m_flSecondy)>=0.01){
  602. m_flFirstyTemp=(m_flFirsty-m_flSecondy)*((float)CurY-flCut2y)/(flCut2y-m_flSecondy)+m_flFirsty;
  603.  }
  604.  }  
  605.  break;  
  606.  }
  607.  //CShape::Draw(pDC);
  608.  }
  609.  }
  610.  /////////////////////////////////////////////
  611.  //function Rotate(...)
  612.  //Rotate flAngle degrees around the ptCenter given as a param
  613.  ////////////////////////////////////////////
  614.  void CParallelogram::Rotate(CDC *pDC,float CX,float CY,float flAngle)
  615.  {  
  616.  if(m_flScaleTemp!=1){
  617.  RefreshData(TRUE);
  618.  }
  619.  
  620. //  CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  621.  
  622.  m_ptRotateCenterTemp=CPoint(CX,CY);
  623.  m_flAngleTemp=flAngle;
  624.  m_bModified=TRUE;
  625.  
  626.  m_flFirstxTemp=((m_flFirstx-CX)*cos(flAngle)-(m_flFirsty-CY)*sin(flAngle))+CX;
  627.  m_flFirstyTemp=((m_flFirsty-CY)*cos(flAngle)+(m_flFirstx-CX)*sin(flAngle))+CY;
  628.  m_flSecondxTemp=((m_flSecondx-CX)*cos(flAngle)-(m_flSecondy-CY)*sin(flAngle))+CX;
  629.  m_flSecondyTemp=((m_flSecondy-CY)*cos(flAngle)+(m_flSecondx-CX)*sin(flAngle))+CY;
  630.  m_flThirdxTemp=((m_flThirdx-CX)*cos(flAngle)-(m_flThirdy-CY)*sin(flAngle))+CX;
  631.  m_flThirdyTemp=((m_flThirdy-CY)*cos(flAngle)+(m_flThirdx-CX)*sin(flAngle))+CY;
  632.   
  633.  m_flForthxTemp=((m_flForthx-CX)*cos(flAngle)-(m_flForthy-CY)*sin(flAngle))+CX;
  634.  m_flForthyTemp=((m_flForthy-CY)*cos(flAngle)+(m_flForthx-CX)*sin(flAngle))+CY;
  635.  //Draw(pDC);
  636.  }
  638.  /////////////////////////////////////////////
  639.  //function Magnify(...)
  640.  //Magnify flScale times relative to the ptCenter given as a param
  641.  ////////////////////////////////////////////
  642.  void CParallelogram::Magnify(CDC *pDC,float CX,float CY,float flScale)
  643.  {
  644.  if(m_flAngleTemp!=0){
  645.  RefreshData(TRUE);
  646.  }
  647. //  CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));  
  648.  m_ptMagnifyCenterTemp=CPoint(CX,CY);
  649.  m_flScaleTemp=flScale;
  650.  m_bModified=TRUE;
  651.  
  652.  m_flFirstxTemp=(m_flFirstx-CX)*flScale+CX;
  653.  m_flFirstyTemp=(m_flFirsty-CY)*flScale+CY;
  654.  m_flSecondxTemp=(m_flSecondx-CX)*flScale+CX;
  655.  m_flSecondyTemp=(m_flSecondy-CY)*flScale+CY;
  656.  m_flThirdxTemp=(m_flThirdx-CX)*flScale+CX;
  657.  m_flThirdyTemp=(m_flThirdy-CY)*flScale+CY;  
  659.  m_flForthxTemp=(m_flForthx-CX)*flScale+CX;
  660.  m_flForthyTemp=(m_flForthy-CY)*flScale+CY;  
  661.  //Draw(pDC);
  662.  }
  663.  void CParallelogram::TopToBottom(CDC* pDC,CRect rect)
  664.  {
  665.  RefreshData(m_bModified);
  666. //  CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  667.  m_flFirstyTemp=rect.top/1000.0+rect.bottom/1000.0-m_flFirstyTemp;
  668.  m_flSecondyTemp=rect.top/1000.0+rect.bottom/1000.0-m_flSecondyTemp;
  669.  m_flThirdyTemp=rect.top/1000.0+rect.bottom/1000.0-m_flThirdyTemp;
  670.  
  671.  m_flFirsty=rect.top/1000.0+rect.bottom/1000.0-m_flFirsty;
  672.  m_flSecondy=rect.top/1000.0+rect.bottom/1000.0-m_flSecondy;
  673.  m_flThirdy=rect.top/1000.0+rect.bottom/1000.0-m_flThirdy;
  675.  m_flForthyTemp=rect.top/1000.0+rect.bottom/1000.0-m_flForthyTemp;  
  676.  m_flForthy=rect.top/1000.0+rect.bottom/1000.0-m_flForthy;
  677.  //CShape::Draw(pDC);
  678.  }
  680.  void CParallelogram::LeftToRight(CDC* pDC,CRect rect)
  681.  {
  682.  RefreshData(m_bModified);
  683. //  CShape::Draw(pDC,RGB(255,255,255),RGB(255,255,255));
  684.  m_flFirstxTemp=rect.left/1000.0+rect.right/1000.0-m_flFirstxTemp;
  685.  m_flSecondxTemp=rect.left/1000.0+rect.right/1000.0-m_flSecondxTemp;
  686.  m_flThirdxTemp=rect.left/1000.0+rect.right/1000.0-m_flThirdxTemp;
  687.  
  688.  m_flFirstx=rect.left/1000.0+rect.right/1000.0-m_flFirstx;
  689.  m_flSecondx=rect.left/1000.0+rect.right/1000.0-m_flSecondx;
  690.  m_flThirdx=rect.left/1000.0+rect.right/1000.0-m_flThirdx;
  692.  m_flForthxTemp=rect.left/1000.0+rect.right/1000.0-m_flForthxTemp;  
  693.  m_flForthx=rect.left/1000.0+rect.right/1000.0-m_flForthx;
  694.  //CShape::Draw(pDC);
  695.  } 
  696.  ///
  697.  void CParallelogram::RefreshData(bool bRefresh)
  698.  {
  699.  if(bRefresh){
  700.  
  701.  m_flFirstx = m_flFirstxTemp;
  702.      m_flFirsty = m_flFirstyTemp;
  703.  m_flSecondx = m_flSecondxTemp ;
  704.  m_flSecondy = m_flSecondyTemp;
  705.  m_flThirdx = m_flThirdxTemp;
  706.  m_flThirdy = m_flThirdyTemp;
  708.  m_flForthx = m_flForthxTemp;
  709.  m_flForthy = m_flForthyTemp;
  711.  m_bModified=FALSE;
  712.  m_ptMagnifyCenterTemp=CPoint(0,0);
  713.  m_flScaleTemp=1;
  714.  m_ptRotateCenterTemp=CPoint(0,0);
  715.  m_flAngleTemp=0;
  716.  }
  717.  }
  718.  //////////////////////////////////////////////////////////////////////
  720.  //////////////////////////////////////////////////////////////////////
  721.  /////////////////////////////////////////////
  722.  //function------IsInRect
  723.  //return value
  724.  //0----------out
  725.  //1----------cut
  726.  //2----------in
  727.  /////////////////////////////////////////////
  728.  int CParallelogram::IsInRect(CRect rect)
  729.  {
  730.  int nRltVal=0,nTemp;
  731.  float flForthx,flForthy;
  732.  flForthx=m_flForthxTemp;
  733.  flForthy=m_flForthyTemp;
  734.  
  735.  if((nTemp=GetLineStateToRect(m_flFirstxTemp,m_flFirstyTemp,m_flSecondxTemp,m_flSecondyTemp,rect))!=0){
  736.  nRltVal= nRltVal|nTemp;
  737.  }
  738.  if((nTemp=GetLineStateToRect(m_flSecondxTemp,m_flSecondyTemp,m_flThirdxTemp,m_flThirdyTemp,rect))!=0){
  739.  nRltVal= nRltVal|nTemp;
  740.  }
  741.  if((nTemp=GetLineStateToRect(m_flThirdxTemp,m_flThirdyTemp,flForthx,flForthy,rect))!=0){
  742.  nRltVal= nRltVal|nTemp;
  743.  }
  744.  if((nTemp=GetLineStateToRect(flForthx,flForthy,m_flFirstxTemp,m_flFirstyTemp,rect))!=0){
  745.  nRltVal= nRltVal|nTemp;
  746.  }
  747.  if(nRltVal==3){
  748.  nRltVal=1;
  749.  }else if(nRltVal==0){
  750.  CPoint pt[4];
  751.  pt[0].x=rect.left;
  752.  pt[0].y=rect.top;
  753.  pt[1].x=rect.right;
  754.  pt[1].y=rect.top;
  755.  pt[2].x=rect.right;
  756.  pt[2].y=rect.bottom;
  757.  pt[3].x=rect.left;
  758.  pt[3].y=rect.bottom;
  759.  if(IsPointinRegion(pt[0])&&IsPointinRegion(pt[1])&&
  760.  IsPointinRegion(pt[2])&&IsPointinRegion(pt[3])&&
  761.  m_nFillStyle==_shape_solid_fill){
  762.  nRltVal=1;      
  763.  }
  764.  }  
  765.  return nRltVal;
  766.  }
  767.  CRect CParallelogram::GetBoundaryRect()
  768.  {
  769.  CRect rect;
  770.  float flForthx,flForthy;
  771.  flForthx=m_flForthxTemp;
  772.  flForthy=m_flForthyTemp;
  773.  
  774.  rect.left=1000*min(m_flFirstxTemp,min(m_flSecondxTemp,min(m_flThirdxTemp,flForthx)));
  775.  rect.right=1000*max(m_flFirstxTemp,max(m_flSecondxTemp,max(m_flThirdxTemp,flForthx)));
  776.  rect.top=1000*min(m_flFirstyTemp,min(m_flSecondyTemp,min(m_flThirdyTemp,flForthy)));
  777.  rect.bottom=1000*max(m_flFirstyTemp,max(m_flSecondyTemp,max(m_flThirdyTemp,flForthy)));
  778.  
  779.  return rect;
  780.  }
  781.  CPoint CParallelogram::GetCenterPoint()
  782.  {
  783.  CRect rect=GetBoundaryRect();
  784.  return rect.CenterPoint();
  785.  }
  786.  int CParallelogram::IsPointinRegion(POINT point)
  787.  //方法：
  788.  //通过计算点的右射线与四边形各边（线段）的交点来判断！
  789.  //仅当焦点数为1时，点在四边形内
  790.  {
  791.  int nRltVal=0;
  792.  float flForthx,flForthy;
  793.  flForthx=m_flForthxTemp;
  794.  flForthy=m_flForthyTemp; 
  795.  
  796.  //in
  797.  if(point.y>min(m_flFirstyTemp,m_flSecondyTemp)&&point.y<max(m_flFirstyTemp,m_flSecondyTemp))
  798.  {  
  799.  if((m_flSecondxTemp-(m_flSecondxTemp-m_flFirstxTemp)*(m_flSecondyTemp-point.y)/(m_flSecondyTemp-m_flFirstyTemp))>=point.x){
  800.  nRltVal+=1;
  801.  }
  802.  }
  803.  if(point.y>min(m_flThirdyTemp,m_flSecondyTemp)&&point.y<max(m_flThirdyTemp,m_flSecondyTemp))
  804.  {
  805.  if((m_flSecondxTemp-(m_flSecondxTemp-m_flThirdxTemp)*(m_flSecondyTemp-point.y)/(m_flSecondyTemp-m_flThirdyTemp))>=point.x){
  806.  nRltVal+=1;
  807.  }
  808.  }
  809.  if(point.y>min(m_flThirdyTemp,flForthy)&&point.y<max(m_flThirdyTemp,flForthy))
  810.  {
  811.  if((flForthx-(flForthx-m_flThirdxTemp)*(flForthy-point.y)/(flForthy-m_flThirdyTemp))>=point.x){
  812.  nRltVal+=1;
  813.  }
  814.  }
  815.  if(point.y>min(m_flFirstyTemp,flForthy)&&point.y<max(m_flFirstyTemp,flForthy))
  816.  {
  817.  if((flForthx-(flForthx-m_flFirstxTemp)*(flForthy-point.y)/(flForthy-m_flFirstyTemp))>=point.x){
  818.  nRltVal+=1;
  819.  }
  820.  }
  821.  if(nRltVal==1){
  822.  return 1;
  823.  } 
  825.  //out
  826.  return 0;  
  827.  }
  828.  //////////////// 
  829.  int CParallelogram::GetPtState(float flx,float fly,float flRate)
  830.  {
  831.  //on out point
  832.  if(IsPtInRect(m_flFirstxTemp-3*flRate,m_flFirstyTemp-3*flRate,m_flFirstxTemp+3*flRate,m_flFirstyTemp+3*flRate,flx,fly)){
  833.  m_nSelectPtNum=0;
  834.  m_nSelectLineNum=-1;
  835.  return 1;
  836.  }
  837.  
  838.  if(IsPtInRect(m_flSecondxTemp-3*flRate,m_flSecondyTemp-3*flRate,m_flSecondxTemp+3*flRate,m_flSecondyTemp+3*flRate,flx,fly)){
  839.  m_nSelectPtNum=1;
  840.  m_nSelectLineNum=-1;
  841.  return 1;
  842.  }  
  843.  
  844.  if(IsPtInRect(m_flThirdxTemp-3*flRate,m_flThirdyTemp-3*flRate,m_flThirdxTemp+3*flRate,m_flThirdyTemp+3*flRate,flx,fly)){
  845.  m_nSelectPtNum=2;
  846.  m_nSelectLineNum=-1;
  847.  return 1;
  848.  }  
  849.  
  850.  if(IsPtInRect(m_flForthxTemp-3*flRate,m_flForthyTemp-3*flRate,m_flForthxTemp+3*flRate,m_flForthyTemp+3*flRate,flx,fly)){
  851.  m_nSelectPtNum=3;
  852.  m_nSelectLineNum=-1;
  853.  return 1;
  854.  }
  855.  
  856.  //on out line
  857.  if(GetPtStateToBigLine(m_flFirstxTemp,m_flFirstyTemp,m_flSecondxTemp,m_flSecondyTemp,5*flRate,flx,fly)){
  858.  m_nSelectPtNum=-1;
  859.  m_nSelectLineNum=0;
  860.  return 2;
  861.  }
  862.  if(GetPtStateToBigLine(m_flSecondxTemp,m_flSecondyTemp,m_flThirdxTemp,m_flThirdyTemp,5*flRate,flx,fly)){
  863.  m_nSelectPtNum=-1;
  864.  m_nSelectLineNum=1;
  865.  return 2;
  866.  }
  867.  if(GetPtStateToBigLine(m_flThirdxTemp,m_flThirdyTemp,m_flForthxTemp,m_flForthyTemp,5*flRate,flx,fly)){
  868.  m_nSelectPtNum=-1;
  869.  m_nSelectLineNum=2;
  870.  return 2;
  871.  }
  872.  if(GetPtStateToBigLine(m_flForthxTemp,m_flForthyTemp,m_flFirstxTemp,m_flFirstyTemp,5*flRate,flx,fly)){
  873.  m_nSelectPtNum=-1;
  874.  m_nSelectLineNum=3;
  875.  return 2;
  876.  }      
  877.  //out
  878.  
  879.  m_nSelectPtNum=-1;
  880.  m_nSelectLineNum=-1;
  881.  
  882.  return 0;
  883.  }
  884.  //////////////////////////////////////////////////////////////////////
  885.  //End of File
  886.  float CParallelogram::GetSelectLineRate()
  887.  {
  888.  if(m_nSelectLineNum==0||m_nSelectLineNum==2){
  889.  return -GetLineRate(m_flFirstxTemp,m_flFirstyTemp,m_flSecondxTemp,m_flSecondyTemp);
  890.  }
  891.  if(m_nSelectLineNum==1||m_nSelectLineNum==3){
  892.  return -GetLineRate(m_flSecondxTemp,m_flSecondyTemp,m_flThirdxTemp,m_flThirdyTemp);
  893.  }
  894.  return 0;
  895.  }
  896.  
  897.  //////////////////////////////////////////////////////////////////////
  898.  // MODULE   :ExPort
  899.  // ABSTRACT :Export to a txt file
  900.  // FUNCTION :File->Export...
  901.  // NOTE     :
  902.  // RETURN   :
  903.  // ARGUMENTS:
  904.  //              I/O           TYPE      NAME       EXPLANATION
  905.  //               O            FILE*    outStream    Out put File
  906.  // CREATE   :  FNST)handwolf  2004-4-14
  907.  // UPDATE   :  
  908.  //          : 
  909.  //////////////////////////////////////////////////////////////////////
  910.  
  911.  void CParallelogram::ExPort(FILE* outStream)//增加导出txt功能时用
  912.  {
  913.  fprintf(outStream, " CParallelogram n");
  914.  CShape::ExPort(outStream);
  915.  fprintf( outStream, "%f %f %f %f %f %fn",m_flFirstxTemp, m_flFirstyTemp, m_flSecondxTemp, m_flSecondyTemp,m_flThirdxTemp,m_flThirdyTemp);
  916.  }
  917.  
  918.  //////////////////////////////////////////////////////////////////////
  919.  // MODULE   :ImPort
  920.  // ABSTRACT :ImPort from a txt file
  921.  // FUNCTION :File->ImPort...
  922.  // NOTE     :
  923.  // RETURN   :
  924.  // ARGUMENTS:
  925.  //              I/O           TYPE      NAME       EXPLANATION
  926.  //               I            FILE*    inStream    in put File
  927.  // CREATE   :  FNST)handwolf  2004-4-14
  928.  // UPDATE   :  
  929.  //          : 
  930.  //////////////////////////////////////////////////////////////////////
  931.  void CParallelogram::ImPort(FILE* inStream)
  932.  {
  933.  CShape::ImPort(inStream);
  934.  fscanf(inStream, "%f %f %f %f %f %f",&m_flFirstx, &m_flFirsty, &m_flSecondx, &m_flSecondy,&m_flThirdx,&m_flThirdy);
  935.  m_flFirstxTemp=m_flFirstx;
  936.  m_flFirstyTemp=m_flFirsty;
  937.  m_flSecondxTemp=m_flSecondx;
  938.  m_flSecondyTemp=m_flSecondy;
  939.  m_flThirdxTemp=m_flThirdx;
  940.  m_flThirdyTemp=m_flThirdy;
  941.  
  942.  m_flForthx=m_flThirdxTemp+m_flFirstxTemp-m_flSecondxTemp;
  943.  m_flForthy=m_flThirdyTemp+m_flFirstyTemp-m_flSecondyTemp;
  944.  m_flForthxTemp=m_flForthx;
  945.  m_flForthyTemp=m_flForthy;
  946.  }
  947.  CString CParallelogram::GetNameString()
  948.  {
  949.  CString str;
  950.  str.LoadString(IDS_PARALLELOGRAM);
  951.  return str;
  952.  }
  953.  //////////////////////////////////////////////////////////////////////
  954.  //End of File//////////////////////