react-native-vroom-chart 0.11.0 → 0.12.0

package/cpp/VroomChartHostObject.cpp

@@ -63,6 +63,7 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setBollinger"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVolume"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVolumeCollapse"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setAxisCollapse"));
   out.push_back(jsi::PropNameID::forAscii(rt, "coordAt"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLines"));
   out.push_back(jsi::PropNameID::forAscii(rt, "hitTestPriceLine"));
@@ -919,6 +920,27 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setAxisCollapse") {
+    // setAxisCollapse(yT, xT) — hides the price / time axis strips. Both take
+    // EASED progress (0 shown, 1 hidden); there is no per-element stagger for
+    // the core to distribute, so the host owns the curve.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setAxisCollapse"),
+        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_axis_collapse(
+              chart_,
+              static_cast<float>(args[0].asNumber()),
+              static_cast<float>(args[1].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "coordAt") {
     // coordAt(x, y) -> { timeMs, price } | null. The continuous data coordinate
     // at a pixel — not snapped to a candle slot. Null when there are no candles

package/cpp/_core_include/vroom/vroom_chart.h

@@ -187,6 +187,13 @@ typedef struct VroomDrawing {
     int32_t               kind;         // 0 = line, 1 = box, 2 = pencil, 3 = path
     const VroomDrawPoint* points;       // pencil/path points (kind 2/3), else null
     int32_t               point_count;  // number of `points`, else 0
+    // Box (kind 1) interior fill, 0xAARRGGBB. Alpha 0 means unset, in which case
+    // the interior falls back to `color` at 10% alpha. Ignored by other kinds.
+    uint32_t              fill;
+    // Protects the drawing from editing: hit_test reports its body (so a host
+    // can still select it and offer to unlock) but never its handles, and no
+    // handles are drawn. Rendering is otherwise unaffected.
+    bool                  locked;
 } VroomDrawing;
 
 // A resting-liquidity band: a price interval carrying a total order size on one
@@ -257,6 +264,14 @@ typedef struct VroomCoord {
     double  price;
 } VroomCoord;
 
+// An axis-aligned rectangle in CSS pixels, relative to the chart's top-left.
+typedef struct VroomRect {
+    float x;
+    float y;
+    float width;
+    float height;
+} VroomRect;
+
 // ---- Styling keys ---------------------------------------------------------
 
 typedef enum {
@@ -267,8 +282,12 @@ typedef enum {
     VROOM_COLOR_GRID,
     VROOM_COLOR_AXIS_TEXT,
     VROOM_COLOR_CROSSHAIR,
-    VROOM_COLOR_TOOLTIP_BG,
-    VROOM_COLOR_TOOLTIP_TEXT,
+    // Retired (was VROOM_COLOR_TOOLTIP_BG, never rendered). Held open because
+    // the TypeScript theme maps hardcode the indices below it.
+    VROOM_COLOR_RESERVED_7_,
+    // Text drawn on a filled badge: the current-price indicator, the crosshair's
+    // axis badges, and price-line pills. Defaults to white.
+    VROOM_COLOR_BADGE_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
@@ -549,6 +568,19 @@ void vroom_chart_set_volume(VroomChart* chart, const VroomVolume* cfg);
 // `enabled`, so the host only needs it while animating.
 void vroom_chart_set_volume_collapse(VroomChart* chart, float t, int32_t easing);
 
+// Collapses the axis strips: 0 leaves a strip at full size, 1 hides it. Driven
+// per-frame by the host animation loop, which owns the eased clock — unlike the
+// volume collapse there is no per-element stagger, so these take *eased*
+// progress directly.
+//
+// Hiding is a collapse rather than a zeroed dimension because the y-axis width
+// is measured from the widest price label and recomputed on most data changes,
+// which would overwrite a zero. The price pane grows into whatever the strips
+// give up, and each strip's contents (labels, price badge, crosshair and
+// price-line badges) fade out over the first half of the collapse so text is
+// never squeezed into a strip too narrow to hold it.
+void vroom_chart_set_axis_collapse(VroomChart* chart, float y_t, float x_t);
+
 // ---- Drawings (line annotations) ------------------------------------------
 
 // Replaces the full set of committed line drawings (data-anchored, so they track
@@ -578,6 +610,18 @@ 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);
 
+// Fills *out with the pixel bounding box of committed drawing `index` and
+// returns true; false (out untouched) for an out-of-range index, an empty
+// series, or a degenerate viewport.
+//
+// The rectangle spans the shape's painted extent — every anchor of a pencil or
+// path, both corners of a line or box — grown by half the stroke width, so it
+// covers the pixels the stroke actually paints. It is the anchor a host uses to
+// position UI against the selection, and because it is computed from live core
+// state it stays correct mid-reshape, before the edit reaches the host's array.
+bool vroom_chart_drawing_bounds(VroomChart* chart, int32_t index,
+                                VroomRect* out);
+
 // Selects a committed drawing (renders its handles). `index` -1 clears the
 // selection. `grabbed_endpoint` renders that handle 50% larger while it's being
 // dragged (0/1 for a line, 0 for the box corner the host normalized to, the

package/cpp/_core_src/chart.cpp

@@ -64,13 +64,16 @@ vroom::Layout VroomChart::layout() const {
     return vroom::Layout{
         width_px,
         height_px,
-        axis_w,
-        theme.floats[VROOM_FLOAT_X_AXIS_HEIGHT_PX],
+        vroom::axis_extent(axis_w, y_axis_collapse_t),
+        vroom::axis_extent(theme.floats[VROOM_FLOAT_X_AXIS_HEIGHT_PX],
+                           x_axis_collapse_t),
         theme.floats[VROOM_FLOAT_RIGHT_PADDING_PX],
         theme.floats[VROOM_FLOAT_CANDLE_WIDTH_RATIO],
         0.05f,
         0.05f,
         indicator_h,
+        vroom::axis_opacity(y_axis_collapse_t),
+        vroom::axis_opacity(x_axis_collapse_t),
     };
 }
 

package/cpp/_core_src/chart.h

@@ -191,6 +191,13 @@ struct VroomChart {
     float volume_collapse_t = 0.f;
     int32_t volume_collapse_easing = VROOM_EASING_IN_OUT;
 
+    // Collapse of the axis strips, driven per-frame by the host animation loop:
+    // 0 = full strip, 1 = hidden. Unlike the volume collapse these change the
+    // layout, so the price pane grows into whatever the strips give up. The host
+    // pre-eases them (there is no per-element stagger to distribute here).
+    float y_axis_collapse_t = 0.f;
+    float x_axis_collapse_t = 0.f;
+
     // --- drawings (annotations) --------------------------------------------
     // Committed drawings, anchored in data space so they track the candles on
     // pan/zoom. Drawn on the price pane above candles/overlays.
@@ -206,6 +213,8 @@ struct VroomChart {
         float                       width = 2.f;
         int32_t                     kind = 0;
         std::vector<VroomDrawPoint> points;  // pencil path (kind 2)
+        uint32_t                    fill = 0;      // 0 alpha = derive from color
+        bool                        locked = false;
     };
     std::vector<StoredDrawing> drawings;
 

package/cpp/_core_src/chart_facade.cpp

@@ -926,6 +926,8 @@ extern "C" void vroom_chart_set_drawings(VroomChart* chart,
         d.color = src.color;
         d.width = src.width;
         d.kind = src.kind;
+        d.fill = src.fill;
+        d.locked = src.locked;
         if ((src.kind == 2 || src.kind == 3) && src.points && src.point_count > 0) {
             d.points.assign(src.points, src.points + src.point_count);
             // Keep a/b mirroring the path ends so bounds/handle code is uniform.
@@ -1152,6 +1154,31 @@ extern "C" bool vroom_chart_hit_test_drawing(VroomChart* chart, float x_px,
     return true;
 }
 
+extern "C" bool vroom_chart_drawing_bounds(VroomChart* chart, int32_t index,
+                                           VroomRect* 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();
+    // Same bounds as coord_at / draw_chart so the rectangle 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);
+    vroom::drawing_bounds::RectPx r{};
+    if (!vroom::drawings::bounds_of(*chart, lay, bounds, window_ms, index, &r))
+        return false;
+    out->x = r.x;
+    out->y = r.y;
+    out->width = r.width;
+    out->height = r.height;
+    return true;
+}
+
 extern "C" bool vroom_chart_hit_test_price_line(VroomChart* chart, float x_px,
                                                 float y_px, int32_t* out_index,
                                                 int32_t* out_part) {
@@ -1374,6 +1401,15 @@ extern "C" void vroom_chart_set_volume_collapse(VroomChart* chart, float t,
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_axis_collapse(VroomChart* chart, float y_t,
+                                              float x_t) {
+    if (!chart) return;
+    chart->y_axis_collapse_t = std::clamp(y_t, 0.f, 1.f);
+    chart->x_axis_collapse_t = std::clamp(x_t, 0.f, 1.f);
+    // Changes the layout, so every cached pane geometry has to be re-derived.
+    chart->mark_dirty();
+}
+
 // ---- Direct draw (used by hosts that don't need the SkPicture cache) ------
 
 extern "C" void vroom_chart_draw(VroomChart* chart, SkCanvas* canvas) {

package/cpp/_core_src/crosshair.cpp

@@ -42,7 +42,9 @@ void draw_badge(SkCanvas* canvas,
                 float cx,
                 float cy,
                 SkColor fill,
-                SkColor text_color) {
+                SkColor text_color,
+                float opacity) {
+    if (opacity <= 0.f) return;
     const size_t len = std::strlen(text);
     SkRect tb;
     const float text_w = font.measureText(text, len, SkTextEncoding::kUTF8, &tb);
@@ -54,11 +56,13 @@ void draw_badge(SkCanvas* canvas,
     SkPaint box;
     box.setAntiAlias(true);
     box.setColor(fill);
+    box.setAlphaf(box.getAlphaf() * opacity);
     canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
 
     SkPaint text_paint;
     text_paint.setAntiAlias(true);
     text_paint.setColor(text_color);
+    text_paint.setAlphaf(text_paint.getAlphaf() * opacity);
     canvas->drawString(text, cx - text_w * 0.5f,
                        cy - (tb.fTop + tb.fBottom) * 0.5f, font, text_paint);
 }
@@ -108,8 +112,8 @@ void draw(SkCanvas* canvas,
     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.
+    // Axis badges 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;
@@ -119,6 +123,7 @@ void draw(SkCanvas* canvas,
     font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
 
     const SkColor badge_fill = chart.theme.colors[VROOM_COLOR_CROSSHAIR_TARGET];
+    const SkColor badge_text = chart.theme.colors[VROOM_COLOR_BADGE_TEXT];
 
     // Date/time badge over the x-axis strip, centered on the vertical line and
     // vertically aligned with the time labels (centered in the strip).
@@ -140,7 +145,7 @@ void draw(SkCanvas* canvas,
         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);
+                   badge_text, lay.x_axis_opacity);
     }
 
     // Price badge over the y-axis strip, centered on the horizontal line and
@@ -155,7 +160,7 @@ void draw(SkCanvas* canvas,
         vroom::format_price(buf, sizeof(buf), price, fmt);
         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);
+                   badge_text, lay.y_axis_opacity);
     }
 }
 

package/cpp/_core_src/drawing_bounds.h

@@ -0,0 +1,70 @@
+// The pixel bounding box of a drawing (see bounds_of in drawings.cpp).
+//
+// A host anchoring UI to a selected drawing needs one rectangle, whatever the
+// shape: a box and a freehand stroke both have to yield something positionable.
+// Reducing the projected anchors to their extent gives that uniformly, where the
+// anchors themselves would not — a pencil stroke's `a`/`b` are just its first
+// and last samples, which say nothing about how far the stroke wandered between
+// them.
+//
+// The extent is grown by half the stroke width on every side, because a stroke
+// straddles its path: a 2px line through y=100 paints 99..101. Without that the
+// rectangle would clip the very pixels it is meant to describe.
+//
+// Skia-free and header-only so the unit tests can cover it; see
+// tests/test_drawing_bounds.cpp.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+namespace vroom::drawing_bounds {
+
+// An axis-aligned rectangle in CSS pixels, relative to the chart's top-left.
+struct RectPx {
+    float x = 0.f;
+    float y = 0.f;
+    float width = 0.f;
+    float height = 0.f;
+};
+
+// Accumulates projected points into their extent. Points are fed one at a time
+// so callers can project straight from their own storage without materializing
+// an intermediate array.
+struct Accumulator {
+    float min_x = 0.f;
+    float min_y = 0.f;
+    float max_x = 0.f;
+    float max_y = 0.f;
+    bool  has = false;
+
+    // Non-finite coordinates are dropped rather than propagated: a single NaN
+    // would otherwise poison every comparison and hand the host an unusable
+    // rectangle.
+    void add(float x, float y) {
+        if (!std::isfinite(x) || !std::isfinite(y)) return;
+        if (!has) {
+            min_x = max_x = x;
+            min_y = max_y = y;
+            has = true;
+            return;
+        }
+        min_x = std::min(min_x, x);
+        max_x = std::max(max_x, x);
+        min_y = std::min(min_y, y);
+        max_y = std::max(max_y, y);
+    }
+
+    // The extent grown by half of `stroke_width` on each side. A single point
+    // yields a zero-extent rectangle inflated to the stroke's own footprint,
+    // which is exactly what a one-sample pencil stroke paints.
+    RectPx to_rect(float stroke_width) const {
+        if (!has) return RectPx{};
+        const float pad = std::max(stroke_width, 0.f) * 0.5f;
+        return RectPx{min_x - pad, min_y - pad, (max_x - min_x) + pad * 2.f,
+                      (max_y - min_y) + pad * 2.f};
+    }
+};
+
+}  // namespace vroom::drawing_bounds

package/cpp/_core_src/drawings.cpp

@@ -51,17 +51,23 @@ SkRect box_rect(SkPoint a, SkPoint b) {
                             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) {
+// Strokes the box outline and paints its interior, spanning opposite corners
+// `a` and `b`. `fill_color` is used as given; alpha 0 means the caller didn't
+// set one, and the interior falls back to a faint tint of the border (~10% of
+// its alpha) — a solid default would hide the candles the box was drawn around.
+void draw_box(SkCanvas* canvas, SkPoint a, SkPoint b, SkColor color, float width,
+              SkColor fill_color) {
     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));
+    if (SkColorGetA(fill_color) != 0) {
+        fill.setColor(fill_color);
+    } else {
+        const U8CPU fill_alpha = static_cast<U8CPU>(SkColorGetA(color) * 0.1f);
+        fill.setColor(SkColorSetA(color, fill_alpha));
+    }
     canvas->drawRect(r, fill);
 
     SkPaint border;
@@ -334,7 +340,8 @@ void draw(SkCanvas* canvas,
             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);
+                draw_box(canvas, a, b, static_cast<SkColor>(d.color), d.width,
+                         static_cast<SkColor>(d.fill));
                 continue;
             }
             SkPaint line;
@@ -348,9 +355,12 @@ void draw(SkCanvas* canvas,
     }
 
     // 1b. Handles on the selected committed drawing (unclipped, like the draft's
-    //     dots). The grabbed endpoint renders 50% larger.
+    //     dots). The grabbed endpoint renders 50% larger. A locked drawing shows
+    //     none: nothing about it can be dragged, so an affordance saying
+    //     otherwise would be a lie.
     if (chart.selected_drawing >= 0 &&
-        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size()) {
+        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size() &&
+        !chart.drawings[chart.selected_drawing].locked) {
         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);
@@ -432,8 +442,10 @@ void draw(SkCanvas* canvas,
         canvas->save();
         canvas->clipRect(clip);
         if (chart.draft_kind == 1) {
+            // The draft has no fill of its own — the preview shows the default
+            // tint until the box is committed with one.
             draw_box(canvas, a, b, static_cast<SkColor>(chart.draft_color),
-                     chart.draft_width);
+                     chart.draft_width, SK_ColorTRANSPARENT);
         } else {
             SkPaint guide;
             guide.setAntiAlias(true);
@@ -463,9 +475,13 @@ HitResult hit_test(const VroomChart& chart,
     if (window_ms <= 0 || chart.drawings.empty()) return miss;
 
     // Grab-priority: if a drawing is selected, its (visible) handles win first.
+    // A locked drawing draws no handles, so there is nothing here to grab — it
+    // falls through to the body pass and stays selectable, which is how a host
+    // toolbar can still reach it to unlock it.
     constexpr float kHandleHit = kNodeRingRadius + 6.f;
     if (chart.selected_drawing >= 0 &&
-        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size()) {
+        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size() &&
+        !chart.drawings[chart.selected_drawing].locked) {
         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);
@@ -546,4 +562,37 @@ HitResult hit_test(const VroomChart& chart,
     return best_i >= 0 ? HitResult{best_i, best_part, best_t} : miss;
 }
 
+bool bounds_of(const VroomChart& chart,
+               const Layout& lay,
+               const PriceBounds& bounds,
+               int64_t window_ms,
+               int32_t index,
+               vroom::drawing_bounds::RectPx* out) {
+    if (!out || window_ms <= 0) return false;
+    if (index < 0 || static_cast<size_t>(index) >= chart.drawings.size())
+        return false;
+    const auto& d = chart.drawings[static_cast<size_t>(index)];
+
+    vroom::drawing_bounds::Accumulator acc;
+    if ((d.kind == 2 || d.kind == 3) && !d.points.empty()) {
+        // Pencil/path: every sample counts. `a`/`b` only mirror the first and
+        // last, so they would miss however far the stroke wandered between them.
+        for (const auto& p : d.points) {
+            const SkPoint q = to_px(chart, lay, bounds, window_ms, p);
+            acc.add(q.fX, q.fY);
+        }
+    } else {
+        // Line/box: the two stored corners already span the shape — a box's
+        // derived corners are exactly their extent.
+        const SkPoint a = to_px(chart, lay, bounds, window_ms, d.a);
+        const SkPoint b = to_px(chart, lay, bounds, window_ms, d.b);
+        acc.add(a.fX, a.fY);
+        acc.add(b.fX, b.fY);
+    }
+    if (!acc.has) return false;
+
+    *out = acc.to_rect(d.width > 0.f ? d.width : 2.f);
+    return true;
+}
+
 }  // namespace vroom::drawings

package/cpp/_core_src/drawings.h

@@ -12,6 +12,7 @@
 
 #pragma once
 
+#include "drawing_bounds.h"
 #include "viewport.h"
 #include "vroom/vroom_chart.h"
 
@@ -59,4 +60,18 @@ HitResult hit_test(const VroomChart& chart,
                    float x,
                    float y);
 
+// The pixel bounding box of committed drawing `index`, written to `out`. False
+// (leaving `out` untouched) for an out-of-range index or a degenerate viewport.
+//
+// The rectangle covers the shape's painted extent — every anchor of a pencil or
+// path, both corners of a line or box — grown by half the stroke width. It is
+// what the host positions a selection toolbar against, so it tracks the drawing
+// live through a pan, a zoom, and a reshape in progress.
+bool bounds_of(const VroomChart& chart,
+               const vroom::Layout& lay,
+               const vroom::PriceBounds& bounds,
+               int64_t window_ms,
+               int32_t index,
+               vroom::drawing_bounds::RectPx* out);
+
 }  // namespace vroom::drawings

package/cpp/_core_src/labels.cpp

@@ -147,6 +147,9 @@ void draw_y_labels(SkCanvas* canvas,
                    const PriceBounds& bounds) {
     auto tf = vroom::axis_typeface();
     if (!tf) return;
+    // The fade state still advances in update_y_fades, so a hidden axis picks up
+    // wherever the ticks moved to once it is revealed again.
+    if (lay.y_axis_opacity <= 0.f) return;
 
     const float candle_area_h = vroom::price_pane_bottom(lay);
 
@@ -186,7 +189,7 @@ void draw_y_labels(SkCanvas* canvas,
         if (baseline_y - cap_h < 0.f) continue;
         if (baseline_y > candle_area_h) continue;
 
-        text_paint.setAlphaf(f.opacity);
+        text_paint.setAlphaf(f.opacity * lay.y_axis_opacity);
         canvas->drawString(buf, text_x, baseline_y, font, text_paint);
     }
 }
@@ -279,6 +282,8 @@ void draw_x_labels(SkCanvas* canvas,
     auto tf = vroom::axis_typeface();
     if (!tf || chart.candles.empty()) return;
     if (end_ms <= start_ms) return;
+    // See draw_y_labels: update_x_fades keeps running while the strip is hidden.
+    if (lay.x_axis_opacity <= 0.f) return;
 
     // X-axis labels live in the bottom strip, which stays anchored regardless
     // of any indicator pane above it.
@@ -345,7 +350,7 @@ void draw_x_labels(SkCanvas* canvas,
         if (text_x < 0.f) continue;
         if (text_x + text_w > candle_area_w) continue;
 
-        text_paint.setAlphaf(f.opacity);
+        text_paint.setAlphaf(f.opacity * lay.x_axis_opacity);
         canvas->drawString(buf, text_x, baseline_y, font, text_paint);
     }
 }

package/cpp/_core_src/macd_pane.cpp

@@ -211,14 +211,15 @@ void draw(SkCanvas* canvas,
     }
     canvas->restore();
 
-    // "0" label in the y-axis strip at the zero line.
-    if (tf) {
+    // "0" label in the y-axis strip at the zero line — hidden with that strip.
+    if (tf && lay.y_axis_opacity > 0.f) {
         SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
         font.setSubpixel(true);
         font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
         SkPaint text_paint;
         text_paint.setAntiAlias(true);
         text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
         SkRect tb;
         const float tw =
             font.measureText("0", 1, SkTextEncoding::kUTF8, &tb);

package/cpp/_core_src/price_indicator.cpp

@@ -59,9 +59,11 @@ void draw(SkCanvas* canvas,
     canvas->drawLine(0.f, y, candle_right, y, line);
 
     // Price box in the y-axis strip. Needs the axis typeface; if it isn't
-    // loaded yet, the line alone still conveys the level.
+    // loaded yet, the line alone still conveys the level. Same when the y-axis
+    // is hidden — the level stays readable, it just loses its badge.
     auto tf = vroom::axis_typeface();
     if (!tf) return;
+    if (lay.y_axis_opacity <= 0.f) return;
 
     SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
     font.setSubpixel(true);
@@ -95,14 +97,16 @@ void draw(SkCanvas* canvas,
     SkPaint box;
     box.setAntiAlias(true);
     box.setColor(color);
+    box.setAlphaf(box.getAlphaf() * lay.y_axis_opacity);
     canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
 
-    // White price text, horizontally centered on the same axis center, and
-    // vertically centered: shift the baseline so the glyph bounds' midpoint
-    // lands on `y` (= the box center and the dotted line).
+    // Price text horizontally centered on the same axis center, and vertically
+    // centered: shift the baseline so the glyph bounds' midpoint lands on `y`
+    // (= the box center and the dotted line).
     SkPaint text_paint;
     text_paint.setAntiAlias(true);
-    text_paint.setColor(SK_ColorWHITE);
+    text_paint.setColor(chart.theme.colors[VROOM_COLOR_BADGE_TEXT]);
+    text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
     const float text_x = axis_center_x - text_w * 0.5f;
     const float baseline_y = y - (tb.fTop + tb.fBottom) * 0.5f;
     canvas->drawString(buf, text_x, baseline_y, font, text_paint);

package/cpp/_core_src/price_lines.cpp

@@ -215,8 +215,10 @@ void draw_axis_badge(SkCanvas* canvas,
                      double price,
                      float y,
                      SkColor fill,
+                     SkColor text_color,
                      const PriceFormat& fmt) {
     if (lay.y_axis_width_px <= 0.f) return;
+    if (lay.y_axis_opacity <= 0.f) return;
 
     char buf[48];
     vroom::format_price(buf, sizeof(buf), price, fmt);
@@ -233,11 +235,13 @@ void draw_axis_badge(SkCanvas* canvas,
     SkPaint box;
     box.setAntiAlias(true);
     box.setColor(fill);
+    box.setAlphaf(box.getAlphaf() * lay.y_axis_opacity);
     canvas->drawRRect(SkRRect::MakeRectXY(rect, kCorner, kCorner), box);
 
     SkPaint text;
     text.setAntiAlias(true);
-    text.setColor(SK_ColorWHITE);
+    text.setColor(text_color);
+    text.setAlphaf(text.getAlphaf() * lay.y_axis_opacity);
     canvas->drawString(buf, cx - text_w * 0.5f,
                        y - (tb.fTop + tb.fBottom) * 0.5f, font, text);
 }
@@ -254,6 +258,7 @@ void draw(SkCanvas* canvas,
     if (chart.price_lines.empty()) return;
 
     const VroomPriceLineStyle& style = chart.price_line_style;
+    const SkColor badge_text = chart.theme.colors[VROOM_COLOR_BADGE_TEXT];
     SkFont font;
     const bool has_font = label_font(chart, &font);
     const vroom::PriceFormat fmt = vroom::with_tick_guard(
@@ -336,12 +341,12 @@ void draw(SkCanvas* canvas,
                                    line_color);
             }
             if (!group.quantity.empty()) {
-                // Solid fill + white text, so size reads at a glance against the
+                // Solid fill + badge text, so size reads at a glance against the
                 // translucent body.
                 draw_pill(canvas, group.quantity, first == &group.quantity,
                           last == &group.quantity, line_color, SK_ColorTRANSPARENT);
                 draw_centered_text(canvas, font, pl.quantity, group.quantity, y,
-                                   SK_ColorWHITE);
+                                   badge_text);
             }
             if (!group.close.empty()) {
                 const SkColor close_color =
@@ -357,7 +362,7 @@ void draw(SkCanvas* canvas,
 
         if (has_font && (pl.flags & VROOM_PRICE_LINE_AXIS_LABEL) != 0) {
             draw_axis_badge(canvas, font, lay, render_price(chart, i), y,
-                            line_color, fmt);
+                            line_color, badge_text, fmt);
         }
     }
 }

package/cpp/_core_src/rsi_pane.cpp

@@ -158,13 +158,15 @@ void draw(SkCanvas* canvas,
     // 70 / 30 labels in the y-axis strip (drawn after the clip; the strip's
     // background was already masked by draw_chart before this call). They label
     // the band rules, so they go with them.
-    if (tf && cfg.bands_visible) {
+    // The band labels live in the y-axis strip, so they go with it when it hides.
+    if (tf && cfg.bands_visible && lay.y_axis_opacity > 0.f) {
         SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
         font.setSubpixel(true);
         font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
         SkPaint text_paint;
         text_paint.setAntiAlias(true);
         text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
 
         const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
         auto label = [&](const char* s, float y) {