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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 微处理器开发 > 查看源码
GUI_BASIC.C
资源名称：TanChiShezlggui.rar　[点击查看]
上传用户：zfj3589
上传日期：2022-07-13
资源大小：635k
文件大小：53k
源码类别：

微处理器开发

开发平台：

C/C++

GUI_BASIC.C：源码内容
  1. /****************************************************************************************
  2. * 文件名：GUI_BASIC.C
  3. * 功能：GUI基本绘图函数。进行基本绘图运算，并调用相应的刷新程序更新LCD显示。
  4. * 作者：黄绍斌
  5. * 日期：2004.02.26
  6. * 备注：图形操作层，进行各种图形运算操作。
  7. ****************************************************************************************/
  8. #include "config.h"
  9. #include <math.h>
  12. /****************************************************************************
  13. * 名称：GUI_Rectangle()
  14. * 功能：画矩形。
  15. * 入口参数： x0 矩形左上角的x坐标值
  16. *           y0 矩形左上角的y坐标值
  17. *           x1      矩形右下角的x坐标值
  18. *           y1      矩形右下角的y坐标值
  19. *           color 显示颜色
  20. * 出口参数：无
  21. * 说明：操作失败原因是指定地址超出有效范围。
  22. ****************************************************************************/
  23. void  GUI_Rectangle(uint32 x0, uint32 y0, uint32 x1, uint32 y1, TCOLOR color)
  24. {  GUI_HLine(x0, y0, x1, color);
  25.    GUI_HLine(x0, y1, x1, color);
  26.    GUI_RLine(x0, y0, y1, color);
  27.    GUI_RLine(x1, y0, y1, color);
  28. }
  33. /****************************************************************************
  34. * 名称：GUI_RectangleFill()
  35. * 功能：填充矩形。画一个填充的矩形，填充色与边框色一样。
  36. * 入口参数： x0 矩形左上角的x坐标值
  37. *           y0 矩形左上角的y坐标值
  38. *           x1      矩形右下角的x坐标值
  39. *           y1      矩形右下角的y坐标值
  40. *           color 填充颜色
  41. * 出口参数：无
  42. * 说明：操作失败原因是指定地址超出有效范围。
  43. ****************************************************************************/
  44. void  GUI_RectangleFill(uint32 x0, uint32 y0, uint32 x1, uint32 y1, TCOLOR color)
  45. {  uint32  i;
  47.    /* 先找出矩形左上角与右下角的两个点，保存在(x0,y0)，(x1,y1) */
  48.    if(x0>x1)  // 若x0>x1，则x0与x1交换
  49.    {  i = x0;
  50.       x0 = x1;
  51.       x1 = i;
  52.    }
  53.    if(y0>y1) // 若y0>y1，则y0与y1交换
  54.    {  i = y0;
  55.       y0 = y1;
  56.       y1 = i;
  57.    }
  58.    
  59.    /* 判断是否只是直线 */
  60.    if(y0==y1) 
  61.    {  GUI_HLine(x0, y0, x1, color);
  62.       return;
  63.    }
  64.    if(x0==x1) 
  65.    {  GUI_RLine(x0, y0, y1, color);
  66.       return;
  67.    }
  69.    while(y0<=y1)
  70.    {  GUI_HLine(x0, y0, x1, color); // 当前画水平线
  71.       y0++; // 下一行
  72.    }
  73. }
  76. /****************************************************************************
  77. * 名称：GUI_Square()
  78. * 功能：画正方形。
  79. * 入口参数： x0 正方形左上角的x坐标值
  80. *           y0 正方形左上角的y坐标值
  81. *           with    正方形的边长
  82. *           color 显示颜色
  83. * 出口参数：无
  84. * 说明：操作失败原因是指定地址超出有效范围。
  85. ****************************************************************************/
  86. void  GUI_Square(uint32 x0, uint32 y0, uint32  with, TCOLOR  color)
  87. {   if(with==0) return;
  88. if( (x0+with) > GUI_LCM_XMAX ) return;
  89. if( (y0+with) > GUI_LCM_YMAX ) return;
  90. GUI_Rectangle(x0, y0, x0+with, y0+with, color);
  91. }
  95. /****************************************************************************
  96. * 名称：GUI_Line()
  97. * 功能：画任意两点之间的直线。
  98. * 入口参数： x0 直线起点的x坐标值
  99. *           y0 直线起点的y坐标值
  100. *           x1      直线终点的x坐标值
  101. *           y1      直线终点的y坐标值
  102. *           color 显示颜色(对于黑白色LCM，为0时灭，为1时显示)
  103. * 出口参数：无
  104. * 说明：操作失败原因是指定地址超出有效范围。
  105. ****************************************************************************/
  106. void  GUI_Line(uint32 x0, uint32 y0, uint32 x1, uint32 y1, TCOLOR color)
  107. {  int32   dx; // 直线x轴差值变量
  108.    int32   dy;           // 直线y轴差值变量
  109.    int8    dx_sym; // x轴增长方向，为-1时减值方向，为1时增值方向
  110.    int8    dy_sym; // y轴增长方向，为-1时减值方向，为1时增值方向
  111.    int32   dx_x2; // dx*2值变量，用于加快运算速度
  112.    int32   dy_x2; // dy*2值变量，用于加快运算速度
  113.    int32   di; // 决策变量
  114.    
  115.    
  116.    dx = x1-x0; // 求取两点之间的差值
  117.    dy = y1-y0;
  118.    
  119.    /* 判断增长方向，或是否为水平线、垂直线、点 */
  120.    if(dx>0) // 判断x轴方向
  121.    {  dx_sym = 1; // dx>0，设置dx_sym=1
  122.    }
  123.    else
  124.    {  if(dx<0)
  125.       {  dx_sym = -1; // dx<0，设置dx_sym=-1
  126.       }
  127.       else
  128.       {  // dx==0，画垂直线，或一点
  129.          GUI_RLine(x0, y0, y1, color);
  130.         return;
  131.       }
  132.    }
  133.    
  134.    if(dy>0) // 判断y轴方向
  135.    {  dy_sym = 1; // dy>0，设置dy_sym=1
  136.    }
  137.    else
  138.    {  if(dy<0)
  139.       {  dy_sym = -1; // dy<0，设置dy_sym=-1
  140.       }
  141.       else
  142.       {  // dy==0，画水平线，或一点
  143.          GUI_HLine(x0, y0, x1, color);
  144.         return;
  145.       }
  146.    }
  147.     
  148.    /* 将dx、dy取绝对值 */
  149.    dx = dx_sym * dx;
  150.    dy = dy_sym * dy;
  151.  
  152.    /* 计算2倍的dx及dy值 */
  153.    dx_x2 = dx*2;
  154.    dy_x2 = dy*2;
  155.    
  156.    /* 使用Bresenham法进行画直线 */
  157.    if(dx>=dy) // 对于dx>=dy，则使用x轴为基准
  158.    {  di = dy_x2 - dx;
  159.       while(x0!=x1)
  160.       {  GUI_Point(x0, y0, color);
  161.          x0 += dx_sym;
  162.          if(di<0)
  163.          {  di += dy_x2; // 计算出下一步的决策值
  164.          }
  165.          else
  166.          {  di += dy_x2 - dx_x2;
  167.             y0 += dy_sym;
  168.          }
  169.       }
  170.       GUI_Point(x0, y0, color); // 显示最后一点
  171.    }
  172.    else // 对于dx<dy，则使用y轴为基准
  173.    {  di = dx_x2 - dy;
  174.       while(y0!=y1)
  175.       {  GUI_Point(x0, y0, color);
  176.          y0 += dy_sym;
  177.          if(di<0)
  178.          {  di += dx_x2;
  179.          }
  180.          else
  181.          {  di += dx_x2 - dy_x2;
  182.             x0 += dx_sym;
  183.          }
  184.       }
  185.       GUI_Point(x0, y0, color); // 显示最后一点
  186.    } 
  187.   
  188. }
  191. #if GUI_LineWith_EN==1
  192. /****************************************************************************
  193. * 名称：GUI_LineWith()
  194. * 功能：画任意两点之间的直线，并且可设置线的宽度。
  195. * 入口参数： x0 直线起点的x坐标值
  196. *           y0 直线起点的y坐标值
  197. *           x1      直线终点的x坐标值
  198. *           y1      直线终点的y坐标值
  199. *           with    线宽(0-50)
  200. *           color 显示颜色
  201. * 出口参数：无
  202. * 说明：操作失败原因是指定地址超出有效范围。
  203. ****************************************************************************/
  204. void  GUI_LineWith(uint32 x0, uint32 y0, uint32 x1, uint32 y1, uint8 with, TCOLOR color)
  205. {  int32   dx; // 直线x轴差值变量
  206.    int32   dy;           // 直线y轴差值变量
  207.    int8    dx_sym; // x轴增长方向，为-1时减值方向，为1时增值方向
  208.    int8    dy_sym; // y轴增长方向，为-1时减值方向，为1时增值方向
  209.    int32   dx_x2; // dx*2值变量，用于加快运算速度
  210.    int32   dy_x2; // dy*2值变量，用于加快运算速度
  211.    int32   di; // 决策变量
  212.    
  213.    int32   wx, wy; // 线宽变量
  214.    int32   draw_a, draw_b;
  215.    
  216.    /* 参数过滤 */
  217.    if(with==0) return;
  218.    if(with>50) with = 50;
  219.    
  220.    dx = x1-x0; // 求取两点之间的差值
  221.    dy = y1-y0;
  222.    
  223.    wx = with/2;
  224.    wy = with-wx-1;
  225.    
  226.    /* 判断增长方向，或是否为水平线、垂直线、点 */
  227.    if(dx>0) // 判断x轴方向
  228.    {  dx_sym = 1; // dx>0，设置dx_sym=1
  229.    }
  230.    else
  231.    {  if(dx<0)
  232.       {  dx_sym = -1; // dx<0，设置dx_sym=-1
  233.       }
  234.       else
  235.       {  /* dx==0，画垂直线，或一点 */
  236.          wx = x0-wx;
  237.          if(wx<0) wx = 0;
  238.          wy = x0+wy;
  239.          
  240.          while(1)
  241.          {  x0 = wx;
  242.             GUI_RLine(x0, y0, y1, color);
  243.             if(wx>=wy) break;
  244.             wx++;
  245.          }
  246.          
  247.         return;
  248.       }
  249.    }
  250.    
  251.    if(dy>0) // 判断y轴方向
  252.    {  dy_sym = 1; // dy>0，设置dy_sym=1
  253.    }
  254.    else
  255.    {  if(dy<0)
  256.       {  dy_sym = -1; // dy<0，设置dy_sym=-1
  257.       }
  258.       else
  259.       {  /* dy==0，画水平线，或一点 */
  260.          wx = y0-wx;
  261.          if(wx<0) wx = 0;
  262.          wy = y0+wy;
  263.          
  264.          while(1)
  265.          {  y0 = wx;
  266.             GUI_HLine(x0, y0, x1, color);
  267.             if(wx>=wy) break;
  268.             wx++;
  269.          }
  270.         return;
  271.       }
  272.    }
  273.     
  274.    /* 将dx、dy取绝对值 */
  275.    dx = dx_sym * dx;
  276.    dy = dy_sym * dy;
  277.  
  278.    /* 计算2倍的dx及dy值 */
  279.    dx_x2 = dx*2;
  280.    dy_x2 = dy*2;
  281.    
  282.    /* 使用Bresenham法进行画直线 */
  283.    if(dx>=dy) // 对于dx>=dy，则使用x轴为基准
  284.    {  di = dy_x2 - dx;
  285.       while(x0!=x1)
  286.       {  /* x轴向增长，则宽度在y方向，即画垂直线 */
  287.          draw_a = y0-wx;
  288.          if(draw_a<0) draw_a = 0;
  289.          draw_b = y0+wy;
  290.          GUI_RLine(x0, draw_a, draw_b, color);
  291.          
  292.          x0 += dx_sym;
  293.          if(di<0)
  294.          {  di += dy_x2; // 计算出下一步的决策值
  295.          }
  296.          else
  297.          {  di += dy_x2 - dx_x2;
  298.             y0 += dy_sym;
  299.          }
  300.       }
  301.       draw_a = y0-wx;
  302.       if(draw_a<0) draw_a = 0;
  303.       draw_b = y0+wy;
  304.       GUI_RLine(x0, draw_a, draw_b, color);
  305.    }
  306.    else // 对于dx<dy，则使用y轴为基准
  307.    {  di = dx_x2 - dy;
  308.       while(y0!=y1)
  309.       {  /* y轴向增长，则宽度在x方向，即画水平线 */
  310.          draw_a = x0-wx;
  311.          if(draw_a<0) draw_a = 0;
  312.          draw_b = x0+wy;
  313.          GUI_HLine(draw_a, y0, draw_b, color);
  314.          
  315.          y0 += dy_sym;
  316.          if(di<0)
  317.          {  di += dx_x2;
  318.          }
  319.          else
  320.          {  di += dx_x2 - dy_x2;
  321.             x0 += dx_sym;
  322.          }
  323.       }
  324.       draw_a = x0-wx;
  325.       if(draw_a<0) draw_a = 0;
  326.       draw_b = x0+wy;
  327.       GUI_HLine(draw_a, y0, draw_b, color);
  328.    } 
  329.   
  330. }
  331. #endif
  335. /****************************************************************************
  336. * 名称：GUI_LineS()
  337. * 功能：多个点之间的连续连线。从第一点连到第二点，再连到第三点...
  338. * 入口参数： points  多个点坐标数据的指针，数据排列为(x0,y0)、(x1,y1)、(x2,y2)...
  339. *           no      点数目，至少要大于1
  340. *           color 显示颜色
  341. * 出口参数：无
  342. * 说明：操作失败原因是指定地址超出有效范围。
  343. ****************************************************************************/
  344. void  GUI_LineS(uint32 const *points, uint8 no, TCOLOR color)
  345. {  uint32  x0, y0;
  346.    uint32  x1, y1;
  347.    uint8  i;
  349.    /* 入口参数过滤 */
  350.    if(0==no) return;
  351.    if(1==no) // 单点
  352.    {  x0 = *points++;
  353.       y0 = *points;
  354.       GUI_Point(x0, y0, color);
  355.    }
  356.    
  357.    /* 画多条线条 */
  358.    x0 = *points++; // 取出第一点坐标值，作为原起点坐标值
  359.    y0 = *points++;
  360.    for(i=1; i<no; i++)
  361.    {  x1 = *points++; // 取出下一点坐标值
  362.       y1 = *points++;
  363.       GUI_Line(x0, y0, x1, y1, color);
  364.       x0 = x1; // 更新原起点坐标
  365.       y0 = y1;
  366.    }
  367. }
  371. #if  GUI_CircleX_EN==1
  372. /****************************************************************************
  373. * 名称：GUI_Circle()
  374. * 功能：指定圆心位置及半径，画圆。
  375. * 入口参数： x0 圆心的x坐标值
  376. *           y0 圆心的y坐标值
  377. *           r       圆的半径
  378. *           color 显示颜色
  379. * 出口参数：无
  380. * 说明：操作失败原因是指定地址超出有效范围。
  381. ****************************************************************************/
  382. void  GUI_Circle(uint32 x0, uint32 y0, uint32 r, TCOLOR color)
  383. {  int32  draw_x0, draw_y0; // 刽图点坐标变量
  384.    int32  draw_x1, draw_y1;
  385.    int32  draw_x2, draw_y2;
  386.    int32  draw_x3, draw_y3;
  387.    int32  draw_x4, draw_y4;
  388.    int32  draw_x5, draw_y5;
  389.    int32  draw_x6, draw_y6;
  390.    int32  draw_x7, draw_y7;
  391.    int32  xx, yy; // 画圆控制变量
  392.  
  393.    int32  di; // 决策变量
  394.    
  395.    /* 参数过滤 */
  396.    if(0==r) return;
  397.    
  398.    /* 计算出8个特殊点(0、45、90、135、180、225、270度)，进行显示 */
  399.    draw_x0 = draw_x1 = x0;
  400.    draw_y0 = draw_y1 = y0 + r;
  401.    if(draw_y0<GUI_LCM_YMAX) GUI_Point(draw_x0, draw_y0, color); // 90度
  403.    draw_x2 = draw_x3 = x0;
  404.    draw_y2 = draw_y3 = y0 - r;
  405.    if(draw_y2>=0) GUI_Point(draw_x2, draw_y2, color); // 270度
  406.    
  408.    draw_x4 = draw_x6 = x0 + r;
  409.    draw_y4 = draw_y6 = y0;
  410.    if(draw_x4<GUI_LCM_XMAX) GUI_Point(draw_x4, draw_y4, color); // 0度
  411.    
  412.    draw_x5 = draw_x7 = x0 - r;
  413.    draw_y5 = draw_y7 = y0;
  414.    if(draw_x5>=0) GUI_Point(draw_x5, draw_y5, color); // 180度   
  415.    if(1==r) return; // 若半径为1，则已圆画完
  416.    
  417.    
  418.    /* 使用Bresenham法进行画圆 */
  419.    di = 3 - 2*r; // 初始化决策变量
  420.    
  421.    xx = 0;
  422.    yy = r;
  423.    while(xx<yy)
  424.    {  if(di<0)
  425.   {  di += 4*xx + 6;       
  426.   }
  427.   else
  428.   {  di += 4*(xx - yy) + 10;
  429.   
  430.      yy--;   
  431.  draw_y0--;
  432.  draw_y1--;
  433.  draw_y2++;
  434.  draw_y3++;
  435.  draw_x4--;
  436.  draw_x5++;
  437.  draw_x6--;
  438.  draw_x7++;  
  439.   }
  440.   
  441.   xx++;   
  442.   draw_x0++;
  443.   draw_x1--;
  444.   draw_x2++;
  445.   draw_x3--;
  446.   draw_y4++;
  447.   draw_y5++;
  448.   draw_y6--;
  449.   draw_y7--;
  452.   /* 要判断当前点是否在有效范围内 */
  453.   if( (draw_x0<=GUI_LCM_XMAX)&&(draw_y0>=0) )
  454.   {  GUI_Point(draw_x0, draw_y0, color);
  455.   }     
  456.   if( (draw_x1>=0)&&(draw_y1>=0) )
  457.   {  GUI_Point(draw_x1, draw_y1, color);
  458.   }
  459.   if( (draw_x2<=GUI_LCM_XMAX)&&(draw_y2<=GUI_LCM_YMAX) )
  460.   {  GUI_Point(draw_x2, draw_y2, color);   
  461.   }
  462.   if( (draw_x3>=0)&&(draw_y3<=GUI_LCM_YMAX) )
  463.   {  GUI_Point(draw_x3, draw_y3, color);
  464.   }
  465.   if( (draw_x4<=GUI_LCM_XMAX)&&(draw_y4>=0) )
  466.   {  GUI_Point(draw_x4, draw_y4, color);
  467.   }
  468.   if( (draw_x5>=0)&&(draw_y5>=0) )
  469.   {  GUI_Point(draw_x5, draw_y5, color);
  470.   }
  471.   if( (draw_x6<=GUI_LCM_XMAX)&&(draw_y6<=GUI_LCM_YMAX) )
  472.   {  GUI_Point(draw_x6, draw_y6, color);
  473.   }
  474.   if( (draw_x7>=0)&&(draw_y7<=GUI_LCM_YMAX) )
  475.   {  GUI_Point(draw_x7, draw_y7, color);
  476.   }
  477.    }
  478. }
  481. /****************************************************************************
  482. * 名称：GUI_CircleFill()
  483. * 功能：指定圆心位置及半径，画圆并填充，填充色与边框色一样。
  484. * 入口参数： x0 圆心的x坐标值
  485. *           y0 圆心的y坐标值
  486. *           r       圆的半径
  487. *           color 填充颜色
  488. * 出口参数：无
  489. * 说明：操作失败原因是指定地址超出有效范围。
  490. ****************************************************************************/
  491. void  GUI_CircleFill(uint32 x0, uint32 y0, uint32 r, TCOLOR color)
  492. {  int32  draw_x0, draw_y0; // 刽图点坐标变量
  493.    int32  draw_x1, draw_y1;
  494.    int32  draw_x2, draw_y2;
  495.    int32  draw_x3, draw_y3;
  496.    int32  draw_x4, draw_y4;
  497.    int32  draw_x5, draw_y5;
  498.    int32  draw_x6, draw_y6;
  499.    int32  draw_x7, draw_y7;
  500.    int32  fill_x0, fill_y0; // 填充所需的变量，使用垂直线填充
  501.    int32  fill_x1;
  502.    int32  xx, yy; // 画圆控制变量
  503.  
  504.    int32  di; // 决策变量
  505.    
  506.    /* 参数过滤 */
  507.    if(0==r) return;
  508.    
  509.    /* 计算出4个特殊点(0、90、180、270度)，进行显示 */
  510.    draw_x0 = draw_x1 = x0;
  511.    draw_y0 = draw_y1 = y0 + r;
  512.    if(draw_y0<GUI_LCM_YMAX)
  513.    {  GUI_Point(draw_x0, draw_y0, color); // 90度
  514.    }
  515.     
  516.    draw_x2 = draw_x3 = x0;
  517.    draw_y2 = draw_y3 = y0 - r;
  518.    if(draw_y2>=0)
  519.    {  GUI_Point(draw_x2, draw_y2, color); // 270度
  520.    }
  521.   
  522.    draw_x4 = draw_x6 = x0 + r;
  523.    draw_y4 = draw_y6 = y0;
  524.    if(draw_x4<GUI_LCM_XMAX) 
  525.    {  GUI_Point(draw_x4, draw_y4, color); // 0度
  526.       fill_x1 = draw_x4;
  527.    }
  528.    else
  529.    {  fill_x1 = GUI_LCM_XMAX;
  530.    }
  531.    fill_y0 = y0; // 设置填充线条起始点fill_x0
  532.    fill_x0 = x0 - r; // 设置填充线条结束点fill_y1
  533.    if(fill_x0<0) fill_x0 = 0;
  534.    GUI_HLine(fill_x0, fill_y0, fill_x1, color);
  535.    
  536.    draw_x5 = draw_x7 = x0 - r;
  537.    draw_y5 = draw_y7 = y0;
  538.    if(draw_x5>=0) 
  539.    {  GUI_Point(draw_x5, draw_y5, color); // 180度
  540.    }
  541.    if(1==r) return;
  542.    
  543.    
  544.    /* 使用Bresenham法进行画圆 */
  545.    di = 3 - 2*r; // 初始化决策变量
  546.    
  547.    xx = 0;
  548.    yy = r;
  549.    while(xx<yy)
  550.    {  if(di<0)
  551.   {  di += 4*xx + 6;
  552.   }
  553.   else
  554.   {  di += 4*(xx - yy) + 10;
  555.   
  556.      yy--;   
  557.  draw_y0--;
  558.  draw_y1--;
  559.  draw_y2++;
  560.  draw_y3++;
  561.  draw_x4--;
  562.  draw_x5++;
  563.  draw_x6--;
  564.  draw_x7++;  
  565.   }
  566.   
  567.   xx++;   
  568.   draw_x0++;
  569.   draw_x1--;
  570.   draw_x2++;
  571.   draw_x3--;
  572.   draw_y4++;
  573.   draw_y5++;
  574.   draw_y6--;
  575.   draw_y7--;
  578.   /* 要判断当前点是否在有效范围内 */
  579.   if( (draw_x0<=GUI_LCM_XMAX)&&(draw_y0>=0) )
  580.   {  GUI_Point(draw_x0, draw_y0, color);
  581.   }     
  582.   if( (draw_x1>=0)&&(draw_y1>=0) )
  583.   {  GUI_Point(draw_x1, draw_y1, color);
  584.   }
  585.   
  586.   /* 第二点水直线填充(下半圆的点) */
  587.   if(draw_x1>=0)
  588.   {  /* 设置填充线条起始点fill_x0 */
  589.      fill_x0 = draw_x1;
  590.      /* 设置填充线条起始点fill_y0 */
  591.      fill_y0 = draw_y1;
  592.          if(fill_y0>GUI_LCM_YMAX) fill_y0 = GUI_LCM_YMAX;
  593.          if(fill_y0<0) fill_y0 = 0; 
  594.          /* 设置填充线条结束点fill_x1 */
  595.          fill_x1 = x0*2 - draw_x1;
  596.          if(fill_x1>GUI_LCM_XMAX) fill_x1 = GUI_LCM_XMAX;
  597.          GUI_HLine(fill_x0, fill_y0, fill_x1, color);
  598.       }
  599.   
  600.   
  601.   if( (draw_x2<=GUI_LCM_XMAX)&&(draw_y2<=GUI_LCM_YMAX) )
  602.   {  GUI_Point(draw_x2, draw_y2, color);   
  603.   }
  604.        
  605.   if( (draw_x3>=0)&&(draw_y3<=GUI_LCM_YMAX) )
  606.   {  GUI_Point(draw_x3, draw_y3, color);
  607.   }
  608.   
  609.   /* 第四点垂直线填充(上半圆的点) */
  610.   if(draw_x3>=0)
  611.   {  /* 设置填充线条起始点fill_x0 */
  612.      fill_x0 = draw_x3;
  613.      /* 设置填充线条起始点fill_y0 */
  614.      fill_y0 = draw_y3;
  615.          if(fill_y0>GUI_LCM_YMAX) fill_y0 = GUI_LCM_YMAX;
  616.          if(fill_y0<0) fill_y0 = 0;
  617.          /* 设置填充线条结束点fill_x1 */
  618.          fill_x1 = x0*2 - draw_x3;
  619.          if(fill_x1>GUI_LCM_XMAX) fill_x1 = GUI_LCM_XMAX;
  620.          GUI_HLine(fill_x0, fill_y0, fill_x1, color);
  621.       }
  622.   
  623.      
  624.   if( (draw_x4<=GUI_LCM_XMAX)&&(draw_y4>=0) )
  625.   {  GUI_Point(draw_x4, draw_y4, color);
  626.   }
  627.   if( (draw_x5>=0)&&(draw_y5>=0) )
  628.   {  GUI_Point(draw_x5, draw_y5, color);
  629.   }
  630.   
  631.   /* 第六点垂直线填充(上半圆的点) */
  632.   if(draw_x5>=0)
  633.   {  /* 设置填充线条起始点fill_x0 */
  634.      fill_x0 = draw_x5;
  635.      /* 设置填充线条起始点fill_y0 */
  636.      fill_y0 = draw_y5;
  637.          if(fill_y0>GUI_LCM_YMAX) fill_y0 = GUI_LCM_YMAX;
  638.          if(fill_y0<0) fill_y0 = 0;
  639.          /* 设置填充线条结束点fill_x1 */
  640.          fill_x1 = x0*2 - draw_x5;
  641.          if(fill_x1>GUI_LCM_XMAX) fill_x1 = GUI_LCM_XMAX;
  642.          GUI_HLine(fill_x0, fill_y0, fill_x1, color);
  643.       }
  644.   
  645.   
  646.   if( (draw_x6<=GUI_LCM_XMAX)&&(draw_y6<=GUI_LCM_YMAX) )
  647.   {  GUI_Point(draw_x6, draw_y6, color);
  648.   }
  649.   
  650.   if( (draw_x7>=0)&&(draw_y7<=GUI_LCM_YMAX) )
  651.   {  GUI_Point(draw_x7, draw_y7, color);
  652.   }
  653.   
  654.   /* 第八点垂直线填充(上半圆的点) */
  655.   if(draw_x7>=0)
  656.   {  /* 设置填充线条起始点fill_x0 */
  657.      fill_x0 = draw_x7;
  658.      /* 设置填充线条起始点fill_y0 */
  659.      fill_y0 = draw_y7;
  660.          if(fill_y0>GUI_LCM_YMAX) fill_y0 = GUI_LCM_YMAX;
  661.          if(fill_y0<0) fill_y0 = 0;
  662.          /* 设置填充线条结束点fill_x1 */
  663.          fill_x1 = x0*2 - draw_x7;
  664.          if(fill_x1>GUI_LCM_XMAX) fill_x1 = GUI_LCM_XMAX;
  665.          GUI_HLine(fill_x0, fill_y0, fill_x1, color);
  666.       }
  667.   
  668.    }
  669. }
  670. #endif
  675. #if  GUI_EllipseX_EN==1
  676. /****************************************************************************
  677. * 名称：GUI_Ellipse()
  678. * 功能：画正椭圆。给定椭圆的四个点的参数，最左、最右点的x轴坐标值为x0、x1，最上、最下点
  679. *      的y轴坐标为y0、y1。
  680. * 入口参数： x0 最左点的x坐标值
  681. *           x1 最右点的x坐标值
  682. *           y0 最上点的y坐标值
  683. *           y1      最下点的y坐标值
  684. *           color 显示颜色
  685. * 出口参数：无
  686. * 说明：操作失败原因是指定地址超出有效范围。
  687. ****************************************************************************/
  688. void  GUI_Ellipse(uint32 x0, uint32 x1, uint32 y0, uint32 y1, TCOLOR color)
  689. {  int32  draw_x0, draw_y0; // 刽图点坐标变量
  690.    int32  draw_x1, draw_y1;
  691.    int32  draw_x2, draw_y2;
  692.    int32  draw_x3, draw_y3;
  693.    int32  xx, yy; // 画图控制变量
  694.     
  695.    int32  center_x, center_y; // 椭圆中心点坐标变量
  696.    int32  radius_x, radius_y; // 椭圆的半径，x轴半径和y轴半径
  697.    int32  radius_xx, radius_yy; // 半径乘平方值
  698.    int32  radius_xx2, radius_yy2; // 半径乘平方值的两倍
  699.    int32  di; // 定义决策变量
  701.    /* 参数过滤 */
  702.    if( (x0==x1) || (y0==y1) ) return;
  703.    
  704.    /* 计算出椭圆中心点坐标 */
  705.    center_x = (x0 + x1) >> 1;
  706.    center_y = (y0 + y1) >> 1;
  707.    
  708.    /* 计算出椭圆的半径，x轴半径和y轴半径 */
  709.    if(x0 > x1)
  710.    {  radius_x = (x0 - x1) >> 1;
  711.    }
  712.    else
  713.    {  radius_x = (x1 - x0) >> 1;
  714.    }
  715.    if(y0 > y1)
  716.    {  radius_y = (y0 - y1) >> 1;
  717.    }
  718.    else
  719.    {  radius_y = (y1 - y0) >> 1;
  720.    }
  722.    /* 计算半径平方值 */
  723.    radius_xx = radius_x * radius_x;
  724.    radius_yy = radius_y * radius_y;
  726.    /* 计算半径平方值乘2值 */
  727.    radius_xx2 = radius_xx<<1;
  728.    radius_yy2 = radius_yy<<1;
  730.    /* 初始化画图变量 */
  731.    xx = 0;
  732.    yy = radius_y;
  733.   
  734.    di = radius_yy2 + radius_xx - radius_xx2*radius_y ; // 初始化决策变量 
  736.    /* 计算出椭圆y轴上的两个端点坐标，作为作图起点 */
  737.    draw_x0 = draw_x1 = draw_x2 = draw_x3 = center_x;
  738.    draw_y0 = draw_y1 = center_y + radius_y;
  739.    draw_y2 = draw_y3 = center_y - radius_y;
  740.   
  741.  
  742.    GUI_Point(draw_x0, draw_y0, color); // 画y轴上的两个端点 
  743.    GUI_Point(draw_x2, draw_y2, color);
  745.    while( (radius_yy*xx) < (radius_xx*yy) ) 
  746.    {  if(di<0)
  747.   {  di+= radius_yy2*(2*xx+3);
  748.   }
  749.   else
  750.   {  di += radius_yy2*(2*xx+3) + 4*radius_xx - 4*radius_xx*yy;
  751.     
  752.      yy--;
  753.  draw_y0--;
  754.  draw_y1--;
  755.  draw_y2++;
  756.  draw_y3++;  
  757.   }
  758.   
  759.   xx ++; // x轴加1
  760.  
  761.   draw_x0++;
  762.   draw_x1--;
  763.   draw_x2++;
  764.   draw_x3--;
  766.   GUI_Point(draw_x0, draw_y0, color);
  767.   GUI_Point(draw_x1, draw_y1, color);
  768.   GUI_Point(draw_x2, draw_y2, color);
  769.   GUI_Point(draw_x3, draw_y3, color);
  770.    }
  771.   
  772.    di = radius_xx2*(yy-1)*(yy-1) + radius_yy2*xx*xx + radius_yy + radius_yy2*xx - radius_xx2*radius_yy;
  773.    while(yy>=0) 
  774.    {  if(di<0)
  775.   {  di+= radius_xx2*3 + 4*radius_yy*xx + 4*radius_yy - 2*radius_xx2*yy;
  776.     
  777.      xx ++; // x轴加1  
  778.      draw_x0++;
  779.      draw_x1--;
  780.      draw_x2++;
  781.      draw_x3--;  
  782.   }
  783.   else
  784.   {  di += radius_xx2*3 - 2*radius_xx2*yy;            
  785.   }
  786.   
  787.   yy--;
  788.     draw_y0--;
  789.   draw_y1--;
  790.   draw_y2++;
  791.   draw_y3++;
  793.   GUI_Point(draw_x0, draw_y0, color);
  794.   GUI_Point(draw_x1, draw_y1, color);
  795.   GUI_Point(draw_x2, draw_y2, color);
  796.   GUI_Point(draw_x3, draw_y3, color);
  797.    }     
  798. }
  801. /****************************************************************************
  802. * 名称：GUI_EllipseFill()
  803. * 功能：画正椭圆，并填充。给定椭圆的四个点的参数，最左、最右点的x轴坐标值为x0、x1，最上、最下点
  804. *      的y轴坐标为y0、y1。
  805. * 入口参数： x0 最左点的x坐标值
  806. *           x1 最右点的x坐标值
  807. *           y0 最上点的y坐标值
  808. *           y1      最下点的y坐标值
  809. *           color 填充颜色
  810. * 出口参数：无
  811. * 说明：操作失败原因是指定地址超出有效范围。
  812. ****************************************************************************/
  813. void  GUI_EllipseFill(uint32 x0, uint32 x1, uint32 y0, uint32 y1, TCOLOR color)
  814. {  int32  draw_x0, draw_y0; // 刽图点坐标变量
  815.    int32  draw_x1, draw_y1;
  816.    int32  draw_x2, draw_y2;
  817.    int32  draw_x3, draw_y3;
  818.    int32  xx, yy; // 画图控制变量
  819.     
  820.    int32  center_x, center_y; // 椭圆中心点坐标变量
  821.    int32  radius_x, radius_y; // 椭圆的半径，x轴半径和y轴半径
  822.    int32  radius_xx, radius_yy; // 半径乘平方值
  823.    int32  radius_xx2, radius_yy2; // 半径乘平方值的两倍
  824.    int32  di; // 定义决策变量
  826.    /* 参数过滤 */
  827.    if( (x0==x1) || (y0==y1) ) return;
  828.    
  829.    /* 计算出椭圆中心点坐标 */
  830.    center_x = (x0 + x1) >> 1;
  831.    center_y = (y0 + y1) >> 1;
  832.    
  833.    /* 计算出椭圆的半径，x轴半径和y轴半径 */
  834.    if(x0 > x1)
  835.    {  radius_x = (x0 - x1) >> 1;
  836.    }
  837.    else
  838.    {  radius_x = (x1 - x0) >> 1;
  839.    }
  840.    if(y0 > y1)
  841.    {  radius_y = (y0 - y1) >> 1;
  842.    }
  843.    else
  844.    {  radius_y = (y1 - y0) >> 1;
  845.    }
  847.    /* 计算半径乘平方值 */
  848.    radius_xx = radius_x * radius_x;
  849.    radius_yy = radius_y * radius_y;
  851.    /* 计算半径乘4值 */
  852.    radius_xx2 = radius_xx<<1;
  853.    radius_yy2 = radius_yy<<1;
  854.    
  855.     /* 初始化画图变量 */
  856.    xx = 0;
  857.    yy = radius_y;
  858.   
  859.    di = radius_yy2 + radius_xx - radius_xx2*radius_y ; // 初始化决策变量 
  861.    /* 计算出椭圆y轴上的两个端点坐标，作为作图起点 */
  862.    draw_x0 = draw_x1 = draw_x2 = draw_x3 = center_x;
  863.    draw_y0 = draw_y1 = center_y + radius_y;
  864.    draw_y2 = draw_y3 = center_y - radius_y;
  865.   
  866.  
  867.    GUI_Point(draw_x0, draw_y0, color); // 画y轴上的两个端点
  868.    GUI_Point(draw_x2, draw_y2, color);
  870.    while( (radius_yy*xx) < (radius_xx*yy) ) 
  871.    {  if(di<0)
  872.   {  di+= radius_yy2*(2*xx+3);
  873.   }
  874.   else
  875.   {  di += radius_yy2*(2*xx+3) + 4*radius_xx - 4*radius_xx*yy;
  876.     
  877.      yy--;
  878.  draw_y0--;
  879.  draw_y1--;
  880.  draw_y2++;
  881.  draw_y3++;  
  882.   }
  883.   
  884.   xx ++; // x轴加1
  885.  
  886.   draw_x0++;
  887.   draw_x1--;
  888.   draw_x2++;
  889.   draw_x3--;
  891.   GUI_Point(draw_x0, draw_y0, color);
  892.   GUI_Point(draw_x1, draw_y1, color);
  893.   GUI_Point(draw_x2, draw_y2, color);
  894.   GUI_Point(draw_x3, draw_y3, color);
  895.   
  896.   /* 若y轴已变化，进行填充 */
  897.   if(di>=0)
  898.   {  GUI_HLine(draw_x0, draw_y0, draw_x1, color);
  899.      GUI_HLine(draw_x2, draw_y2, draw_x3, color);
  900.   }
  901.    }
  902.   
  903.    di = radius_xx2*(yy-1)*(yy-1) + radius_yy2*xx*xx + radius_yy + radius_yy2*xx - radius_xx2*radius_yy;
  904.    while(yy>=0) 
  905.    {  if(di<0)
  906.   {  di+= radius_xx2*3 + 4*radius_yy*xx + 4*radius_yy - 2*radius_xx2*yy;
  907.     
  908.      xx ++; // x轴加1  
  909.      draw_x0++;
  910.      draw_x1--;
  911.      draw_x2++;
  912.      draw_x3--;  
  913.   }
  914.   else
  915.   {  di += radius_xx2*3 - 2*radius_xx2*yy;            
  916.   }
  917.   
  918.   yy--;
  919.     draw_y0--;
  920.   draw_y1--;
  921.   draw_y2++;
  922.   draw_y3++;
  924.   GUI_Point(draw_x0, draw_y0, color);
  925.   GUI_Point(draw_x1, draw_y1, color);
  926.   GUI_Point(draw_x2, draw_y2, color);
  927.   GUI_Point(draw_x3, draw_y3, color);
  928.   
  929.   /* y轴已变化，进行填充 */
  930.   GUI_HLine(draw_x0, draw_y0, draw_x1, color);
  931.   GUI_HLine(draw_x2, draw_y2, draw_x3, color); 
  932.    }     
  933. }
  934. #endif
  939. #if  GUI_FloodFill_EN==1
  940. /****************************************************************************
  941. * 名称：GUI_ReadLeftPoint()
  942. * 功能：找出指定点左边最近的非color点。
  943. * 入口参数： x0 指定点的x坐标值
  944. *           y0 指定点的y坐标值
  945. *           color 指定颜色值
  946. * 出口参数：返回该点的x轴坐标值。
  947. * 说明：若没有找出，则返回最左的x坐标0。
  948. ****************************************************************************/
  949. uint32  GUI_ReadLeftPoint(uint32 x0, uint32 y0, TCOLOR color)
  950. {  uint32  i;
  951.    TCOLOR  bakc;
  952.    
  953.    for(i=x0-1; i>0; i--)
  954.    {  GUI_ReadPoint(i, y0, &bakc);
  955.       if( GUI_CmpColor(bakc,color)==0 ) return(i+1); // 若找到，则返回
  956.    }
  957.    GUI_ReadPoint(i, y0, &bakc);
  958.    if( GUI_CmpColor(bakc,color)==0 ) return(1); // 若找到，则返回
  959.    
  960.    return(0);
  961. }
  964. /****************************************************************************
  965. * 名称：GUI_ReadRightPoint()
  966. * 功能：找出指定点右边最近的非color点。
  967. * 入口参数： x0 指定点的x轴坐标值
  968. *           y0 指定点的y轴坐标值
  969. *           color 指定颜色值
  970. * 出口参数：返回该点的x轴坐标值。
  971. * 说明：若没有找出，则返回最右的x坐标GUI_LCM_XMAX。
  972. ****************************************************************************/
  973. uint32  GUI_ReadRightPoint(uint32 x0, uint32 y0, TCOLOR color)
  974. {  uint32  i;
  975.    TCOLOR  bakc;
  976.    
  977.    for(i=x0+1; i<GUI_LCM_XMAX; i++)
  978.    {  GUI_ReadPoint(i, y0, &bakc);
  979.       if( GUI_CmpColor(bakc,color)==0 ) return(i-1); // 若找到，则返回
  980.    }
  981.    return(GUI_LCM_XMAX);
  982. }
  985. /****************************************************************************
  986. * 名称：GUI_CmpPointColor()
  987. * 功能：判断指定点上的颜色是否为某种颜色。
  988. * 入口参数：x 指定点的x轴坐标值
  989. *    y 指定点的y轴坐标值
  990. *          color 颜色值
  991. * 出口参数：返回1表示相同，返回0表示不相同。
  992. * 说明：
  993. ****************************************************************************/
  994. int  GUI_CmpPointColor(uint32 x, uint32 y, TCOLOR color)
  995. {  TCOLOR  bakc;
  996.    
  997.    GUI_ReadPoint(x, y, &bakc);
  998.    return( GUI_CmpColor(bakc,color) );
  999. }
  1002. /* 定义折点个数 */
  1003. #ifndef  DOWNP_N
  1004. #define  DOWNP_N 20
  1005. #endif
  1006. #ifndef  UPP_N
  1007. #define  UPP_N 20
  1008. #endif
  1009. /****************************************************************************
  1010. * 名称：GUI_FloodFill()
  1011. * 功能：图形填充，将指定点内的封闭图形进行填充。对指定点的颜色区域进行填充，即不是该颜色
  1012. *      的像素为边界(如，指定点上的颜色为红色，则其它颜色像素均为边界)。
  1013. * 入口参数： x0 指定点的x坐标值
  1014. *           y0 指定点的y坐标值
  1015. *           color 填充颜色
  1016. * 出口参数：无
  1017. * 说明：操作失败原因是指定地址超出有效范围、指定点不在封闭图形内。
  1018. ****************************************************************************/
  1019. void  GUI_FloodFill(uint32 x0, uint32 y0, TCOLOR color)
  1020. {  PointXY  down_point[DOWNP_N]; // 定义向下填充转折点缓冲区
  1021.    uint8    down_no; // 向下折点个数
  1022.    PointXY  up_point[UPP_N]; // 定义向上填充转折点缓冲区
  1023.    uint8    up_no; // 向上折点个数
  1024.    TCOLOR   fcolor; // 填充点上的颜色
  1025.    
  1026.    uint32  xx, yy; // 填充临时x，y变量 (当前填充行的中点)
  1027.    uint32  xx0; // 当前填充行的左x值变量
  1028.    uint32  xx1; // 当前填充行的右y值变量
  1029.    uint32  i;
  1030.    
  1031.    uint32  x0_bak, y0_bak;
  1032.    uint32  x1_bak;
  1033.    
  1034.    /* 参数过滤 */
  1035.    if(x0>=GUI_LCM_XMAX) return;
  1036.    if(y0>=GUI_LCM_YMAX) return;
  1037.    
  1038.    /* 判断指定点是否为填充颜色，若是则直接返回 */
  1039.    GUI_ReadPoint(x0, y0, &fcolor); // 取得填充点的颜色
  1040.    if( GUI_CmpColor(fcolor,color)!=0 ) return;
  1041.    
  1042.    y0_bak = y0;
  1043.    x0_bak = xx0 = GUI_ReadLeftPoint(x0, y0, fcolor); // 找出当前y坐标上的最左边的点
  1044.    x1_bak = xx1 = GUI_ReadRightPoint(x0, y0, fcolor); // 找出当前y坐标上的最右边的点
  1045.    down_point[0].x = up_point[0].x = (xx1 + xx0)/2;
  1046.    down_point[0].y = up_point[0].y = y0;
  1047.    down_no = 1;
  1048.    up_no = 1;
  1049.    
  1050.    /* 开始向上填充 */
  1051. FILL_UP:  
  1052.    if(0==up_no) goto FILL_DOWN; // 若向下扫描已完成，则退出
  1053.    xx = up_point[up_no-1].x; // 否则取出下一折点
  1054.    yy = up_point[up_no-1].y;
  1055.    up_no--; 
  1056.    xx0 = GUI_ReadLeftPoint(xx, yy, fcolor);
  1057.    xx1 = GUI_ReadRightPoint(xx, yy, fcolor);
  1058.    while(1) 
  1059.    {  yy += 1; // 中心点向上一点
  1060.        
  1061.       if( GUI_CmpPointColor(xx, yy, fcolor)==0 )
  1062.       {  /* 判断此点是否为终点，若是则退出此次循环 */
  1063.          for(i=xx0; i<=xx1; i++)      // 查找此行是否有需填充点
  1064.          {  if( GUI_CmpPointColor(i, yy, fcolor)!=0 ) break;
  1065.          }
  1066.          if(i>xx1) goto FILL_UP; 
  1067.          
  1068.          /* 找出新一行中最右边的点 */
  1069.          xx = i; // 更新xx到要填充的有效区域内
  1070.          xx1 = GUI_ReadRightPoint(xx, yy, fcolor);
  1071.       }
  1072.       else
  1073.       {  /* 找出新一行中最右边的点 */
  1074.          xx1 = GUI_ReadRightPoint(xx, yy, fcolor);
  1075.       }
  1076.       xx0 = GUI_ReadLeftPoint(xx, yy, fcolor);
  1077.       
  1078.       /* 向下折点。使用y0作为折点变量，x0作为上一折点变量 */
  1079.       if(down_no<DOWNP_N)
  1080.       {  y0 = xx0;
  1081.          x0 = y0-1;
  1082.          for(i=y0; i<=xx1; i++)
  1083.          {  if( GUI_CmpPointColor(i, yy-1, fcolor)==0 ) // 更新折点
  1084.             {  y0 = i;
  1085.             }
  1086.             else
  1087.             {  if(x0!=y0) // 找到新的折点
  1088.                {  x0 = y0;
  1089.                   down_point[down_no].x = i;
  1090.                   down_point[down_no].y = yy;
  1091.                   down_no++;
  1092.                }
  1093.             }
  1094.             if(down_no>=DOWNP_N) break; // 若缓冲区已保存满，则退出
  1095.          } // end  of for(i=y0+1; i<xx1; i++)
  1096.       } // end of if(down_no<DOWNP_N)
  1097.       
  1098.       xx = (xx1 + xx0)/2; // 更新中心点
  1099.       GUI_HLine(xx0, yy, xx1, color); // 填充一行
  1100.       
  1101.       /* 向上折点。使用y0作为折点变量，x0作为上一折点变量 */
  1102.       if(up_no<UPP_N)
  1103.       {  y0 = xx0;
  1104.          x0 = y0-1;
  1105.          for(i=y0; i<=xx1; i++)
  1106.          {  if( GUI_CmpPointColor(i, yy+1, fcolor)==0 ) // 更新折点
  1107.             {  y0 = i;
  1108.             }
  1109.             else
  1110.             {  if(x0!=y0) // 找到新的折点
  1111.                {  x0 = y0;
  1112.                   up_point[up_no].x = i;
  1113.                   up_point[up_no].y = yy;
  1114.                   up_no++;
  1115.                }
  1116.             }
  1117.             if(up_no>=UPP_N) break; // 若缓冲区已保存满，则退出
  1118.          }
  1119.       } // end of if(up_no<UPP_N)
  1120.       
  1121.    } // end of while(1) 
  1123.    /* 向下填充 */
  1124. FILL_DOWN: 
  1125.    if(0==down_no) 
  1126.    {  if(0==up_no) 
  1127.       {  GUI_HLine(x0_bak, y0_bak, x1_bak, color);
  1128.          return; // 若向下扫描已完成，且没有发现新的向上折点，则退出
  1129.       }
  1130.       else
  1131.       {  goto FILL_UP;
  1132.       }
  1133.    }
  1134.    xx = down_point[down_no-1].x; // 否则取出下一折点
  1135.    yy = down_point[down_no-1].y;
  1136.    down_no--;
  1137.    xx0 = GUI_ReadLeftPoint(xx, yy, fcolor);
  1138.    xx1 = GUI_ReadRightPoint(xx, yy, fcolor);
  1139.    
  1140.    while(1) 
  1141.    {  yy -= 1; // 中心点向上一点 
  1142.       if( GUI_CmpPointColor(xx, yy, fcolor)==0 )
  1143.       {  /* 判断此点是否为终点，若是则退出此次循环 */
  1144.          for(i=xx0; i<=xx1; i++)      // 查找下一行是否有需填充点
  1145.          {  if( GUI_CmpPointColor(i, yy, fcolor)!=0 ) break;
  1146.          }
  1147.          if(i>xx1) goto FILL_DOWN; 
  1148.          
  1149.          /* 找出新一行中最右边的点 */
  1150.          xx = i;
  1151.          xx1 = GUI_ReadRightPoint(xx, yy, fcolor);
  1152.       }
  1153.       else
  1154.       {  /* 找出新一行中最右边的点 */
  1155.          xx1 = GUI_ReadRightPoint(xx, yy, fcolor);
  1156.       }
  1157.       xx0 = GUI_ReadLeftPoint(xx, yy, fcolor);
  1158.             
  1159.       /* 向上折点。使用y0作为折点变量，x0作为上一折点变量 */
  1160.       if(up_no<UPP_N)
  1161.       {  y0 = xx0;
  1162.          x0 = y0-1;
  1163.          for(i=y0; i<=xx1; i++)
  1164.          {  if( GUI_CmpPointColor(i, yy+1, fcolor)==0 ) // 更新折点
  1165.             {  y0 = i;
  1166.             }
  1167.             else
  1168.             {  if(x0!=y0) // 找到新的折点
  1169.                {  x0 = y0;
  1170.                   up_point[up_no].x = i;
  1171.                   up_point[up_no].y = yy;
  1172.                   up_no++;
  1173.                }
  1174.             }
  1175.             if(up_no>=UPP_N) break; // 若缓冲区已保存满，则退出
  1176.          }
  1177.       }
  1178.             
  1179.       xx = (xx1 + xx0)/2; 
  1180.       GUI_HLine(xx0, yy, xx1, color); // 填充一行
  1181.       
  1182.       /* 向下折点。使用y0作为折点变量，x0作为上一折点变量 */
  1183.       if(down_no<DOWNP_N)
  1184.       {  y0 = xx0;
  1185.          x0 = y0-1;
  1186.          for(i=y0; i<=xx1; i++)
  1187.          {  if( GUI_CmpPointColor(i, yy-1, fcolor)==0 ) // 更新折点
  1188.             {  y0 = i;
  1189.             }
  1190.             else
  1191.             {  if(x0!=y0) // 找到新的折点
  1192.                {  x0 = y0;
  1193.                   down_point[down_no].x = i;
  1194.                   down_point[down_no].y = yy;
  1195.                   down_no++;
  1196.                }
  1197.             }
  1198.             if(down_no>=DOWNP_N) break; // 若缓冲区已保存满，则退出
  1199.          }
  1200.       } // end of if(down_no<DOWNP_N)
  1201.       
  1202.    } // end of while(1) 
  1203.    
  1204.    GUI_HLine(x0_bak, y0_bak, x1_bak, color);
  1205. }
  1206. #endif
  1211. #if  GUI_ArcX_EN==1
  1212. /****************************************************************************
  1213. * 名称：GUI_Arc4()
  1214. * 功能：画弧。起点及终点只能为0度-90度、90度-180度、180度-270度、270度-0度等。即分别
  1215. *      为第1-4像限的90度弧。
  1216. * 入口参数： x0 圆心的x坐标值
  1217. *           y0 圆心的y坐标值
  1218. *           r       圆弧的半径
  1219. *           angle 画弧的像限(1-4)
  1220. *           color 显示颜色
  1221. * 出口参数：无
  1222. * 说明：操作失败原因是指定地址超出有效范围。
  1223. ****************************************************************************/
  1224. void  GUI_Arc4(uint32 x, uint32 y, uint32 r, uint8 angle, TCOLOR color)
  1225. {  int32  draw_x, draw_y;
  1227.    int32  op_x, op_y;
  1228.    int32  op_2rr;
  1229.    
  1230.    if(r==0) return;
  1231.    
  1232.    op_2rr = 2*r*r; // 计算r平方乖以2
  1233.    
  1234.    switch(angle)
  1235.    {  case  1:
  1236.             draw_x = x+r;
  1237.             draw_y = y;
  1238.             
  1239.             op_x = r;
  1240.             op_y = 0;
  1241.  
  1242.             while(1)
  1243.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1244.                  
  1245.                /* 计算下一点 */
  1246.                op_y++;
  1247.                draw_y++;
  1248.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1249.                {  op_x--;
  1250.                   draw_x--;
  1251.                }
  1252.                if(op_y>=op_x) break;
  1253.             }
  1254.             while(1)
  1255.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1256.                  
  1257.                /* 计算下一点 */
  1258.                op_x--;
  1259.                draw_x--;
  1260.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 )  // 使用逐点比较法实现画圆弧
  1261.                {  op_y++;
  1262.                   draw_y++;
  1263.                }
  1264.                if(op_x<=0)
  1265.                {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1266.                   break;
  1267.                }
  1268.             }
  1269.    
  1270.             break;      
  1271.    
  1272.       case  2:
  1273.             draw_x = x-r;
  1274.             draw_y = y;
  1275.             
  1276.             op_x = r;
  1277.             op_y = 0;
  1278.  
  1279.             while(1)
  1280.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1281.                  
  1282.                /* 计算下一点 */
  1283.                op_y++;
  1284.                draw_y++;
  1285.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1286.                {  op_x--;
  1287.                   draw_x++;
  1288.                }
  1289.                if(op_y>=op_x) break;
  1290.             }
  1291.             while(1)
  1292.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1293.                  
  1294.                /* 计算下一点 */
  1295.                op_x--;
  1296.                draw_x++;
  1297.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 )  // 使用逐点比较法实现画圆弧
  1298.                {  op_y++;
  1299.                   draw_y++;
  1300.                }
  1301.                if(op_x<=0)
  1302.                {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1303.                   break;
  1304.                }
  1305.             }
  1306.   
  1307.             break;
  1308.             
  1309.       case  3:
  1310.             draw_x = x-r;
  1311.             draw_y = y;
  1312.             
  1313.             op_x = r;
  1314.             op_y = 0;
  1315.  
  1316.             while(1)
  1317.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1318.                  
  1319.                /* 计算下一点 */
  1320.                op_y++;
  1321.                draw_y--;
  1322.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1323.                {  op_x--;
  1324.                   draw_x++;
  1325.                }
  1326.                if(op_y>=op_x) break;
  1327.             }
  1328.             while(1)
  1329.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1330.                  
  1331.                /* 计算下一点 */
  1332.                op_x--;
  1333.                draw_x++;
  1334.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 )  // 使用逐点比较法实现画圆弧
  1335.                {  op_y++;
  1336.                   draw_y--;
  1337.                }
  1338.                if(op_x<=0)
  1339.                {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1340.                   break;
  1341.                }
  1342.             }
  1343.       
  1344.             break;
  1345.             
  1346.       case  4:
  1347.             draw_x = x+r;
  1348.             draw_y = y;
  1349.             
  1350.             op_x = r;
  1351.             op_y = 0;
  1352.  
  1353.             while(1)
  1354.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1355.                  
  1356.                /* 计算下一点 */
  1357.                op_y++;
  1358.                draw_y--;
  1359.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1360.                {  op_x--;
  1361.                   draw_x--;
  1362.                }
  1363.                if(op_y>=op_x) break;
  1364.             }
  1365.             while(1)
  1366.             {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1367.                  
  1368.                /* 计算下一点 */
  1369.                op_x--;
  1370.                draw_x--;
  1371.                if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 )  // 使用逐点比较法实现画圆弧
  1372.                {  op_y++;
  1373.                   draw_y--;
  1374.                }
  1375.                if(op_x<=0)
  1376.                {  GUI_Point(draw_x, draw_y, color); // 开始画图
  1377.                   break;
  1378.                }
  1379.             }
  1380.             break;
  1381.             
  1382.       default:
  1383.             break;
  1384.       
  1385.    }
  1387. }
  1389. /****************************************************************************
  1390. * 名称：GUI_Arc()
  1391. * 功能：指定起点、终点及半径画弧(不能画圆)。使用的是顺时针方向画图。
  1392. * 入口参数： x 圆心的x轴坐标值
  1393. *           y 圆心的y轴坐标值
  1394. *           stangle  起始角度(0-359度)
  1395. *           endangle 终止角度(0-359度)
  1396. *           r   圆的半径终点
  1397. *           color 显示颜色
  1398. * 出口参数：无
  1399. * 说明：操作失败原因是指定地址超出有效范围。
  1400. ****************************************************************************/
  1401. void  GUI_Arc(uint32 x, uint32 y, uint32 r, uint32 stangle, uint32 endangle, TCOLOR color)
  1402. {  int32  draw_x, draw_y; // 画图坐标变量
  1403.    int32  op_x, op_y; // 操作坐标
  1404.    int32  op_2rr; // 2*r*r值变量
  1405.    
  1406.    int32  pno_angle; // 度角点的个数
  1407.    uint8  draw_on; // 画点开关，为1时画点，为0时不画
  1408.    
  1409.    
  1410.    /* 参数过滤 */
  1411.    if(r==0) return; // 半径为0则直接退出
  1412.    if(stangle==endangle) return; // 起始角度与终止角度相同，退出
  1413.    if( (stangle>=360) || (endangle>=360) ) return;
  1415.    op_2rr = 2*r*r; // 计算r平方乖以2
  1416.    pno_angle = 0;
  1417.    /* 先计算出在此半径下的45度的圆弧的点数 */       
  1418.    op_x = r;
  1419.    op_y = 0;
  1420.    while(1)
  1421.    {  pno_angle++;  // 画点计数         
  1422.       /* 计算下一点 */
  1423.       op_y++;
  1424.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1425.       {  op_x--;
  1426.       }
  1427.       if(op_y>=op_x) break;
  1428.    }
  1429.    
  1430.    draw_on = 0; // 最开始关画点开关
  1431.    /* 设置起始点及终点 */
  1432.    if(endangle>stangle) draw_on = 1; // 若终点大于起点，则从一开始即画点(359)
  1433.    stangle = (360-stangle)*pno_angle/45;
  1434.    endangle = (360-endangle)*pno_angle/45;
  1435.    if(stangle==0) stangle=1;
  1436.    if(endangle==0) endangle=1;
  1437.    
  1438.    /* 开始顺时针画弧，从359度开始(第4像限) */
  1439.    pno_angle = 0;
  1440.    
  1441.    draw_x = x+r;
  1442.    draw_y = y;         
  1443.    op_x = r;
  1444.    op_y = 0;
  1445.    while(1)
  1446.    {  /* 计算下一点 */
  1447.       op_y++;
  1448.       draw_y--;
  1449.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1450.       {  op_x--;
  1451.          draw_x--;
  1452.       }
  1453.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1454.       pno_angle++;
  1455.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1456.       {  draw_on = 1-draw_on;
  1457.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1458.       } 
  1459.       if(op_y>=op_x)
  1460.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1461.          break;
  1462.       }
  1463.    }
  1464.    
  1465.    while(1)
  1466.    {  /* 计算下一点 */
  1467.       op_x--;
  1468.       draw_x--;
  1469.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 ) // 使用逐点比较法实现画圆弧
  1470.       {  op_y++;
  1471.          draw_y--;
  1472.       }
  1473.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1474.       pno_angle++;
  1475.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1476.       {  draw_on = 1-draw_on;
  1477.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1478.       } 
  1479.       
  1480.       if(op_x<=0)
  1481.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1482.          break;
  1483.       }
  1484.    }
  1485.     
  1486.     
  1487.    /* 开始顺时针画弧，从269度开始(第3像限) */
  1488.    draw_y = y-r;
  1489.    draw_x = x;         
  1490.    op_y = r;
  1491.    op_x = 0;
  1492.    while(1)
  1493.    {  /* 计算下一点 */
  1494.       op_x++;
  1495.       draw_x--;
  1496.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_y +1)>0 ) // 使用逐点比较法实现画圆弧
  1497.       {  op_y--;
  1498.          draw_y++;
  1499.       }
  1500.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1501.       pno_angle++;
  1502.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1503.       {  draw_on = 1-draw_on;
  1504.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1505.       } 
  1506.       
  1507.       if(op_x>=op_y)
  1508.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1509.          break;
  1510.       }
  1511.    }
  1512.    
  1513.    while(1)
  1514.    {  /* 计算下一点 */
  1515.       op_y--;
  1516.       draw_y++;
  1517.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_x +1)<=0 ) // 使用逐点比较法实现画圆弧
  1518.       {  op_x++;
  1519.          draw_x--;
  1520.       }
  1521.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1522.       pno_angle++;
  1523.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1524.       {  draw_on = 1-draw_on;
  1525.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1526.       } 
  1527.       if(op_y<=0)
  1528.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1529.          break;
  1530.       }
  1531.    }
  1532.    
  1533.    
  1534.    /* 开始顺时针画弧，从179度开始(第2像限) */
  1535.    draw_x = x-r;
  1536.    draw_y = y;         
  1537.    op_x = r;
  1538.    op_y = 0;
  1539.    while(1)
  1540.    {  /* 计算下一点 */
  1541.       op_y++;
  1542.       draw_y++;
  1543.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1544.       {  op_x--;
  1545.          draw_x++;
  1546.       }
  1547.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1548.       pno_angle++;
  1549.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1550.       {  draw_on = 1-draw_on;
  1551.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1552.       } 
  1553.       if(op_y>=op_x)
  1554.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1555.          break;
  1556.       }
  1557.    }
  1558.    
  1559.    while(1)
  1560.    {  /* 计算下一点 */
  1561.       op_x--;
  1562.       draw_x++;
  1563.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 ) // 使用逐点比较法实现画圆弧
  1564.       {  op_y++;
  1565.          draw_y++;
  1566.       }
  1567.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1568.       pno_angle++;
  1569.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1570.       {  draw_on = 1-draw_on;
  1571.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1572.       } 
  1573.       
  1574.       if(op_x<=0)
  1575.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1576.          break;
  1577.       }
  1578.    }
  1579.   
  1580.   
  1581.    /* 开始顺时针画弧，从89度开始(第1像限) */
  1582.    draw_y = y+r;
  1583.    draw_x = x;         
  1584.    op_y = r;
  1585.    op_x = 0;
  1586.    while(1)
  1587.    {  /* 计算下一点 */
  1588.       op_x++;
  1589.       draw_x++;
  1590.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_y +1)>0 ) // 使用逐点比较法实现画圆弧
  1591.       {  op_y--;
  1592.          draw_y--;
  1593.       }
  1594.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1595.       pno_angle++;
  1596.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1597.       {  draw_on = 1-draw_on;
  1598.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1599.       } 
  1600.       
  1601.       if(op_x>=op_y)
  1602.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1603.          break;
  1604.       }
  1605.    }
  1606.    
  1607.    while(1)
  1608.    {  /* 计算下一点 */
  1609.       op_y--;
  1610.       draw_y--;
  1611.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_x +1)<=0 ) // 使用逐点比较法实现画圆弧
  1612.       {  op_x++;
  1613.          draw_x++;
  1614.       }
  1615.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1616.       pno_angle++;
  1617.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1618.       {  draw_on = 1-draw_on;
  1619.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1620.       } 
  1621.       if(op_y<=0)
  1622.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1623.          break;
  1624.       }
  1625.    }
  1626.    
  1627. }
  1628. #endif
  1633. #if  GUI_Pieslice_EN==1
  1634. /****************************************************************************
  1635. * 名称：GUI_Pieslice()
  1636. * 功能：指定起点、终点及半径扇形(不能画圆)。使用的是顺时针方向画图。
  1637. * 入口参数： x 圆心的x轴坐标值
  1638. *           y 圆心的y轴坐标值
  1639. *           stangle  起始角度(0-359度)
  1640. *           endangle 终止角度(0-359度)
  1641. *           r   圆的半径终点
  1642. *           color 显示颜色
  1643. * 出口参数：无
  1644. * 说明：操作失败原因是指定地址超出有效范围。
  1645. ****************************************************************************/
  1646. void  GUI_Pieslice(uint32 x, uint32 y, uint32 r, uint32 stangle, uint32 endangle, TCOLOR color)
  1647. {  int32  draw_x, draw_y; // 画图坐标变量
  1648.    int32  op_x, op_y; // 操作坐标
  1649.    int32  op_2rr; // 2*r*r值变量
  1650.    
  1651.    int32  pno_angle; // 度角点的个数
  1652.    uint8  draw_on; // 画点开关，为1时画点，为0时不画
  1653.    
  1654.    
  1655.    /* 参数过滤 */
  1656.    if(r==0) return; // 半径为0则直接退出
  1657.    if(stangle==endangle) return; // 起始角度与终止角度相同，退出
  1658.    if( (stangle>=360) || (endangle>=360) ) return;
  1660.    op_2rr = 2*r*r; // 计算r平方乖以2
  1661.    pno_angle = 0;
  1662.    /* 先计算出在此半径下的45度的圆弧的点数 */       
  1663.    op_x = r;
  1664.    op_y = 0;
  1665.    while(1)
  1666.    {  pno_angle++;  // 画点计数         
  1667.       /* 计算下一点 */
  1668.       op_y++;
  1669.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1670.       {  op_x--;
  1671.       }
  1672.       if(op_y>=op_x) break;
  1673.    }
  1674.    
  1675.    draw_on = 0; // 最开始关画点开关
  1676.    /* 设置起始点及终点 */
  1677.    if(endangle>stangle) draw_on = 1; // 若终点大于起点，则从一开始即画点(359)
  1678.    stangle = (360-stangle)*pno_angle/45;
  1679.    endangle = (360-endangle)*pno_angle/45;
  1680.    if(stangle==0) stangle=1;
  1681.    if(endangle==0) endangle=1;
  1682.    
  1683.    /* 开始顺时针画弧，从359度开始(第4像限) */
  1684.    pno_angle = 0;
  1685.    
  1686.    draw_x = x+r;
  1687.    draw_y = y;         
  1688.    op_x = r;
  1689.    op_y = 0;
  1690.    while(1)
  1691.    {  /* 计算下一点 */
  1692.       op_y++;
  1693.       draw_y--;
  1694.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1695.       {  op_x--;
  1696.          draw_x--;
  1697.       }
  1698.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1699.       pno_angle++;
  1700.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1701.       {  draw_on = 1-draw_on;
  1702.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1703.          GUI_Line(x, y, draw_x, draw_y, color);
  1704.       } 
  1705.       if(op_y>=op_x)
  1706.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1707.          break;
  1708.       }
  1709.    }
  1710.    
  1711.    while(1)
  1712.    {  /* 计算下一点 */
  1713.       op_x--;
  1714.       draw_x--;
  1715.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 ) // 使用逐点比较法实现画圆弧
  1716.       {  op_y++;
  1717.          draw_y--;
  1718.       }
  1719.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1720.       pno_angle++;
  1721.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1722.       {  draw_on = 1-draw_on;
  1723.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1724.          GUI_Line(x, y, draw_x, draw_y, color);
  1725.       } 
  1726.       
  1727.       if(op_x<=0)
  1728.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1729.          break;
  1730.       }
  1731.    }
  1732.     
  1733.     
  1734.    /* 开始顺时针画弧，从269度开始(第3像限) */
  1735.    draw_y = y-r;
  1736.    draw_x = x;         
  1737.    op_y = r;
  1738.    op_x = 0;
  1739.    while(1)
  1740.    {  /* 计算下一点 */
  1741.       op_x++;
  1742.       draw_x--;
  1743.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_y +1)>0 ) // 使用逐点比较法实现画圆弧
  1744.       {  op_y--;
  1745.          draw_y++;
  1746.       }
  1747.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1748.       pno_angle++;
  1749.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1750.       {  draw_on = 1-draw_on;
  1751.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1752.          GUI_Line(x, y, draw_x, draw_y, color);
  1753.       } 
  1754.       
  1755.       if(op_x>=op_y)
  1756.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1757.          break;
  1758.       }
  1759.    }
  1760.    
  1761.    while(1)
  1762.    {  /* 计算下一点 */
  1763.       op_y--;
  1764.       draw_y++;
  1765.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_x +1)<=0 ) // 使用逐点比较法实现画圆弧
  1766.       {  op_x++;
  1767.          draw_x--;
  1768.       }
  1769.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1770.       pno_angle++;
  1771.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1772.       {  draw_on = 1-draw_on;
  1773.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1774.          GUI_Line(x, y, draw_x, draw_y, color);
  1775.       } 
  1776.       if(op_y<=0)
  1777.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1778.          break;
  1779.       }
  1780.    }
  1781.    
  1782.    
  1783.    /* 开始顺时针画弧，从179度开始(第2像限) */
  1784.    draw_x = x-r;
  1785.    draw_y = y;         
  1786.    op_x = r;
  1787.    op_y = 0;
  1788.    while(1)
  1789.    {  /* 计算下一点 */
  1790.       op_y++;
  1791.       draw_y++;
  1792.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_x +1)>0 )  // 使用逐点比较法实现画圆弧
  1793.       {  op_x--;
  1794.          draw_x++;
  1795.       }
  1796.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1797.       pno_angle++;
  1798.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1799.       {  draw_on = 1-draw_on;
  1800.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1801.          GUI_Line(x, y, draw_x, draw_y, color);
  1802.       } 
  1803.       if(op_y>=op_x)
  1804.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1805.          break;
  1806.       }
  1807.    }
  1808.    
  1809.    while(1)
  1810.    {  /* 计算下一点 */
  1811.       op_x--;
  1812.       draw_x++;
  1813.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_y +1)<=0 ) // 使用逐点比较法实现画圆弧
  1814.       {  op_y++;
  1815.          draw_y++;
  1816.       }
  1817.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1818.       pno_angle++;
  1819.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1820.       {  draw_on = 1-draw_on;
  1821.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1822.          GUI_Line(x, y, draw_x, draw_y, color);
  1823.       } 
  1824.       
  1825.       if(op_x<=0)
  1826.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1827.          break;
  1828.       }
  1829.    }
  1830.   
  1831.   
  1832.    /* 开始顺时针画弧，从89度开始(第1像限) */
  1833.    draw_y = y+r;
  1834.    draw_x = x;         
  1835.    op_y = r;
  1836.    op_x = 0;
  1837.    while(1)
  1838.    {  /* 计算下一点 */
  1839.       op_x++;
  1840.       draw_x++;
  1841.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr - 2*op_y +1)>0 ) // 使用逐点比较法实现画圆弧
  1842.       {  op_y--;
  1843.          draw_y--;
  1844.       }
  1845.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1846.       pno_angle++;
  1847.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1848.       {  draw_on = 1-draw_on;
  1849.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1850.          GUI_Line(x, y, draw_x, draw_y, color);
  1851.       } 
  1852.       
  1853.       if(op_x>=op_y)
  1854.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1855.          break;
  1856.       }
  1857.    }
  1858.    
  1859.    while(1)
  1860.    {  /* 计算下一点 */
  1861.       op_y--;
  1862.       draw_y--;
  1863.       if( (2*op_x*op_x + 2*op_y*op_y - op_2rr + 2*op_x +1)<=0 ) // 使用逐点比较法实现画圆弧
  1864.       {  op_x++;
  1865.          draw_x++;
  1866.       }
  1867.       if(draw_on==1) GUI_Point(draw_x, draw_y, color); // 开始画图
  1868.       pno_angle++;
  1869.       if( (pno_angle==stangle)||(pno_angle==endangle) ) // 若遇到起点或终点，画点开关取反
  1870.       {  draw_on = 1-draw_on;
  1871.          if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1872.          GUI_Line(x, y, draw_x, draw_y, color);
  1873.       } 
  1874.       if(op_y<=0)
  1875.       {  if(draw_on==1) GUI_Point(draw_x, draw_y, color);
  1876.          break;
  1877.       }
  1878.    }
  1879.    
  1880. }
  1881. #endif