react-native-vroom-chart 0.6.0 → 0.8.0

package/cpp/_core_src/chart_facade.cpp

@@ -63,6 +63,13 @@ int64_t damp_future_delta(int64_t delta_ms, int64_t cur_future,
 void apply_default_framing(VroomChart* chart) {
     if (chart->candles.empty()) return;
 
+    // A candle occupies the slot [time_ms, time_ms + duration) and draws centered
+    // in it, so the right edge of the view is the last slot's *end*. Pinning it to
+    // the last candle's time_ms instead puts that candle's center half a slot past
+    // the plot area, hiding the newest candle behind the y-axis strip.
+    const int64_t right_edge_ms =
+        chart->candles.back().time_ms + chart->candle_duration_ms;
+
     // Px-driven framing. Reuses the inversion from vroom_chart_scale_time_axis:
     // body_w = usable × (dur / window) × ratio  →  window = usable × dur × ratio / body_w.
     // Needs a valid layout (width_px); until size is known it falls through to
@@ -81,7 +88,7 @@ void apply_default_framing(VroomChart* chart) {
                 chart->candles.back().time_ms - chart->candles.front().time_ms;
             window_ms = std::clamp<int64_t>(window_ms, chart->candle_duration_ms,
                                             span > 0 ? span : window_ms);
-            chart->visible_end_ms = chart->candles.back().time_ms;
+            chart->visible_end_ms = right_edge_ms;
             chart->visible_start_ms = chart->visible_end_ms - window_ms;
             return;
         }
@@ -92,7 +99,7 @@ void apply_default_framing(VroomChart* chart) {
         ? chart->candles.size() - kDefaultVisible
         : 0;
     chart->visible_start_ms = chart->candles[start_idx].time_ms;
-    chart->visible_end_ms = chart->candles.back().time_ms;
+    chart->visible_end_ms = right_edge_ms;
 }
 
 // On the first manual-y gesture, adopt the on-screen auto-fit bounds so the
@@ -242,6 +249,10 @@ extern "C" void vroom_chart_reset_view(VroomChart* chart) {
     chart->visible_start_ms = 0;
     chart->visible_end_ms = 0;
     chart->price_bounds_manual = false;
+    // An asset switch reframes wholesale, so a slot-paired morph is meaningless
+    // here — drop any capture rather than leaving it to reshape the wrong data.
+    chart->morph_from.clear();
+    chart->interval_morph_t = 1.f;
     apply_default_framing(chart);
     vroom::labels::recompute_axis_width(*chart);
     if (chart->cb.on_viewport_changed) {
@@ -258,6 +269,104 @@ extern "C" void vroom_chart_reset_price_scale(VroomChart* chart) {
     chart->mark_dirty();
 }
 
+extern "C" bool vroom_chart_get_visible_price_envelope(VroomChart* chart,
+                                                       double* out_low,
+                                                       double* out_high) {
+    if (!chart) return false;
+    const auto idx = vroom::visible_indices(
+        chart->candles.data(), chart->candles.size(),
+        chart->visible_start_ms, chart->visible_end_ms);
+    if (idx.end <= idx.start) return false;
+    const auto env = vroom::price_bounds(chart->candles.data() + idx.start,
+                                         idx.end - idx.start);
+    if (out_low) *out_low = env.min;
+    if (out_high) *out_high = env.max;
+    return true;
+}
+
+extern "C" void vroom_chart_preserve_price_envelope(VroomChart* chart,
+                                                    double prev_low,
+                                                    double prev_high) {
+    // Auto mode already holds the envelope's pixel height constant (auto_price_
+    // bounds widens it by a fixed factor), so there is nothing to preserve.
+    if (!chart || !chart->price_bounds_manual) return;
+
+    double new_low = 0.0, new_high = 0.0;
+    const bool has_new =
+        vroom_chart_get_visible_price_envelope(chart, &new_low, &new_high);
+    if (!has_new || !(prev_high > prev_low) || !(new_high > new_low)) {
+        // Nothing to scale against — fall back to re-fitting the price scale.
+        vroom_chart_reset_price_scale(chart);
+        return;
+    }
+
+    chart->price_bounds = vroom::preserve_envelope_bounds(
+        chart->price_bounds, {prev_low, prev_high}, {new_low, new_high});
+    vroom::labels::recompute_axis_width(*chart);
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_begin_interval_morph(VroomChart* chart) {
+    if (!chart) return;
+    chart->morph_from.clear();
+    chart->interval_morph_t = 1.f;
+
+    const auto lay = chart->layout();
+    const float area_w = vroom::candle_area_width(lay);
+    const int64_t window_ms = chart->visible_end_ms - chart->visible_start_ms;
+    if (area_w <= 0.f || window_ms <= 0) return;
+
+    const auto idx = vroom::visible_indices(
+        chart->candles.data(), chart->candles.size(),
+        chart->visible_start_ms, chart->visible_end_ms);
+    const std::size_t n = idx.end - idx.start;
+    if (n == 0) return;
+    const ::VroomCandle* visible = chart->candles.data() + idx.start;
+
+    const auto bounds = chart->price_bounds_manual
+        ? chart->price_bounds
+        : vroom::auto_price_bounds(visible, n);
+
+    // Normalized so the capture is independent of both the price bounds (which
+    // the swap is about to replace) and the surface size (which may change
+    // mid-morph). Newest candle first, matching the slot indexing in
+    // candles::draw.
+    chart->morph_from.resize(n);
+    for (std::size_t k = 0; k < n; ++k) {
+        const auto& c = visible[n - 1 - k];
+        chart->morph_from[k] = vroom::CandleSnapshot{
+            vroom::candle_center_x(lay, c.time_ms, chart->candle_duration_ms,
+                                   chart->visible_start_ms, window_ms) / area_w,
+            static_cast<float>(vroom::price_fraction(bounds, c.open)),
+            static_cast<float>(vroom::price_fraction(bounds, c.high)),
+            static_cast<float>(vroom::price_fraction(bounds, c.low)),
+            static_cast<float>(vroom::price_fraction(bounds, c.close)),
+            c.close >= c.open,
+        };
+    }
+
+    // The scale the capture was taken against — the axes render their outgoing
+    // ticks from it, and it's about to be replaced on the chart itself.
+    chart->morph_from_bounds = bounds;
+    chart->morph_from_start_ms = chart->visible_start_ms;
+    chart->morph_from_end_ms = chart->visible_end_ms;
+
+    // Open the morph at 0 rather than leaving it at 1: the caller still has to
+    // push the new candles, and any frame painted in between should show the
+    // captured geometry — which is what the pre-switch frame looked like.
+    chart->interval_morph_t = 0.f;
+}
+
+extern "C" void vroom_chart_set_interval_morph(VroomChart* chart, float t) {
+    if (!chart) return;
+    chart->interval_morph_t = std::clamp(t, 0.f, 1.f);
+    if (chart->interval_morph_t >= 1.f) {
+        chart->morph_from.clear();
+        chart->morph_from.shrink_to_fit();
+    }
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_pan(VroomChart* chart, float dx_px, float /*dy_px*/) {
     if (!chart || dx_px == 0.f || chart->candles.empty()) return;
 
@@ -481,7 +590,7 @@ extern "C" void vroom_chart_scale_time_axis(VroomChart* chart, float dx_px) {
 extern "C" void vroom_chart_resize_indicator_pane(VroomChart* chart, float dy_px) {
     if (!chart || dy_px == 0.f) return;
 
-    const int pane_count = (chart->rsi_enabled ? 1 : 0) + (chart->macd_enabled ? 1 : 0);
+    const int pane_count = (chart->rsi.enabled ? 1 : 0) + (chart->macd.enabled ? 1 : 0);
     if (pane_count == 0) return;  // nothing below the chart to resize
 
     const auto lay = chart->layout();
@@ -535,8 +644,8 @@ extern "C" void vroom_chart_scale_indicator_axis(VroomChart* chart, float y_px,
     struct ActivePane { int order; int type; };  // type: 0 = RSI, 1 = MACD
     ActivePane panes[2];
     int count = 0;
-    if (chart->rsi_enabled) panes[count++] = {chart->rsi_order, 0};
-    if (chart->macd_enabled) panes[count++] = {chart->macd_order, 1};
+    if (chart->rsi.enabled) panes[count++] = {chart->rsi_order, 0};
+    if (chart->macd.enabled) panes[count++] = {chart->macd_order, 1};
     if (count == 0) return;
     if (count == 2 && panes[0].order > panes[1].order) {
         const ActivePane tmp = panes[0];
@@ -774,8 +883,9 @@ extern "C" void vroom_chart_set_drawings(VroomChart* chart,
                                          const VroomDrawing* drawings,
                                          size_t count) {
     if (!chart) return;
-    // Deep-copy into the owning form: a pencil's path lives in the chart, so the
-    // caller's `points` buffer may be freed as soon as this returns.
+    // Deep-copy into the owning form: a pencil stroke's or path's points live in
+    // the chart, so the caller's `points` buffer may be freed as soon as this
+    // returns.
     chart->drawings.clear();
     chart->drawings.reserve(count);
     for (size_t i = 0; i < count; ++i) {
@@ -786,7 +896,7 @@ extern "C" void vroom_chart_set_drawings(VroomChart* chart,
         d.color = src.color;
         d.width = src.width;
         d.kind = src.kind;
-        if (src.kind == 2 && src.points && src.point_count > 0) {
+        if ((src.kind == 2 || src.kind == 3) && src.points && src.point_count > 0) {
             d.points.assign(src.points, src.points + src.point_count);
             // Keep a/b mirroring the path ends so bounds/handle code is uniform.
             d.a = d.points.front();
@@ -916,6 +1026,27 @@ extern "C" void vroom_chart_append_draft_point(VroomChart* chart, int64_t time_m
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_draft_path(VroomChart* chart,
+                                           const VroomDrawPoint* points,
+                                           int32_t count, bool has_cursor,
+                                           int64_t cursor_time,
+                                           double cursor_price, uint32_t color,
+                                           float width) {
+    if (!chart) return;
+    chart->draft_active = true;
+    chart->draft_kind = 3;
+    chart->draft_guide = true;
+    chart->draft_color = color;
+    chart->draft_width = width;
+    chart->draft_points.clear();
+    if (points && count > 0) chart->draft_points.assign(points, points + count);
+    chart->draft_has_b = has_cursor;
+    chart->draft_b = VroomDrawPoint{cursor_time, cursor_price};
+    // draft_a doubles as the first placed vertex for the shared node-dot path.
+    if (!chart->draft_points.empty()) chart->draft_a = chart->draft_points.front();
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_clear_draft(VroomChart* chart) {
     if (!chart) return;
     if (!chart->draft_active) return;
@@ -1042,6 +1173,21 @@ extern "C" void vroom_chart_move_drawing_endpoint(VroomChart* chart, int32_t ind
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_move_drawing_vertex(VroomChart* chart, int32_t index,
+                                                int32_t vertex, int64_t time_ms,
+                                                double price) {
+    if (!chart) return;
+    if (index < 0 || index >= static_cast<int32_t>(chart->drawings.size())) return;
+    auto& d = chart->drawings[index];
+    if (d.kind != 3) return;
+    if (vertex < 0 || vertex >= static_cast<int32_t>(d.points.size())) return;
+    d.points[vertex] = VroomDrawPoint{time_ms, price};
+    // a/b mirror the path ends, so moving a terminal vertex has to restate them.
+    d.a = d.points.front();
+    d.b = d.points.back();
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
                                               int64_t d_time_ms, double d_price) {
     if (!chart) return;
@@ -1051,6 +1197,7 @@ extern "C" void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
         p.time_ms += d_time_ms;
         p.price += d_price;
     };
+    // a/b mirror the path/stroke ends, so shifting everything keeps them in sync.
     shift(d.a);
     shift(d.b);
     for (VroomDrawPoint& p : d.points) shift(p);
@@ -1059,61 +1206,66 @@ extern "C" void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
 
 // ---- Indicators -----------------------------------------------------------
 
-extern "C" void vroom_chart_set_rsi(VroomChart* chart, bool enabled, int period,
-                                    double upper_band, double lower_band,
-                                    bool ma_enabled, int ma_period) {
-    if (!chart) return;
-    if (period < 2) period = 2;
-    if (ma_period < 1) ma_period = 1;
-    upper_band = std::clamp(upper_band, 0.0, 100.0);
-    lower_band = std::clamp(lower_band, 0.0, 100.0);
-
-    // Only the series-affecting fields force a recompute; band changes are
-    // render-only.
-    const bool recompute = chart->rsi_enabled != enabled ||
-                           chart->rsi_period != period ||
-                           chart->rsi_ma_enabled != ma_enabled ||
-                           chart->rsi_ma_period != ma_period;
-    const bool changed = recompute || chart->rsi_upper != upper_band ||
-                         chart->rsi_lower != lower_band;
-    if (!changed) return;
+extern "C" void vroom_chart_set_rsi(VroomChart* chart, const VroomRSI* cfg) {
+    if (!chart || !cfg) return;
+    VroomRSI next = *cfg;
+    next.enabled = next.enabled ? 1 : 0;
+    next.ma_visible = next.ma_visible ? 1 : 0;
+    next.line_visible = next.line_visible ? 1 : 0;
+    next.bands_visible = next.bands_visible ? 1 : 0;
+    if (next.period < 2) next.period = 2;
+    if (next.ma_period < 1) next.ma_period = 1;
+    next.upper_band = std::clamp(next.upper_band, 0.0, 100.0);
+    next.lower_band = std::clamp(next.lower_band, 0.0, 100.0);
+
+    // Only the series-affecting fields force a recompute; band levels, color,
+    // width, and visibility changes are render-only. The trendline is one of
+    // them: it isn't computed while hidden, so revealing it needs a recompute.
+    const VroomRSI& cur = chart->rsi;
+    const bool recompute = cur.enabled != next.enabled ||
+                           cur.period != next.period ||
+                           cur.ma_visible != next.ma_visible ||
+                           cur.ma_period != next.ma_period ||
+                           cur.ma_kind != next.ma_kind;
 
     // Pane order: claim the next slot on an off->on transition, release on off.
-    if (enabled && !chart->rsi_enabled) chart->rsi_order = chart->pane_seq++;
-    else if (!enabled) chart->rsi_order = -1;
-
-    chart->rsi_enabled = enabled;
-    chart->rsi_period = period;
-    chart->rsi_upper = upper_band;
-    chart->rsi_lower = lower_band;
-    chart->rsi_ma_enabled = ma_enabled;
-    chart->rsi_ma_period = ma_period;
+    if (next.enabled && !cur.enabled) chart->rsi_order = chart->pane_seq++;
+    else if (!next.enabled) chart->rsi_order = -1;
+
+    chart->rsi = next;
     if (recompute) chart->rsi_dirty = true;
     chart->mark_dirty();
 }
 
-extern "C" void vroom_chart_set_macd(VroomChart* chart, bool enabled, int fast,
-                                     int slow, int signal) {
-    if (!chart) return;
-    if (fast < 1) fast = 1;
-    if (slow < 1) slow = 1;
-    if (slow <= fast) slow = fast + 1;
-    if (signal < 1) signal = 1;
-
-    const bool recompute = chart->macd_enabled != enabled ||
-                           chart->macd_fast != fast ||
-                           chart->macd_slow != slow ||
-                           chart->macd_signal != signal;
-    if (!recompute) return;
-
-    if (enabled && !chart->macd_enabled) chart->macd_order = chart->pane_seq++;
-    else if (!enabled) chart->macd_order = -1;
-
-    chart->macd_enabled = enabled;
-    chart->macd_fast = fast;
-    chart->macd_slow = slow;
-    chart->macd_signal = signal;
-    chart->macd_dirty = true;
+extern "C" void vroom_chart_set_macd(VroomChart* chart, const VroomMACD* cfg) {
+    if (!chart || !cfg) return;
+    VroomMACD next = *cfg;
+    next.enabled = next.enabled ? 1 : 0;
+    next.line_visible = next.line_visible ? 1 : 0;
+    next.signal_visible = next.signal_visible ? 1 : 0;
+    next.hist_visible = next.hist_visible ? 1 : 0;
+    next.zero_visible = next.zero_visible ? 1 : 0;
+    if (next.fast < 1) next.fast = 1;
+    if (next.slow < 1) next.slow = 1;
+    if (next.slow <= next.fast) next.slow = next.fast + 1;
+    if (next.signal < 1) next.signal = 1;
+
+    // Only the series-affecting fields force a recompute; color, width, and
+    // visibility changes are render-only.
+    const VroomMACD& cur = chart->macd;
+    const bool recompute = cur.enabled != next.enabled ||
+                           cur.fast != next.fast ||
+                           cur.slow != next.slow ||
+                           cur.signal != next.signal ||
+                           cur.source != next.source ||
+                           cur.ma_kind != next.ma_kind ||
+                           cur.signal_ma_kind != next.signal_ma_kind;
+
+    if (next.enabled && !cur.enabled) chart->macd_order = chart->pane_seq++;
+    else if (!next.enabled) chart->macd_order = -1;
+
+    chart->macd = next;
+    if (recompute) chart->macd_dirty = true;
     chart->mark_dirty();
 }
 
@@ -1126,19 +1278,21 @@ extern "C" void vroom_chart_set_overlays(VroomChart* chart,
     chart->mark_dirty();
 }
 
-extern "C" void vroom_chart_set_vwap(VroomChart* chart, bool enabled,
-                                     int reset_offset_min, uint32_t color,
-                                     float width) {
-    if (!chart) return;
+extern "C" void vroom_chart_set_vwap(VroomChart* chart, const VroomVWAP* cfg) {
+    if (!chart || !cfg) return;
+    VroomVWAP next = *cfg;
+    next.enabled = next.enabled ? 1 : 0;
     // Keep the offset within a day [0, 1440).
-    int off = reset_offset_min % 1440;
-    if (off < 0) off += 1440;
-    const bool recompute =
-        chart->vwap_enabled != enabled || chart->vwap_reset_offset_min != off;
-    chart->vwap_enabled = enabled;
-    chart->vwap_reset_offset_min = off;
-    chart->vwap_color = color;
-    chart->vwap_width = width;
+    next.reset_offset_min %= 1440;
+    if (next.reset_offset_min < 0) next.reset_offset_min += 1440;
+
+    // Only the series-affecting fields force a recompute; color and width
+    // changes are render-only.
+    const VroomVWAP& cur = chart->vwap;
+    const bool recompute = cur.enabled != next.enabled ||
+                           cur.reset_offset_min != next.reset_offset_min;
+
+    chart->vwap = next;
     if (recompute) chart->vwap_dirty = true;
     chart->mark_dirty();
 }
@@ -1166,6 +1320,30 @@ extern "C" void vroom_chart_set_bollinger(VroomChart* chart,
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_volume(VroomChart* chart,
+                                       const VroomVolume* cfg) {
+    if (!chart || !cfg) return;
+    VroomVolume next = *cfg;
+    next.enabled = next.enabled ? 1 : 0;
+    // Negative means "inherit", so only clamp the ranges once a value is set.
+    if (next.height_frac >= 0.f) next.height_frac = std::min(next.height_frac, 1.f);
+    if (next.opacity >= 0.f) next.opacity = std::min(next.opacity, 1.f);
+    chart->volume = next;
+    // Snap the collapse to the new target, the way set_chart_type snaps the
+    // candle↔line morph. A host that wants the toggle animated overrides this
+    // from its frame loop before the next paint.
+    chart->volume_collapse_t = next.enabled ? 0.f : 1.f;
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_set_volume_collapse(VroomChart* chart, float t,
+                                               int32_t easing) {
+    if (!chart) return;
+    chart->volume_collapse_t = std::clamp(t, 0.f, 1.f);
+    chart->volume_collapse_easing = easing;
+    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/drawings.cpp

@@ -115,6 +115,99 @@ void draw_path(SkCanvas* canvas, const VroomChart& chart, const Layout& lay,
     canvas->drawPath(builder.detach(), paint);
 }
 
+// Strokes straight segments through `pts` (already in pixels). Unlike a pencil
+// stroke a path's vertices were each placed deliberately, so the corners are the
+// point — no smoothing. Round joins/caps keep the corners from spiking at the
+// sharp angles a wave count tends to produce.
+void draw_polyline(SkCanvas* canvas, const std::vector<SkPoint>& pts,
+                   SkColor color, float width) {
+    if (pts.size() < 2) return;
+    SkPathBuilder builder;
+    builder.moveTo(pts[0]);
+    for (size_t i = 1; i < pts.size(); ++i) builder.lineTo(pts[i]);
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    paint.setColor(color);
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStrokeWidth(width > 0.f ? width : 2.f);
+    paint.setStrokeCap(SkPaint::kRound_Cap);
+    paint.setStrokeJoin(SkPaint::kRound_Join);
+    canvas->drawPath(builder.detach(), paint);
+}
+
+// Apex-to-base length of the arrowhead. Scales with the stroke so a thicker
+// path gets a proportionally bigger head.
+float arrow_head_len(float width) {
+    return 5.f + 2.5f * (width > 0.f ? width : 2.f);
+}
+
+// Fills a small triangular arrowhead with its apex at `tip`, pointing away from
+// `from`. Skipped when the segment is too short to seat one (otherwise the head
+// would swallow the whole segment and flip direction on tiny jitters).
+void draw_arrow_head(SkCanvas* canvas, SkPoint tip, SkPoint from, SkColor color,
+                     float width) {
+    const float len = arrow_head_len(width);
+    const float half = len * 0.45f;  // base half-width
+    const float dx = tip.fX - from.fX;
+    const float dy = tip.fY - from.fY;
+    const float dist = std::sqrt(dx * dx + dy * dy);
+    if (dist < len) return;
+
+    const float ux = dx / dist;  // unit vector pointing at the tip
+    const float uy = dy / dist;
+    const SkPoint base{tip.fX - ux * len, tip.fY - uy * len};
+
+    SkPathBuilder head;
+    head.moveTo(tip);
+    head.lineTo(base.fX - uy * half, base.fY + ux * half);  // base, one side
+    head.lineTo(base.fX + uy * half, base.fY - ux * half);  // base, the other
+    head.close();
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    paint.setColor(color);
+    paint.setStyle(SkPaint::kFill_Style);
+    canvas->drawPath(head.detach(), paint);
+}
+
+// Projects every point of a path/stroke to pixels in one pass, so the render and
+// arrowhead code can index them without re-projecting.
+std::vector<SkPoint> project_all(const VroomChart& chart, const Layout& lay,
+                                 const PriceBounds& bounds, int64_t window_ms,
+                                 const std::vector<VroomDrawPoint>& pts) {
+    std::vector<SkPoint> out;
+    out.reserve(pts.size());
+    for (const auto& p : pts) out.push_back(to_px(chart, lay, bounds, window_ms, p));
+    return out;
+}
+
+// Draws a whole arrow-tipped path from its already-projected points: the
+// segments, then the head on the last one.
+void draw_arrow_path(SkCanvas* canvas, const std::vector<SkPoint>& pts,
+                     SkColor color, float width) {
+    if (pts.size() < 2) return;
+    const SkPoint tip = pts.back();
+    const SkPoint prev = pts[pts.size() - 2];
+    const float len = arrow_head_len(width);
+    const float dx = tip.fX - prev.fX;
+    const float dy = tip.fY - prev.fY;
+    const float dist = std::sqrt(dx * dx + dy * dy);
+    if (dist < len) {  // no room for a head — just the bare segments
+        draw_polyline(canvas, pts, color, width);
+        return;
+    }
+
+    // Stop the stroke at the head's base rather than running it to the apex:
+    // its round cap is a half-disc of radius width/2 centred on the endpoint, so
+    // at the apex it bulges past the point and blunts it. The base is wider than
+    // the stroke, so the cap ends up hidden inside the triangle.
+    std::vector<SkPoint> body(pts);
+    body.back() = SkPoint{tip.fX - dx / dist * len, tip.fY - dy / dist * len};
+    draw_polyline(canvas, body, color, width);
+    draw_arrow_head(canvas, tip, prev, color, width);
+}
+
 void draw_node(SkCanvas* canvas, SkPoint pt, float scale = 1.f) {
     SkPaint fill;
     fill.setAntiAlias(true);
@@ -232,6 +325,12 @@ void draw(SkCanvas* canvas,
                           static_cast<SkColor>(d.color), d.width);
                 continue;
             }
+            if (d.kind == 3) {
+                draw_arrow_path(
+                    canvas, project_all(chart, lay, bounds, window_ms, d.points),
+                    static_cast<SkColor>(d.color), d.width);
+                continue;
+            }
             const SkPoint a = to_px(chart, lay, bounds, window_ms, d.a);
             const SkPoint b = to_px(chart, lay, bounds, window_ms, d.b);
             if (d.kind == 1) {
@@ -255,7 +354,16 @@ void draw(SkCanvas* canvas,
         const auto& d = chart.drawings[chart.selected_drawing];
         const SkPoint sa = to_px(chart, lay, bounds, window_ms, d.a);
         const SkPoint sb = to_px(chart, lay, bounds, window_ms, d.b);
-        if (d.kind == 2) {
+        if (d.kind == 3) {
+            // Path: every vertex was placed by hand, so every one is a grab
+            // handle. The one being dragged renders 50% larger, like a line's.
+            const auto pts = project_all(chart, lay, bounds, window_ms, d.points);
+            for (size_t i = 0; i < pts.size(); ++i) {
+                draw_node(canvas, pts[i],
+                          chart.grabbed_endpoint == static_cast<int32_t>(i) ? 1.5f
+                                                                            : 1.f);
+            }
+        } else if (d.kind == 2) {
             // Pencil: anchors on the first/last point are a visual cue that the
             // stroke is movable — they aren't grab handles, so never enlarged.
             draw_node(canvas, sa);
@@ -289,6 +397,28 @@ void draw(SkCanvas* canvas,
         return;
     }
 
+    // 1d. Path in progress: the vertices placed so far, plus a rubber-band
+    //     segment to the cursor. The arrow rides the leading edge — on the
+    //     cursor while drawing, and (once committed) on the final vertex — so
+    //     the preview reads as the arrow it's about to become.
+    if (chart.draft_kind == 3) {
+        if (chart.draft_points.empty()) return;
+        auto pts = project_all(chart, lay, bounds, window_ms, chart.draft_points);
+        if (chart.draft_has_b) {
+            pts.push_back(to_px(chart, lay, bounds, window_ms, chart.draft_b));
+        }
+        canvas->save();
+        canvas->clipRect(clip);
+        draw_arrow_path(canvas, pts, static_cast<SkColor>(chart.draft_color),
+                        chart.draft_width);
+        canvas->restore();
+        // Node dots on the placed vertices only (not the cursor) — unclipped, so
+        // a vertex on the very edge still renders whole.
+        const size_t placed = chart.draft_points.size();
+        for (size_t i = 0; i < placed; ++i) draw_node(canvas, pts[i]);
+        return;
+    }
+
     const SkPoint a = to_px(chart, lay, bounds, window_ms, chart.draft_a);
     const bool has_b = chart.draft_has_b;
     const SkPoint b =
@@ -339,7 +469,18 @@ HitResult hit_test(const VroomChart& chart,
         const auto& d = chart.drawings[chart.selected_drawing];
         const SkPoint a = to_px(chart, lay, bounds, window_ms, d.a);
         const SkPoint b = to_px(chart, lay, bounds, window_ms, d.b);
-        if (d.kind == 2) {
+        if (d.kind == 3) {
+            // Path: every vertex is a handle. Later vertices win an overlap, so
+            // stacked points stay individually reachable by peeling them off.
+            for (size_t i = d.points.size(); i-- > 0;) {
+                const SkPoint p = to_px(chart, lay, bounds, window_ms, d.points[i]);
+                if (std::hypot(x - p.fX, y - p.fY) <= kHandleHit) {
+                    return HitResult{chart.selected_drawing,
+                                     VROOM_DRAW_PART_VERTEX + static_cast<int32_t>(i),
+                                     0.f};
+                }
+            }
+        } else if (d.kind == 2) {
             // Pencil has no grab handles — its anchors translate like any other
             // part of the stroke, so fall through to the body pass.
         } else if (d.kind == 1) {
@@ -367,13 +508,15 @@ HitResult hit_test(const VroomChart& chart,
     float best_t = 0.f;
     for (size_t i = 0; i < chart.drawings.size(); ++i) {
         const auto& d = chart.drawings[i];
-        if (d.kind == 2) {
+        // Pencil and path share the polyline distance — a path's straight
+        // segments are exactly what dist_to_path already measures against.
+        if (d.kind == 2 || d.kind == 3) {
             const float dist = dist_to_path(x, y, chart, lay, bounds, window_ms,
                                             d.points, kBodyHit);
             if (dist <= best) {  // <= so later (topmost) drawings win ties
                 best = dist;
                 best_i = static_cast<int32_t>(i);
-                best_part = 5;
+                best_part = d.kind == 3 ? 6 : 5;
                 best_t = 0.f;
             }
             continue;

package/cpp/_core_src/drawings.h

@@ -1,10 +1,11 @@
 // Drawing annotations — user-placed line tools rendered on the price pane.
 //
 // Two kinds of geometry are drawn here:
-//   * Committed lines (chart.drawings) — two-point trendlines anchored in data
-//     space, so they stay glued to the candles as the user pans/zooms.
+//   * Committed shapes (chart.drawings) — lines, boxes, freehand strokes and
+//     arrow-tipped paths, anchored in data space so they stay glued to the
+//     candles as the user pans/zooms.
 //   * The transient "draft" (chart.draft_*) — the in-progress node dots and the
-//     live guideline shown while the user is placing a line.
+//     live guideline shown while the user is placing a shape.
 //
 // Like ma_overlay / crosshair this is its own module so the chart orchestrator
 // stays thin. Drawn after the overlays and before the axis backgrounds.
@@ -39,8 +40,12 @@ void draw(SkCanvas* canvas,
 //   * pencil — always 5 (stroke body). A freehand stroke has no grab handles:
 //              its end anchors are a visual cue only and translate the whole
 //              path like any other part of it.
-// Corner/endpoint hits are only reported for the currently selected drawing
-// (whose handles are visible).
+//   * path   — 6 (path body) or VROOM_DRAW_PART_VERTEX + i for vertex i. Unlike
+//              a pencil every vertex was placed deliberately, so every one is a
+//              grab handle; the offset keeps those indices clear of the small
+//              part numbers above.
+// Corner/endpoint/vertex hits are only reported for the currently selected
+// drawing (whose handles are visible).
 struct HitResult {
     int32_t index;
     int32_t part;