react-native-vroom-chart 0.1.4 → 0.4.0

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"
 
@@ -54,10 +55,37 @@ int64_t damp_future_delta(int64_t delta_ms, int64_t cur_future,
     return static_cast<int64_t>(static_cast<double>(delta_ms) * resist);
 }
 
-// Frame the default view: the most recent ~80 candles — a narrower x-window
-// so candles read wider. No-op when there are no candles.
+// Frame the default view. When the consumer has set a target candle body width
+// (default_candle_px), size the window so each candle renders ~that wide with the
+// right edge pinned to the latest candle; otherwise fall back to the legacy
+// "most recent ~80 candles". No-op when there are no candles.
 void apply_default_framing(VroomChart* chart) {
     if (chart->candles.empty()) return;
+
+    // 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
+    // the candle-count default below.
+    if (chart->default_candle_px > 0.f) {
+        const auto lay = chart->layout();
+        const double usable =
+            lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
+        const double ratio = chart->theme.floats[VROOM_FLOAT_CANDLE_WIDTH_RATIO];
+        const double dur = static_cast<double>(chart->candle_duration_ms);
+        const double body = std::clamp(static_cast<double>(chart->default_candle_px),
+                                       kMinCandleBodyPx, kMaxCandleBodyPx);
+        if (usable > 0.0 && ratio > 0.0 && dur > 0.0 && body > 0.0) {
+            int64_t window_ms = static_cast<int64_t>((usable * dur * ratio) / body);
+            const int64_t span =
+                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_start_ms = chart->visible_end_ms - window_ms;
+            return;
+        }
+    }
+
     constexpr size_t kDefaultVisible = 80;
     const size_t start_idx = chart->candles.size() > kDefaultVisible
         ? chart->candles.size() - kDefaultVisible
@@ -167,6 +195,36 @@ extern "C" void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_m
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_default_candle_width(VroomChart* chart, float px) {
+    if (!chart) return;
+    chart->default_candle_px = px;
+    // Re-frame so a value that arrives after set_candles still drives the initial
+    // view. Intended for initial framing only — calling it after the user has
+    // panned would snap the view back to the default frame.
+    if (!chart->candles.empty()) apply_default_framing(chart);
+    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) {
@@ -712,14 +770,49 @@ 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();
+}
+
+// ---- Liquidity bands (order-book depth overlay) ---------------------------
+
+extern "C" void vroom_chart_set_liquidity(VroomChart* chart,
+                                          const VroomBand* bands, size_t count,
+                                          const VroomLiquidityStyle* style) {
+    if (!chart) return;
+    chart->bands.assign(bands, bands + count);
+    if (style) chart->liquidity_style = *style;
     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,
-                                      float width) {
+                                      float width, int32_t kind) {
     if (!chart) return;
     chart->draft_active = true;
     chart->draft_a = VroomDrawPoint{a_time, a_price};
@@ -728,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();
 }
 
@@ -735,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();
 }
 
@@ -760,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,

package/cpp/_core_src/drawings.cpp

@@ -5,10 +5,16 @@
 #include "include/core/SkCanvas.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #pragma clang diagnostic pop
 
+#include <algorithm>
+#include <array>
+#include <cmath>
+
 #include "chart.h"
 
 namespace vroom::drawings {
@@ -31,18 +37,176 @@ SkPoint to_px(const VroomChart& chart, const Layout& lay, const PriceBounds& bou
     return SkPoint{x, y};
 }
 
-void draw_node(SkCanvas* canvas, SkPoint pt) {
+// The four corners of the box with opposite corners `a` and `b`, in the fixed
+// order used by hit-test `part` indices: a, (b.x,a.y), b, (a.x,b.y). Corner k's
+// diagonal is corner (k+2)%4.
+std::array<SkPoint, 4> box_corners(SkPoint a, SkPoint b) {
+    return {SkPoint{a.fX, a.fY}, SkPoint{b.fX, a.fY}, SkPoint{b.fX, b.fY},
+            SkPoint{a.fX, b.fY}};
+}
+
+// The normalized (L,T,R,B) rectangle spanning opposite corners `a` and `b`.
+SkRect box_rect(SkPoint a, SkPoint b) {
+    return SkRect::MakeLTRB(std::min(a.fX, b.fX), std::min(a.fY, b.fY),
+                            std::max(a.fX, b.fX), std::max(a.fY, b.fY));
+}
+
+// Strokes the box outline and paints a faint fill (~10% of the border alpha) of
+// the same color, spanning opposite corners `a` and `b`.
+void draw_box(SkCanvas* canvas, SkPoint a, SkPoint b, SkColor color, float width) {
+    const SkRect r = box_rect(a, b);
+
+    SkPaint fill;
+    fill.setAntiAlias(true);
+    fill.setStyle(SkPaint::kFill_Style);
+    // Faint fill: 10% of the border's alpha, same RGB.
+    const U8CPU fill_alpha = static_cast<U8CPU>(SkColorGetA(color) * 0.1f);
+    fill.setColor(SkColorSetA(color, fill_alpha));
+    canvas->drawRect(r, fill);
+
+    SkPaint border;
+    border.setAntiAlias(true);
+    border.setColor(color);
+    border.setStyle(SkPaint::kStroke_Style);
+    border.setStrokeWidth(width > 0.f ? width : 2.f);
+    canvas->drawRect(r, border);
+}
+
+// Strokes a freehand path through `pts` (data space). The polyline is smoothed
+// with quadratic curves through segment midpoints — each captured point becomes
+// a control point, so the stroke reads as one organic curve instead of a chain
+// of visible corners. Round caps/joins give it a pen-like feel.
+void draw_path(SkCanvas* canvas, const VroomChart& chart, const Layout& lay,
+               const PriceBounds& bounds, int64_t window_ms,
+               const std::vector<VroomDrawPoint>& pts, SkColor color,
+               float width) {
+    if (pts.empty()) return;
+    const float w = width > 0.f ? width : 2.f;
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    paint.setColor(color);
+
+    // A stroke that's still a single sample renders as a dot, so pressing down
+    // gives immediate feedback before the pointer moves.
+    if (pts.size() == 1) {
+        const SkPoint p = to_px(chart, lay, bounds, window_ms, pts[0]);
+        paint.setStyle(SkPaint::kFill_Style);
+        canvas->drawCircle(p.fX, p.fY, w * 0.5f, paint);
+        return;
+    }
+
+    SkPathBuilder builder;
+    builder.moveTo(to_px(chart, lay, bounds, window_ms, pts[0]));
+    // Curve through every interior point, ending each quad at the midpoint of
+    // the next segment; finish with a straight run to the final sample.
+    for (size_t i = 1; i + 1 < pts.size(); ++i) {
+        const SkPoint cur = to_px(chart, lay, bounds, window_ms, pts[i]);
+        const SkPoint next = to_px(chart, lay, bounds, window_ms, pts[i + 1]);
+        builder.quadTo(cur, SkPoint{(cur.fX + next.fX) * 0.5f,
+                                    (cur.fY + next.fY) * 0.5f});
+    }
+    builder.lineTo(to_px(chart, lay, bounds, window_ms, pts.back()));
+
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStrokeWidth(w);
+    paint.setStrokeCap(SkPaint::kRound_Cap);
+    paint.setStrokeJoin(SkPaint::kRound_Join);
+    canvas->drawPath(builder.detach(), paint);
+}
+
+void draw_node(SkCanvas* canvas, SkPoint pt, float scale = 1.f) {
     SkPaint fill;
     fill.setAntiAlias(true);
     fill.setColor(kNodeFill);
-    canvas->drawCircle(pt.fX, pt.fY, kNodeFillRadius, fill);
+    canvas->drawCircle(pt.fX, pt.fY, kNodeFillRadius * scale, fill);
 
     SkPaint border;
     border.setAntiAlias(true);
     border.setColor(kNodeBorder);
     border.setStyle(SkPaint::kStroke_Style);
     border.setStrokeWidth(kNodeBorderWidth);
-    canvas->drawCircle(pt.fX, pt.fY, kNodeRingRadius, border);
+    canvas->drawCircle(pt.fX, pt.fY, kNodeRingRadius * scale, border);
+}
+
+// Clamped projection parameter (0..1) of point (px,py) onto segment
+// (ax,ay)-(bx,by): 0 at A, 1 at B.
+float segment_t(float px, float py, float ax, float ay, float bx, float by) {
+    const float dx = bx - ax;
+    const float dy = by - ay;
+    const float len2 = dx * dx + dy * dy;
+    const float t = len2 > 0.f ? ((px - ax) * dx + (py - ay) * dy) / len2 : 0.f;
+    return std::clamp(t, 0.f, 1.f);
+}
+
+// Shortest distance from point (px,py) to segment (ax,ay)-(bx,by), in px.
+float dist_to_segment(float px, float py, float ax, float ay, float bx, float by) {
+    const float t = segment_t(px, py, ax, ay, bx, by);
+    const float cx = ax + t * (bx - ax);
+    const float cy = ay + t * (by - ay);
+    const float ex = px - cx;
+    const float ey = py - cy;
+    return std::sqrt(ex * ex + ey * ey);
+}
+
+// True when (px,py) is inside the box (the grabbable fill area).
+bool point_in_rect(float px, float py, SkPoint a, SkPoint b) {
+    const SkRect r = box_rect(a, b);
+    return px >= r.fLeft && px <= r.fRight && py >= r.fTop && py <= r.fBottom;
+}
+
+// Shortest distance from (px,py) to the freehand polyline through `pts`, in px.
+// Cheap bounding-box reject first (a stroke can hold many points and most
+// hit-tests miss), then distance-to-segment across consecutive samples — the
+// same two-stage approach Excalidraw uses for its freedraw elements. Returns a
+// value greater than `tol` on a clear miss.
+float dist_to_path(float px, float py, const VroomChart& chart, const Layout& lay,
+                   const PriceBounds& bounds, int64_t window_ms,
+                   const std::vector<VroomDrawPoint>& pts, float tol) {
+    const float kMiss = tol + 1.f;
+    if (pts.size() < 2) return kMiss;
+
+    float min_x = 0.f, max_x = 0.f, min_y = 0.f, max_y = 0.f;
+    for (size_t i = 0; i < pts.size(); ++i) {
+        const SkPoint p = to_px(chart, lay, bounds, window_ms, pts[i]);
+        if (i == 0) {
+            min_x = max_x = p.fX;
+            min_y = max_y = p.fY;
+        } else {
+            min_x = std::min(min_x, p.fX);
+            max_x = std::max(max_x, p.fX);
+            min_y = std::min(min_y, p.fY);
+            max_y = std::max(max_y, p.fY);
+        }
+    }
+    if (px < min_x - tol || px > max_x + tol || py < min_y - tol ||
+        py > max_y + tol) {
+        return kMiss;
+    }
+
+    float best = kMiss;
+    SkPoint prev = to_px(chart, lay, bounds, window_ms, pts[0]);
+    for (size_t i = 1; i < pts.size(); ++i) {
+        const SkPoint cur = to_px(chart, lay, bounds, window_ms, pts[i]);
+        best = std::min(best,
+                        dist_to_segment(px, py, prev.fX, prev.fY, cur.fX, cur.fY));
+        prev = cur;
+    }
+    return best;
+}
+
+// Shortest distance from (px,py) to the box's four edges, in px (0 when on an
+// edge). Used so the border is grabbable even outside the fill's tolerance.
+float dist_to_rect_edges(float px, float py, SkPoint a, SkPoint b) {
+    const auto c = box_corners(a, b);
+    float best = dist_to_segment(px, py, c[0].fX, c[0].fY, c[1].fX, c[1].fY);
+    for (int i = 1; i < 4; ++i) {
+        const SkPoint& p0 = c[i];
+        const SkPoint& p1 = c[(i + 1) % 4];
+        best = std::min(best,
+                        dist_to_segment(px, py, p0.fX, p0.fY, p1.fX, p1.fY));
+    }
+    return best;
 }
 }  // namespace
 
@@ -62,9 +226,18 @@ void draw(SkCanvas* canvas,
     if (!chart.drawings.empty()) {
         canvas->save();
         canvas->clipRect(clip);
-        for (const VroomDrawing& d : chart.drawings) {
+        for (const auto& d : chart.drawings) {
+            if (d.kind == 2) {
+                draw_path(canvas, 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) {
+                draw_box(canvas, a, b, static_cast<SkColor>(d.color), d.width);
+                continue;
+            }
             SkPaint line;
             line.setAntiAlias(true);
             line.setColor(static_cast<SkColor>(d.color));
@@ -75,34 +248,159 @@ void draw(SkCanvas* canvas,
         canvas->restore();
     }
 
+    // 1b. Handles on the selected committed drawing (unclipped, like the draft's
+    //     dots). The grabbed endpoint renders 50% larger.
+    if (chart.selected_drawing >= 0 &&
+        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size()) {
+        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) {
+            // 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);
+            draw_node(canvas, sb);
+        } else if (d.kind == 1) {
+            // Four corner handles. The gesture layer stores the grabbed corner
+            // as endpoint `a` (its diagonal as `b`), so corner 0 is the active
+            // one while dragging.
+            const auto corners = box_corners(sa, sb);
+            for (int i = 0; i < 4; ++i) {
+                draw_node(canvas, corners[i],
+                          (chart.grabbed_endpoint == 0 && i == 0) ? 1.5f : 1.f);
+            }
+        } else {
+            draw_node(canvas, sa, chart.grabbed_endpoint == 0 ? 1.5f : 1.f);
+            draw_node(canvas, sb, chart.grabbed_endpoint == 1 ? 1.5f : 1.f);
+        }
+    }
+
     if (!chart.draft_active) return;
 
+    // 1c. Freehand stroke in progress: draw the live path, clipped like the
+    //     committed shapes. It grows a point at a time via append_draft_point.
+    if (chart.draft_kind == 2) {
+        if (chart.draft_points.empty()) return;
+        canvas->save();
+        canvas->clipRect(clip);
+        draw_path(canvas, chart, lay, bounds, window_ms, chart.draft_points,
+                  static_cast<SkColor>(chart.draft_color), chart.draft_width);
+        canvas->restore();
+        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 =
         has_b ? to_px(chart, lay, bounds, window_ms, chart.draft_b) : a;
 
-    // 2. Guideline preview (A->B), clipped to the candle area. Only while the
-    //    second point is still being placed (draft_guide); once committed, the
-    //    solid segment comes from chart.drawings instead.
+    // 2. Live preview (A->B), clipped to the candle area. Only while the second
+    //    point is still being placed (draft_guide); once committed, the solid
+    //    shape comes from chart.drawings instead. A box previews as a rectangle;
+    //    a line as a guideline.
     if (chart.draft_guide && has_b) {
         canvas->save();
         canvas->clipRect(clip);
-        SkPaint guide;
-        guide.setAntiAlias(true);
-        guide.setColor(static_cast<SkColor>(chart.draft_color));
-        guide.setStyle(SkPaint::kStroke_Style);
-        guide.setStrokeWidth(chart.draft_width > 0.f ? chart.draft_width : 2.f);
-        canvas->drawLine(a, b, guide);
+        if (chart.draft_kind == 1) {
+            draw_box(canvas, a, b, static_cast<SkColor>(chart.draft_color),
+                     chart.draft_width);
+        } else {
+            SkPaint guide;
+            guide.setAntiAlias(true);
+            guide.setColor(static_cast<SkColor>(chart.draft_color));
+            guide.setStyle(SkPaint::kStroke_Style);
+            guide.setStrokeWidth(chart.draft_width > 0.f ? chart.draft_width : 2.f);
+            canvas->drawLine(a, b, guide);
+        }
         canvas->restore();
     }
 
     // 3. Node dots on top (not clipped, so an edge dot still renders fully).
     //    While guiding (placing the second point) only the anchor dot shows; the
-    //    moving end is conveyed by the guideline. Once selected (committed) both
-    //    endpoints show dots.
+    //    moving end is conveyed by the preview shape. Once selected (committed)
+    //    both endpoints show dots.
     draw_node(canvas, a);
     if (has_b && !chart.draft_guide) draw_node(canvas, b);
 }
 
+HitResult hit_test(const VroomChart& chart,
+                   const Layout& lay,
+                   const PriceBounds& bounds,
+                   int64_t window_ms,
+                   float x,
+                   float y) {
+    HitResult miss{-1, -1, 0.f};
+    if (window_ms <= 0 || chart.drawings.empty()) return miss;
+
+    // Grab-priority: if a drawing is selected, its (visible) handles win first.
+    constexpr float kHandleHit = kNodeRingRadius + 6.f;
+    if (chart.selected_drawing >= 0 &&
+        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size()) {
+        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) {
+            // 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) {
+            // Box: four corner handles (part 0..3).
+            const auto corners = box_corners(a, b);
+            for (int c = 0; c < 4; ++c) {
+                if (std::hypot(x - corners[c].fX, y - corners[c].fY) <= kHandleHit)
+                    return HitResult{chart.selected_drawing, c, 0.f};
+            }
+        } else {
+            if (std::hypot(x - a.fX, y - a.fY) <= kHandleHit)
+                return HitResult{chart.selected_drawing, 0, 0.f};
+            if (std::hypot(x - b.fX, y - b.fY) <= kHandleHit)
+                return HitResult{chart.selected_drawing, 1, 1.f};
+        }
+    }
+
+    // Otherwise the nearest drawing body within tolerance (topmost = last drawn).
+    // Line body is distance-to-segment (part 2); box body is the interior (dist
+    // 0) or a nearby edge (part 4).
+    constexpr float kBodyHit = 6.f;
+    float best = kBodyHit;
+    int32_t best_i = -1;
+    int32_t best_part = 2;
+    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) {
+            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_t = 0.f;
+            }
+            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) {
+            const float dist = point_in_rect(x, y, a, b)
+                                   ? 0.f
+                                   : dist_to_rect_edges(x, y, a, b);
+            if (dist <= best) {  // <= so later (topmost) drawings win ties
+                best = dist;
+                best_i = static_cast<int32_t>(i);
+                best_part = 4;
+                best_t = 0.f;
+            }
+        } else {
+            const float dist = dist_to_segment(x, y, a.fX, a.fY, b.fX, b.fY);
+            if (dist <= best) {  // <= so later (topmost) drawings win ties
+                best = dist;
+                best_i = static_cast<int32_t>(i);
+                best_part = 2;
+                best_t = segment_t(x, y, a.fX, a.fY, b.fX, b.fY);
+            }
+        }
+    }
+    return best_i >= 0 ? HitResult{best_i, best_part, best_t} : miss;
+}
+
 }  // namespace vroom::drawings

package/cpp/_core_src/drawings.h

@@ -31,4 +31,27 @@ void draw(SkCanvas* canvas,
           float candle_right,
           float candle_area_h);
 
+// Result of a hit-test against the committed drawings. `index` is the drawing
+// index (or -1 for a miss). `part` depends on the drawing kind:
+//   * line   — 0 (endpoint A), 1 (endpoint B), or 2 (line body).
+//   * box    — 0..3 (the four corners, in the order returned by box_corners:
+//              a, (b.x,a.y), b, (a.x,b.y)) or 4 (box body: interior or edges).
+//   * 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).
+struct HitResult {
+    int32_t index;
+    int32_t part;
+    float   t;  // 0..1 grab position along a line segment (A→B); 0 for box/handle hits
+};
+
+HitResult hit_test(const VroomChart& chart,
+                   const vroom::Layout& lay,
+                   const vroom::PriceBounds& bounds,
+                   int64_t window_ms,
+                   float x,
+                   float y);
+
 }  // namespace vroom::drawings