react-native-vroom-chart 0.2.0 → 0.4.0

package/cpp/VroomChartHostObject.cpp

@@ -27,13 +27,15 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(22);
+  out.reserve(24);
   out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setFloat"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVisibleRange"));
   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, "pan"));
   out.push_back(jsi::PropNameID::forAscii(rt, "translate"));
   out.push_back(jsi::PropNameID::forAscii(rt, "zoom"));
@@ -188,6 +190,41 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setChartType") {
+    // setChartType(mode) — 0 = candlesticks (default), 1 = line chart.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setChartType"),
+        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_chart_type(
+              chart_, static_cast<int32_t>(args[0].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setMorph") {
+    // setMorph(collapse, fade) — candle↔line blend for animated transitions.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setMorph"),
+        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_set_morph(chart_,
+                                static_cast<float>(args[0].asNumber()),
+                                static_cast<float>(args[1].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

@@ -55,12 +55,24 @@ typedef struct VroomDrawPoint {
     double  price;
 } VroomDrawPoint;
 
-// A committed line drawing: a two-point trendline on the price pane.
+// A committed drawing on the price pane. `kind` selects the geometry:
+//   0 = line   — a two-point trendline from `a` to `b`.
+//   1 = box    — an axis-aligned rectangle whose two opposite corners are `a`
+//                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.
+//
+// `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.
 typedef struct VroomDrawing {
-    VroomDrawPoint a;
-    VroomDrawPoint b;
-    uint32_t       color;  // 0xAARRGGBB
-    float          width;  // stroke width in px
+    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               point_count;  // number of `points`, else 0
 } VroomDrawing;
 
 // A resting-liquidity band: a price interval carrying a total order size on one
@@ -112,6 +124,7 @@ typedef enum {
     VROOM_COLOR_WICK_BEAR,         // bear wick; 0 alpha => inherit BEAR fill
     VROOM_COLOR_ACCENT_BULL,       // generic up color: price indicator, volume, MACD
     VROOM_COLOR_ACCENT_BEAR,       // generic down color
+    VROOM_COLOR_LINE,              // line-chart-mode close-price polyline
     VROOM_COLOR_COUNT_
 } VroomColorKey;
 
@@ -127,6 +140,7 @@ typedef enum {
     VROOM_FLOAT_CANDLE_RADIUS_PX,        // candle body corner radius px (0 = square)
     VROOM_FLOAT_WICK_ROUND_CAP,          // 0/1: round the wick end caps
     VROOM_FLOAT_VOLUME_RADIUS_PX,        // volume bar top-corner radius px (0 = square)
+    VROOM_FLOAT_LINE_WIDTH_PX,           // line-chart-mode polyline stroke width px
     VROOM_FLOAT_COUNT_
 } VroomFloatKey;
 
@@ -163,6 +177,17 @@ void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_ms, int64_t
 // set_visible_range still overrides it.
 void vroom_chart_set_default_candle_width(VroomChart* chart, float px);
 
+// Chart render mode: 0 = candlesticks (default), 1 = line chart (a polyline
+// through each candle's close). Other layers (volume, indicators, overlays,
+// crosshair, drawings) are unaffected.
+void vroom_chart_set_chart_type(VroomChart* chart, int32_t mode);
+
+// Candle↔line morph blend for animated transitions. `collapse` folds candles
+// toward their close price; `fade` crossfades candles→line. Both 0 = candles,
+// both 1 = line. Driven per-frame by the host animation loop; set_chart_type
+// snaps both to the target.
+void vroom_chart_set_morph(VroomChart* chart, float collapse, float fade);
+
 // Reads the current visible time window. Either out pointer may be null.
 // Both are 0 when the window is still uninitialized.
 void vroom_chart_get_visible_range(VroomChart* chart,
@@ -304,6 +329,34 @@ void vroom_chart_set_vwap(VroomChart* chart, bool enabled, int reset_offset_min,
 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.
+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.
+void vroom_chart_set_selected_drawing(VroomChart* chart, int32_t index,
+                                      int32_t grabbed_endpoint);
+
+// Moves one endpoint of a committed drawing to a new data-space anchor (for live
+// handle dragging). `endpoint` is 0 (A) or 1 (B). No-op for an out-of-range index.
+void vroom_chart_move_drawing_endpoint(VroomChart* chart, int32_t index,
+                                       int32_t endpoint, 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
+// 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);
+
 // ---- Liquidity bands (order-book depth overlay) ---------------------------
 
 // Replaces the full set of resting-liquidity bands and their shared style.
@@ -314,14 +367,29 @@ void vroom_chart_set_liquidity(VroomChart* chart, const VroomBand* bands,
 
 // 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 guideline A->B (the live line preview); `guide == 0`
-// draws node dots only (the committed segment already renders via set_drawings).
-// `color`/`width` style the guideline to match the eventual line.
+// `guide != 0` also draws the live preview (a guideline for a line, or a preview
+// rectangle for a box); `guide == 0` draws node dots only (the committed shape
+// already renders via set_drawings). `kind` matches VroomDrawing (0 = line,
+// 1 = box) so the preview geometry matches the eventual shape. `color`/`width`
+// style the preview to match the eventual drawing.
 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, float width);
-
-// Clears the draft (hides the in-progress node dots / guideline).
+                           bool guide, uint32_t color, float width,
+                           int32_t kind);
+
+// Begins a freehand (pencil) draft stroke, clearing any previous draft points.
+// Follow with vroom_chart_append_draft_point per captured sample; the growing
+// path renders live. `color`/`width` style it to match the eventual stroke.
+void vroom_chart_start_draft_stroke(VroomChart* chart, uint32_t color,
+                                    float width);
+
+// Appends one point to the in-progress freehand draft. Cheap (O(1) amortized) so
+// it can be called on every pointer move without restating the whole path.
+// No-op unless a draft stroke was started.
+void vroom_chart_append_draft_point(VroomChart* chart, int64_t time_ms,
+                                    double price);
+
+// Clears the draft (hides the in-progress node dots / guideline / stroke).
 void vroom_chart_clear_draft(VroomChart* chart);
 
 // Fills *out with the continuous data coordinate (time_ms, price) at pixel
@@ -331,6 +399,13 @@ void vroom_chart_clear_draft(VroomChart* chart);
 bool vroom_chart_coord_at(VroomChart* chart, float x_px, float y_px,
                           VroomCoord* out);
 
+// Projects a data coordinate (time_ms, price) to its pixel position, filling
+// *out_x / *out_y (either may be null) with the free (non-snapped) mapping — the
+// inverse of vroom_chart_coord_at, matching the rendered drawing geometry.
+// Returns false (out params untouched) when there are no candles / degenerate.
+bool vroom_chart_project(VroomChart* chart, int64_t time_ms, double price,
+                         float* out_x, float* out_y);
+
 // ---- Rendering ------------------------------------------------------------
 
 void vroom_chart_draw(VroomChart* chart, SkCanvas* canvas);

package/cpp/_core_src/candles.cpp

@@ -30,11 +30,28 @@ void draw(SkCanvas* canvas,
           const PriceBounds& bounds,
           int64_t window_ms,
           int64_t visible_start_ms,
-          int64_t candle_duration_ms) {
+          int64_t candle_duration_ms,
+          float collapse,
+          float opacity) {
     if (!canvas || n == 0) return;
 
-    const float body_w = vroom::candle_body_width(
+    collapse = std::clamp(collapse, 0.f, 1.f);
+    opacity = std::clamp(opacity, 0.f, 1.f);
+    if (opacity <= 0.f) return;
+
+    // During the candle→line morph, fade the entire candle layer as one unit so
+    // overlapping bars/wicks composite cleanly instead of stacking alpha.
+    const bool fade_layer = opacity < 0.999f;
+    if (fade_layer) {
+        canvas->saveLayerAlpha(nullptr,
+                               static_cast<U8CPU>(opacity * 255.f + 0.5f));
+    }
+
+    const float full_body_w = vroom::candle_body_width(
         lay, window_ms, candle_duration_ms);
+    // Thin the body toward the line stroke width as candles collapse to the line.
+    const float line_w = theme.floats[VROOM_FLOAT_LINE_WIDTH_PX];
+    const float body_w = full_body_w + (line_w - full_body_w) * collapse;
 
     const uint32_t fill_bull = theme.colors[VROOM_COLOR_BULL];
     const uint32_t fill_bear = theme.colors[VROOM_COLOR_BEAR];
@@ -94,10 +111,18 @@ void draw(SkCanvas* canvas,
         const float cx = vroom::candle_center_x(
             lay, c.time_ms, candle_duration_ms,
             visible_start_ms, window_ms);
-        const float y_high = vroom::price_to_y(lay, bounds, c.high);
-        const float y_low = vroom::price_to_y(lay, bounds, c.low);
-        const float y_open = vroom::price_to_y(lay, bounds, c.open);
         const float y_close = vroom::price_to_y(lay, bounds, c.close);
+        // Collapse high/low/open toward the close so the candle folds into its
+        // close point (the line vertex) as `collapse` → 1.
+        const float y_high =
+            vroom::price_to_y(lay, bounds, c.high) * (1.f - collapse) +
+            y_close * collapse;
+        const float y_low =
+            vroom::price_to_y(lay, bounds, c.low) * (1.f - collapse) +
+            y_close * collapse;
+        const float y_open =
+            vroom::price_to_y(lay, bounds, c.open) * (1.f - collapse) +
+            y_close * collapse;
 
         canvas->drawLine(cx, y_high, cx, y_low,
                          bull ? wick_bull : wick_bear);
@@ -133,6 +158,8 @@ void draw(SkCanvas* canvas,
             }
         }
     }
+
+    if (fade_layer) canvas->restore();
 }
 
 }  // namespace vroom::candles

package/cpp/_core_src/candles.h

@@ -21,6 +21,11 @@ namespace vroom::candles {
 
 // Draws every candle in [visible, visible + n). The visible slice should
 // already be filtered by `visible_indices` in viewport.h.
+//
+// `collapse` (0..1) morphs each candle vertically toward its close price for the
+// candle→line transition: 0 = normal candle, 1 = a flat point at the close (the
+// body/wick heights and width shrink to the line). `opacity` (0..1) fades the
+// whole candle layer out as the line fades in. Both default to a no-op.
 void draw(SkCanvas* canvas,
           const ::VroomCandle* visible,
           std::size_t n,
@@ -29,6 +34,8 @@ void draw(SkCanvas* canvas,
           const PriceBounds& bounds,
           int64_t window_ms,
           int64_t visible_start_ms,
-          int64_t candle_duration_ms);
+          int64_t candle_duration_ms,
+          float collapse = 0.f,
+          float opacity = 1.f);
 
 }  // namespace vroom::candles

package/cpp/_core_src/chart.cpp

@@ -149,9 +149,27 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
                            candle_area_h);
 
-    // 5. Candles (wicks + bodies)
-    vroom::candles::draw(canvas, visible, n, lay, theme, bounds,
-                         window_ms, visible_start_ms, candle_duration_ms);
+    // 5. Price series — candles, a close-price line, or a blend of the two during
+    //    the candle↔line morph. `morph_fade` crossfades candles→line and
+    //    `morph_collapse` folds each candle toward its close (the line vertex).
+    //    fade 0 = pure candles, fade 1 = pure line. The line reuses the MA-overlay
+    //    polyline routine, fed the visible closes and styled by theme.LINE.
+    const float fade = morph_fade;
+    const float collapse = morph_collapse;
+    if (fade < 1.f) {
+        vroom::candles::draw(canvas, visible, n, lay, theme, bounds, window_ms,
+                             visible_start_ms, candle_duration_ms, collapse,
+                             1.f - fade);
+    }
+    if (fade > 0.f) {
+        std::vector<double> closes(n);
+        for (std::size_t i = 0; i < n; ++i) closes[i] = visible[i].close;
+        vroom::ma_overlay::draw(
+            canvas, lay, bounds, visible, n, closes.data(), window_ms,
+            visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
+            theme.colors[VROOM_COLOR_LINE], theme.floats[VROOM_FLOAT_LINE_WIDTH_PX],
+            nullptr, fade);
+    }
 
     // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
     //      candles. They share the candle price scale and don't reserve a pane.

package/cpp/_core_src/chart.h

@@ -54,6 +54,15 @@ struct VroomChart {
     // initial zoom). 0 = legacy "last ~80 candles" behavior.
     float default_candle_px = 0.f;
 
+    // Render mode: 0 = candlesticks (default), 1 = line chart (close polyline).
+    int chart_type = 0;
+
+    // Candle↔line morph blend, driven per-frame by the JS animation loop.
+    // `morph_collapse` folds candles toward their close; `morph_fade` crossfades
+    // candles→line. Both 0 = candles, both 1 = line. set_chart_type snaps them.
+    float morph_collapse = 0.f;
+    float morph_fade = 0.f;
+
     // Cached y-axis width in pixels, sized to fit the widest formatted price
     // label. 0 = uncomputed; layout() falls back to a width ratio.
     float axis_width_px = 0.f;
@@ -126,10 +135,22 @@ struct VroomChart {
     std::vector<unsigned char> vwap_breaks;
     bool vwap_dirty = true;
 
-    // --- drawings (line annotations) ---------------------------------------
-    // Committed two-point lines, anchored in data space so they track the
-    // candles on pan/zoom. Drawn on the price pane above candles/overlays.
-    std::vector<VroomDrawing> drawings;
+    // --- drawings (annotations) --------------------------------------------
+    // 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.
+    struct StoredDrawing {
+        VroomDrawPoint              a{};
+        VroomDrawPoint              b{};
+        uint32_t                    color = 0xff2962ff;
+        float                       width = 2.f;
+        int32_t                     kind = 0;
+        std::vector<VroomDrawPoint> points;  // pencil path (kind 2)
+    };
+    std::vector<StoredDrawing> drawings;
 
     // Transient in-progress "draft" the drawing tool shows while placing points.
     // draft_a is always drawn (node dot); draft_b is drawn when draft_has_b.
@@ -143,6 +164,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.
+    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.
+    int32_t        selected_drawing = -1;
+    int32_t        grabbed_endpoint = -1;
 
     // --- liquidity bands (order-book depth overlay) ------------------------
     // Resting-order bands anchored in price space, drawn behind the candles and

package/cpp/_core_src/chart_facade.cpp

@@ -12,6 +12,7 @@
 #include <limits>
 
 #include "chart.h"
+#include "drawings.h"
 #include "labels.h"
 #include "viewport.h"
 
@@ -204,6 +205,26 @@ extern "C" void vroom_chart_set_default_candle_width(VroomChart* chart, float px
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_chart_type(VroomChart* chart, int32_t mode) {
+    if (!chart) return;
+    chart->chart_type = mode;
+    // Snap the morph blend to the target so a direct set (no animation) renders
+    // the requested mode immediately. The JS animation loop uses set_morph for
+    // the in-between frames and then calls this to lock the final state.
+    const float t = mode == 1 ? 1.f : 0.f;
+    chart->morph_collapse = t;
+    chart->morph_fade = t;
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_set_morph(VroomChart* chart, float collapse,
+                                      float fade) {
+    if (!chart) return;
+    chart->morph_collapse = collapse;
+    chart->morph_fade = fade;
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_get_visible_range(VroomChart* chart,
                                               int64_t* out_start_ms,
                                               int64_t* out_end_ms) {
@@ -749,7 +770,31 @@ extern "C" void vroom_chart_set_drawings(VroomChart* chart,
                                          const VroomDrawing* drawings,
                                          size_t count) {
     if (!chart) return;
-    chart->drawings.assign(drawings, drawings + count);
+    // 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.
+    chart->drawings.clear();
+    chart->drawings.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+        const VroomDrawing& src = drawings[i];
+        VroomChart::StoredDrawing d;
+        d.a = src.a;
+        d.b = src.b;
+        d.color = src.color;
+        d.width = src.width;
+        d.kind = src.kind;
+        if (src.kind == 2 && 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();
+            d.b = d.points.back();
+        }
+        chart->drawings.push_back(std::move(d));
+    }
+    // Drop selection if the new set no longer contains that index.
+    if (chart->selected_drawing >= static_cast<int32_t>(count)) {
+        chart->selected_drawing = -1;
+        chart->grabbed_endpoint = -1;
+    }
     chart->mark_dirty();
 }
 
@@ -767,7 +812,7 @@ extern "C" void vroom_chart_set_liquidity(VroomChart* chart,
 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,
-                                      float width) {
+                                      float width, int32_t kind) {
     if (!chart) return;
     chart->draft_active = true;
     chart->draft_a = VroomDrawPoint{a_time, a_price};
@@ -776,6 +821,30 @@ extern "C" void vroom_chart_set_draft(VroomChart* chart, int64_t a_time,
     chart->draft_guide = guide;
     chart->draft_color = color;
     chart->draft_width = width;
+    chart->draft_kind = kind;
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_start_draft_stroke(VroomChart* chart, uint32_t color,
+                                               float width) {
+    if (!chart) return;
+    chart->draft_active = true;
+    chart->draft_kind = 2;
+    chart->draft_guide = true;
+    chart->draft_has_b = false;
+    chart->draft_color = color;
+    chart->draft_width = width;
+    chart->draft_points.clear();
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_append_draft_point(VroomChart* chart, int64_t time_ms,
+                                               double price) {
+    if (!chart) return;
+    if (!chart->draft_active || chart->draft_kind != 2) return;
+    chart->draft_points.push_back(VroomDrawPoint{time_ms, price});
+    // draft_a doubles as the stroke's first point for the node-dot code path.
+    if (chart->draft_points.size() == 1) chart->draft_a = chart->draft_points.front();
     chart->mark_dirty();
 }
 
@@ -783,6 +852,7 @@ extern "C" void vroom_chart_clear_draft(VroomChart* chart) {
     if (!chart) return;
     if (!chart->draft_active) return;
     chart->draft_active = false;
+    chart->draft_points.clear();
     chart->mark_dirty();
 }
 
@@ -808,6 +878,91 @@ extern "C" bool vroom_chart_coord_at(VroomChart* chart, float x_px, float y_px,
     return true;
 }
 
+extern "C" bool vroom_chart_project(VroomChart* chart, int64_t time_ms,
+                                    double price, float* out_x, float* out_y) {
+    if (!chart || chart->candles.empty()) return false;
+    const int64_t window_ms = chart->visible_end_ms - chart->visible_start_ms;
+    if (window_ms <= 0) return false;
+    const auto lay = chart->layout();
+    // Same bounds as coord_at / draw_chart so the projection matches the render.
+    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);
+    if (out_x)
+        *out_x = vroom::x_at_time(lay, chart->visible_start_ms, window_ms, time_ms);
+    if (out_y) *out_y = vroom::price_to_y(lay, bounds, price);
+    return true;
+}
+
+extern "C" 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) {
+    if (!chart || chart->candles.empty()) return false;
+    const int64_t window_ms = chart->visible_end_ms - chart->visible_start_ms;
+    if (window_ms <= 0) return false;
+    const auto lay = chart->layout();
+    // Same bounds as coord_at / draw_chart so screen geometry matches the render.
+    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 auto hit = vroom::drawings::hit_test(*chart, lay, bounds, window_ms, x_px, y_px);
+    if (hit.index < 0) return false;
+    if (out_index) *out_index = hit.index;
+    if (out_part) *out_part = hit.part;
+    if (out_t) *out_t = hit.t;
+    return true;
+}
+
+extern "C" void vroom_chart_set_selected_drawing(VroomChart* chart,
+                                                 int32_t index,
+                                                 int32_t grabbed_endpoint) {
+    if (!chart) return;
+    if (index < 0 || index >= static_cast<int32_t>(chart->drawings.size())) {
+        index = -1;
+        grabbed_endpoint = -1;
+    }
+    chart->selected_drawing = index;
+    chart->grabbed_endpoint = grabbed_endpoint;
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_move_drawing_endpoint(VroomChart* chart, int32_t index,
+                                                  int32_t endpoint, int64_t time_ms,
+                                                  double price) {
+    if (!chart) return;
+    if (index < 0 || index >= static_cast<int32_t>(chart->drawings.size())) return;
+    VroomDrawPoint& pt = endpoint == 0 ? chart->drawings[index].a
+                                       : chart->drawings[index].b;
+    pt.time_ms = time_ms;
+    pt.price = price;
+    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;
+    if (index < 0 || index >= static_cast<int32_t>(chart->drawings.size())) return;
+    auto& d = chart->drawings[index];
+    const auto shift = [&](VroomDrawPoint& p) {
+        p.time_ms += d_time_ms;
+        p.price += d_price;
+    };
+    shift(d.a);
+    shift(d.b);
+    for (VroomDrawPoint& p : d.points) shift(p);
+    chart->mark_dirty();
+}
+
 // ---- Indicators -----------------------------------------------------------
 
 extern "C" void vroom_chart_set_rsi(VroomChart* chart, bool enabled, int period,