react-native-vroom-chart 0.1.0

package/cpp/_core_src/crosshair.h

@@ -0,0 +1,32 @@
+// Crosshair drawing — two perpendicular dashed lines with a hollow ring at
+// their intersection, kept in its own module alongside candles / labels so the
+// chart orchestrator stays thin.
+//
+// Non-interactive for now: the intersection is parked at the center of the
+// candle area. Once pointer tracking lands, the position will come from
+// chart.crosshair_x_px / crosshair_y_px (see chart.h).
+
+#pragma once
+
+#include "vroom/vroom_chart.h"
+
+class SkCanvas;
+struct VroomChart;
+
+namespace vroom::crosshair {
+
+// Draws the crosshair. `candle_right` is the x of the y-axis strip. The
+// horizontal line and ring live in the price pane: the ring's y is clamped to
+// `candle_area_h` (the price-pane bottom) and the horizontal line stops at
+// `candle_right`. The vertical line spans from the top down to `vline_bottom`
+// (the bottom of the indicator region, so it stays visible over any RSI/MACD
+// panes); pass `candle_area_h` for both when there are no panes. `snap_x` is the
+// candle-snapped x for the vertical line and ring.
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          float candle_right,
+          float candle_area_h,
+          float vline_bottom,
+          float snap_x);
+
+}  // namespace vroom::crosshair

package/cpp/_core_src/fonts.cpp

@@ -0,0 +1,22 @@
+#include "fonts.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkTypeface.h"
+#pragma clang diagnostic pop
+
+#include <utility>
+
+namespace vroom {
+
+namespace {
+sk_sp<SkTypeface> g_axis_typeface;
+}  // namespace
+
+sk_sp<SkTypeface> axis_typeface() { return g_axis_typeface; }
+
+void set_axis_typeface(sk_sp<SkTypeface> typeface) {
+    g_axis_typeface = std::move(typeface);
+}
+
+}  // namespace vroom

package/cpp/_core_src/fonts.h

@@ -0,0 +1,25 @@
+// Global typeface for axis/label text rendering.
+//
+// Loaded once at startup by the bridge layer (which uses RN-Skia's platform-
+// context font manager to grab the system default). Held as a process-global
+// so all charts share it; per-chart font configuration is not modeled yet.
+
+#pragma once
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkRefCnt.h"
+#pragma clang diagnostic pop
+
+class SkTypeface;
+
+namespace vroom {
+
+// Returns the currently-installed axis typeface, or nullptr if none has been
+// set yet. Drawing code should null-check.
+sk_sp<SkTypeface> axis_typeface();
+
+// Replaces the axis typeface. Charts pick it up on their next draw.
+void set_axis_typeface(sk_sp<SkTypeface> typeface);
+
+}  // namespace vroom

package/cpp/_core_src/labels.cpp

@@ -0,0 +1,340 @@
+#include "labels.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontMetrics.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkTypeface.h"
+#pragma clang diagnostic pop
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+
+#include "chart.h"
+#include "fonts.h"
+#include "ticks.h"
+#include "viewport.h"
+
+namespace vroom::labels {
+
+namespace {
+
+// Fuzzy equality for price keys: a label like 65.000000001 should still match
+// an existing fade entry at 65.0 after a few FP roundtrips.
+bool price_matches(double a, double b) {
+    const double tol = std::max(std::abs(a), std::abs(b)) * 1e-9 + 1e-9;
+    return std::abs(a - b) < tol;
+}
+
+// Advance a label's opacity toward its target by `step`. On the first render
+// of a chart `chart.last_dt_seconds == 0` (and we'd be stuck at opacity 0
+// forever), so we snap to the target then; subsequent frames fade normally.
+template <typename Fade>
+void advance(Fade& f, float step, float dt) {
+    if (dt == 0.f) {
+        f.opacity = f.target;
+    } else if (f.opacity < f.target) {
+        f.opacity = std::min(f.target, f.opacity + step);
+    } else if (f.opacity > f.target) {
+        f.opacity = std::max(f.target, f.opacity - step);
+    }
+}
+
+}  // namespace
+
+// ----- Y-axis ---------------------------------------------------------------
+
+void update_y_fades(VroomChart& chart,
+                    const Layout& lay,
+                    const PriceBounds& bounds) {
+    const double range = bounds.max - bounds.min;
+    if (range <= 0.0) return;
+
+    const float candle_area_h = vroom::price_pane_bottom(lay);
+    const double interval = vroom::pick_price_interval(range, candle_area_h);
+    if (interval <= 0.0) return;
+
+    for (auto& f : chart.y_fades) f.target = 0.f;
+
+    const double first = std::ceil(bounds.min / interval) * interval;
+    constexpr int kMaxLabels = 64;
+    int promoted = 0;
+    for (double price = first;
+         price <= bounds.max && promoted < kMaxLabels;
+         price += interval, ++promoted) {
+        bool found = false;
+        for (auto& f : chart.y_fades) {
+            if (price_matches(f.price, price)) {
+                f.target = 1.f;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            chart.y_fades.push_back(YLabelFade{price, 0.f, 1.f});
+        }
+    }
+
+    const float step = kFadeRate * chart.last_dt_seconds;
+    for (auto& f : chart.y_fades) advance(f, step, chart.last_dt_seconds);
+}
+
+void draw_y_gridlines(SkCanvas* canvas,
+                      const VroomChart& chart,
+                      const Layout& lay,
+                      const PriceBounds& bounds,
+                      float candle_right,
+                      float candle_area_h) {
+    SkPaint grid;
+    grid.setColor(chart.theme.colors[VROOM_COLOR_GRID]);
+    grid.setStrokeWidth(1.f);
+    grid.setAntiAlias(true);
+    for (const auto& f : chart.y_fades) {
+        if (f.opacity <= 1e-3f) continue;
+        const float y = vroom::price_to_y(lay, bounds, f.price);
+        if (y < 0.f || y > candle_area_h) continue;
+        grid.setAlphaf(f.opacity);
+        canvas->drawLine(0.f, y, candle_right, y, grid);
+    }
+}
+
+void draw_y_labels(SkCanvas* canvas,
+                   const VroomChart& chart,
+                   const Layout& lay,
+                   const PriceBounds& bounds) {
+    auto tf = vroom::axis_typeface();
+    if (!tf) return;
+
+    const float candle_area_h = vroom::price_pane_bottom(lay);
+
+    SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+    font.setSubpixel(true);
+    font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+
+    SkFontMetrics metrics;
+    font.getMetrics(&metrics);
+    const float cap_h = metrics.fCapHeight > 0
+        ? metrics.fCapHeight
+        : -metrics.fAscent * 0.7f;
+
+    SkPaint text_paint;
+    text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+    text_paint.setAntiAlias(true);
+
+    // Horizontal center of the y-axis container ([width - y_axis_width, width]).
+    // Labels (and the price box) center on this so their text shares a column.
+    const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+
+    for (const auto& f : chart.y_fades) {
+        if (f.opacity <= 1e-3f) continue;
+        const float y = vroom::price_to_y(lay, bounds, f.price);
+
+        char buf[32];
+        std::snprintf(buf, sizeof(buf), "%.2f", f.price);
+        const size_t len = std::strlen(buf);
+        const float text_w = font.measureText(
+            buf, len, SkTextEncoding::kUTF8);
+
+        const float text_x = axis_center_x - text_w * 0.5f;
+        const float baseline_y = y + cap_h * 0.5f;
+        if (baseline_y - cap_h < 0.f) continue;
+        if (baseline_y > candle_area_h) continue;
+
+        text_paint.setAlphaf(f.opacity);
+        canvas->drawString(buf, text_x, baseline_y, font, text_paint);
+    }
+}
+
+void gc_y_fades(VroomChart& chart) {
+    chart.y_fades.erase(
+        std::remove_if(chart.y_fades.begin(), chart.y_fades.end(),
+                       [](const YLabelFade& f) {
+                           return f.opacity <= 0.f && f.target <= 0.f;
+                       }),
+        chart.y_fades.end());
+}
+
+// ----- X-axis ---------------------------------------------------------------
+
+void update_x_fades(VroomChart& chart, const Layout& lay) {
+    if (chart.candles.empty()) return;
+    if (chart.visible_end_ms <= chart.visible_start_ms) return;
+
+    const float candle_area_w =
+        lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
+    if (candle_area_w <= 0.f) return;
+
+    const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
+    const int64_t interval = vroom::pick_time_interval(window_ms, candle_area_w);
+    if (interval <= 0) return;
+
+    for (auto& f : chart.x_fades) f.target = 0.f;
+
+    int64_t t = (chart.visible_start_ms / interval) * interval;
+    if (t < chart.visible_start_ms) t += interval;
+    constexpr int kMaxLabels = 64;
+    int promoted = 0;
+    for (; t <= chart.visible_end_ms && promoted < kMaxLabels;
+         t += interval, ++promoted) {
+        bool found = false;
+        for (auto& f : chart.x_fades) {
+            if (f.time_ms == t) {
+                f.target = 1.f;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            chart.x_fades.push_back(XLabelFade{t, 0.f, 1.f});
+        }
+    }
+
+    const float step = kFadeRate * chart.last_dt_seconds;
+    for (auto& f : chart.x_fades) advance(f, step, chart.last_dt_seconds);
+}
+
+void draw_x_gridlines(SkCanvas* canvas,
+                      const VroomChart& chart,
+                      float candle_area_w,
+                      float candle_area_h) {
+    if (chart.visible_end_ms <= chart.visible_start_ms) return;
+    const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
+    if (window_ms <= 0 || candle_area_w <= 0.f) return;
+
+    SkPaint grid;
+    grid.setColor(chart.theme.colors[VROOM_COLOR_GRID]);
+    grid.setStrokeWidth(1.f);
+    grid.setAntiAlias(true);
+    for (const auto& f : chart.x_fades) {
+        if (f.opacity <= 1e-3f) continue;
+        const float frac =
+            static_cast<float>(f.time_ms - chart.visible_start_ms) /
+            static_cast<float>(window_ms);
+        const float x = frac * candle_area_w;
+        if (x < 0.f || x > candle_area_w) continue;
+        grid.setAlphaf(f.opacity);
+        canvas->drawLine(x, 0.f, x, candle_area_h, grid);
+    }
+}
+
+void draw_x_labels(SkCanvas* canvas,
+                   const VroomChart& chart,
+                   const Layout& lay) {
+    auto tf = vroom::axis_typeface();
+    if (!tf || chart.candles.empty()) return;
+    if (chart.visible_end_ms <= chart.visible_start_ms) return;
+
+    // X-axis labels live in the bottom strip, which stays anchored regardless
+    // of any indicator pane above it.
+    const float candle_area_h = vroom::x_axis_top(lay);
+    const float candle_area_w =
+        lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
+    if (candle_area_w <= 0.f) return;
+
+    const int64_t window_ms = chart.visible_end_ms - chart.visible_start_ms;
+    // Recompute interval here just to decide HH:MM vs MM/DD formatting.
+    const int64_t interval = vroom::pick_time_interval(window_ms, candle_area_w);
+
+    SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+    font.setSubpixel(true);
+    font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+
+    SkFontMetrics metrics;
+    font.getMetrics(&metrics);
+    const float cap_h = metrics.fCapHeight > 0
+        ? metrics.fCapHeight
+        : -metrics.fAscent * 0.7f;
+
+    SkPaint text_paint;
+    text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+    text_paint.setAntiAlias(true);
+
+    const float baseline_y =
+        candle_area_h + (lay.x_axis_height_px + cap_h) * 0.5f;
+    const bool use_date = interval >= 24LL * 60 * 60 * 1000;
+    for (const auto& f : chart.x_fades) {
+        if (f.opacity <= 1e-3f) continue;
+        const float frac =
+            static_cast<float>(f.time_ms - chart.visible_start_ms) /
+            static_cast<float>(window_ms);
+        const float x_center = frac * candle_area_w;
+
+        char buf[16];
+        const time_t time_s = static_cast<time_t>(f.time_ms / 1000);
+        struct tm tm_buf;
+        localtime_r(&time_s, &tm_buf);
+        if (use_date) {
+            std::snprintf(buf, sizeof(buf), "%02d/%02d",
+                          tm_buf.tm_mon + 1, tm_buf.tm_mday);
+        } else {
+            std::snprintf(buf, sizeof(buf), "%02d:%02d",
+                          tm_buf.tm_hour, tm_buf.tm_min);
+        }
+
+        const size_t len = std::strlen(buf);
+        const float text_w = font.measureText(
+            buf, len, SkTextEncoding::kUTF8);
+        const float text_x = x_center - text_w * 0.5f;
+        if (text_x < 0.f) continue;
+        if (text_x + text_w > candle_area_w) continue;
+
+        text_paint.setAlphaf(f.opacity);
+        canvas->drawString(buf, text_x, baseline_y, font, text_paint);
+    }
+}
+
+void gc_x_fades(VroomChart& chart) {
+    chart.x_fades.erase(
+        std::remove_if(chart.x_fades.begin(), chart.x_fades.end(),
+                       [](const XLabelFade& f) {
+                           return f.opacity <= 0.f && f.target <= 0.f;
+                       }),
+        chart.x_fades.end());
+}
+
+// ----- Axis-width sizing ----------------------------------------------------
+
+void recompute_axis_width(VroomChart& chart) {
+    auto tf = vroom::axis_typeface();
+    if (!tf) {
+        chart.axis_width_px = 0.f;
+        return;
+    }
+    double hi, lo;
+    if (chart.price_bounds_initialized) {
+        hi = chart.price_bounds.max;
+        lo = chart.price_bounds.min;
+    } else if (!chart.candles.empty()) {
+        hi = chart.candles.front().high;
+        lo = chart.candles.front().low;
+        for (const auto& c : chart.candles) {
+            if (c.high > hi) hi = c.high;
+            if (c.low < lo) lo = c.low;
+        }
+    } else {
+        chart.axis_width_px = 0.f;
+        return;
+    }
+
+    SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+    char buf_hi[32], buf_lo[32];
+    std::snprintf(buf_hi, sizeof(buf_hi), "%.2f", hi);
+    std::snprintf(buf_lo, sizeof(buf_lo), "%.2f", lo);
+    const float w_hi = font.measureText(
+        buf_hi, std::strlen(buf_hi), SkTextEncoding::kUTF8);
+    const float w_lo = font.measureText(
+        buf_lo, std::strlen(buf_lo), SkTextEncoding::kUTF8);
+    const float text_w = std::max(w_hi, w_lo);
+
+    constexpr float kPaddingLeft = 8.f;   // separator ↔ text
+    constexpr float kPaddingRight = 6.f;  // text ↔ screen edge
+    chart.axis_width_px = text_w + kPaddingLeft + kPaddingRight;
+}
+
+}  // namespace vroom::labels

package/cpp/_core_src/labels.h

@@ -0,0 +1,85 @@
+// Axis labels and their gridlines — both subsystems share a per-axis fade
+// state so they animate in lockstep. When an interval swap happens (e.g.,
+// 30m → 1h on x), the old labels and their gridlines fade out together, and
+// the new ones fade in together.
+//
+// Free functions over `VroomChart&` rather than methods so the struct
+// definition can stay in chart.h and the implementations can live here.
+
+#pragma once
+
+#include <cstdint>
+
+class SkCanvas;
+struct VroomChart;
+
+namespace vroom {
+struct Layout;
+struct PriceBounds;
+}  // namespace vroom
+
+namespace vroom::labels {
+
+// Per-label fade state. Updated each frame: labels in the new active set get
+// target=1 and fade in; labels falling out get target=0 and fade out.
+struct YLabelFade {
+    double price;
+    float opacity = 0.f;
+    float target = 1.f;
+};
+
+struct XLabelFade {
+    int64_t time_ms;
+    float opacity = 0.f;
+    float target = 1.f;
+};
+
+// Opacity step per second (1 / 0.2s ≈ 200ms full fade).
+inline constexpr float kFadeRate = 5.f;
+
+// Y-axis (price) -----------------------------------------------------------
+
+// Sets targets, walks the active price-interval set, advances opacities by
+// `chart.last_dt_seconds`. Must be called once per frame before either
+// `draw_y_gridlines` or `draw_y_labels`.
+void update_y_fades(VroomChart& chart,
+                    const Layout& lay,
+                    const PriceBounds& bounds);
+
+void draw_y_gridlines(SkCanvas* canvas,
+                      const VroomChart& chart,
+                      const Layout& lay,
+                      const PriceBounds& bounds,
+                      float candle_right,
+                      float candle_area_h);
+
+void draw_y_labels(SkCanvas* canvas,
+                   const VroomChart& chart,
+                   const Layout& lay,
+                   const PriceBounds& bounds);
+
+void gc_y_fades(VroomChart& chart);
+
+// X-axis (time) ------------------------------------------------------------
+
+void update_x_fades(VroomChart& chart, const Layout& lay);
+
+void draw_x_gridlines(SkCanvas* canvas,
+                      const VroomChart& chart,
+                      float candle_area_w,
+                      float candle_area_h);
+
+void draw_x_labels(SkCanvas* canvas,
+                   const VroomChart& chart,
+                   const Layout& lay);
+
+void gc_x_fades(VroomChart& chart);
+
+// Y-axis width sizing ------------------------------------------------------
+
+// Recomputes `chart.axis_width_px` to fit the widest formatted price label
+// at the current bounds. No-op if the typeface isn't loaded yet — the layout
+// then falls back to `VROOM_FLOAT_Y_AXIS_WIDTH_RATIO`.
+void recompute_axis_width(VroomChart& chart);
+
+}  // namespace vroom::labels

package/cpp/_core_src/ma.cpp

@@ -0,0 +1,53 @@
+#include "ma.h"
+
+#include <cmath>  // std::nan
+
+namespace vroom::ma {
+
+double source_value(const ::VroomCandle& c, int source) {
+    switch (source) {
+        case SOURCE_OPEN: return c.open;
+        case SOURCE_HIGH: return c.high;
+        case SOURCE_LOW: return c.low;
+        case SOURCE_HL2: return (c.high + c.low) / 2.0;
+        case SOURCE_HLC3: return (c.high + c.low + c.close) / 3.0;
+        case SOURCE_OHLC4: return (c.open + c.high + c.low + c.close) / 4.0;
+        case SOURCE_CLOSE:
+        default: return c.close;
+    }
+}
+
+void compute(const ::VroomCandle* candles, std::size_t n, int kind, int period,
+             int source, std::vector<double>& out) {
+    out.assign(n, std::nan(""));
+    if (!candles || period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+    if (n < P) return;
+
+    std::vector<double> src(n);
+    for (std::size_t i = 0; i < n; ++i) src[i] = source_value(candles[i], source);
+
+    if (kind == KIND_EMA) {
+        // SMA-seeded EMA: seed at index P-1 with the SMA of the first P values.
+        double sum = 0.0;
+        for (std::size_t i = 0; i < P; ++i) sum += src[i];
+        double prev = sum / static_cast<double>(P);
+        out[P - 1] = prev;
+        const double alpha = 2.0 / (static_cast<double>(P) + 1.0);
+        for (std::size_t i = P; i < n; ++i) {
+            prev = alpha * src[i] + (1.0 - alpha) * prev;
+            out[i] = prev;
+        }
+        return;
+    }
+
+    // SMA via a rolling window sum (O(n)).
+    double sum = 0.0;
+    for (std::size_t i = 0; i < n; ++i) {
+        sum += src[i];
+        if (i >= P) sum -= src[i - P];
+        if (i >= P - 1) out[i] = sum / static_cast<double>(P);
+    }
+}
+
+}  // namespace vroom::ma

package/cpp/_core_src/ma.h

@@ -0,0 +1,39 @@
+// Moving averages (SMA / EMA) over a candle source series — pure, no Skia, so
+// it builds into the unit-test target. Used by the price-pane overlay lines.
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::ma {
+
+// Source selector. Index order is mirrored on the TS side (MA_SOURCES).
+enum Source {
+    SOURCE_CLOSE = 0,
+    SOURCE_OPEN,
+    SOURCE_HIGH,
+    SOURCE_LOW,
+    SOURCE_HL2,    // (high + low) / 2
+    SOURCE_HLC3,   // (high + low + close) / 3
+    SOURCE_OHLC4,  // (open + high + low + close) / 4
+};
+
+// Kind selector (mirrored on the TS side).
+enum Kind {
+    KIND_SMA = 0,
+    KIND_EMA = 1,
+};
+
+// The source price for a candle.
+double source_value(const ::VroomCandle& c, int source);
+
+// Computes the SMA (kind 0) or SMA-seeded EMA (kind 1) of the chosen source over
+// [candles, candles+n). `period` is clamped to >= 1. Fills `out` (resized to n):
+// out[i] is the average at candle i, or NaN for i < period-1 and when n < period.
+void compute(const ::VroomCandle* candles, std::size_t n, int kind, int period,
+             int source, std::vector<double>& out);
+
+}  // namespace vroom::ma

package/cpp/_core_src/ma_overlay.cpp

@@ -0,0 +1,73 @@
+#include "ma_overlay.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkRect.h"
+#pragma clang diagnostic pop
+
+#include <cmath>
+
+#include "viewport.h"
+
+namespace vroom::ma_overlay {
+
+void draw(SkCanvas* canvas,
+          const Layout& lay,
+          const PriceBounds& bounds,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* values_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float candle_area_h,
+          uint32_t color,
+          float width,
+          const unsigned char* break_before) {
+    if (!canvas || !values_visible || n == 0 || candle_right <= 0.f ||
+        candle_area_h <= 0.f) {
+        return;
+    }
+
+    // SkPathBuilder (not SkPath's edit methods, removed in newer Skia tips).
+    SkPathBuilder path;
+    bool pen_down = false;
+    for (std::size_t i = 0; i < n; ++i) {
+        const double v = values_visible[i];
+        if (!std::isfinite(v)) {
+            pen_down = false;
+            continue;
+        }
+        const float x = vroom::candle_center_x(
+            lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
+            window_ms);
+        const float y = vroom::price_to_y(lay, bounds, v);
+        if (pen_down && !(break_before && break_before[i])) {
+            path.lineTo(x, y);
+        } else {
+            path.moveTo(x, y);
+            pen_down = true;
+        }
+    }
+
+    SkPaint line;
+    line.setAntiAlias(true);
+    line.setColor(static_cast<SkColor>(color));
+    line.setStyle(SkPaint::kStroke_Style);
+    line.setStrokeWidth(width > 0.f ? width : 1.5f);
+
+    // Clip to the candle area so a line that runs off-range doesn't bleed into
+    // the axis strips or any indicator pane below.
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
+    canvas->drawPath(path.detach(), line);
+    canvas->restore();
+}
+
+}  // namespace vroom::ma_overlay