asclass AbstractTickerPainter extends ScaledDiagram is G2Drawable, MakesBufferedImage {

  settable TickerSequence ticker;

  // the following two are old, use priceCells instead

  settable double percentLineDistance;

  settable bool drawPercentLines;

  settable PriceCells priceCells;

  settable Color percentStripesColor = Color.darkGray;

  new L<TradingPosition> positions;

  new L<G2Drawable> additionalObjects;

  public BufferedImage render aka getBufferedImage() {

    // Make black image

    var img = blackImage(w, h);

    var g = img.createGraphics();

    drawOn(g);

    ret img;

  }

  void drawPercentLines(Graphics2D g) {

    if (priceCells != null) {

      int cellNumber = ifloor(priceCells.toCellNumber(verticalRange.end));

      int safety = 250;

      while (safety-- > 0) {

        double y2 = priceCells.fromCellNumber(cellNumber-1);

        if (y2 < verticalRange.start) break;

        double y = priceCells.fromCellNumber(cellNumber);

        var yy = iround(yToScreen(y));

        var yy2 = iround(yToScreen(y2));

        //drawLine(g, 0, yy, w-1, yy, Color.gray);

        fillRect(g, 0, yy, w-1, yy2-yy, percentStripesColor);

        cellNumber -= 2;

      }

    }

  }

  void drawPositions(Graphics2D g) {

    for (position : positions) {

      var time = position.openingTime();

      var price = position.openingPrice();

      var x = xToScreen(time);

      var y = yToScreen(price);

      var color = colorForPosition(position);

      // Mark opening point

      fillRect(g, rectAroundPt(iround(x), iround(y), 10), color);

      if (not(position.isOpen())) {

        time = position.closingTime();

        price = position.closingPrice();

        var x2 = xToScreen(time);

        var y2 = yToScreen(price);

        drawArrowBetweenPoints(g, toPt_round(doublePt(x, y)), toPt_round(doublePt(x2, y2)), color);

      }

    }

  }

  void drawAdditionalObjects(Graphics2D g) {

    for (o : additionalObjects) pcall {

      o.drawOn(g);

    }

  }

  void addVerticalLine(double x, Color color default Color.gray) {

    additionalObjects.add(g -> drawVerticalLine(g, x, color));

  }

  void add(G2Drawable object) {

    addIfNotNull(additionalObjects, object);

  }

  void drawVerticalLine(Graphics2D g, double x, Color color default Color.gray) {

    int xScreen = iround(xToScreen(x));

    drawLine(g, xScreen, 0, xScreen, h-1, color);

  }

  void addHorizontalLine(double y, Color color default Color.gray) {

    additionalObjects.add(g -> drawHorizontalLine(g, y, color));

  }

  void drawHorizontalLine(Graphics2D g, double y, Color color default Color.gray) {

    int yScreen = iround(yToScreen(y));

    drawLine(g, 0, yScreen, w-1, yScreen, color);

  }

  DoubleRange horizontalRangeForTicker(TickerSequence ticker) {

    var timeRange = ticker.timeRange();

    if (timeRange == null) null;

    ret doubleRange(timeRange.startTime().unixDate(), timeRange.endTime().unixDate());

  }

  DoubleRange verticalRangeForTicker(TickerSequence ticker) {

    ret doubleRange(ticker.minPrice(), ticker.maxPrice());

  }

  void addTimeGrid(double minutes) {

    additionalObjects.add(g -> drawTimeGrid(g, minutes));

  }

  void drawTimeGrid(Graphics2D g, double minutes) {

    double ms = minutesToMS(minutes);

    assertTrue(ms >= 100);

    double time = roundUpTo(ms, horizontalRange().start);

    while (time < horizontalRange().end) {

      drawVerticalLine(g, time);

      time += ms;

    }

  }

  class LineIndicator is G2Drawable {

    settable TickerSequence values;

    settable Color color = Color.yellow;

    *() {}

    *(TickerSequence *values) {}

    *(TickerSequence *values, Color *color) {}

    public void drawOn(Graphics2D g) {

      g.setColor(color);

      var xRange = roundToIntRange(xRange());

      var sub = values.subSequenceByTimestamps(

        lround(xFromScreen(xRange.start)),

        lround(xFromScreen(xRange.end)));

      int lastx = 0, lasty = 0;

      for (int i = 0; i < sub.size(); i++) {

        double price = sub.getPrice(i);

        long time = sub.getTimestamp(i);

        int x = iround(xToScreen(time));

        int y = iround(yToScreen(price));

        if (i != 0)

          g.drawLine(lastx, lasty, x, y);

        lastx = x;

        lasty = y;

      }

    }

  }

  selfType priceCells aka cellSize(double cellSize) {

    ret priceCells(new GeometricPriceCells(cellSize));

  }

  swappable Color colorForPosition(TradingPosition position) {

    bool winner = position.isWinner();

    //bool green = position.isLong();

    //var color = colorFromHex(green ? "1da2b4" : "f1493f");

    ret winner

      ? directionToCandleColor(position.direction())

      : position.isLong() ? Color.yellow : Color.blue;

  }

}