react-native-vroom-chart 0.5.0 → 0.6.0

package/cpp/VroomJsiInstaller.cpp

@@ -40,7 +40,17 @@ static void ensureAxisTypeface(jsi::Runtime& runtime) {
   if (!ctx) return;
   auto mgr = ctx->createFontMgr();
   if (!mgr) return;
-  auto tf = mgr->matchFamilyStyle(nullptr, SkFontStyle());  // system default
+
+  // A null family name is meant to request "the platform default" — CoreText
+  // (iOS) honors that, but Android's SkFontMgr_New_Android does not: it
+  // returns null unless given an actual family name, even though its
+  // underlying font set (sans-serif, arial, ...) is perfectly populated. Fall
+  // back to "sans-serif" (Android's standard generic-family alias) whenever
+  // the null-family lookup comes back empty.
+  auto tf = mgr->matchFamilyStyle(nullptr, SkFontStyle());
+  if (!tf) {
+    tf = mgr->matchFamilyStyle("sans-serif", SkFontStyle());
+  }
   if (!tf) return;
   vroom::set_axis_typeface(tf);
   done = true;

package/cpp/VroomSkiaContext.cpp

@@ -12,13 +12,21 @@ std::shared_ptr<RNSkia::RNSkPlatformContext> getRNSkContext(
   if (!obj.isHostObject(runtime)) return nullptr;
   auto host = obj.asHostObject(runtime);
 
-  auto base = std::dynamic_pointer_cast<RNSkia::JsiSkHostObject>(host);
-  if (!base) return nullptr;
-
-  // The accessor class adds no fields; static_cast is safe even though the
-  // runtime type is JsiSkApi (a different JsiSkHostObject subclass). We only
-  // call the inherited non-virtual getContext() through this view.
-  auto* accessor = static_cast<HostObjectAccessor*>(base.get());
+  // `global.SkiaApi` is always installed by RN-Skia's own
+  // RNSkManager::installBindings() as exactly a `JsiSkApi` host object — never
+  // any other JsiSkHostObject subclass — so this cast is safe as a plain
+  // static_cast, without any RTTI check. We deliberately avoid
+  // dynamic_pointer_cast here: on Android, RN-Skia is compiled into its own
+  // librnskia.so, separate from libvroomchart.so, so a `JsiSkApi` constructed
+  // by librnskia.so's code carries typeinfo from that .so; a dynamic_cast
+  // performed here (in libvroomchart.so) sees an unmerged RTTI record for
+  // "the same" class and always fails, even though the object is perfectly
+  // valid to use. (Same underlying issue as the JsiSkPicture cross-.so cast
+  // documented in VroomChartHostObject.cpp — but there RN-Skia's own compiled
+  // code does the cast on an object *we* construct, so we can't avoid it;
+  // here *we* do the cast on an object *they* construct, so we can just skip
+  // the runtime check we don't need.)
+  auto* accessor = static_cast<HostObjectAccessor*>(host.get());
   return accessor->getContext();
 }
 

package/cpp/_core_include/vroom/vroom_chart.h

@@ -118,6 +118,44 @@ typedef struct VroomLiquidityStyle {
     float    width_frac;
 } VroomLiquidityStyle;
 
+// ---- Price status lines ---------------------------------------------------
+
+// Bit flags for VroomPriceLine::flags.
+typedef enum {
+    VROOM_PRICE_LINE_DRAGGABLE   = 1 << 0,  // the line can be dragged vertically
+    VROOM_PRICE_LINE_CLOSABLE    = 1 << 1,  // render the trailing close ("x") button
+    VROOM_PRICE_LINE_AXIS_LABEL  = 1 << 2,  // render the price badge in the y-axis strip
+    VROOM_PRICE_LINE_EXTEND_LEFT = 1 << 3,  // extend the line to the pane's left edge
+} VroomPriceLineFlags;
+
+// A consumer-supplied horizontal status line at a fixed price — the primitive
+// behind resting limit orders, take-profits, liquidation levels and the like.
+//
+// Visually: a line across the price pane ending in a label group made of a body
+// pill (`text`), an optional solid-filled `quantity` pill, and an optional close
+// button, plus an optional price badge in the y-axis strip.
+//
+// `text` / `quantity` are UTF-8 and copied internally, so the caller may free
+// them as soon as the call returns. A null or empty string hides that segment.
+typedef struct VroomPriceLine {
+    double      price;
+    uint32_t    color;       // 0xAARRGGBB — line, border, body text, close icon
+    float       width;       // stroke width in px
+    int32_t     line_style;  // 0 = solid, 1 = dotted, 2 = dashed
+    const char* text;        // body label
+    const char* quantity;    // trailing solid-fill segment
+    int32_t     flags;       // bitwise-or of VroomPriceLineFlags
+} VroomPriceLine;
+
+// Layout/style shared by every price line, so the per-line struct stays small.
+typedef struct VroomPriceLineStyle {
+    uint32_t body_bg;           // translucent body/close-button pill fill (0xAARRGGBB)
+    float    font_size_px;      // 0 = inherit VROOM_FLOAT_AXIS_FONT_SIZE_PX
+    float    line_length_frac;  // 0..1 of pane width: the label group's right-edge inset
+    int32_t  align;             // 0 = left, 1 = center, 2 = right
+    float    hover_boost;       // brightness multiplier for the hovered segment (1 = flat)
+} VroomPriceLineStyle;
+
 // A continuous data coordinate at a pixel position (no candle snapping). Used to
 // translate a drawing-tool click into a data-space anchor.
 typedef struct VroomCoord {
@@ -390,6 +428,38 @@ void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
 void vroom_chart_set_liquidity(VroomChart* chart, const VroomBand* bands,
                                size_t count, const VroomLiquidityStyle* style);
 
+// ---- Price status lines ---------------------------------------------------
+
+// Replaces the full set of price status lines and their shared style. Lines
+// render on the price pane above the axis labels (so their badges cover any
+// label they overlap) and below the crosshair. A line whose price maps outside
+// the price pane is skipped rather than clamped. Pass count 0 to clear;
+// `style` may be null when count is 0.
+void vroom_chart_set_price_lines(VroomChart* chart, const VroomPriceLine* lines,
+                                 size_t count,
+                                 const VroomPriceLineStyle* style);
+
+// Hit-tests pixel (x_px, y_px) against the price lines. On a hit, fills
+// *out_index with the line index and *out_part with 0 (the line or its label
+// body — the drag target) or 1 (the close button), and returns true. When
+// several lines are within tolerance the nearest in y wins. Only draggable
+// lines report part 0 and only closable lines report part 1. Returns false on a
+// miss (out params untouched). Either out pointer may be null.
+bool vroom_chart_hit_test_price_line(VroomChart* chart, float x_px, float y_px,
+                                     int32_t* out_index, int32_t* out_part);
+
+// Marks a price line's segment as hovered so it renders highlighted. `index` -1
+// clears the hover. `part` matches vroom_chart_hit_test_price_line.
+void vroom_chart_set_price_line_hover(VroomChart* chart, int32_t index,
+                                      int32_t part);
+
+// Drives the live drag preview: the line, its label and its badge render at
+// `price` instead of the committed one, and a faint ghost marks where it
+// started. `index` -1 ends the preview. The committed price is never mutated —
+// the host applies (or rejects) the new price by restating its lines.
+void vroom_chart_set_price_line_drag(VroomChart* chart, int32_t index,
+                                     double price);
+
 // Sets the transient in-progress "draft" the drawing tool shows while the user
 // places points. Node A is always shown; when `has_b`, node B is shown too.
 // `guide != 0` also draws the live preview (a guideline for a line, or a preview

package/cpp/_core_src/chart.cpp

@@ -30,6 +30,7 @@
 #include "macd.h"
 #include "macd_pane.h"
 #include "price_indicator.h"
+#include "price_lines.h"
 #include "rsi.h"
 #include "rsi_pane.h"
 #include "volume.h"
@@ -279,6 +280,12 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::price_indicator::draw(canvas, *this, lay, bounds,
                                  candle_right, candle_area_h);
 
+    // 7.55. Consumer-supplied price status lines — same tier as the current-price
+    //       indicator (their badges must cover the labels underneath), but after
+    //       it so a resting order at the last close stays readable.
+    vroom::price_lines::draw(canvas, *this, lay, bounds, candle_right,
+                             candle_area_h);
+
     // 7.6. Indicator panes stacked below the candles, ordered by enable
     //      sequence (most recently enabled at the bottom). Each pane is
     //      INDICATOR_HEIGHT_FRAC of the height; the candle pane already shrank

package/cpp/_core_src/chart.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <chrono>
+#include <string>
 #include <vector>
 
 #include "vroom/vroom_chart.h"
@@ -195,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;
 

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;
@@ -812,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,
@@ -926,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) {

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