react-native-vroom-chart 0.6.0 → 0.7.0

package/cpp/_core_src/candles.cpp

@@ -20,6 +20,31 @@ namespace {
 inline uint32_t resolve_color(uint32_t color, uint32_t fill) {
     return (color >> 24) == 0 ? fill : color;
 }
+
+// Channel-wise ARGB blend, for a candle that changes direction mid-morph.
+inline uint32_t lerp_argb(uint32_t a, uint32_t b, float t) {
+    uint32_t out = 0;
+    for (int shift = 0; shift < 32; shift += 8) {
+        const float ca = static_cast<float>((a >> shift) & 0xFFu);
+        const float cb = static_cast<float>((b >> shift) & 0xFFu);
+        const auto v = static_cast<uint32_t>(ca + (cb - ca) * t + 0.5f);
+        out |= v << shift;
+    }
+    return out;
+}
+
+inline uint32_t scale_alpha(uint32_t argb, float a) {
+    const auto alpha =
+        static_cast<uint32_t>(static_cast<float>((argb >> 24) & 0xFFu) * a + 0.5f);
+    return (alpha << 24) | (argb & 0x00FFFFFFu);
+}
+
+inline float lerp(float a, float b, float t) { return a + (b - a) * t; }
+
+// One slot's wick/body extents in pixels.
+struct SlotGeom {
+    float x, open, high, low, close;
+};
 }  // namespace
 
 void draw(SkCanvas* canvas,
@@ -32,13 +57,23 @@ void draw(SkCanvas* canvas,
           int64_t visible_start_ms,
           int64_t candle_duration_ms,
           float collapse,
-          float opacity) {
-    if (!canvas || n == 0) return;
+          float opacity,
+          const CandleSnapshot* from,
+          std::size_t from_n,
+          float morph_t) {
+    if (!canvas) return;
 
     collapse = std::clamp(collapse, 0.f, 1.f);
     opacity = std::clamp(opacity, 0.f, 1.f);
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
     if (opacity <= 0.f) return;
 
+    // A finished morph drops the capture, reducing the loop below to the plain
+    // candle path.
+    const std::size_t from_count = vroom::morph_from_count(from, from_n, morph_t);
+    const std::size_t slots = std::max(n, from_count);
+    if (slots == 0) return;
+
     // During the candle→line morph, fade the entire candle layer as one unit so
     // overlapping bars/wicks composite cleanly instead of stacking alpha.
     const bool fade_layer = opacity < 0.999f;
@@ -60,13 +95,20 @@ void draw(SkCanvas* canvas,
     const bool wick_round = theme.floats[VROOM_FLOAT_WICK_ROUND_CAP] > 0.5f;
 
     constexpr float kBorderWidthPx = 1.f;
+    const uint32_t wick_color_bull =
+        resolve_color(theme.colors[VROOM_COLOR_WICK_BULL], fill_bull);
+    const uint32_t wick_color_bear =
+        resolve_color(theme.colors[VROOM_COLOR_WICK_BEAR], fill_bear);
+    const uint32_t border_color_bull =
+        resolve_color(theme.colors[VROOM_COLOR_BORDER_BULL], fill_bull);
+    const uint32_t border_color_bear =
+        resolve_color(theme.colors[VROOM_COLOR_BORDER_BEAR], fill_bear);
+
     // Draw the border only when it differs from the fill; an inherited/transparent
     // border color (the default, and the "hide" path) renders nothing — so a hidden
     // border costs no pixels and never affects candle width.
-    const bool draw_border_bull =
-        resolve_color(theme.colors[VROOM_COLOR_BORDER_BULL], fill_bull) != fill_bull;
-    const bool draw_border_bear =
-        resolve_color(theme.colors[VROOM_COLOR_BORDER_BEAR], fill_bear) != fill_bear;
+    const bool draw_border_bull = border_color_bull != fill_bull;
+    const bool draw_border_bear = border_color_bear != fill_bear;
 
     SkPaint bull_paint;
     bull_paint.setAntiAlias(true);
@@ -78,15 +120,13 @@ void draw(SkCanvas* canvas,
 
     SkPaint wick_bull;
     wick_bull.setAntiAlias(true);
-    wick_bull.setColor(
-        resolve_color(theme.colors[VROOM_COLOR_WICK_BULL], fill_bull));
+    wick_bull.setColor(wick_color_bull);
     wick_bull.setStrokeWidth(theme.floats[VROOM_FLOAT_WICK_WIDTH_PX]);
     wick_bull.setStyle(SkPaint::kStroke_Style);
     wick_bull.setStrokeCap(wick_round ? SkPaint::kRound_Cap : SkPaint::kButt_Cap);
 
     SkPaint wick_bear = wick_bull;
-    wick_bear.setColor(
-        resolve_color(theme.colors[VROOM_COLOR_WICK_BEAR], fill_bear));
+    wick_bear.setColor(wick_color_bear);
 
     // 1px body outlines, drawn *inside* the body (see the inset at draw time) so
     // a contrasting border never widens the candle. Default sentinel resolves to
@@ -95,52 +135,110 @@ void draw(SkCanvas* canvas,
     border_bull.setAntiAlias(true);
     border_bull.setStyle(SkPaint::kStroke_Style);
     border_bull.setStrokeWidth(kBorderWidthPx);
-    border_bull.setColor(
-        resolve_color(theme.colors[VROOM_COLOR_BORDER_BULL], fill_bull));
+    border_bull.setColor(border_color_bull);
 
     SkPaint border_bear = border_bull;
-    border_bear.setColor(
-        resolve_color(theme.colors[VROOM_COLOR_BORDER_BEAR], fill_bear));
+    border_bear.setColor(border_color_bear);
+
+    // Scratch paints for the slots that need a per-slot color (see below).
+    SkPaint slot_wick, slot_fill, slot_border;
 
     const float half_body = body_w * 0.5f;
+    const float area_w = vroom::candle_area_width(lay);
 
-    for (std::size_t i = 0; i < n; ++i) {
-        const auto& c = visible[i];
-        const bool bull = c.close >= c.open;
+    // Iterate slots counting back from the right edge — the pairing a timeframe
+    // switch preserves — descending so the paint order stays oldest-first and
+    // touching wicks/borders composite exactly as they do without a morph.
+    for (std::size_t k = slots; k-- > 0;) {
+        const ::VroomCandle* to = (k < n) ? &visible[n - 1 - k] : nullptr;
+        const CandleSnapshot* frm = (k < from_count) ? &from[k] : nullptr;
+
+        SlotGeom g{};
+        bool bull;
+        float alpha = 1.f;
+
+        if (to) {
+            const SlotGeom t{
+                vroom::candle_center_x(lay, to->time_ms, candle_duration_ms,
+                                       visible_start_ms, window_ms),
+                vroom::price_to_y(lay, bounds, to->open),
+                vroom::price_to_y(lay, bounds, to->high),
+                vroom::price_to_y(lay, bounds, to->low),
+                vroom::price_to_y(lay, bounds, to->close),
+            };
+            bull = to->close >= to->open;
+            if (frm) {
+                // The snapshot is in band fractions, so it lands on the same
+                // pixels it occupied pre-switch even though the bounds changed.
+                g.x = lerp(frm->x * area_w, t.x, morph_t);
+                g.open = lerp(vroom::y_at_fraction(lay, frm->open), t.open, morph_t);
+                g.high = lerp(vroom::y_at_fraction(lay, frm->high), t.high, morph_t);
+                g.low = lerp(vroom::y_at_fraction(lay, frm->low), t.low, morph_t);
+                g.close =
+                    lerp(vroom::y_at_fraction(lay, frm->close), t.close, morph_t);
+            } else {
+                g = t;
+                // A slot with no counterpart: fade in rather than pop.
+                if (from_count > 0) alpha = morph_t;
+            }
+        } else {
+            g = {frm->x * area_w,
+                 vroom::y_at_fraction(lay, frm->open),
+                 vroom::y_at_fraction(lay, frm->high),
+                 vroom::y_at_fraction(lay, frm->low),
+                 vroom::y_at_fraction(lay, frm->close)};
+            bull = frm->bull;
+            alpha = 1.f - morph_t;  // the new data dropped this slot
+        }
+        if (alpha <= 0.f) continue;
 
-        const float cx = vroom::candle_center_x(
-            lay, c.time_ms, candle_duration_ms,
-            visible_start_ms, window_ms);
-        const float y_close = vroom::price_to_y(lay, bounds, c.close);
         // Collapse high/low/open toward the close so the candle folds into its
         // close point (the line vertex) as `collapse` → 1.
-        const float y_high =
-            vroom::price_to_y(lay, bounds, c.high) * (1.f - collapse) +
-            y_close * collapse;
-        const float y_low =
-            vroom::price_to_y(lay, bounds, c.low) * (1.f - collapse) +
-            y_close * collapse;
-        const float y_open =
-            vroom::price_to_y(lay, bounds, c.open) * (1.f - collapse) +
-            y_close * collapse;
-
-        canvas->drawLine(cx, y_high, cx, y_low,
-                         bull ? wick_bull : wick_bear);
+        const float y_close = g.close;
+        const float y_high = g.high * (1.f - collapse) + y_close * collapse;
+        const float y_low = g.low * (1.f - collapse) + y_close * collapse;
+        const float y_open = g.open * (1.f - collapse) + y_close * collapse;
+
+        // Fast path: the prebuilt bull/bear paints. A faded slot and a candle
+        // that changes direction mid-morph both need per-slot colors.
+        const SkPaint* wick_p = bull ? &wick_bull : &wick_bear;
+        const SkPaint* fill_p = bull ? &bull_paint : &bear_paint;
+        const SkPaint* border_p = bull ? &border_bull : &border_bear;
+        bool draw_border = bull ? draw_border_bull : draw_border_bear;
+
+        const bool flip = frm && to && frm->bull != bull;
+        if (flip || alpha < 0.999f) {
+            const auto blend = [&](uint32_t c_bull, uint32_t c_bear) {
+                uint32_t c = bull ? c_bull : c_bear;
+                if (flip) c = lerp_argb(bull ? c_bear : c_bull, c, morph_t);
+                return scale_alpha(c, alpha);
+            };
+            slot_wick = *wick_p;
+            slot_wick.setColor(blend(wick_color_bull, wick_color_bear));
+            slot_fill = *fill_p;
+            slot_fill.setColor(blend(fill_bull, fill_bear));
+            slot_border = *border_p;
+            slot_border.setColor(blend(border_color_bull, border_color_bear));
+            wick_p = &slot_wick;
+            fill_p = &slot_fill;
+            border_p = &slot_border;
+            if (flip) draw_border = draw_border_bull || draw_border_bear;
+        }
+
+        canvas->drawLine(g.x, y_high, g.x, y_low, *wick_p);
 
         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);
-        const SkRect body = SkRect::MakeXYWH(cx - half_body, y_top, body_w, h);
+        const SkRect body = SkRect::MakeXYWH(g.x - half_body, y_top, body_w, h);
         // Corner radius clamped so thin candles / short bodies don't over-round.
         const float r = std::min({body_r, body_w * 0.5f, h * 0.5f});
-        const SkPaint& fill = bull ? bull_paint : bear_paint;
         if (r > 0.f) {
-            canvas->drawRoundRect(body, r, r, fill);
+            canvas->drawRoundRect(body, r, r, *fill_p);
         } else {
-            canvas->drawRect(body, fill);
+            canvas->drawRect(body, *fill_p);
         }
 
-        const bool draw_border = bull ? draw_border_bull : draw_border_bear;
         // Inset by half the stroke so the centered stroke falls fully within the
         // body: the border overlaps the fill's outer edge instead of straddling
         // it, keeping the candle's footprint exactly body_w. Skip when the body is
@@ -148,13 +246,12 @@ void draw(SkCanvas* canvas,
         if (draw_border && body_w > kBorderWidthPx && h > kBorderWidthPx) {
             const SkRect inner =
                 body.makeInset(kBorderWidthPx * 0.5f, kBorderWidthPx * 0.5f);
-            const SkPaint& bp = bull ? border_bull : border_bear;
             // Concentric radius so the inside border follows the rounded body.
             const float ir = std::max(0.f, r - kBorderWidthPx * 0.5f);
             if (ir > 0.f) {
-                canvas->drawRoundRect(inner, ir, ir, bp);
+                canvas->drawRoundRect(inner, ir, ir, *border_p);
             } else {
-                canvas->drawRect(inner, bp);
+                canvas->drawRect(inner, *border_p);
             }
         }
     }

package/cpp/_core_src/candles.h

@@ -12,6 +12,7 @@
 class SkCanvas;
 
 namespace vroom {
+struct CandleSnapshot;
 struct Layout;
 struct PriceBounds;
 struct Theme;
@@ -26,6 +27,12 @@ namespace vroom::candles {
 // candle→line transition: 0 = normal candle, 1 = a flat point at the close (the
 // body/wick heights and width shrink to the line). `opacity` (0..1) fades the
 // whole candle layer out as the line fades in. Both default to a no-op.
+//
+// `from` / `from_n` is the outgoing geometry of an interval morph, indexed from
+// the right of the visible slice (slot 0 = newest), and `morph_t` (0..1) is the
+// eased progress toward `visible`. Each slot's wick and body interpolate between
+// the two; slots present on only one side fade in or out. `morph_t == 1` (the
+// default) draws `visible` alone.
 void draw(SkCanvas* canvas,
           const ::VroomCandle* visible,
           std::size_t n,
@@ -36,6 +43,9 @@ void draw(SkCanvas* canvas,
           int64_t visible_start_ms,
           int64_t candle_duration_ms,
           float collapse = 0.f,
-          float opacity = 1.f);
+          float opacity = 1.f,
+          const CandleSnapshot* from = nullptr,
+          std::size_t from_n = 0,
+          float morph_t = 1.f);
 
 }  // namespace vroom::candles

package/cpp/_core_src/chart.cpp

@@ -33,11 +33,16 @@
 #include "price_lines.h"
 #include "rsi.h"
 #include "rsi_pane.h"
+#include "style_inherit.h"
 #include "volume.h"
 #include "vwap.h"
 #include "theme.h"
 #include "viewport.h"
 
+namespace {
+constexpr SkColor kVwapLine = 0xff00bcd4;  // cyan
+}  // namespace
+
 VroomChart::VroomChart() : theme(vroom::default_theme()) {}
 
 void VroomChart::mark_dirty() {
@@ -49,7 +54,7 @@ vroom::Layout VroomChart::layout() const {
     const float axis_w = axis_width_px > 0.f
         ? axis_width_px
         : width_px * theme.floats[VROOM_FLOAT_Y_AXIS_WIDTH_RATIO];
-    const int pane_count = (rsi_enabled ? 1 : 0) + (macd_enabled ? 1 : 0);
+    const int pane_count = (rsi.enabled ? 1 : 0) + (macd.enabled ? 1 : 0);
     const float indicator_h = static_cast<float>(pane_count) * height_px *
                               theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
     return vroom::Layout{
@@ -66,10 +71,11 @@ vroom::Layout VroomChart::layout() const {
 }
 
 void VroomChart::ensure_rsi() {
-    if (!rsi_enabled || !rsi_dirty) return;
-    vroom::rsi::compute(candles.data(), candles.size(), rsi_period, rsi_cache);
-    if (rsi_ma_enabled) {
-        vroom::rsi::compute_ma(rsi_cache, rsi_ma_period, rsi_ma_cache);
+    if (!rsi.enabled || !rsi_dirty) return;
+    vroom::rsi::compute(candles.data(), candles.size(), rsi.period, rsi_cache);
+    if (rsi.ma_visible) {
+        vroom::rsi::compute_ma(rsi_cache, rsi.ma_period, rsi.ma_kind,
+                               rsi_ma_cache);
     } else {
         rsi_ma_cache.clear();
     }
@@ -77,9 +83,10 @@ void VroomChart::ensure_rsi() {
 }
 
 void VroomChart::ensure_macd() {
-    if (!macd_enabled || !macd_dirty) return;
-    vroom::macd::compute(candles.data(), candles.size(), macd_fast, macd_slow,
-                         macd_signal, macd_cache, macd_signal_cache,
+    if (!macd.enabled || !macd_dirty) return;
+    vroom::macd::compute(candles.data(), candles.size(), macd.fast, macd.slow,
+                         macd.signal, macd.source, macd.ma_kind,
+                         macd.signal_ma_kind, macd_cache, macd_signal_cache,
                          macd_hist_cache);
     macd_dirty = false;
 }
@@ -96,8 +103,8 @@ void VroomChart::ensure_overlays() {
 }
 
 void VroomChart::ensure_vwap() {
-    if (!vwap_enabled || !vwap_dirty) return;
-    vroom::vwap::compute(candles.data(), candles.size(), vwap_reset_offset_min,
+    if (!vwap.enabled || !vwap_dirty) return;
+    vroom::vwap::compute(candles.data(), candles.size(), vwap.reset_offset_min,
                          vwap_cache, vwap_breaks);
     vwap_dirty = false;
 }
@@ -112,6 +119,7 @@ void VroomChart::ensure_bollinger() {
 }
 
 void VroomChart::draw_chart(SkCanvas* canvas) {
+    begin_frame();
     const auto lay = layout();
 
     // 1. Background
@@ -140,19 +148,60 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
 
     // 3. Update label fade state ONCE per frame — both gridlines and labels
     //    share these opacities so their animations stay in lockstep.
-    vroom::labels::update_y_fades(*this, lay, bounds);
-    vroom::labels::update_x_fades(*this, lay);
+    //    While an interval morph fades the old ticks out, the axes are still laid
+    //    out against the pre-switch scale and window so nothing appears to move;
+    //    they adopt the new ones at the midpoint, invisible. Every axis call in
+    //    the frame has to agree on which of the two it's using.
+    const auto axis_phase = vroom::labels::interval_phase(*this);
+    const auto& axis_bounds = axis_phase.outgoing ? morph_from_bounds : bounds;
+    const int64_t axis_start_ms =
+        axis_phase.outgoing ? morph_from_start_ms : visible_start_ms;
+    const int64_t axis_end_ms =
+        axis_phase.outgoing ? morph_from_end_ms : visible_end_ms;
+    vroom::labels::update_y_fades(*this, lay, axis_bounds);
+    vroom::labels::update_x_fades(*this, lay, axis_start_ms, axis_end_ms);
 
     // 4. Gridlines — drawn before candles so candle bodies overlay them.
     //    Vertical (time) gridlines are intentionally disabled for now —
     //    re-enable by adding `vroom::labels::draw_x_gridlines(canvas, *this,
-    //    candle_right, candle_area_h);` here.
-    vroom::labels::draw_y_gridlines(canvas, *this, lay, bounds,
+    //    axis_start_ms, axis_end_ms, candle_right, candle_area_h);` here.
+    vroom::labels::draw_y_gridlines(canvas, *this, lay, axis_bounds,
                                     candle_right, candle_area_h);
 
+    // 4.35. Price-series morph state, shared by the gradient fill below and the
+    //       series itself (5). `morph_fade` crossfades candles→line and
+    //       `morph_collapse` folds each candle toward its close (the line vertex);
+    //       fade 0 = pure candles, fade 1 = pure line. An interval morph
+    //       additionally reshapes each slot from the geometry it held before the
+    //       timeframe switch (see `morph_from`) — candle bodies, line vertices and
+    //       the fill alike, so every layer stays in step mid-crossfade.
+    const float fade = morph_fade;
+    const float collapse = morph_collapse;
+    const bool morphing = interval_morph_t < 1.f && !morph_from.empty();
+    const vroom::CandleSnapshot* morph_src = morphing ? morph_from.data() : nullptr;
+    const std::size_t morph_n = morphing ? morph_from.size() : 0;
+    const float morph_t = morphing ? interval_morph_t : 1.f;
+
+    // 4.4. Line-mode gradient fill — the wash under the close polyline. Behind the
+    //      volume bars so they stay legible on top of it, which puts it at the
+    //      back of the price pane's content.
+    if (fade > 0.f) {
+        vroom::ma_overlay::draw_close_gradient(
+            canvas, lay, bounds, visible, n, window_ms,
+            visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
+            theme.colors[VROOM_COLOR_LINE],
+            theme.floats[VROOM_FLOAT_LINE_GRADIENT_OPACITY],
+            fade, morph_src, morph_n, morph_t);
+    }
+
     // 4.5. Volume bars — drawn under the candles so candles z-index above.
-    vroom::volume::draw(canvas, visible, n, lay, theme,
-                        window_ms, visible_start_ms, candle_duration_ms);
+    //      A fully collapsed chart has no bars left to draw, which is also how
+    //      "volume disabled" is represented (set_volume snaps the scalar).
+    if (volume_collapse_t < 1.f) {
+        vroom::volume::draw(canvas, visible, n, lay, theme, volume,
+                            volume_collapse_t, volume_collapse_easing,
+                            window_ms, visible_start_ms, candle_duration_ms);
+    }
 
     // 4.6. Liquidity bands (resting-order depth) — behind the candles so the
     //      candle bodies paint over the volume-driven tint. Anchored in price
@@ -178,25 +227,19 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     }
 
     // 5. Price series — candles, a close-price line, or a blend of the two during
-    //    the candle↔line morph. `morph_fade` crossfades candles→line and
-    //    `morph_collapse` folds each candle toward its close (the line vertex).
-    //    fade 0 = pure candles, fade 1 = pure line. The line reuses the MA-overlay
-    //    polyline routine, fed the visible closes and styled by theme.LINE.
-    const float fade = morph_fade;
-    const float collapse = morph_collapse;
+    //    the candle↔line morph (state hoisted to 4.35 for the gradient fill). The
+    //    line is styled by theme.LINE.
     if (fade < 1.f) {
         vroom::candles::draw(canvas, visible, n, lay, theme, bounds, window_ms,
                              visible_start_ms, candle_duration_ms, collapse,
-                             1.f - fade);
+                             1.f - fade, morph_src, morph_n, morph_t);
     }
     if (fade > 0.f) {
-        std::vector<double> closes(n);
-        for (std::size_t i = 0; i < n; ++i) closes[i] = visible[i].close;
-        vroom::ma_overlay::draw(
-            canvas, lay, bounds, visible, n, closes.data(), window_ms,
+        vroom::ma_overlay::draw_close_line(
+            canvas, lay, bounds, visible, n, window_ms,
             visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
             theme.colors[VROOM_COLOR_LINE], theme.floats[VROOM_FLOAT_LINE_WIDTH_PX],
-            nullptr, fade);
+            fade, morph_src, morph_n, morph_t);
     }
 
     // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
@@ -216,7 +259,7 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
 
     // 5.6. VWAP overlay (session, configurable reset) — a single price-pane line
     //      that breaks at each session reset (vwap_breaks).
-    if (vwap_enabled) {
+    if (vwap.enabled) {
         ensure_vwap();
         if (vwap_cache.size() == candles.size()) {
             const double* vis = vwap_cache.data() + range.start;
@@ -226,7 +269,10 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             vroom::ma_overlay::draw(canvas, lay, bounds, visible, n, vis,
                                     window_ms, visible_start_ms,
                                     candle_duration_ms, candle_right,
-                                    candle_area_h, vwap_color, vwap_width, brk);
+                                    candle_area_h,
+                                    vroom::style::color_or(vwap.color, kVwapLine),
+                                    vroom::style::width_or(vwap.width, 1.5f),
+                                    brk);
         }
     }
 
@@ -272,8 +318,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         axis_bg);
 
     // 7. Labels (read from y_fades / x_fades, no state mutation here)
-    vroom::labels::draw_y_labels(canvas, *this, lay, bounds);
-    vroom::labels::draw_x_labels(canvas, *this, lay);
+    vroom::labels::draw_y_labels(canvas, *this, lay, axis_bounds);
+    vroom::labels::draw_x_labels(canvas, *this, lay, axis_start_ms, axis_end_ms);
 
     // 7.5. Current-price line + box — above labels so the box covers any label
     //      it overlaps; tracks the latest close as the price scale moves.
@@ -294,8 +340,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         struct ActivePane { int order; int type; };  // type: 0 = RSI, 1 = MACD
         ActivePane panes[2];
         int count = 0;
-        if (rsi_enabled) panes[count++] = {rsi_order, 0};
-        if (macd_enabled) panes[count++] = {macd_order, 1};
+        if (rsi.enabled) panes[count++] = {rsi_order, 0};
+        if (macd.enabled) panes[count++] = {macd_order, 1};
         if (count == 2 && panes[0].order > panes[1].order) {
             const ActivePane tmp = panes[0];
             panes[0] = panes[1];
@@ -312,7 +358,7 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
                 const double* rsi_vis = rsi_cache.size() == candles.size()
                     ? rsi_cache.data() + range.start : nullptr;
                 const double* rsi_ma_vis =
-                    (rsi_ma_enabled && rsi_ma_cache.size() == candles.size())
+                    (rsi.ma_visible && rsi_ma_cache.size() == candles.size())
                         ? rsi_ma_cache.data() + range.start : nullptr;
                 vroom::rsi_pane::draw(canvas, *this, lay, visible, n, rsi_vis,
                                       rsi_ma_vis, window_ms, visible_start_ms,
@@ -361,19 +407,24 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::labels::gc_x_fades(*this);
 }
 
-void VroomChart::rebuild_chart_picture() {
-    // Compute dt for fade animations. We cap large gaps (resume from
-    // background, long idle) so we don't snap animations to completion.
-    auto now = std::chrono::steady_clock::now();
+void VroomChart::begin_frame() {
+    // dt for the fade animations. A large gap (resume from background, or an idle
+    // chart that a click just woke up) is clamped to a nominal frame rather than
+    // zeroed: dt == 0 means "snap" to the fade updaters, which would finish every
+    // fade in the first frame after any idle period.
+    constexpr float kNominalFrameSeconds = 1.f / 60.f;
+    const auto now = std::chrono::steady_clock::now();
     float dt = 0.f;
     if (anim_started) {
         dt = std::chrono::duration<float>(now - last_anim_tick).count();
-        if (dt > 0.1f) dt = 0.f;
+        if (dt > 0.1f) dt = kNominalFrameSeconds;
     }
     last_anim_tick = now;
     anim_started = true;
     last_dt_seconds = dt;
+}
 
+void VroomChart::rebuild_chart_picture() {
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(SkRect::MakeWH(width_px, height_px));
     draw_chart(canvas);