candlePath method

dynamic candlePath(dynamic x, dynamic y, dynamic w, dynamic h,)

Implementation

candlePath(x, y, w, h) {
  var pathData = {};
  var downData = [], upData = [], zxData = [], fillData = [];
  // var lastDownData = [], lastUpData = [], lastZxData = [], lastFillData = [];
  int i = 0, j = 0,newkStartI = 0, newkStopI = 0;
  double och = 1.0,
      cy = 0.0,
      oy = 0.0,
      hy = 0.0,
      ly = 0.0,
      lx = 0.0,
      firstlx = 0.0,
      firstcy = 0.0,
      fillh = 0.0;
  var itemKData = {};
  double leftW = 0.0;
  newkStopI = kStopI;
  var curDownData = [], curUpData = [];
  isZx = klineState.widget.propertys['interval'] == 'fs';
  if (!isZx) {
    for (i = kStartI; i < newkStopI; i++) {
      // if (newkStopI == chartData.kDataL && i == newkStopI - 1) {
      //   curDownData = lastDownData;
      //   curUpData = lastUpData;
      // } else {
        curDownData = downData;
        curUpData = upData;
      // }
      itemKData = chartData.klineData[i];
      j = i - kStartI;
      hy = Tools.priceToY(h, itemKData['high'], kYMin, kScale);
      ly = Tools.priceToY(h, itemKData['low'], kYMin, kScale);
      oy = Tools.priceToY(h, itemKData['open'], kYMin, kScale);
      cy = Tools.priceToY(h, itemKData['close'], kYMin, kScale);
      lx = (x + kStartX + j * kWG + kGap + kW / 2);//.floor();
      och = (oy - cy).abs();
      och = Tools.max(1.0, och);
      double rx = (x + kStartX + j * kWG + kGap);//.floor();
      double ry = 0;
      if (itemKData['close'] < itemKData['open']) {
        ry = y + oy;
        if (kW > 1) {
          curDownData.addAll([
            [
              "drawRect",
              [rx, ry, kW, och]
            ],
            [
              "moveTo",
              [lx, y + hy]
            ],
            [
              "lineTo",
              [lx, y + oy]
            ],
            [
              "moveTo",
              [lx, y + ly]
            ],
            [
              "lineTo",
              [lx, y + cy]
            ]
          ]);
        } else {
          curDownData.addAll([
            [
              "moveTo",
              [lx, y + hy]
            ],
            [
              "lineTo",
              [lx, y + ly]
            ]
          ]);
        }
      } else {
        ry = y + cy;
        if (kW > 1) {
          curUpData.addAll([
            [
              "drawRect",
              [rx, ry, kW, och]
            ],
            [
              "moveTo",
              [lx, y + hy]
            ],
            [
              "lineTo",
              [lx, y + cy]
            ],
            [
              "moveTo",
              [lx, y + ly]
            ],
            [
              "lineTo",
              [lx, y + oy]
            ]
          ]);
        } else {
          curUpData.addAll([
            [
              "moveTo",
              [lx, y + hy]
            ],
            [
              "lineTo",
              [lx, y + ly]
            ]
          ]);
        }
      }
    }
    pathData = {
      'isZx': false,
      'candleFillType': candleFillType,
      'downData': downData,
      // 'lastDownData': lastDownData,
      'upData': upData,
      // 'lastUpData': lastUpData
    };
  } else {
    newkStartI = kStartI - 1 < 0 ? kStartI : kStartI - 1;
    newkStopI = kStopI + 1 > chartData.kDataL ? chartData.kDataL : kStopI + 1;
    if (newkStartI == kStartI - 1) {
      leftW = kWG;
    } else {
      leftW = 0;
    }
    double lastLx1 = 0;
    // double lastLy1 = 0;
    for (i = newkStartI; i < newkStopI; i++) {
      itemKData = chartData.klineData[i];
      j = i - newkStartI;
      cy = Tools.priceToY(h, itemKData['close'], kYMin, kScale);
      lx = (x + kStartX + j * kWG + kGap + kW / 2) - leftW; //.floor()
      fillh = y + cy > y + h ? y + h : y + cy;
      if (i == newkStartI) {
        //起始点
        firstlx = Tools.max(lx, 0.0);
        firstcy = cy;
        //边线
        zxData.add([
          "moveTo",
          [lx, fillh]
        ]);
        //填充
        fillData.add([
          "moveTo",
          [firstlx, fillh]
        ]);
      } else {
        // if (newkStopI == chartData.kDataL && i == newkStopI - 1) {
        //   lastZxData.add(["moveTo", zxData[zxData.length - 1][1]]);
        //   lastZxData.add([
        //     "lineTo",
        //     [lx, fillh]
        //   ]);
        //   lastFillData.add(["moveTo", fillData[fillData.length - 1][1]]);
        //   lastFillData.add([
        //     "lineTo",
        //     [lx, fillh]
        //   ]);
        // } else {
          //左边部分最后一个点
          lastLx1 = lx;
          // lastLy1 = fillh;
          //边线
          zxData.add([
            "lineTo",
            [lx, fillh]
          ]);
          //填充
          fillData.add([
            "lineTo",
            [lx, fillh]
          ]);
        // }
      }
    }
    //填充封闭
    fillData.addAll([
      [
        "lineTo", //右竖线
        [lastLx1, y + h]
      ],
      [
        "lineTo", //下横线
        [firstlx, y + h]
      ],
      [
        "lineTo", //左竖线
        [firstlx, y + firstcy]
      ]
    ]);
    // lastFillData.addAll([
    //   [
    //     "lineTo", //右竖线
    //     [lx, y + h]
    //   ],
    //   [
    //     "lineTo", //下横线
    //     [lastLx1, y + h]
    //   ],
    //   [
    //     "lineTo", //左竖线
    //     [lastLx1, y + lastLy1]
    //   ]
    // ]);
    pathData = {
      'isZx': true,
      'zxData': zxData,
      // 'lastZxData': lastZxData,
      'zxFill': zxFill,
      'fillData': fillData,
      // 'lastFillData': lastFillData,
      'gradientSize': [0.0, 0.0, lastLx1, h],
      'lastgradientSize': [0.0, 0.0, w - lastLx1, h]
    };
  }
  return pathData;
}