draw method

dynamic draw(dynamic kx, dynamic ky, dynamic kw, dynamic kh, dynamic lineType, dynamic draw, dynamic pro,)

Implementation

draw(kx, ky, kw, kh, lineType, draw, pro) {
  num x1 = 0, y1 = 0, x2 = 0, y2 = 0, x3 = 0, y3 = 0, y4 = 0, k = 0, b = 0;
  var circleR = style['drawLineStyle']['property']['circleR'];
  var linePath = [];
  var fillPath = [];
  var circlePath = [];
  var txtPath = [];
  var reactPath = [];
  var startPoint = {'x': 0 as num, 'y': 0 as num};
  var stopPoint = {'x': 0 as num, 'y': 0 as num};
  var firstPoint = {};
  var point = draw['p'];
  if (lineType == Line['ZX']) {
    if (point.length >= 2) {
      //鼠标点
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);
      //原始开始结束点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};
      //绘画开始结束点
      k = (y2 - y1) / (x2 - x1);
      b = y1 - k * x1;
      startPoint['x'] = kx;
      startPoint['y'] = k * startPoint['x']! + b;
      stopPoint['x'] = kx + kw;
      stopPoint['y'] = k * stopPoint['x']! + b;
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['SPZX']) {
    if (point.length >= 1) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      //绘制点
      startPoint = {'x': kx, 'y': y1};
      stopPoint = {'x': kx + kw, 'y': y1};
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.add([
          "drawCircle",
          [x1, y1, circleR]
        ]);
      }
    }
  } else if (lineType == Line['CZZX']) {
    if (point.length >= 1) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      //绘制点
      startPoint = {'x': x1, 'y': 0};
      stopPoint = {'x': x1, 'y': ky + kh};
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.add([
          "drawCircle",
          [x1, y1, circleR]
        ]);
      }
    }
  } else if (lineType == Line['XD']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};
      //根据鼠标点计算直线方程所需参数
      callKb(x1, y1, x2, y2, draw);
      //根据参数计算绘制点
      startPoint = {'x': x1, 'y': y1};
      stopPoint = {'x': x2, 'y': y2};
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['JT']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};
      //根据鼠标点计算直线方程所需参数
      callKb(x1, y1, x2, y2, draw);
      //根据参数计算绘制点
      startPoint = {'x': x1, 'y': y1};
      stopPoint = {'x': x2, 'y': y2};
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      arow([startPoint['x'], startPoint['y']],
          [stopPoint['x'], stopPoint['y']], 9, 5, linePath);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['SPXD']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = y1;
      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};
      //根据鼠标点计算直线方程所需参数
      callKb(x1, y1, x2, y2, draw);
      //根据参数计算绘制点
      startPoint = {'x': x1, 'y': y1};
      stopPoint = {'x': x2, 'y': y2 + 0.5};
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['SX']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};
      //根据鼠标点计算直线方程所需参数
      k = (y2 - y1) / (x2 - x1);
      //第一根线 两个点
      b = y1 - k * x1;
      if (x2 > x1) {
        startPoint['x'] = x1;
        startPoint['y'] = y1;
        stopPoint['x'] = kx + kw;
        stopPoint['y'] = k * stopPoint['x']! + b;
      } else {
        startPoint['x'] = kx;
        startPoint['y'] = k * startPoint['x']! + b;
        stopPoint['x'] = x1;
        stopPoint['y'] = y1;
      }
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
        draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['SPSX']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = y1;
      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};

      if (x2 > x1) {
        //根据参数计算绘制点
        startPoint = {'x': x1, 'y': y1};
        stopPoint = {'x': kx + kw, 'y': y2 + 0.5};
      } else {
        //根据参数计算绘制点
        startPoint = {'x': kx, 'y': y2 + 0.5};
        stopPoint = {'x': x1, 'y': y1};
      }

      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['JGX']) {
    //价格线 跟水平射线一样  只是多了价格  斐波那契可以理解为多跟价格线 将区间y分成几份
    if (point.length >= 1) {
      //x1 直接采用点击时的屏幕x坐标(通过xxbfb * _kw反推出来，这样屏幕尺寸发生改变后，x1也会在正确的位置)，不在和k线挂钩，这样k线移动不受影响，线始终以点击时坐标为基准布局。但是y轴随之变化
      x1 = kx +
          (point[0]['xxbfb'] * kw)
              .floor(); //(point[0]['x']-pro.kStartI)*(pro.kW+pro.kGap)+point[0]['xp']+pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};

      //根据参数计算绘制点
      startPoint = {'x': x1, 'y': y1};
      stopPoint = {'x': x1 + kw, 'y': y1};
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      txtPath.add(
          [point[0]['y'], x1 + 5, y1 + 5, config[Line['JGX']]['txtStyle']]);

      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.add([
          "drawCircle",
          [x1, y1, circleR]
        ]);
      }

    }
  } else if (lineType == Line['SJ']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);
      linePath.addAll([
        [
          "moveTo",
          [x1, y1]
        ],
        [
          "lineTo",
          [x2, y2]
        ]
      ]);
      if (point.length >= 3) {
        x3 = kx +
            (point[2]['x'] - pro.kStartI) * pro.kWG +
            point[2]['xp'] +
            pro.kStartX;
        y3 = ky +
            Tools.priceToY(pro.kYh, point[2]['y'], pro.kYMin, pro.kScale);
        linePath.addAll([
          [
            "lineTo",
            [x3, y3]
          ],
          [
            "lineTo",
            [x1, y1]
          ]
        ]);
      }
      fillPath = linePath;
      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['secondPoint'] = {'x': x2, 'y': y2};
      draw['stopPoint'] = {'x': x3, 'y': y3};

      if ((draw['selected'] != null && draw['selected'] ||
              draw['highlight'] != null && draw['highlight']) &&
          point.length >= 3) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ],
          [
            "drawCircle",
            [x3, y3, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['JX']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * (pro.kWG) +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * (pro.kWG) +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);
      // print('x1 ${x1} x2 ${x2}.  kx ${kx}. kStartI${pro.kStartI}. pro.kWG ${pro.kWG}. point ${point}');
      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};
      reactPath.add([
        "drawRect",
        [
          (x2 < x1 ? x1 - (x2 - x1).abs() : x1),
          (y2 < y1 ? y1 - (y2 - y1).abs() : y1),
          (x2 - x1).abs(),
          (y2 - y1).abs(),
        ]
      ]);
      fillPath = reactPath;
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }
    }
  } else if (lineType == Line['PXSX']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      k = (y2 - y1) / (x2 - x1);
      //第一根线 两个点
      b = y1 - k * x1;
      if (x2 > x1) {
        startPoint['x'] = x1;
        startPoint['y'] = y1;
        stopPoint['x'] = kx + kw;
        stopPoint['y'] = k * stopPoint['x']! + b;
      } else {
        startPoint['x'] = kx;
        startPoint['y'] = k * startPoint['x']! + b;
        stopPoint['x'] = x1;
        stopPoint['y'] = y1;
      }
      firstPoint = startPoint;
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      fillPath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (point.length >= 3) {
        //第三个点 产生另外一条线
        //第二根线 一个点 从新计算b 斜率相同
        x3 = kx +
            (point[2]['x'] - pro.kStartI) * pro.kWG +
            point[2]['xp'] +
            pro.kStartX;
        y3 = ky +
            Tools.priceToY(pro.kYh, point[2]['y'], pro.kYMin, pro.kScale);
        b = y3 - k * x3;
        if (x2 > x1) {
          startPoint['x'] = x3;
          startPoint['y'] = y3;
          stopPoint['x'] = kx + kw;
          stopPoint['y'] = k * stopPoint['x']! + b;
        } else {
          startPoint['x'] = kx;
          startPoint['y'] = k * startPoint['x']! + b;
          stopPoint['x'] = x3;
          stopPoint['y'] = y3;
        }
        linePath.addAll([
          [
            "moveTo",
            [startPoint['x'], startPoint['y']]
          ],
          [
            "lineTo",
            [stopPoint['x'], stopPoint['y']]
          ]
        ]);

        fillPath.addAll([
          [
            "lineTo",
            [stopPoint['x'], stopPoint['y']]
          ],
          [
            "lineTo",
            [startPoint['x'], startPoint['y']]
          ],[
            "lineTo",
            [firstPoint['x'], firstPoint['y']]
          ],
        ]);
      }

      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['secondPoint'] = {'x': x2, 'y': y2};
      draw['stopPoint'] = {'x': x3, 'y': y3};

      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
        if (point.length >= 3) {
          //第三个点 产生另外一条线
          //第二根线 一个点 从新计算b 斜率相同
          circlePath.add([
            "drawCircle",
            [x3, y3, circleR]
          ]);
        }
      }
    }
  } else if (lineType == Line['PXZX']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);
      k = (y2 - y1) / (x2 - x1);
      //第一根线 两个点
      b = y1 - k * x1;
      startPoint['x'] = kx;
      startPoint['y'] = k * startPoint['x']! + b;
      stopPoint['x'] = kx + kw;
      stopPoint['y'] = k * stopPoint['x']! + b;
      firstPoint = startPoint;

      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      fillPath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      //第二根线 一个点 从新计算b 斜率相同
      if (point.length >= 3) {
        //第三个点 产生另外一条线
        x3 = kx +
            (point[2]['x'] - pro.kStartI) * pro.kWG +
            point[2]['xp'] +
            pro.kStartX;
        y3 = ky +
            Tools.priceToY(pro.kYh, point[2]['y'], pro.kYMin, pro.kScale);
        b = y3 - k * x3;
        startPoint['x'] = kx;
        startPoint['y'] = k * startPoint['x']! + b;
        stopPoint['x'] = kx + kw;
        stopPoint['y'] = k * stopPoint['x']! + b;
        linePath.addAll([
          [
            "moveTo",
            [startPoint['x'], startPoint['y']]
          ],
          [
            "lineTo",
            [stopPoint['x'], stopPoint['y']]
          ]
        ]);
        fillPath.addAll([
          [
            "lineTo",
            [stopPoint['x'], stopPoint['y']]
          ],
          [
            "lineTo",
            [startPoint['x'], startPoint['y']]
          ],[
            "lineTo",
            [firstPoint['x'], firstPoint['y']]
          ],
        ]);
      }

      //原始点
      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['secondPoint'] = {'x': x2, 'y': y2};
      draw['stopPoint'] = {'x': x3, 'y': y3};

      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
        //第二根线 一个点 从新计算b 斜率相同
        if (point.length >= 3) {
          //第三个点 产生另外一条线
          circlePath.add([
            "drawCircle",
            [x3, y3, circleR]
          ]);
        }
      }
    }
  } else if (lineType == Line['TDX']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      if (x1 == x2) {
        //竖向通道线
        startPoint['x'] = x1;
        startPoint['y'] = ky;
        stopPoint['x'] = x2;
        stopPoint['y'] = ky + kh;
      } else if (y1 == y2) {
        //横向通道线
        startPoint['x'] = kx;
        startPoint['y'] = y1;
        stopPoint['x'] = kx + kw;
        stopPoint['y'] = y2;
      } else {
        k = (y2 - y1) / (x2 - x1);
        b = y1 - k * x1;
        startPoint['x'] = kx;
        startPoint['y'] = k * startPoint['x']! + b;
        stopPoint['x'] = kx + kw;
        stopPoint['y'] = k * stopPoint['x']! + b;
      }
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (point.length >= 3) {
        x3 = kx +
            (point[2]['x'] - pro.kStartI) * pro.kWG +
            point[2]['xp'] +
            pro.kStartX;
        y3 = ky +
            Tools.priceToY(pro.kYh, point[2]['y'], pro.kYMin, pro.kScale);

        if (x1 == x2) {
          //竖向通道线
          startPoint['x'] = x1 - (x3 - x1).abs();
          startPoint['y'] = ky;
          stopPoint['x'] = x1 - (x3 - x1).abs();
          stopPoint['y'] = ky + kh;
          linePath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          firstPoint = startPoint;
          fillPath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          startPoint['x'] = x1 + (x3 - x1).abs();
          startPoint['y'] = ky;
          stopPoint['x'] = x1 + (x3 - x1).abs();
          stopPoint['y'] = ky + kh;
          linePath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          fillPath.addAll([
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ],
            [
              "lineTo",
              [startPoint['x'], startPoint['y']]
            ],[
              "lineTo",
              [firstPoint['x'], firstPoint['y']]
            ],
          ]);
        } else if (y1 == y2) {
          //横向通道线
          startPoint['x'] = kx;
          startPoint['y'] = y1 - (y3 - y1).abs();
          stopPoint['x'] = kx + kw;
          stopPoint['y'] = y1 - (y3 - y1).abs();
          linePath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          firstPoint = startPoint;
          fillPath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          startPoint['x'] = kx;
          startPoint['y'] = y1 + (y3 - y1).abs();
          stopPoint['x'] = kx + kw;
          stopPoint['y'] = y1 + (y3 - y1).abs();
          linePath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          fillPath.addAll([
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ],
            [
              "lineTo",
              [startPoint['x'], startPoint['y']]
            ],[
              "lineTo",
              [firstPoint['x'], firstPoint['y']]
            ],
          ]);
        } else {
          var p1 = k * x3 + b;
          y4 = p1 - (y3 - p1);
          b = y3 - k * x3;
          startPoint['x'] = kx;
          startPoint['y'] = k * startPoint['x']! + b;
          stopPoint['x'] = kx + kw;
          stopPoint['y'] = k * stopPoint['x']! + b;
          linePath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          firstPoint = startPoint;
          fillPath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          b = y4 - k * x3;
          startPoint['x'] = kx;
          startPoint['y'] = k * startPoint['x']! + b;
          stopPoint['x'] = kx + kw;
          stopPoint['y'] = k * stopPoint['x']! + b;
          linePath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          fillPath.addAll([
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ],
            [
              "lineTo",
              [startPoint['x'], startPoint['y']]
            ],[
              "lineTo",
              [firstPoint['x'], firstPoint['y']]
            ],
          ]);

        }
      }

      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['secondPoint'] = {'x': x2, 'y': y2};
      draw['stopPoint'] = {'x': x3, 'y': y3};

      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
        if (point.length >= 3) {
          circlePath.add([
            "drawCircle",
            [x3, y3, circleR]
          ]);
        }
      }
    }
  } else if (lineType == Line['FBNQ']) {
    if (point.length >= 2) {
      x1 = kx + (point[0]['xxbfb'] * kw).floor();
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = x1;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};

      var jg = (point[0]['y'] - point[1]['y']).abs();
      if (jg > 0) {
        var dic = y2 < y1 ? 1 : -1; // -1 向上画线 1向下画线
        dynamic fbnqp, fbnqy;
        dic *= 1; //Tools.YDIC;

        for (var i = 0, il = FBNQP.length; i < il; i++) {
          fbnqp = point[1]['y'] - dic * jg * FBNQP[i];
          fbnqp = Tools.toFixed(
              fbnqp, klineState.widget.propertys['priceDigits']);

          fbnqy = ky +
              Tools.priceToY(
                  pro.kYh, num.parse(fbnqp), pro.kYMin, pro.kScale);

          linePath.addAll([
            [
              "moveTo",
              [x1, fbnqy]
            ],
            [
              "lineTo",
              [x1 + kw, fbnqy]
            ]
          ]);
          if(i == 0){
            firstPoint = {'x':x1,'y':fbnqy};
            fillPath.addAll([
              [
                "moveTo",
                [x1, fbnqy]
              ],
              [
                "lineTo",
                [x1 + kw, fbnqy]
              ]
            ]);
          }else if(i == il-1){
            fillPath.addAll([
              [
                "lineTo",
                [x1 + kw, fbnqy]
              ],
              [
                "lineTo",
                [x1, fbnqy]
              ],
              [
                "lineTo",
                [firstPoint['x'], firstPoint['y']]
              ]
            ]);
          }
          txtPath.add([
            '${Tools.toFixed(FBNQP[i] * 100, 1)}%   $fbnqp',
            x1,
            fbnqy + 5,
            config[Line['FBNQ']]['txtStyle']
          ]); //
        }
      }

      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.add([
          "drawCircle",
          [x2, y2, circleR]
        ]);
      }
    }
  } else if (lineType == Line['FBNQSX']) {
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};

      k = (y2 - y1) / (x2 - x1);
      //第一根线 两个点
      b = y1 - k * x1;
      if (x2 > x1) {
        startPoint['x'] = x1;
        startPoint['y'] = y1;
        stopPoint['x'] = kx + kw;
        stopPoint['y'] = k * stopPoint['x']! + b;
      } else {
        startPoint['x'] = kx;
        startPoint['y'] = k * startPoint['x']! + b;
        stopPoint['x'] = x1;
        stopPoint['y'] = y1;
      }

      firstPoint = startPoint;
      linePath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      fillPath.addAll([
        [
          "moveTo",
          [startPoint['x'], startPoint['y']]
        ],
        [
          "lineTo",
          [stopPoint['x'], stopPoint['y']]
        ]
      ]);
      if (draw['selected'] != null && draw['selected'] ||
          draw['highlight'] != null && draw['highlight']) {
        circlePath.addAll([
          [
            "drawCircle",
            [x1, y1, circleR]
          ],
          [
            "drawCircle",
            [x2, y2, circleR]
          ]
        ]);
      }

      //其余三根线
      var jg = (point[0]['y'] - point[1]['y']).abs();
      if (jg > 0) {
        var dic = y2 < y1 ? 1 : -1; // -1 向上画线 1向下画线
        dynamic p;
        dic *= 1; //Tools.YDIC;
        var drawp = {};
        for (var i = 0, il = FBNQSXP.length; i < il; i++) {
          //计算y2
          p = (point[1]['y']) - dic * jg * FBNQSXP[i];
          p = Tools.toFixed(p, klineState.widget.propertys['priceDigits']);
          y2 = ky +
              Tools.priceToY(pro.kYh, num.parse(p), pro.kYMin, pro.kScale);
          drawp['startPoint'] = {'x': x1, 'y': y1};
          drawp['stopPoint'] = {'x': x2, 'y': y2};

          //用来计算是否在此条线上用的
          draw["sxPoint$i"] = {'x': x2, 'y': y2};
          k = (y2 - y1) / (x2 - x1);
          //第一根线 两个点
          b = y1 - k * x1;
          if (x2 > x1) {
            startPoint['x'] = x1;
            startPoint['y'] = y1;
            stopPoint['x'] = kx + kw;
            stopPoint['y'] = k * stopPoint['x']! + b;
          } else {
            startPoint['x'] = kx;
            startPoint['y'] = k * startPoint['x']! + b;
            stopPoint['x'] = x1;
            stopPoint['y'] = y1;
          }

          linePath.addAll([
            [
              "moveTo",
              [startPoint['x'], startPoint['y']]
            ],
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ]
          ]);
          txtPath.add([
            '${Tools.toFixed(FBNQSXP[i] * 100, 1)}%   $p',
            x2,
            y2,
            config[Line['FBNQSX']]['txtStyle']
          ]); //

          if(i == il-1){
            fillPath.addAll([
            [
              "lineTo",
              [stopPoint['x'], stopPoint['y']]
            ],
            [
              "lineTo",
              [startPoint['x'], startPoint['y']]
            ],[
              "lineTo",
              [firstPoint['x'], firstPoint['y']]
            ],
          ]);
          }
        }
      }
    }
  } else if (lineType == Line['CL']) {
    //退出画线时，需要移出lineName 是 Line['CL'] 的 测量线路径
    if (point.length >= 2) {
      x1 = kx +
          (point[0]['x'] - pro.kStartI) * pro.kWG +
          point[0]['xp'] +
          pro.kStartX;
      y1 = ky + Tools.priceToY(pro.kYh, point[0]['y'], pro.kYMin, pro.kScale);
      x2 = kx +
          (point[1]['x'] - pro.kStartI) * pro.kWG +
          point[1]['xp'] +
          pro.kStartX;
      y2 = ky + Tools.priceToY(pro.kYh, point[1]['y'], pro.kYMin, pro.kScale);

      draw['startPoint'] = {'x': x1, 'y': y1};
      draw['stopPoint'] = {'x': x2, 'y': y2};

      var knum = point[1]['x'] - point[0]['x'];
      var interval = klineState.widget.propertys['interval'];
      var ktime = Tools.getClStr(interval, knum);
      var pcha = Tools.floatSub(point[1]['y'], point[0]['y']);
      var showstr =
          '${klineState.widget.propertys['i18n']['cltip'].replaceAll("v1", knum.toString())}  $ktime  $pcha';
      var ktimesize = Tools.getStrW(showstr, style['drawLineStyle']['font']);
      reactPath.add([
        "drawRect",
        [
          (x2 < x1 ? x1 - (x2 - x1).abs() : x1),
          (y2 < y1 ? y1 - (y2 - y1).abs() : y1),
          (x2 - x1).abs(),
          (y2 - y1).abs(),
        ]
      ]);
      txtPath.add([
        showstr,
        x1 + (x2 - x1) / 2 - ktimesize['width'] / 2,
        y1 + (y2 - y1 - ktimesize['height']) / 2,
        config[Line['CL']]['txtStyle']
      ]);
    }
  }

  return {
    'style': draw['style'],
    'linePath': linePath,
    'txtPath': txtPath,
    'reactPath': reactPath,
    'fillPath':fillPath,
    'circlePath': circlePath,

  };
}