react-native-vroom-chart 0.4.0 → 0.6.0

package/cpp/_core_src/chart.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <chrono>
+#include <string>
 #include <vector>
 
 #include "vroom/vroom_chart.h"
@@ -135,6 +136,20 @@ struct VroomChart {
     std::vector<unsigned char> vwap_breaks;
     bool vwap_dirty = true;
 
+    // Bollinger Bands overlay (price pane; no pane reserved). Caches aligned to
+    // `candles` (NaN warmup), recomputed lazily by ensure_bollinger() when
+    // bollinger_dirty. Defaults: 20-period SMA of close, ±2σ, blue bands /
+    // orange basis, 10% fill.
+    VroomBollinger bollinger{0, 20, 2.f, 0, 0,
+                             0xff2962ff, 1.f,   // upper: blue
+                             0xffff6d00, 1.f,   // middle: orange
+                             0xff2962ff, 1.f,   // lower: blue
+                             1, 0.1f};
+    std::vector<double> bb_middle_cache;
+    std::vector<double> bb_upper_cache;
+    std::vector<double> bb_lower_cache;
+    bool bollinger_dirty = true;
+
     // --- drawings (annotations) --------------------------------------------
     // Committed drawings, anchored in data space so they track the candles on
     // pan/zoom. Drawn on the price pane above candles/overlays.
@@ -181,6 +196,32 @@ struct VroomChart {
     std::vector<VroomBand>   bands;
     VroomLiquidityStyle      liquidity_style{};
 
+    // --- price status lines -------------------------------------------------
+    // Consumer-supplied horizontal lines at fixed prices (resting orders, TP/SL,
+    // liquidation levels), each with a label group and an optional close button.
+    //
+    // Mirrors the public VroomPriceLine but *owns* its label strings, so the
+    // caller may free theirs as soon as the setter returns.
+    struct StoredPriceLine {
+        double      price = 0.0;
+        uint32_t    color = 0xffef5350;
+        float       width = 1.f;
+        int32_t     line_style = 1;  // dotted, matching the price indicator
+        std::string text;
+        std::string quantity;
+        int32_t     flags = 0;  // VroomPriceLineFlags
+    };
+    std::vector<StoredPriceLine> price_lines;
+    VroomPriceLineStyle          price_line_style{};
+
+    // Interaction state, driven by the host's gesture layer. The hovered segment
+    // renders highlighted; while a line is dragged it renders at
+    // dragged_price_line_price with a ghost at its committed price. -1 = none.
+    int32_t hovered_price_line = -1;
+    int32_t hovered_price_line_part = -1;
+    int32_t dragged_price_line = -1;
+    double  dragged_price_line_price = 0.0;
+
     // --- theme --------------------------------------------------------------
     vroom::Theme theme;
 
@@ -222,6 +263,10 @@ struct VroomChart {
     // Recomputes the VWAP cache when vwap_dirty and VWAP is enabled.
     void ensure_vwap();
 
+    // Recomputes the Bollinger Band caches when bollinger_dirty and the
+    // indicator is enabled.
+    void ensure_bollinger();
+
     // The main drawing pass. Calls into the labels and candles modules.
     void draw_chart(SkCanvas* canvas);
 

package/cpp/_core_src/chart_facade.cpp

@@ -14,6 +14,7 @@
 #include "chart.h"
 #include "drawings.h"
 #include "labels.h"
+#include "price_lines.h"
 #include "viewport.h"
 
 class SkCanvas;
@@ -131,6 +132,7 @@ extern "C" void vroom_chart_set_candles(VroomChart* chart, const VroomCandle* da
     chart->macd_dirty = true;
     chart->overlays_dirty = true;
     chart->vwap_dirty = true;
+    chart->bollinger_dirty = true;
 
     // Infer the candle period from the first interval. Robust enough for
     // uniform-duration series (the only kind we model today).
@@ -158,6 +160,7 @@ extern "C" void vroom_chart_append_candle(VroomChart* chart, const VroomCandle*
     chart->macd_dirty = true;
     chart->overlays_dirty = true;
     chart->vwap_dirty = true;
+    chart->bollinger_dirty = true;
     chart->mark_dirty();
 }
 
@@ -168,6 +171,7 @@ extern "C" void vroom_chart_update_last(VroomChart* chart, const VroomCandle* c)
     chart->macd_dirty = true;
     chart->overlays_dirty = true;
     chart->vwap_dirty = true;
+    chart->bollinger_dirty = true;
     chart->mark_dirty();
 }
 
@@ -809,6 +813,70 @@ extern "C" void vroom_chart_set_liquidity(VroomChart* chart,
     chart->mark_dirty();
 }
 
+// ---- Price status lines ---------------------------------------------------
+
+extern "C" void vroom_chart_set_price_lines(VroomChart* chart,
+                                            const VroomPriceLine* lines,
+                                            size_t count,
+                                            const VroomPriceLineStyle* style) {
+    if (!chart) return;
+    // Deep-copy into the owning form: the label strings live in the chart, so the
+    // caller's buffers may be freed as soon as this returns.
+    chart->price_lines.clear();
+    chart->price_lines.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+        const VroomPriceLine& src = lines[i];
+        VroomChart::StoredPriceLine pl;
+        pl.price = src.price;
+        pl.color = src.color;
+        pl.width = src.width;
+        pl.line_style = src.line_style;
+        if (src.text) pl.text = src.text;
+        if (src.quantity) pl.quantity = src.quantity;
+        pl.flags = src.flags;
+        chart->price_lines.push_back(std::move(pl));
+    }
+    if (style) chart->price_line_style = *style;
+    // Drop interaction state that no longer refers to a live line — otherwise a
+    // removed line would leave a stuck hover highlight or drag preview.
+    const auto n = static_cast<int32_t>(count);
+    if (chart->hovered_price_line >= n) {
+        chart->hovered_price_line = -1;
+        chart->hovered_price_line_part = -1;
+    }
+    if (chart->dragged_price_line >= n) chart->dragged_price_line = -1;
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_set_price_line_hover(VroomChart* chart, int32_t index,
+                                                 int32_t part) {
+    if (!chart) return;
+    if (index < 0 || index >= static_cast<int32_t>(chart->price_lines.size())) {
+        index = -1;
+        part = -1;
+    }
+    if (chart->hovered_price_line == index && chart->hovered_price_line_part == part) {
+        return;  // hover fires on every pointer move; don't redraw for nothing
+    }
+    chart->hovered_price_line = index;
+    chart->hovered_price_line_part = part;
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_set_price_line_drag(VroomChart* chart, int32_t index,
+                                                double price) {
+    if (!chart) return;
+    if (index < 0 || index >= static_cast<int32_t>(chart->price_lines.size())) {
+        if (chart->dragged_price_line == -1) return;
+        chart->dragged_price_line = -1;
+        chart->mark_dirty();
+        return;
+    }
+    chart->dragged_price_line = index;
+    chart->dragged_price_line_price = price;
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_set_draft(VroomChart* chart, int64_t a_time,
                                       double a_price, bool has_b, int64_t b_time,
                                       double b_price, bool guide, uint32_t color,
@@ -923,6 +991,32 @@ extern "C" bool vroom_chart_hit_test_drawing(VroomChart* chart, float x_px,
     return true;
 }
 
+extern "C" bool vroom_chart_hit_test_price_line(VroomChart* chart, float x_px,
+                                                float y_px, int32_t* out_index,
+                                                int32_t* out_part) {
+    if (!chart || chart->price_lines.empty() || chart->candles.empty()) return false;
+    const auto lay = chart->layout();
+    // Same bounds and pane geometry as draw_chart, so the grab regions line up
+    // with what's on screen.
+    const auto range = vroom::visible_indices(
+        chart->candles.data(), chart->candles.size(),
+        chart->visible_start_ms, chart->visible_end_ms);
+    const size_t n = range.end - range.start;
+    const auto bounds =
+        chart->price_bounds_manual
+            ? chart->price_bounds
+            : vroom::auto_price_bounds(chart->candles.data() + range.start, n);
+    const float candle_area_h = vroom::price_pane_bottom(lay);
+    const float candle_right =
+        chart->width_px - lay.y_axis_width_px - lay.right_padding_px;
+    const auto hit = vroom::price_lines::hit_test(*chart, lay, bounds, candle_right,
+                                                  candle_area_h, x_px, y_px);
+    if (hit.index < 0) return false;
+    if (out_index) *out_index = hit.index;
+    if (out_part) *out_part = hit.part;
+    return true;
+}
+
 extern "C" void vroom_chart_set_selected_drawing(VroomChart* chart,
                                                  int32_t index,
                                                  int32_t grabbed_endpoint) {
@@ -1049,6 +1143,29 @@ extern "C" void vroom_chart_set_vwap(VroomChart* chart, bool enabled,
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_bollinger(VroomChart* chart,
+                                          const VroomBollinger* cfg) {
+    if (!chart || !cfg) return;
+    VroomBollinger next = *cfg;
+    next.enabled = next.enabled ? 1 : 0;
+    next.fill_enabled = next.fill_enabled ? 1 : 0;
+    if (next.period < 1) next.period = 1;
+    if (!(next.mult >= 0.f)) next.mult = 0.f;
+    next.fill_opacity = std::clamp(next.fill_opacity, 0.f, 1.f);
+
+    // Only the series-affecting fields force a recompute; style and fill
+    // changes are render-only.
+    const VroomBollinger& cur = chart->bollinger;
+    const bool recompute = cur.enabled != next.enabled ||
+                           cur.period != next.period ||
+                           cur.mult != next.mult ||
+                           cur.source != next.source ||
+                           cur.basis_kind != next.basis_kind;
+    chart->bollinger = next;
+    if (recompute) chart->bollinger_dirty = true;
+    chart->mark_dirty();
+}
+
 // ---- Direct draw (used by hosts that don't need the SkPicture cache) ------
 
 extern "C" void vroom_chart_draw(VroomChart* chart, SkCanvas* canvas) {

package/cpp/_core_src/ma_overlay.cpp

@@ -78,4 +78,71 @@ void draw(SkCanvas* canvas,
     canvas->restore();
 }
 
+void fill_between(SkCanvas* canvas,
+                  const Layout& lay,
+                  const PriceBounds& bounds,
+                  const ::VroomCandle* visible,
+                  std::size_t n,
+                  const double* upper_visible,
+                  const double* lower_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 opacity) {
+    if (!canvas || !upper_visible || !lower_visible || n == 0 ||
+        candle_right <= 0.f || candle_area_h <= 0.f) {
+        return;
+    }
+    opacity = std::clamp(opacity, 0.f, 1.f);
+    if (opacity <= 0.f) return;
+
+    // One closed contour per maximal run where both series are finite; a
+    // single-point run has no area. Multiple runs (e.g. around a data gap)
+    // become multiple contours in one path.
+    SkPathBuilder path;
+    std::size_t i = 0;
+    while (i < n) {
+        if (!std::isfinite(upper_visible[i]) ||
+            !std::isfinite(lower_visible[i])) {
+            ++i;
+            continue;
+        }
+        std::size_t e = i;
+        while (e + 1 < n && std::isfinite(upper_visible[e + 1]) &&
+               std::isfinite(lower_visible[e + 1])) {
+            ++e;
+        }
+        if (e > i) {
+            const auto x_at = [&](std::size_t k) {
+                return vroom::candle_center_x(lay, visible[k].time_ms,
+                                              candle_duration_ms,
+                                              visible_start_ms, window_ms);
+            };
+            path.moveTo(x_at(i), vroom::price_to_y(lay, bounds, upper_visible[i]));
+            for (std::size_t k = i + 1; k <= e; ++k) {
+                path.lineTo(x_at(k), vroom::price_to_y(lay, bounds, upper_visible[k]));
+            }
+            for (std::size_t k = e + 1; k-- > i;) {
+                path.lineTo(x_at(k), vroom::price_to_y(lay, bounds, lower_visible[k]));
+            }
+            path.close();
+        }
+        i = e + 1;
+    }
+
+    SkPaint fill;
+    fill.setAntiAlias(true);
+    fill.setColor(static_cast<SkColor>(color));
+    fill.setAlphaf(fill.getAlphaf() * opacity);
+    fill.setStyle(SkPaint::kFill_Style);
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
+    canvas->drawPath(path.detach(), fill);
+    canvas->restore();
+}
+
 }  // namespace vroom::ma_overlay

package/cpp/_core_src/ma_overlay.h

@@ -40,4 +40,25 @@ void draw(SkCanvas* canvas,
           const unsigned char* break_before = nullptr,
           float opacity = 1.f);
 
+// Fills the closed region between two aligned series (NaN where undefined)
+// with `color` at its alpha × `opacity` — used for the Bollinger Band fill.
+// Runs where either series is NaN are skipped, so the fill never bridges the
+// warmup gap. Plain-alpha SkPaint fill, no gradient shader (the Skia gradient
+// APIs diverge across our pinned versions; see liquidity.cpp). Clipped to the
+// candle area like draw().
+void fill_between(SkCanvas* canvas,
+                  const Layout& lay,
+                  const PriceBounds& bounds,
+                  const ::VroomCandle* visible,
+                  std::size_t n,
+                  const double* upper_visible,
+                  const double* lower_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 opacity);
+
 }  // namespace vroom::ma_overlay

package/cpp/_core_src/price_line_layout.cpp

@@ -0,0 +1,87 @@
+#include "price_line_layout.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace vroom::price_lines {
+
+namespace {
+// A pill's width is its text plus symmetric padding. Zero-width text means the
+// segment is absent, not a padding-only sliver.
+float pill_width(float text_w) {
+    return text_w > 0.f ? text_w + 2.f * kPadH : 0.f;
+}
+}  // namespace
+
+bool contains(const Rect& r, float x, float y) {
+    if (r.empty()) return false;
+    return x >= r.left && x <= r.right && y >= r.top && y <= r.bottom;
+}
+
+GroupLayout layout_group(const LabelMetrics& metrics,
+                         float y,
+                         float pane_right,
+                         const ::VroomPriceLineStyle& style) {
+    GroupLayout out;
+
+    const float body_w = pill_width(metrics.text_w);
+    const float qty_w = pill_width(metrics.quantity_w);
+    // The close button is a square cell, so its icon stays centered whatever the
+    // font size works out to.
+    const float close_w = metrics.closable ? metrics.label_h : 0.f;
+    const float group_w = body_w + qty_w + close_w;
+
+    if (group_w <= 0.f || metrics.label_h <= 0.f || pane_right <= 0.f) {
+        // A bare line: no group, but still report a degenerate span at the
+        // anchor so callers can treat left/right uniformly.
+        out.left = out.right = pane_right;
+        return out;
+    }
+
+    float left = 0.f;
+    switch (style.align) {
+        case 0:  // left
+            left = 0.f;
+            break;
+        case 1:  // center
+            left = (pane_right - group_w) * 0.5f;
+            break;
+        default: {  // right
+            const float frac = std::clamp(style.line_length_frac, 0.f, 1.f);
+            const float right = pane_right - frac * pane_right - kAxisGutter;
+            left = right - group_w;
+            break;
+        }
+    }
+    // Keep the group on-screen: never past the axis, never off the left edge.
+    left = std::min(left, pane_right - group_w);
+    left = std::max(left, 0.f);
+
+    const float top = y - metrics.label_h * 0.5f;
+    const float bottom = top + metrics.label_h;
+
+    float x = left;
+    if (body_w > 0.f) {
+        out.body = Rect{x, top, x + body_w, bottom};
+        x += body_w;
+    }
+    if (qty_w > 0.f) {
+        out.quantity = Rect{x, top, x + qty_w, bottom};
+        x += qty_w;
+    }
+    if (close_w > 0.f) {
+        out.close = Rect{x, top, x + close_w, bottom};
+        x += close_w;
+    }
+
+    out.left = left;
+    out.right = x;
+    return out;
+}
+
+bool hits_line(float line_y, float stroke_width, float y) {
+    const float band = std::max(stroke_width, 1.f) + kLineHitTolerance;
+    return std::fabs(y - line_y) <= band;
+}
+
+}  // namespace vroom::price_lines

package/cpp/_core_src/price_line_layout.h

@@ -0,0 +1,80 @@
+// Price-status-line geometry — pure functions, no Skia, no state.
+//
+// Split out from price_lines.cpp so the rendering pass and the hit-test pass
+// derive their rectangles from the same arithmetic: a label the user can see but
+// not click (or vice versa) is the classic failure mode for this widget. Being
+// Skia-free it also unit-tests without a Skia checkout.
+
+#pragma once
+
+#include "vroom/vroom_chart.h"
+namespace vroom::price_lines {
+
+// Pill padding / corner radius, matching the current-price indicator so a price
+// line and the price badge read as the same family of chrome.
+constexpr float kPadH = 8.f;    // left/right of the text
+constexpr float kPadV = 4.f;    // above/below the text
+constexpr float kCorner = 6.f;  // rounded-pill corner radius
+
+// Extra grab band above and below the stroke, so a 1px line is still an easy
+// target. Matches the tolerance TradingView's own chart libraries settled on.
+constexpr float kLineHitTolerance = 7.f;
+
+// Gap between the label group and the price axis when right-aligned. Wide enough
+// that the line still shows through it — a couple of dashes reading as "this
+// continues to the badge" rather than one orphaned dot.
+constexpr float kAxisGutter = 12.f;
+
+struct Rect {
+    float left = 0.f;
+    float top = 0.f;
+    float right = 0.f;
+    float bottom = 0.f;
+
+    // Empty rects stand in for absent segments (no quantity, no close button).
+    bool empty() const { return right <= left || bottom <= top; }
+    float width() const { return right - left; }
+};
+
+// True when (x, y) falls inside `r`. Always false for an empty rect.
+bool contains(const Rect& r, float x, float y);
+
+// The text extents a caller measured with the real font, plus which optional
+// segments to reserve room for. `label_h` is the pill height (already including
+// kPadV on both sides).
+struct LabelMetrics {
+    float text_w = 0.f;      // body text width; 0 hides the body pill
+    float quantity_w = 0.f;  // quantity text width; 0 hides the quantity pill
+    float label_h = 0.f;
+    bool  closable = false;  // reserve the trailing square close-button cell
+};
+
+// The laid-out label group, vertically centered on the line. Any of the three
+// segment rects may be empty. `left`/`right` bound whichever segments exist and
+// are equal when the group is empty (a bare line).
+struct GroupLayout {
+    Rect  body;
+    Rect  quantity;
+    Rect  close;
+    float left = 0.f;
+    float right = 0.f;
+
+    bool empty() const { return right <= left; }
+};
+
+// Lays the group out on the line at `y`. `pane_right` is the inner edge of the
+// price axis (the line's right end).
+//
+// `style.align` picks the anchor: 2 (right, the default) parks the group's right
+// edge `style.line_length_frac` of the pane width in from the axis; 1 centers
+// it; 0 pins it to the left edge. The group is clamped into [0, pane_right], so
+// a label wider than the pane starts flush left rather than overflowing.
+GroupLayout layout_group(const LabelMetrics& metrics,
+                         float y,
+                         float pane_right,
+                         const ::VroomPriceLineStyle& style);
+
+// True when `y` is within the grab band of a line drawn at `line_y`.
+bool hits_line(float line_y, float stroke_width, float y);
+
+}  // namespace vroom::price_lines