react-native-vroom-chart 0.7.0 → 0.8.0

package/cpp/VroomChartHostObject.cpp

@@ -29,7 +29,7 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(29);
+  out.reserve(39);
   out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
@@ -38,6 +38,13 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setDefaultCandleWidth"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setChartType"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "getVisibleRange"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "resetView"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "resetPriceScale"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "getVisiblePriceEnvelope"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "preservePriceEnvelope"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "beginIntervalMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setIntervalMorph"));
   out.push_back(jsi::PropNameID::forAscii(rt, "pan"));
   out.push_back(jsi::PropNameID::forAscii(rt, "translate"));
   out.push_back(jsi::PropNameID::forAscii(rt, "zoom"));
@@ -297,6 +304,129 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "getVisibleRange") {
+    // getVisibleRange() -> { startMs, endMs }. Both 0 while uninitialized.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "getVisibleRange"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          int64_t s = 0, e = 0;
+          vroom_chart_get_visible_range(chart_, &s, &e);
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "startMs", static_cast<double>(s));
+          obj.setProperty(rt2, "endMs", static_cast<double>(e));
+          return obj;
+        });
+  }
+
+  if (name == "resetView") {
+    // resetView() — reframe the most recent candles and re-enable y auto-fit.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "resetView"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_reset_view(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "resetPriceScale") {
+    // resetPriceScale() — re-enable y auto-fit, leaving the time window alone.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "resetPriceScale"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_reset_price_scale(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "getVisiblePriceEnvelope") {
+    // getVisiblePriceEnvelope() -> { low, high } | null. The extent the visible
+    // candles occupy, not the (wider) axis range. No rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "getVisiblePriceEnvelope"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          double low = 0.0, high = 0.0;
+          if (!vroom_chart_get_visible_price_envelope(chart_, &low, &high)) {
+            return jsi::Value::null();
+          }
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "low", low);
+          obj.setProperty(rt2, "high", high);
+          return obj;
+        });
+  }
+
+  if (name == "preservePriceEnvelope") {
+    // preservePriceEnvelope(prevLow, prevHigh) — scale-lock a manual price
+    // range across a timeframe switch. No-op in auto-y mode.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "preservePriceEnvelope"),
+        2,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::undefined();
+          vroom_chart_preserve_price_envelope(chart_, args[0].asNumber(),
+                                              args[1].asNumber());
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "beginIntervalMorph") {
+    // beginIntervalMorph() — capture the visible candle geometry so the next
+    // setCandles can be animated as a reshape. Call before setCandles.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "beginIntervalMorph"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_begin_interval_morph(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setIntervalMorph") {
+    // setIntervalMorph(t) — advance the capture toward the new candles. `t` is
+    // pre-eased progress: 0 = the captured frame, 1 = settled (capture freed).
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setIntervalMorph"),
+        1,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1) return jsi::Value::undefined();
+          vroom_chart_set_interval_morph(
+              chart_, static_cast<float>(args[0].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "pan") {
     // pan(dx, dy) -> JsiSkPicture
     // Mutates the visible range and renders in one JSI call so gesture

package/cpp/_core_include/vroom/vroom_chart.h

@@ -172,17 +172,20 @@ typedef struct VroomDrawPoint {
 //                and `b`; the other two corners (a.x,b.y) and (b.x,a.y) derive.
 //   2 = pencil — a freehand path through `points` (in draw order). `a`/`b` mirror
 //                the first/last point so bounds and handle code stay uniform.
+//   3 = path   — straight segments through `points` (in draw order), ending in
+//                an arrowhead on the last one. Same storage as a pencil, but
+//                rendered unsmoothed and with every vertex a grab handle.
 //
-// `points`/`point_count` are only read for kind 2; line and box leave them
-// null/0. Like the rest of this API the points are copied internally, so the
-// caller may free them as soon as the call returns.
+// `points`/`point_count` are only read for kinds 2 and 3; line and box leave
+// them null/0. Like the rest of this API the points are copied internally, so
+// the caller may free them as soon as the call returns.
 typedef struct VroomDrawing {
     VroomDrawPoint        a;
     VroomDrawPoint        b;
     uint32_t              color;        // 0xAARRGGBB
     float                 width;        // stroke width in px
-    int32_t               kind;         // 0 = line, 1 = box, 2 = pencil
-    const VroomDrawPoint* points;       // pencil path (kind 2), else null
+    int32_t               kind;         // 0 = line, 1 = box, 2 = pencil, 3 = path
+    const VroomDrawPoint* points;       // pencil/path points (kind 2/3), else null
     int32_t               point_count;  // number of `points`, else 0
 } VroomDrawing;
 
@@ -551,18 +554,31 @@ void vroom_chart_set_drawings(VroomChart* chart, const VroomDrawing* drawings,
                               size_t count);
 
 // Hit-tests pixel (x_px, y_px) against the committed drawings. On a hit, fills
-// *out_index with the drawing index, *out_part with 0 (endpoint A), 1
-// (endpoint B), or 2 (line body), *out_t with the 0..1 grab position along the
-// segment (A→B; 0/1 for handle hits), and returns true. Endpoint hits are only
-// reported for the currently selected drawing (whose handles are visible).
-// Returns false on a miss (out params untouched). Any out pointer may be null.
+// *out_index with the drawing index, *out_part with the sub-part that was hit,
+// *out_t with the 0..1 grab position along the segment (A→B; 0/1 for handle
+// hits, 0 for the shapes that have no meaningful t), and returns true. Handle
+// hits are only reported for the currently selected drawing (whose handles are
+// visible). Returns false on a miss (out params untouched). Any out pointer may
+// be null.
+//
+// `out_part` is per-kind (see VroomDrawing.kind):
+//   line   — 0 (endpoint A), 1 (endpoint B), 2 (body).
+//   box    — 0..3 (corners, in the order a, (b.x,a.y), b, (a.x,b.y)), 4 (body).
+//   pencil — 5 (body; a stroke has no handles).
+//   path   — 6 (body), or VROOM_DRAW_PART_VERTEX + i for vertex i. The offset
+//            keeps a vertex index from colliding with the small part numbers
+//            above, and is why a path is capped at VROOM_PATH_MAX_POINTS.
+#define VROOM_DRAW_PART_VERTEX 100
+#define VROOM_PATH_MAX_POINTS  64
 bool vroom_chart_hit_test_drawing(VroomChart* chart, float x_px, float y_px,
                                   int32_t* out_index, int32_t* out_part,
                                   float* out_t);
 
-// Selects a committed drawing (renders its endpoint handles). `index` -1 clears
-// the selection. `grabbed_endpoint` 0/1 renders that handle 50% larger while it's
-// being dragged; -1 for none. An out-of-range index clears the selection.
+// Selects a committed drawing (renders its handles). `index` -1 clears the
+// selection. `grabbed_endpoint` renders that handle 50% larger while it's being
+// dragged (0/1 for a line, 0 for the box corner the host normalized to, the
+// vertex index for a path); -1 for none. An out-of-range index clears the
+// selection.
 void vroom_chart_set_selected_drawing(VroomChart* chart, int32_t index,
                                       int32_t grabbed_endpoint);
 
@@ -572,8 +588,16 @@ void vroom_chart_move_drawing_endpoint(VroomChart* chart, int32_t index,
                                        int32_t endpoint, int64_t time_ms,
                                        double price);
 
+// Moves one vertex of a committed path (kind 3) to a new data-space anchor, for
+// live handle dragging. `vertex` indexes `points`; a/b are re-mirrored onto the
+// first/last point afterwards. No-op for an out-of-range drawing/vertex index or
+// a drawing that isn't a path.
+void vroom_chart_move_drawing_vertex(VroomChart* chart, int32_t index,
+                                     int32_t vertex, int64_t time_ms,
+                                     double price);
+
 // Shifts a whole committed drawing by a *relative* data-space delta — `a`, `b`,
-// and (for a pencil) every path point. Used for live body dragging of shapes
+// and (for a pencil or path) every point. Used for live body dragging of shapes
 // whose points can't be restated cheaply. No-op for an out-of-range index.
 void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
                                    int64_t d_time_ms, double d_price);
@@ -642,6 +666,19 @@ void vroom_chart_start_draft_stroke(VroomChart* chart, uint32_t color,
 void vroom_chart_append_draft_point(VroomChart* chart, int64_t time_ms,
                                     double price);
 
+// Restates the whole in-progress path (kind 3) draft: `count` vertices placed so
+// far, plus — when `has_cursor` — a rubber-band segment from the last vertex to
+// (cursor_time, cursor_price) carrying the arrow tip. Each placed vertex renders
+// a node dot. A path is placed one deliberate click at a time (so `count` stays
+// small, see VROOM_PATH_MAX_POINTS), which is why this restates rather than
+// appending: the host stays the sole owner of the vertex list, and undoing a
+// point is just a shorter array. Pass count 0 with has_cursor false to show
+// nothing; the points are copied, so the caller may free them on return.
+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);
+
 // Clears the draft (hides the in-progress node dots / guideline / stroke).
 void vroom_chart_clear_draft(VroomChart* chart);
 

package/cpp/_core_src/chart.h

@@ -182,9 +182,10 @@ struct VroomChart {
     // Committed drawings, anchored in data space so they track the candles on
     // pan/zoom. Drawn on the price pane above candles/overlays.
     //
-    // Mirrors the public VroomDrawing but *owns* its points, so a pencil path
-    // (kind 2) can carry a variable number of them. For line/box `points` is
-    // empty and only a/b are used; for pencil a/b mirror the first/last point.
+    // Mirrors the public VroomDrawing but *owns* its points, so a pencil stroke
+    // (kind 2) or path (kind 3) can carry a variable number of them. For
+    // line/box `points` is empty and only a/b are used; for pencil/path a/b
+    // mirror the first/last point.
     struct StoredDrawing {
         VroomDrawPoint              a{};
         VroomDrawPoint              b{};
@@ -199,7 +200,9 @@ struct VroomChart {
     // draft_a is always drawn (node dot); draft_b is drawn when draft_has_b.
     // draft_guide draws the live guideline A->B; when false only node dots show
     // (the committed segment renders via `drawings`). draft_color/draft_width
-    // style the guideline to match the eventual line.
+    // style the guideline to match the eventual line. For a path (draft_kind 3)
+    // draft_points holds the vertices placed so far and draft_b is the cursor
+    // the rubber-band segment runs to (when draft_has_b).
     bool           draft_active = false;
     VroomDrawPoint draft_a{};
     bool           draft_has_b = false;
@@ -207,14 +210,16 @@ struct VroomChart {
     bool           draft_guide = false;
     uint32_t       draft_color = 0xff2962ff;
     float          draft_width = 2.f;
-    int32_t        draft_kind = 0;  // 0 = line, 1 = box, 2 = pencil (VroomDrawing)
-    // Freehand stroke in progress (draft_kind 2), grown one point at a time.
+    int32_t        draft_kind = 0;  // 0 = line, 1 = box, 2 = pencil, 3 = path
+    // Points of the in-progress stroke (draft_kind 2, grown one at a time) or
+    // path (draft_kind 3, restated per click/move).
     std::vector<VroomDrawPoint> draft_points;
 
     // Selection/editing state for committed drawings. selected_drawing indexes
-    // `drawings` (or -1); its endpoints render as handles. grabbed_endpoint is
-    // 0 (A) or 1 (B) while that handle is being dragged (rendered 50% larger),
-    // else -1.
+    // `drawings` (or -1); its handles render on top. grabbed_endpoint is the
+    // handle being dragged — 0 (A) or 1 (B) for a line, 0 for a box (the host
+    // normalizes the grabbed corner to endpoint 0), the vertex index for a path
+    // — rendered 50% larger; -1 when none.
     int32_t        selected_drawing = -1;
     int32_t        grabbed_endpoint = -1;
 

package/cpp/_core_src/chart_facade.cpp

@@ -883,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) {
@@ -895,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();
@@ -1025,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;
@@ -1151,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;
@@ -1160,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);

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;