react-native-vroom-chart 0.1.0 → 0.1.2

package/cpp/VroomChartHostObject.cpp

@@ -42,6 +42,7 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setCrosshair"));
   out.push_back(jsi::PropNameID::forAscii(rt, "clearCrosshair"));
   out.push_back(jsi::PropNameID::forAscii(rt, "getCrosshairCandle"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "getCrosshairInfo"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setRSI"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setMACD"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setOverlays"));
@@ -336,6 +337,42 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "getCrosshairInfo") {
+    // getCrosshairInfo() -> { timeMs, candle: {...} | null } | null. The slot
+    // the crosshair snaps to (real candle or a future candle-aligned slot past
+    // the last bar); null when the crosshair is inactive. `candle` is null in
+    // the empty space ahead of the most recent candle. No rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "getCrosshairInfo"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          VroomCrosshairInfo info{};
+          if (!vroom_chart_get_crosshair_info(chart_, &info)) {
+            return jsi::Value::null();
+          }
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "timeMs", static_cast<double>(info.time_ms));
+          if (info.has_candle) {
+            jsi::Object c(rt2);
+            c.setProperty(rt2, "timeMs",
+                          static_cast<double>(info.candle.time_ms));
+            c.setProperty(rt2, "open", info.candle.open);
+            c.setProperty(rt2, "high", info.candle.high);
+            c.setProperty(rt2, "low", info.candle.low);
+            c.setProperty(rt2, "close", info.candle.close);
+            c.setProperty(rt2, "volume", info.candle.volume);
+            obj.setProperty(rt2, "candle", c);
+          } else {
+            obj.setProperty(rt2, "candle", jsi::Value::null());
+          }
+          return obj;
+        });
+  }
+
   if (name == "setRSI") {
     // setRSI(enabled, period, upperBand, lowerBand, maEnabled, maPeriod) —
     // configures the RSI pane. No render; the next render() picks it up.

package/cpp/_core_include/vroom/vroom_chart.h

@@ -62,6 +62,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;
 
@@ -126,6 +132,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.
@@ -145,6 +164,24 @@ void vroom_chart_clear_crosshair(VroomChart* chart);
 // from the current crosshair x and visible window, matching what's rendered.
 bool vroom_chart_get_crosshair_candle(VroomChart* chart, VroomCandle* out);
 
+// What the crosshair currently snaps to, including future candle-aligned slots
+// to the right of the last candle (empty space the chart leaves ahead of the
+// most recent bar). `time_ms` is the snapped slot's period-start time — always
+// valid. `has_candle` is true when a real candle sits at that slot, in which
+// case `candle` holds its OHLCV; in the future region `has_candle` is false and
+// `candle` is left untouched.
+typedef struct VroomCrosshairInfo {
+    int64_t     time_ms;
+    bool        has_candle;
+    VroomCandle candle;
+} VroomCrosshairInfo;
+
+// Fills *out with the snapped slot the crosshair currently sits on and returns
+// true. Returns false (leaving *out untouched) when the crosshair is inactive
+// or there are no visible candles. Stateless — recomputes the snap from the
+// current crosshair x and visible window, matching what's rendered.
+bool vroom_chart_get_crosshair_info(VroomChart* chart, VroomCrosshairInfo* out);
+
 // ---- Indicators -----------------------------------------------------------
 
 // Configures the RSI indicator (rendered in a pane below the candles). `period`

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

@@ -256,11 +256,17 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     //      horizontal line + ring stay in the price pane (clamped to
     //      candle_area_h).
     if (crosshair_active) {
-        const float snap_x = vroom::snap_x_to_candle(
+        // Snap once: the slot gives both the vertical line's x (its center) and
+        // the time shown in the date badge. (snap_x_to_candle does exactly this
+        // internally, so the line position is unchanged.)
+        const vroom::SnapResult snap = vroom::snap_to_slot(
             lay, visible, n, candle_duration_ms, visible_start_ms, window_ms,
             crosshair_x_px);
-        vroom::crosshair::draw(canvas, *this, candle_right, candle_area_h,
-                               vroom::x_axis_top(lay), snap_x);
+        const float snap_x = vroom::candle_center_x(
+            lay, snap.time_ms, candle_duration_ms, visible_start_ms, window_ms);
+        vroom::crosshair::draw(canvas, *this, lay, bounds, candle_right,
+                               candle_area_h, vroom::x_axis_top(lay), snap_x,
+                               snap.time_ms);
     }
 
     // 8. GC fades that have fully faded out and aren't coming back.

package/cpp/_core_src/chart.h

@@ -78,6 +78,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 +91,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

package/cpp/_core_src/chart_facade.cpp

@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
+#include <limits>
 
 #include "chart.h"
 #include "labels.h"
@@ -29,6 +30,30 @@ constexpr double kAxisDragSensitivity = 300.0;
 constexpr double kMinCandleBodyPx = 1.5;
 constexpr double kMaxCandleBodyPx = 32.0;
 
+// Hard cap on the future gap (visible_end - last_candle): 3/4 of the window so
+// at least 25% of the chart still shows candles. Never forces an existing larger
+// gap (e.g. from the x-axis drag zoom) to snap back — only limits new growth.
+int64_t max_future_gap(int64_t window_ms, int64_t cur_future) {
+    return std::max<int64_t>((window_ms * 3) / 4, cur_future);
+}
+
+// Rubber-band a forward (into-future) pan delta: once the current future gap is
+// past the soft cap (window/2), damp the delta quadratically toward zero as it
+// nears the hard cap (3*window/4). Backward (into-past) deltas are unaffected.
+int64_t damp_future_delta(int64_t delta_ms, int64_t cur_future,
+                          int64_t window_ms) {
+    if (delta_ms <= 0) return delta_ms;       // only resist forward motion
+    const int64_t soft = window_ms / 2;
+    if (cur_future <= soft) return delta_ms;  // free until the soft cap
+    const int64_t hard = (window_ms * 3) / 4;
+    const double span = static_cast<double>(hard - soft);
+    if (span <= 0.0) return 0;
+    const double depth = std::clamp(
+        static_cast<double>(cur_future - soft) / span, 0.0, 1.0);
+    const double resist = (1.0 - depth) * (1.0 - depth);
+    return static_cast<int64_t>(static_cast<double>(delta_ms) * resist);
+}
+
 }  // namespace
 
 // ---- Lifecycle -------------------------------------------------------------
@@ -72,9 +97,11 @@ extern "C" void vroom_chart_set_candles(VroomChart* chart, const VroomCandle* da
         chart->visible_end_ms = chart->candles.back().time_ms;
     }
 
-    // Snap the price (y-axis) bounds to whatever's visible right now. After
-    // this, only zoom / axis-drags change them; panning preserves them.
-    if (!chart->candles.empty()) {
+    // 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);
@@ -154,15 +181,22 @@ extern "C" void vroom_chart_pan(VroomChart* chart, float dx_px, float /*dy_px*/)
         (-dx_px / usable_px) * static_cast<float>(window_ms));
     if (delta_ms == 0) return;
 
-    int64_t new_start = chart->visible_start_ms + delta_ms;
-    int64_t new_end = chart->visible_end_ms + delta_ms;
-
-    // Right edge can overshoot the last candle by up to half a window so the
-    // user can scroll into empty "future" space (e.g., to view right-anchored
-    // indicators). Left edge still hard-clamps at the first candle.
+    // The right edge can overshoot the last candle into empty "future" space.
+    // Free scrolling up to half a window (candles fill >= 50%); from there to
+    // 3/4 of a window (candles fill >= 25%) panning forward is rubber-banded so
+    // it slows and hard-stops at the cap. The x-axis drag zoom can leave a gap
+    // larger than the cap (it zooms in until ~one candle remains), so the cap
+    // never forces it back — it just shrinks naturally as the user scrolls.
+    // Left edge still hard-clamps at the first candle.
     const int64_t first_time = chart->candles.front().time_ms;
     const int64_t last_time = chart->candles.back().time_ms;
-    const int64_t max_future = window_ms / 2;
+    const int64_t cur_future = chart->visible_end_ms - last_time;
+    const int64_t eff_delta = damp_future_delta(delta_ms, cur_future, window_ms);
+
+    int64_t new_start = chart->visible_start_ms + eff_delta;
+    int64_t new_end = chart->visible_end_ms + eff_delta;
+
+    const int64_t max_future = max_future_gap(window_ms, cur_future);
     if (new_end > last_time + max_future) {
         new_end = last_time + max_future;
         new_start = new_end - window_ms;
@@ -202,11 +236,18 @@ extern "C" void vroom_chart_translate(VroomChart* chart, float dx_px, float dy_p
             const int64_t delta_ms = static_cast<int64_t>(
                 (-dx_px / usable_px) * static_cast<float>(window_ms));
             if (delta_ms != 0) {
-                int64_t new_start = chart->visible_start_ms + delta_ms;
-                int64_t new_end = chart->visible_end_ms + delta_ms;
+                // See vroom_chart_pan: rubber-band forward scrolling between the
+                // 50% and 25%-candles caps, and let an existing larger gap (from
+                // the x-axis drag zoom) shrink naturally instead of snapping.
                 const int64_t first_time = chart->candles.front().time_ms;
                 const int64_t last_time = chart->candles.back().time_ms;
-                const int64_t max_future = window_ms / 2;
+                const int64_t cur_future = chart->visible_end_ms - last_time;
+                const int64_t eff_delta =
+                    damp_future_delta(delta_ms, cur_future, window_ms);
+                int64_t new_start = chart->visible_start_ms + eff_delta;
+                int64_t new_end = chart->visible_end_ms + eff_delta;
+                const int64_t max_future =
+                    max_future_gap(window_ms, cur_future);
                 if (new_end > last_time + max_future) {
                     new_end = last_time + max_future;
                     new_start = new_end - window_ms;
@@ -286,23 +327,51 @@ extern "C" void vroom_chart_scale_time_axis(VroomChart* chart, float dx_px) {
     int64_t new_window_ms = static_cast<int64_t>(
         static_cast<double>(window_ms) * scale);
 
-    // Clamp window so candle body width stays in [kMinCandleBodyPx,
-    // kMaxCandleBodyPx]. body_w = usable × (dur / window) × ratio →
+    // Candle body width bounds [kMinCandleBodyPx, kMaxCandleBodyPx] map to a
+    // window range: body_w = usable × (dur / window) × ratio →
     // window for a given body_w = usable × dur × ratio / body_w.
     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);
+    int64_t min_window = 0;
+    int64_t max_window = std::numeric_limits<int64_t>::max();
     if (usable > 0.0 && ratio > 0.0 && dur > 0.0) {
-        const int64_t min_window = static_cast<int64_t>(
-            (usable * dur * ratio) / kMaxCandleBodyPx);
-        const int64_t max_window = static_cast<int64_t>(
-            (usable * dur * ratio) / kMinCandleBodyPx);
-        if (new_window_ms < min_window) new_window_ms = min_window;
-        if (new_window_ms > max_window) new_window_ms = max_window;
+        min_window = static_cast<int64_t>((usable * dur * ratio) / kMaxCandleBodyPx);
+        max_window = static_cast<int64_t>((usable * dur * ratio) / kMinCandleBodyPx);
     }
 
+    // The right edge is pinned, so when it sits in the empty "future" space
+    // past the last candle (pan/scroll allow it to overshoot by up to half a
+    // window), zooming in shrinks the window from the left and slides candles
+    // off-screen. Rather than blocking it outright, allow the zoom down to a
+    // floor that keeps the last candle on screen, and add rubber-band
+    // resistance once the future region passes 50% of the window so the
+    // discouraged zoom visibly slows before it stops.
+    const int64_t last_time = chart->candles.back().time_ms;
+    const int64_t future_ms = chart->visible_end_ms - last_time;
+    if (future_ms > 0 && new_window_ms < window_ms) {
+        const int64_t floor_window = future_ms + chart->candle_duration_ms;
+        const int64_t soft_window = 2 * future_ms;  // future occupies 50%
+        if (soft_window > floor_window) {
+            // depth 0 at the soft point, 1 at the floor; resistance eases the
+            // shrink toward zero as the window approaches the floor.
+            const double span = static_cast<double>(soft_window - floor_window);
+            double depth = (static_cast<double>(soft_window) -
+                            static_cast<double>(window_ms)) / span;
+            depth = std::clamp(depth, 0.0, 1.0);
+            const double resist = (1.0 - depth) * (1.0 - depth);
+            const int64_t raw_delta = new_window_ms - window_ms;  // negative
+            new_window_ms = window_ms + static_cast<int64_t>(
+                static_cast<double>(raw_delta) * resist);
+        }
+        if (new_window_ms < floor_window) new_window_ms = floor_window;
+    }
+
+    if (new_window_ms < min_window) new_window_ms = min_window;
+    if (new_window_ms > max_window) new_window_ms = max_window;
+
     // Pivot around the right edge — most-recent visible candle stays put.
     int64_t new_start = chart->visible_end_ms - new_window_ms;
     const int64_t first_time = chart->candles.front().time_ms;
@@ -318,6 +387,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_initialized && 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,
@@ -387,7 +552,11 @@ extern "C" void vroom_chart_zoom(VroomChart* chart, float scale_x, float scale_y
                 int64_t new_end = new_start + new_window;
                 const int64_t first_time = chart->candles.front().time_ms;
                 const int64_t last_time = chart->candles.back().time_ms;
-                const int64_t max_future = new_window / 2;
+                // Cap the future gap at 3/4 of the (new) window so >= 25% of the
+                // chart still shows candles, without snapping back an existing
+                // larger gap (e.g. from the x-axis drag zoom).
+                const int64_t max_future = max_future_gap(
+                    new_window, chart->visible_end_ms - last_time);
                 if (new_end > last_time + max_future) {
                     new_end = last_time + max_future;
                     new_start = new_end - new_window;
@@ -453,6 +622,31 @@ extern "C" bool vroom_chart_get_crosshair_candle(VroomChart* chart,
     return true;
 }
 
+extern "C" bool vroom_chart_get_crosshair_info(VroomChart* chart,
+                                               VroomCrosshairInfo* out) {
+    if (!chart || !out || !chart->crosshair_active || chart->candles.empty()) {
+        return false;
+    }
+    // Mirror draw_chart's visible-slice derivation so the queried slot is
+    // exactly the one the crosshair snaps to on screen.
+    const auto lay = chart->layout();
+    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 int64_t window_ms = chart->visible_end_ms - chart->visible_start_ms;
+    if (n == 0 || window_ms <= 0) return false;
+
+    const ::VroomCandle* visible = chart->candles.data() + range.start;
+    const vroom::SnapResult snap = vroom::snap_to_slot(
+        lay, visible, n, chart->candle_duration_ms,
+        chart->visible_start_ms, window_ms, chart->crosshair_x_px);
+    out->time_ms = snap.time_ms;
+    out->has_candle = snap.has_candle;
+    if (snap.has_candle) out->candle = visible[snap.index];
+    return true;
+}
+
 // ---- Indicators -----------------------------------------------------------
 
 extern "C" void vroom_chart_set_rsi(VroomChart* chart, bool enabled, int period,

package/cpp/_core_src/crosshair.cpp

@@ -4,13 +4,22 @@
 #pragma clang diagnostic ignored "-Wdocumentation"
 #include "include/core/SkCanvas.h"
 #include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontTypes.h"
 #include "include/core/SkPaint.h"
+#include "include/core/SkRRect.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkTypeface.h"
 #include "include/effects/SkDashPathEffect.h"
 #pragma clang diagnostic pop
 
 #include <algorithm>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
 
 #include "chart.h"
+#include "fonts.h"
 #include "theme.h"
 
 namespace vroom::crosshair {
@@ -18,14 +27,50 @@ namespace vroom::crosshair {
 namespace {
 constexpr float kRingRadius = 3.5f;  // hollow dot at the intersection
 constexpr SkScalar kDash[2] = {2.f, 2.f};
+constexpr float kPadV = 4.f;     // badge padding above/below the text
+constexpr float kPadH = 8.f;     // badge padding left/right of the text
+constexpr float kCorner = 6.f;   // rounded-badge corner radius
+
+// Draws a filled rounded-rect badge with `text` centered on (`cx`, `cy`).
+// Matches the current-price indicator's geometry (glyph-bounds centering so the
+// digits sit on the center regardless of the font's cap-height metric).
+void draw_badge(SkCanvas* canvas,
+                const SkFont& font,
+                const char* text,
+                float cx,
+                float cy,
+                SkColor fill,
+                SkColor text_color) {
+    const size_t len = std::strlen(text);
+    SkRect tb;
+    const float text_w = font.measureText(text, len, SkTextEncoding::kUTF8, &tb);
+    const float box_w = text_w + 2.f * kPadH;
+    const float box_h = tb.height() + 2.f * kPadV;
+    const SkRect rect = SkRect::MakeXYWH(cx - box_w * 0.5f, cy - box_h * 0.5f,
+                                         box_w, box_h);
+
+    SkPaint box;
+    box.setAntiAlias(true);
+    box.setColor(fill);
+    canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
+
+    SkPaint text_paint;
+    text_paint.setAntiAlias(true);
+    text_paint.setColor(text_color);
+    canvas->drawString(text, cx - text_w * 0.5f,
+                       cy - (tb.fTop + tb.fBottom) * 0.5f, font, text_paint);
+}
 }  // namespace
 
 void draw(SkCanvas* canvas,
           const VroomChart& chart,
+          const Layout& lay,
+          const PriceBounds& bounds,
           float candle_right,
           float candle_area_h,
           float vline_bottom,
-          float snap_x) {
+          float snap_x,
+          int64_t snap_time_ms) {
     if (!canvas || candle_right <= 0.f || candle_area_h <= 0.f) return;
 
     // Vertical line + ring snap to the nearest candle's center x; the horizontal
@@ -60,6 +105,52 @@ void draw(SkCanvas* canvas,
     ring.setStyle(SkPaint::kStroke_Style);
     ring.setStrokeWidth(2.f);  // thicker border so the dot reads clearly
     canvas->drawCircle(cx, cy, kRingRadius, ring);
+
+    // Axis badges (neutral grey, white text) sit on top of the axis labels and
+    // the current-price indicator since the crosshair is the last draw step.
+    // They need the axis typeface; if it isn't loaded the lines alone suffice.
+    auto tf = vroom::axis_typeface();
+    if (!tf) return;
+
+    SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+    font.setSubpixel(true);
+    font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+
+    const SkColor badge_fill = chart.theme.colors[VROOM_COLOR_CROSSHAIR_TARGET];
+
+    // Date/time badge over the x-axis strip, centered on the vertical line and
+    // vertically aligned with the time labels (centered in the strip).
+    if (lay.x_axis_height_px > 0.f) {
+        char buf[32];
+        const time_t time_s = static_cast<time_t>(snap_time_ms / 1000);
+        struct tm tm_buf;
+        localtime_r(&time_s, &tm_buf);
+        std::snprintf(buf, sizeof(buf), "%02d/%02d %02d:%02d",
+                      tm_buf.tm_mon + 1, tm_buf.tm_mday, tm_buf.tm_hour,
+                      tm_buf.tm_min);
+
+        const float strip_center_y = vline_bottom + lay.x_axis_height_px * 0.5f;
+        // Keep the badge within the candle area so it never slides under the
+        // y-axis price column.
+        const size_t len = std::strlen(buf);
+        const float text_w = font.measureText(buf, len, SkTextEncoding::kUTF8);
+        const float half_w = (text_w + 2.f * kPadH) * 0.5f;
+        const float badge_cx =
+            std::clamp(cx, half_w, std::max(half_w, candle_right - half_w));
+        draw_badge(canvas, font, buf, badge_cx, strip_center_y, badge_fill,
+                   SK_ColorWHITE);
+    }
+
+    // Price badge over the y-axis strip, centered on the horizontal line and
+    // sharing the y-axis labels' column.
+    if (lay.y_axis_width_px > 0.f) {
+        const double price = vroom::y_to_price(lay, bounds, cy);
+        char buf[32];
+        std::snprintf(buf, sizeof(buf), "%.2f", price);
+        const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+        draw_badge(canvas, font, buf, axis_center_x, cy, badge_fill,
+                   SK_ColorWHITE);
+    }
 }
 
 }  // namespace vroom::crosshair