react-native-vroom-chart 0.1.1 → 0.1.3

package/cpp/_core_include/vroom/vroom_chart.h

@@ -49,6 +49,27 @@ typedef struct VroomOverlay {
     float    width;   // stroke width in px
 } VroomOverlay;
 
+// A drawing anchor in data space (so a drawing tracks the candles on pan/zoom).
+typedef struct VroomDrawPoint {
+    int64_t time_ms;  // epoch milliseconds (not snapped to a candle slot)
+    double  price;
+} VroomDrawPoint;
+
+// A committed line drawing: a two-point trendline on the price pane.
+typedef struct VroomDrawing {
+    VroomDrawPoint a;
+    VroomDrawPoint b;
+    uint32_t       color;  // 0xAARRGGBB
+    float          width;  // stroke width in px
+} VroomDrawing;
+
+// A continuous data coordinate at a pixel position (no candle snapping). Used to
+// translate a drawing-tool click into a data-space anchor.
+typedef struct VroomCoord {
+    int64_t time_ms;
+    double  price;
+} VroomCoord;
+
 // ---- Styling keys ---------------------------------------------------------
 
 typedef enum {
@@ -62,6 +83,12 @@ typedef enum {
     VROOM_COLOR_TOOLTIP_BG,
     VROOM_COLOR_TOOLTIP_TEXT,
     VROOM_COLOR_CROSSHAIR_TARGET,  // the hollow ring/dot at the intersection
+    VROOM_COLOR_BORDER_BULL,       // bull body 1px outline; 0 alpha => inherit BULL fill
+    VROOM_COLOR_BORDER_BEAR,       // bear body 1px outline; 0 alpha => inherit BEAR fill
+    VROOM_COLOR_WICK_BULL,         // bull wick; 0 alpha => inherit BULL fill
+    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_COUNT_
 } VroomColorKey;
 
@@ -103,6 +130,24 @@ void vroom_chart_set_size(VroomChart* chart, float width_px, float height_px, fl
 // ---- Viewport -------------------------------------------------------------
 
 void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_ms, int64_t end_ms);
+
+// 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,
+                                   int64_t* out_start_ms, int64_t* out_end_ms);
+
+// Reset to the fresh-mount view: frame the most recent ~80 candles and
+// re-enable continuous y auto-fit (the price range follows the visible candles
+// until the next manual y gesture). Use when the data series is wholesale
+// replaced — e.g. switching assets. With no candles loaded, clears the window
+// to 0/0 so the next set_candles applies the default framing.
+void vroom_chart_reset_view(VroomChart* chart);
+
+// Re-enable continuous y auto-fit only; the time window is untouched. Use
+// after repositioning the window for a same-asset data swap (e.g. a timeframe
+// switch) so the price scale re-fits the newly visible candles.
+void vroom_chart_reset_price_scale(VroomChart* chart);
+
 void vroom_chart_pan(VroomChart* chart, float dx_px, float dy_px);
 // Directional zoom. scale_x scales the time window around focus_x_px (>1 =
 // narrower window, wider candles); scale_y scales the price range around
@@ -126,6 +171,19 @@ void vroom_chart_translate(VroomChart* chart, float dx_px, float dy_px);
 void vroom_chart_scale_price_axis(VroomChart* chart, float dy_px);
 void vroom_chart_scale_time_axis(VroomChart* chart, float dx_px);
 
+// Scale the y-axis of the below-chart indicator pane that contains y_px.
+// dy_px > 0 (drag down) zooms out (widens the visible value range); dy_px < 0
+// zooms in. RSI scales about 50, MACD about its zero line. No-op when y_px is
+// not over an indicator pane.
+void vroom_chart_scale_indicator_axis(VroomChart* chart, float y_px, float dy_px);
+
+// Drag the separator between the price pane and the below-chart indicator band.
+// dy_px > 0 (drag down) grows the price pane and shrinks the indicator band.
+// Candle pixel scale is preserved: the price range is widened/narrowed in step
+// (anchored at the top price), so the viewport reveals/hides price rather than
+// rescaling candles. No-op when no indicator pane is shown.
+void vroom_chart_resize_indicator_pane(VroomChart* chart, float dy_px);
+
 // Reads the current y-axis width, x-axis height, and below-chart indicator pane
 // height in pixels so callers can hit-test gestures against each region on the
 // JS side. out_indicator_height_px is 0 when no indicator pane is shown.
@@ -193,6 +251,33 @@ void vroom_chart_set_overlays(VroomChart* chart, const VroomOverlay* overlays,
 void vroom_chart_set_vwap(VroomChart* chart, bool enabled, int reset_offset_min,
                           uint32_t color, float width);
 
+// ---- Drawings (line annotations) ------------------------------------------
+
+// Replaces the full set of committed line drawings (data-anchored, so they track
+// the candles on pan/zoom). Pass count 0 to clear. Drawings render on the price
+// pane above the candles/overlays and below the axis labels & crosshair.
+void vroom_chart_set_drawings(VroomChart* chart, const VroomDrawing* drawings,
+                              size_t count);
+
+// 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.
+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).
+void vroom_chart_clear_draft(VroomChart* chart);
+
+// Fills *out with the continuous data coordinate (time_ms, price) at pixel
+// (x_px, y_px) using the free (non-snapped) mapping, and returns true. Returns
+// false (leaving *out untouched) when there are no candles or the viewport is
+// degenerate.
+bool vroom_chart_coord_at(VroomChart* chart, float x_px, float y_px,
+                          VroomCoord* out);
+
 // ---- Rendering ------------------------------------------------------------
 
 void vroom_chart_draw(VroomChart* chart, SkCanvas* canvas);

package/cpp/_core_src/candles.cpp

@@ -14,6 +14,14 @@
 
 namespace vroom::candles {
 
+namespace {
+// New border/wick colors use a transparent sentinel (alpha == 0) to mean
+// "inherit the body fill color". Resolve to `fill` in that case.
+inline uint32_t resolve_color(uint32_t color, uint32_t fill) {
+    return (color >> 24) == 0 ? fill : color;
+}
+}  // namespace
+
 void draw(SkCanvas* canvas,
           const ::VroomCandle* visible,
           std::size_t n,
@@ -28,22 +36,40 @@ void draw(SkCanvas* canvas,
     const float body_w = vroom::candle_body_width(
         lay, window_ms, candle_duration_ms);
 
+    const uint32_t fill_bull = theme.colors[VROOM_COLOR_BULL];
+    const uint32_t fill_bear = theme.colors[VROOM_COLOR_BEAR];
+
     SkPaint bull_paint;
     bull_paint.setAntiAlias(true);
-    bull_paint.setColor(theme.colors[VROOM_COLOR_BULL]);
+    bull_paint.setColor(fill_bull);
 
     SkPaint bear_paint;
     bear_paint.setAntiAlias(true);
-    bear_paint.setColor(theme.colors[VROOM_COLOR_BEAR]);
+    bear_paint.setColor(fill_bear);
 
     SkPaint wick_bull;
     wick_bull.setAntiAlias(true);
-    wick_bull.setColor(theme.colors[VROOM_COLOR_BULL]);
+    wick_bull.setColor(
+        resolve_color(theme.colors[VROOM_COLOR_WICK_BULL], fill_bull));
     wick_bull.setStrokeWidth(theme.floats[VROOM_FLOAT_WICK_WIDTH_PX]);
     wick_bull.setStyle(SkPaint::kStroke_Style);
 
     SkPaint wick_bear = wick_bull;
-    wick_bear.setColor(theme.colors[VROOM_COLOR_BEAR]);
+    wick_bear.setColor(
+        resolve_color(theme.colors[VROOM_COLOR_WICK_BEAR], fill_bear));
+
+    // 1px body outlines. Default sentinel resolves to the fill color, so the
+    // border is invisible until a consumer sets borderBull/borderBear.
+    SkPaint border_bull;
+    border_bull.setAntiAlias(true);
+    border_bull.setStyle(SkPaint::kStroke_Style);
+    border_bull.setStrokeWidth(1.f);
+    border_bull.setColor(
+        resolve_color(theme.colors[VROOM_COLOR_BORDER_BULL], fill_bull));
+
+    SkPaint border_bear = border_bull;
+    border_bear.setColor(
+        resolve_color(theme.colors[VROOM_COLOR_BORDER_BEAR], fill_bear));
 
     const float half_body = body_w * 0.5f;
 
@@ -65,9 +91,9 @@ void draw(SkCanvas* canvas,
         const float y_top = std::min(y_open, y_close);
         const float y_bot = std::max(y_open, y_close);
         const float h = std::max(1.f, y_bot - y_top);
-        canvas->drawRect(
-            SkRect::MakeXYWH(cx - half_body, y_top, body_w, h),
-            bull ? bull_paint : bear_paint);
+        const SkRect body = SkRect::MakeXYWH(cx - half_body, y_top, body_w, h);
+        canvas->drawRect(body, bull ? bull_paint : bear_paint);
+        canvas->drawRect(body, bull ? border_bull : border_bear);
     }
 }
 

package/cpp/_core_src/chart.cpp

@@ -21,6 +21,7 @@
 #include "candles.h"
 #include "chart_internal.h"
 #include "crosshair.h"
+#include "drawings.h"
 #include "labels.h"
 #include "ma.h"
 #include "ma_overlay.h"
@@ -116,9 +117,9 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     if (n == 0) return;
     const ::VroomCandle* visible = candles.data() + range.start;
 
-    const auto bounds = price_bounds_initialized
+    const auto bounds = price_bounds_manual
         ? price_bounds
-        : vroom::price_bounds(visible, n);
+        : vroom::auto_price_bounds(visible, n);
     const int64_t window_ms = visible_end_ms - visible_start_ms;
 
     const float candle_area_h = vroom::price_pane_bottom(lay);
@@ -176,6 +177,11 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         }
     }
 
+    // 5.7. Drawing annotations (committed line tools + the in-progress draft).
+    //      On the price pane above the candles/overlays, below the axis labels.
+    vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
+                          candle_area_h);
+
     // 6. Axis backgrounds (mask any candle overflow). The x-axis separator
     //    line is intentionally omitted for now. The bottom strip anchors at
     //    x_axis_top (below any indicator pane) so it never paints over it.

package/cpp/_core_src/chart.h

@@ -46,7 +46,7 @@ struct VroomChart {
     float height_px = 0.f;
     float px_ratio = 1.f;
 
-    // 0/0 = uninitialized; set_candles defaults to last ~60 candles.
+    // 0/0 = uninitialized; set_candles defaults to last ~80 candles.
     int64_t visible_start_ms = 0;
     int64_t visible_end_ms = 0;
 
@@ -55,10 +55,13 @@ struct VroomChart {
     float axis_width_px = 0.f;
 
     // --- price bounds (y-axis state) ---------------------------------------
-    // Persistent across pans (panning preserves the price scale). Mutated
-    // only by pinch zoom, axis drags, vertical drag-translate.
+    // Two modes. Auto (price_bounds_manual == false, the default): the y-range
+    // continuously follows the visible candles each frame and `price_bounds`
+    // is ignored. Manual: the user has touched the y-axis (pinch zoom, axis
+    // drag, vertical drag-translate) and `price_bounds` is frozen until
+    // vroom_chart_reset_view / reset_price_scale re-enables auto mode.
     vroom::PriceBounds price_bounds{0.0, 1.0};
-    bool price_bounds_initialized = false;
+    bool price_bounds_manual = false;
 
     // --- crosshair (not yet drawn) -----------------------------------------
     bool   crosshair_active = false;
@@ -78,6 +81,9 @@ struct VroomChart {
     std::vector<double> rsi_cache;     // RSI per candle (NaN where undefined)
     std::vector<double> rsi_ma_cache;  // SMA of rsi_cache (empty if MA off)
     bool rsi_dirty = true;
+    // User y-axis zoom for the RSI pane (drag on its y-axis strip). 1.0 = the
+    // default 0..100 fit; >1 zooms in (taller), <1 zooms out. Anchored at 50.
+    double rsi_y_scale = 1.0;
 
     // MACD, drawn in its own pane. Caches aligned to `candles` (NaN warmup).
     bool macd_enabled = false;
@@ -88,6 +94,9 @@ struct VroomChart {
     std::vector<double> macd_signal_cache;
     std::vector<double> macd_hist_cache;
     bool macd_dirty = true;
+    // User y-axis zoom for the MACD pane (drag on its y-axis strip). 1.0 = the
+    // default auto-fit amplitude; >1 zooms in, <1 zooms out. Anchored at zero.
+    double macd_y_scale = 1.0;
 
     // Stacking order for the indicator panes: each indicator gets the next
     // sequence number on its off->on transition, so the most recently enabled
@@ -113,6 +122,24 @@ 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;
+
+    // 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.
+    // 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.
+    bool           draft_active = false;
+    VroomDrawPoint draft_a{};
+    bool           draft_has_b = false;
+    VroomDrawPoint draft_b{};
+    bool           draft_guide = false;
+    uint32_t       draft_color = 0xff2962ff;
+    float          draft_width = 2.f;
+
     // --- theme --------------------------------------------------------------
     vroom::Theme theme;
 

package/cpp/_core_src/chart_facade.cpp

@@ -54,6 +54,33 @@ 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.
+void apply_default_framing(VroomChart* chart) {
+    if (chart->candles.empty()) return;
+    constexpr size_t kDefaultVisible = 80;
+    const size_t start_idx = chart->candles.size() > kDefaultVisible
+        ? chart->candles.size() - kDefaultVisible
+        : 0;
+    chart->visible_start_ms = chart->candles[start_idx].time_ms;
+    chart->visible_end_ms = chart->candles.back().time_ms;
+}
+
+// On the first manual-y gesture, adopt the on-screen auto-fit bounds so the
+// gesture continues from exactly what the user sees. No-op once manual.
+void ensure_manual_price_bounds(VroomChart* chart) {
+    if (chart->price_bounds_manual) return;
+    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) {
+        chart->price_bounds = vroom::auto_price_bounds(
+            chart->candles.data() + idx.start, idx.end - idx.start);
+    }  // else: no visible candles — keep whatever bounds we had
+    chart->price_bounds_manual = true;
+    vroom::labels::recompute_axis_width(*chart);
+}
+
 }  // namespace
 
 // ---- Lifecycle -------------------------------------------------------------
@@ -85,40 +112,12 @@ extern "C" void vroom_chart_set_candles(VroomChart* chart, const VroomCandle* da
     }
     vroom::labels::recompute_axis_width(*chart);
 
-    // Default the visible window to the most recent ~80 candles when the
-    // consumer hasn't set one — a narrower x-window so candles read wider.
-    if (chart->visible_start_ms == 0 && chart->visible_end_ms == 0 &&
-        !chart->candles.empty()) {
-        constexpr size_t kDefaultVisible = 80;
-        const size_t start_idx = chart->candles.size() > kDefaultVisible
-            ? chart->candles.size() - kDefaultVisible
-            : 0;
-        chart->visible_start_ms = chart->candles[start_idx].time_ms;
-        chart->visible_end_ms = chart->candles.back().time_ms;
-    }
-
-    // Snap the price (y-axis) bounds to whatever's visible — but only on the
-    // first load. After they're initialized, leave them alone so live data
-    // updates (new / updated candles) preserve the user's pan/scale; from then
-    // on only zoom / axis-drags / vertical translate change them.
-    if (!chart->candles.empty() && !chart->price_bounds_initialized) {
-        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) {
-            auto b = vroom::price_bounds(
-                chart->candles.data() + idx.start, idx.end - idx.start);
-            // Widen the default y-window beyond the data's min/max so candles
-            // fill less vertical space (shorter candles, more headroom). 1.0 =
-            // snug; larger = wider. Only the default — zoom/axis-drag override.
-            constexpr double kDefaultYZoom = 1.5;
-            const double mid = (b.min + b.max) * 0.5;
-            const double half = (b.max - b.min) * 0.5 * kDefaultYZoom;
-            b.min = mid - half;
-            b.max = mid + half;
-            chart->price_bounds = b;
-            chart->price_bounds_initialized = true;
-        }
+    // Default the visible window when the consumer hasn't set one. The y-axis
+    // needs no equivalent: while the price scale is in auto mode the draw path
+    // fits it to the visible candles every frame, and once the user has taken
+    // it manual, live data updates must not disturb their pan/scale.
+    if (chart->visible_start_ms == 0 && chart->visible_end_ms == 0) {
+        apply_default_framing(chart);
     }
 
     chart->mark_dirty();
@@ -168,6 +167,35 @@ extern "C" void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_m
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_get_visible_range(VroomChart* chart,
+                                              int64_t* out_start_ms,
+                                              int64_t* out_end_ms) {
+    if (!chart) return;
+    if (out_start_ms) *out_start_ms = chart->visible_start_ms;
+    if (out_end_ms) *out_end_ms = chart->visible_end_ms;
+}
+
+extern "C" void vroom_chart_reset_view(VroomChart* chart) {
+    if (!chart) return;
+    chart->visible_start_ms = 0;
+    chart->visible_end_ms = 0;
+    chart->price_bounds_manual = false;
+    apply_default_framing(chart);
+    vroom::labels::recompute_axis_width(*chart);
+    if (chart->cb.on_viewport_changed) {
+        chart->cb.on_viewport_changed(chart->user_ctx, chart->visible_start_ms,
+                                      chart->visible_end_ms);
+    }
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_reset_price_scale(VroomChart* chart) {
+    if (!chart || !chart->price_bounds_manual) return;
+    chart->price_bounds_manual = false;
+    vroom::labels::recompute_axis_width(*chart);
+    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;
 
@@ -269,7 +297,8 @@ extern "C" void vroom_chart_translate(VroomChart* chart, float dx_px, float dy_p
     // Vertical: shift price bounds by the price-equivalent of dy_px. Range
     // stays constant. We divide by draw_h (the 90% slice of candle area
     // that's actually used for price → y) so translation feels 1:1.
-    if (dy_px != 0.f && chart->price_bounds_initialized) {
+    if (dy_px != 0.f && !chart->candles.empty()) {
+        ensure_manual_price_bounds(chart);
         const float candle_area_h = vroom::price_pane_bottom(chart->layout());
         const double draw_h = static_cast<double>(candle_area_h) * 0.9;
         if (draw_h > 0.0) {
@@ -296,7 +325,7 @@ extern "C" void vroom_chart_translate(VroomChart* chart, float dx_px, float dy_p
 
 extern "C" void vroom_chart_scale_price_axis(VroomChart* chart, float dy_px) {
     if (!chart || dy_px == 0.f) return;
-    if (!chart->price_bounds_initialized) return;
+    ensure_manual_price_bounds(chart);
 
     const double range = chart->price_bounds.max - chart->price_bounds.min;
     if (range <= 0.0) return;
@@ -387,6 +416,102 @@ extern "C" void vroom_chart_scale_time_axis(VroomChart* chart, float dx_px) {
     chart->mark_dirty();
 }
 
+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);
+    if (pane_count == 0) return;  // nothing below the chart to resize
+
+    const auto lay = chart->layout();
+    const float old_pane_bottom = vroom::price_pane_bottom(lay);
+    const float old_band = lay.indicator_area_h;
+
+    // Drag down (dy > 0) shrinks the indicator band and grows the price pane.
+    // Keep both regions usable: each pane >= kMinPanePx, price pane >= a share
+    // of the candle+indicator area.
+    constexpr float kMinPanePx = 48.f;
+    const float content_h = lay.height_px - lay.x_axis_height_px;  // candle + indicators
+    const float min_band = static_cast<float>(pane_count) * kMinPanePx;
+    const float max_band = content_h * 0.70f;  // leave the price pane >= 30%
+    if (max_band <= min_band) return;
+
+    float new_band = old_band - dy_px;
+    new_band = std::clamp(new_band, min_band, max_band);
+    if (new_band == old_band) return;
+
+    const float per_pane = new_band / static_cast<float>(pane_count);
+    chart->theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC] =
+        chart->height_px > 0.f ? per_pane / chart->height_px : 0.f;
+
+    // Preserve candle pixel scale: scale the price range by the price-pane
+    // height ratio, anchoring the top (max) price so existing candles stay put
+    // and the newly revealed space opens at the bottom.
+    if (chart->price_bounds_manual && old_pane_bottom > 0.f) {
+        const float new_pane_bottom = content_h - new_band;
+        const double scale = static_cast<double>(new_pane_bottom) /
+                             static_cast<double>(old_pane_bottom);
+        const double range = chart->price_bounds.max - chart->price_bounds.min;
+        if (range > 0.0 && scale > 0.0) {
+            chart->price_bounds.min =
+                chart->price_bounds.max - range * scale;
+            vroom::labels::recompute_axis_width(*chart);
+        }
+    }
+
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_scale_indicator_axis(VroomChart* chart, float y_px,
+                                                  float dy_px) {
+    if (!chart || dy_px == 0.f) return;
+
+    const auto lay = chart->layout();
+    if (lay.indicator_area_h <= 0.f) return;
+
+    // Rebuild the same ordered pane stack draw_chart uses (most recently
+    // enabled pane sorts to the bottom) to find which pane y_px falls in.
+    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 (count == 0) return;
+    if (count == 2 && panes[0].order > panes[1].order) {
+        const ActivePane tmp = panes[0];
+        panes[0] = panes[1];
+        panes[1] = tmp;
+    }
+
+    const float pane_h =
+        chart->height_px * chart->theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
+    if (pane_h <= 0.f) return;
+
+    int target = -1;  // 0 = RSI, 1 = MACD
+    float pane_top = vroom::price_pane_bottom(lay);
+    for (int i = 0; i < count; ++i) {
+        const float pane_bottom = pane_top + pane_h;
+        if (y_px >= pane_top && y_px < pane_bottom) {
+            target = panes[i].type;
+            break;
+        }
+        pane_top = pane_bottom;
+    }
+    if (target < 0) return;  // not over a pane
+
+    // Drag down (dy > 0) widens the visible value range (zoom out), matching
+    // scale_price_axis's sign. The zoom is the inverse of the range scale.
+    double range_scale = 1.0 + static_cast<double>(dy_px) / kAxisDragSensitivity;
+    if (range_scale < 0.05) range_scale = 0.05;  // never collapse or flip
+
+    double& zoom = target == 0 ? chart->rsi_y_scale : chart->macd_y_scale;
+    double next = zoom / range_scale;
+    next = std::clamp(next, 0.1, 10.0);
+    if (next == zoom) return;
+    zoom = next;
+
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_get_axis_metrics(VroomChart* chart,
                                               float* out_y_axis_width_px,
                                               float* out_x_axis_height_px,
@@ -406,7 +531,8 @@ extern "C" void vroom_chart_zoom(VroomChart* chart, float scale_x, float scale_y
 
     // --- Y (price) zoom around fy ------------------------------------------
     // scale_y > 1 (vertical pinch out) narrows the price range → taller candles.
-    if (scale_y > 0.f && scale_y != 1.f && chart->price_bounds_initialized) {
+    if (scale_y > 0.f && scale_y != 1.f && !chart->candles.empty()) {
+        ensure_manual_price_bounds(chart);
         const float candle_area_h = vroom::price_pane_bottom(chart->layout());
         const double range = chart->price_bounds.max - chart->price_bounds.min;
         if (candle_area_h > 0.f && range > 0.0) {
@@ -551,6 +677,60 @@ extern "C" bool vroom_chart_get_crosshair_info(VroomChart* chart,
     return true;
 }
 
+// ---- Drawings (line annotations) ------------------------------------------
+
+extern "C" void vroom_chart_set_drawings(VroomChart* chart,
+                                         const VroomDrawing* drawings,
+                                         size_t count) {
+    if (!chart) return;
+    chart->drawings.assign(drawings, drawings + count);
+    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) {
+    if (!chart) return;
+    chart->draft_active = true;
+    chart->draft_a = VroomDrawPoint{a_time, a_price};
+    chart->draft_has_b = has_b;
+    chart->draft_b = VroomDrawPoint{b_time, b_price};
+    chart->draft_guide = guide;
+    chart->draft_color = color;
+    chart->draft_width = width;
+    chart->mark_dirty();
+}
+
+extern "C" void vroom_chart_clear_draft(VroomChart* chart) {
+    if (!chart) return;
+    if (!chart->draft_active) return;
+    chart->draft_active = false;
+    chart->mark_dirty();
+}
+
+extern "C" bool vroom_chart_coord_at(VroomChart* chart, float x_px, float y_px,
+                                     VroomCoord* out) {
+    if (!chart || !out || 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();
+    // Mirror draw_chart's bounds: the frozen manual scale, else the auto-fit
+    // over the visible slice — so y_to_price matches what's on screen.
+    const auto range = vroom::visible_indices(
+        chart->candles.data(), chart->candles.size(),
+        chart->visible_start_ms, chart->visible_end_ms);
+    const size_t n = range.end - range.start;
+    const auto bounds =
+        chart->price_bounds_manual
+            ? chart->price_bounds
+            : vroom::auto_price_bounds(chart->candles.data() + range.start, n);
+    out->time_ms =
+        vroom::time_at_x(lay, chart->visible_start_ms, window_ms, x_px);
+    out->price = vroom::y_to_price(lay, bounds, y_px);
+    return true;
+}
+
 // ---- Indicators -----------------------------------------------------------
 
 extern "C" void vroom_chart_set_rsi(VroomChart* chart, bool enabled, int period,