react-native-vroom-chart 0.2.0 → 0.5.0

package/cpp/VroomChartHostObject.cpp

@@ -27,13 +27,15 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(22);
+  out.reserve(24);
   out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setFloat"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVisibleRange"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setDefaultCandleWidth"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setChartType"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setMorph"));
   out.push_back(jsi::PropNameID::forAscii(rt, "pan"));
   out.push_back(jsi::PropNameID::forAscii(rt, "translate"));
   out.push_back(jsi::PropNameID::forAscii(rt, "zoom"));
@@ -49,6 +51,7 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setMACD"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setOverlays"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVWAP"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setBollinger"));
   out.push_back(jsi::PropNameID::forAscii(rt, "render"));
   return out;
 }
@@ -188,6 +191,41 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setChartType") {
+    // setChartType(mode) — 0 = candlesticks (default), 1 = line chart.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setChartType"),
+        1,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1) return jsi::Value::undefined();
+          vroom_chart_set_chart_type(
+              chart_, static_cast<int32_t>(args[0].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setMorph") {
+    // setMorph(collapse, fade) — candle↔line blend for animated transitions.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setMorph"),
+        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_morph(chart_,
+                                static_cast<float>(args[0].asNumber()),
+                                static_cast<float>(args[1].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "pan") {
     // pan(dx, dy) -> JsiSkPicture
     // Mutates the visible range and renders in one JSI call so gesture
@@ -514,6 +552,52 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setBollinger") {
+    // setBollinger({enabled, period, mult, source, basisKind, upperColor,
+    // upperWidth, middleColor, middleWidth, lowerColor, lowerWidth,
+    // fillEnabled, fillOpacity}) — Bollinger Bands overlay. No render; the
+    // next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setBollinger"),
+        1,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isObject()) return jsi::Value::undefined();
+          auto s = args[0].asObject(rt2);
+          VroomBollinger cfg{};
+          cfg.enabled = s.getProperty(rt2, "enabled").asBool() ? 1 : 0;
+          cfg.period = static_cast<int32_t>(
+              s.getProperty(rt2, "period").asNumber());
+          cfg.mult = static_cast<float>(
+              s.getProperty(rt2, "mult").asNumber());
+          cfg.source = static_cast<int32_t>(
+              s.getProperty(rt2, "source").asNumber());
+          cfg.basis_kind = static_cast<int32_t>(
+              s.getProperty(rt2, "basisKind").asNumber());
+          cfg.upper_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "upperColor").asNumber());
+          cfg.upper_width = static_cast<float>(
+              s.getProperty(rt2, "upperWidth").asNumber());
+          cfg.middle_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "middleColor").asNumber());
+          cfg.middle_width = static_cast<float>(
+              s.getProperty(rt2, "middleWidth").asNumber());
+          cfg.lower_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "lowerColor").asNumber());
+          cfg.lower_width = static_cast<float>(
+              s.getProperty(rt2, "lowerWidth").asNumber());
+          cfg.fill_enabled =
+              s.getProperty(rt2, "fillEnabled").asBool() ? 1 : 0;
+          cfg.fill_opacity = static_cast<float>(
+              s.getProperty(rt2, "fillOpacity").asNumber());
+          vroom_chart_set_bollinger(chart_, &cfg);
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "render") {
     return jsi::Function::createFromHostFunction(
         rt,

package/cpp/_core_include/vroom/vroom_chart.h

@@ -49,18 +49,50 @@ typedef struct VroomOverlay {
     float    width;   // stroke width in px
 } VroomOverlay;
 
+// Bollinger Bands overlay drawn on the price pane: a basis MA of `source` over
+// `period`, banded at ± `mult` × population standard deviation of the same
+// window. Per TradingView semantics the stdev always uses the window's
+// arithmetic mean, even when `basis_kind` selects an EMA basis line.
+typedef struct VroomBollinger {
+    int32_t  enabled;       // 0/1
+    int32_t  period;        // lookback in candles (clamped >= 1; default 20)
+    float    mult;          // stdev multiplier (clamped >= 0; default 2)
+    int32_t  source;        // 0=close,1=open,2=high,3=low,4=hl2,5=hlc3,6=ohlc4
+    int32_t  basis_kind;    // 0 = SMA, 1 = EMA
+    uint32_t upper_color;   // 0xAARRGGBB
+    float    upper_width;   // stroke px
+    uint32_t middle_color;
+    float    middle_width;
+    uint32_t lower_color;
+    float    lower_width;
+    int32_t  fill_enabled;  // 0/1: translucent fill between upper and lower
+    float    fill_opacity;  // 0..1, multiplied into upper_color's alpha
+} VroomBollinger;
+
 // 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.
+// A committed drawing on the price pane. `kind` selects the geometry:
+//   0 = line   — a two-point trendline from `a` to `b`.
+//   1 = box    — an axis-aligned rectangle whose two opposite corners are `a`
+//                and `b`; the other two corners (a.x,b.y) and (b.x,a.y) derive.
+//   2 = pencil — a freehand path through `points` (in draw order). `a`/`b` mirror
+//                the first/last point so bounds and handle code stay uniform.
+//
+// `points`/`point_count` are only read for kind 2; line and box leave them
+// null/0. Like the rest of this API the points are copied internally, so the
+// caller may free them as soon as the call returns.
 typedef struct VroomDrawing {
-    VroomDrawPoint a;
-    VroomDrawPoint b;
-    uint32_t       color;  // 0xAARRGGBB
-    float          width;  // stroke width in px
+    VroomDrawPoint        a;
+    VroomDrawPoint        b;
+    uint32_t              color;        // 0xAARRGGBB
+    float                 width;        // stroke width in px
+    int32_t               kind;         // 0 = line, 1 = box, 2 = pencil
+    const VroomDrawPoint* points;       // pencil path (kind 2), else null
+    int32_t               point_count;  // number of `points`, else 0
 } VroomDrawing;
 
 // A resting-liquidity band: a price interval carrying a total order size on one
@@ -112,6 +144,7 @@ typedef enum {
     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_LINE,              // line-chart-mode close-price polyline
     VROOM_COLOR_COUNT_
 } VroomColorKey;
 
@@ -127,6 +160,7 @@ typedef enum {
     VROOM_FLOAT_CANDLE_RADIUS_PX,        // candle body corner radius px (0 = square)
     VROOM_FLOAT_WICK_ROUND_CAP,          // 0/1: round the wick end caps
     VROOM_FLOAT_VOLUME_RADIUS_PX,        // volume bar top-corner radius px (0 = square)
+    VROOM_FLOAT_LINE_WIDTH_PX,           // line-chart-mode polyline stroke width px
     VROOM_FLOAT_COUNT_
 } VroomFloatKey;
 
@@ -163,6 +197,17 @@ void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_ms, int64_t
 // set_visible_range still overrides it.
 void vroom_chart_set_default_candle_width(VroomChart* chart, float px);
 
+// Chart render mode: 0 = candlesticks (default), 1 = line chart (a polyline
+// through each candle's close). Other layers (volume, indicators, overlays,
+// crosshair, drawings) are unaffected.
+void vroom_chart_set_chart_type(VroomChart* chart, int32_t mode);
+
+// Candle↔line morph blend for animated transitions. `collapse` folds candles
+// toward their close price; `fade` crossfades candles→line. Both 0 = candles,
+// both 1 = line. Driven per-frame by the host animation loop; set_chart_type
+// snaps both to the target.
+void vroom_chart_set_morph(VroomChart* chart, float collapse, float fade);
+
 // 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,
@@ -296,6 +341,11 @@ 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);
 
+// Configures the Bollinger Bands overlay (three price-pane lines + an optional
+// translucent fill between the bands; no pane is reserved). Color/width/fill
+// changes only re-render; enabled/period/mult/source/basis changes recompute.
+void vroom_chart_set_bollinger(VroomChart* chart, const VroomBollinger* cfg);
+
 // ---- Drawings (line annotations) ------------------------------------------
 
 // Replaces the full set of committed line drawings (data-anchored, so they track
@@ -304,6 +354,34 @@ void vroom_chart_set_vwap(VroomChart* chart, bool enabled, int reset_offset_min,
 void vroom_chart_set_drawings(VroomChart* chart, const VroomDrawing* drawings,
                               size_t count);
 
+// Hit-tests pixel (x_px, y_px) against the committed drawings. On a hit, fills
+// *out_index with the drawing index, *out_part with 0 (endpoint A), 1
+// (endpoint B), or 2 (line body), *out_t with the 0..1 grab position along the
+// segment (A→B; 0/1 for handle hits), and returns true. Endpoint hits are only
+// reported for the currently selected drawing (whose handles are visible).
+// Returns false on a miss (out params untouched). Any out pointer may be null.
+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);
+
+// Selects a committed drawing (renders its endpoint handles). `index` -1 clears
+// the selection. `grabbed_endpoint` 0/1 renders that handle 50% larger while it's
+// being dragged; -1 for none. An out-of-range index clears the selection.
+void vroom_chart_set_selected_drawing(VroomChart* chart, int32_t index,
+                                      int32_t grabbed_endpoint);
+
+// Moves one endpoint of a committed drawing to a new data-space anchor (for live
+// handle dragging). `endpoint` is 0 (A) or 1 (B). No-op for an out-of-range index.
+void vroom_chart_move_drawing_endpoint(VroomChart* chart, int32_t index,
+                                       int32_t endpoint, int64_t time_ms,
+                                       double price);
+
+// Shifts a whole committed drawing by a *relative* data-space delta — `a`, `b`,
+// and (for a pencil) every path point. Used for live body dragging of shapes
+// whose points can't be restated cheaply. No-op for an out-of-range index.
+void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
+                                   int64_t d_time_ms, double d_price);
+
 // ---- Liquidity bands (order-book depth overlay) ---------------------------
 
 // Replaces the full set of resting-liquidity bands and their shared style.
@@ -314,14 +392,29 @@ void vroom_chart_set_liquidity(VroomChart* chart, const VroomBand* bands,
 
 // 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.
+// `guide != 0` also draws the live preview (a guideline for a line, or a preview
+// rectangle for a box); `guide == 0` draws node dots only (the committed shape
+// already renders via set_drawings). `kind` matches VroomDrawing (0 = line,
+// 1 = box) so the preview geometry matches the eventual shape. `color`/`width`
+// style the preview to match the eventual drawing.
 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).
+                           bool guide, uint32_t color, float width,
+                           int32_t kind);
+
+// Begins a freehand (pencil) draft stroke, clearing any previous draft points.
+// Follow with vroom_chart_append_draft_point per captured sample; the growing
+// path renders live. `color`/`width` style it to match the eventual stroke.
+void vroom_chart_start_draft_stroke(VroomChart* chart, uint32_t color,
+                                    float width);
+
+// Appends one point to the in-progress freehand draft. Cheap (O(1) amortized) so
+// it can be called on every pointer move without restating the whole path.
+// No-op unless a draft stroke was started.
+void vroom_chart_append_draft_point(VroomChart* chart, int64_t time_ms,
+                                    double price);
+
+// Clears the draft (hides the in-progress node dots / guideline / stroke).
 void vroom_chart_clear_draft(VroomChart* chart);
 
 // Fills *out with the continuous data coordinate (time_ms, price) at pixel
@@ -331,6 +424,13 @@ void vroom_chart_clear_draft(VroomChart* chart);
 bool vroom_chart_coord_at(VroomChart* chart, float x_px, float y_px,
                           VroomCoord* out);
 
+// Projects a data coordinate (time_ms, price) to its pixel position, filling
+// *out_x / *out_y (either may be null) with the free (non-snapped) mapping — the
+// inverse of vroom_chart_coord_at, matching the rendered drawing geometry.
+// Returns false (out params untouched) when there are no candles / degenerate.
+bool vroom_chart_project(VroomChart* chart, int64_t time_ms, double price,
+                         float* out_x, float* out_y);
+
 // ---- Rendering ------------------------------------------------------------
 
 void vroom_chart_draw(VroomChart* chart, SkCanvas* canvas);

package/cpp/_core_src/bollinger.cpp

@@ -0,0 +1,43 @@
+#include "bollinger.h"
+
+#include <cmath>  // std::nan, std::sqrt
+
+#include "ma.h"
+
+namespace vroom::bollinger {
+
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             double mult, int source, int basis_kind,
+             std::vector<double>& middle, std::vector<double>& upper,
+             std::vector<double>& lower) {
+    vroom::ma::compute(candles, n, basis_kind, period, source, middle);
+    upper.assign(n, std::nan(""));
+    lower.assign(n, std::nan(""));
+    if (!candles || period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+    if (n < P) return;
+
+    std::vector<double> src(n);
+    for (std::size_t i = 0; i < n; ++i) src[i] = vroom::ma::source_value(candles[i], source);
+
+    // Two-pass stdev around the true window mean per bar. O(n·period), but
+    // numerically stable — the rolling Σx²−n·mean² form cancels catastrophically
+    // on large prices with small deviations (e.g. BTC-scale values).
+    for (std::size_t i = P - 1; i < n; ++i) {
+        const std::size_t s = i + 1 - P;
+        double mean = 0.0;
+        for (std::size_t j = s; j <= i; ++j) mean += src[j];
+        mean /= static_cast<double>(P);
+        double var = 0.0;
+        for (std::size_t j = s; j <= i; ++j) {
+            const double d = src[j] - mean;
+            var += d * d;
+        }
+        var /= static_cast<double>(P);
+        const double band = mult * std::sqrt(var);
+        upper[i] = middle[i] + band;
+        lower[i] = middle[i] - band;
+    }
+}
+
+}  // namespace vroom::bollinger

package/cpp/_core_src/bollinger.h

@@ -0,0 +1,31 @@
+// Bollinger Bands over a candle source series — pure, no Skia, so it builds
+// into the unit-test target. Drawn as price-pane overlay lines + a band fill.
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::bollinger {
+
+// Computes the three band series over [candles, candles+n). `period` is clamped
+// to >= 1; `mult` is the standard-deviation multiplier. `source` is a
+// vroom::ma::Source index and `basis_kind` a vroom::ma::Kind (SMA/EMA).
+//
+//   middle = ma::compute(basis_kind, period, source)
+//   upper/lower = middle ± mult * population stdev of source over the trailing
+//                 period window
+//
+// The stdev always uses the window's arithmetic mean, even when basis_kind
+// selects an EMA basis line (TradingView semantics).
+//
+// Each output is resized to n; values are NaN for i < period-1 and when
+// n < period.
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             double mult, int source, int basis_kind,
+             std::vector<double>& middle, std::vector<double>& upper,
+             std::vector<double>& lower);
+
+}  // namespace vroom::bollinger

package/cpp/_core_src/candles.cpp

@@ -30,11 +30,28 @@ void draw(SkCanvas* canvas,
           const PriceBounds& bounds,
           int64_t window_ms,
           int64_t visible_start_ms,
-          int64_t candle_duration_ms) {
+          int64_t candle_duration_ms,
+          float collapse,
+          float opacity) {
     if (!canvas || n == 0) return;
 
-    const float body_w = vroom::candle_body_width(
+    collapse = std::clamp(collapse, 0.f, 1.f);
+    opacity = std::clamp(opacity, 0.f, 1.f);
+    if (opacity <= 0.f) 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;
+    if (fade_layer) {
+        canvas->saveLayerAlpha(nullptr,
+                               static_cast<U8CPU>(opacity * 255.f + 0.5f));
+    }
+
+    const float full_body_w = vroom::candle_body_width(
         lay, window_ms, candle_duration_ms);
+    // Thin the body toward the line stroke width as candles collapse to the line.
+    const float line_w = theme.floats[VROOM_FLOAT_LINE_WIDTH_PX];
+    const float body_w = full_body_w + (line_w - full_body_w) * collapse;
 
     const uint32_t fill_bull = theme.colors[VROOM_COLOR_BULL];
     const uint32_t fill_bear = theme.colors[VROOM_COLOR_BEAR];
@@ -94,10 +111,18 @@ void draw(SkCanvas* canvas,
         const float cx = vroom::candle_center_x(
             lay, c.time_ms, candle_duration_ms,
             visible_start_ms, window_ms);
-        const float y_high = vroom::price_to_y(lay, bounds, c.high);
-        const float y_low = vroom::price_to_y(lay, bounds, c.low);
-        const float y_open = vroom::price_to_y(lay, bounds, c.open);
         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);
@@ -133,6 +158,8 @@ void draw(SkCanvas* canvas,
             }
         }
     }
+
+    if (fade_layer) canvas->restore();
 }
 
 }  // namespace vroom::candles

package/cpp/_core_src/candles.h

@@ -21,6 +21,11 @@ namespace vroom::candles {
 
 // Draws every candle in [visible, visible + n). The visible slice should
 // already be filtered by `visible_indices` in viewport.h.
+//
+// `collapse` (0..1) morphs each candle vertically toward its close price for the
+// 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.
 void draw(SkCanvas* canvas,
           const ::VroomCandle* visible,
           std::size_t n,
@@ -29,6 +34,8 @@ void draw(SkCanvas* canvas,
           const PriceBounds& bounds,
           int64_t window_ms,
           int64_t visible_start_ms,
-          int64_t candle_duration_ms);
+          int64_t candle_duration_ms,
+          float collapse = 0.f,
+          float opacity = 1.f);
 
 }  // namespace vroom::candles

package/cpp/_core_src/chart.cpp

@@ -18,6 +18,7 @@
 #include "include/core/SkRect.h"
 #pragma clang diagnostic pop
 
+#include "bollinger.h"
 #include "candles.h"
 #include "chart_internal.h"
 #include "crosshair.h"
@@ -100,6 +101,15 @@ void VroomChart::ensure_vwap() {
     vwap_dirty = false;
 }
 
+void VroomChart::ensure_bollinger() {
+    if (!bollinger.enabled || !bollinger_dirty) return;
+    vroom::bollinger::compute(candles.data(), candles.size(), bollinger.period,
+                              bollinger.mult, bollinger.source,
+                              bollinger.basis_kind, bb_middle_cache,
+                              bb_upper_cache, bb_lower_cache);
+    bollinger_dirty = false;
+}
+
 void VroomChart::draw_chart(SkCanvas* canvas) {
     const auto lay = layout();
 
@@ -149,9 +159,44 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
                            candle_area_h);
 
-    // 5. Candles (wicks + bodies)
-    vroom::candles::draw(canvas, visible, n, lay, theme, bounds,
-                         window_ms, visible_start_ms, candle_duration_ms);
+    // 4.7. Bollinger Band fill — the translucent region between the upper and
+    //      lower bands, behind the candles so their bull/bear colors stay
+    //      untinted. The band lines themselves draw above the candles (5.65).
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        if (bollinger.fill_enabled &&
+            bb_upper_cache.size() == candles.size() &&
+            bb_lower_cache.size() == candles.size()) {
+            vroom::ma_overlay::fill_between(
+                canvas, lay, bounds, visible, n,
+                bb_upper_cache.data() + range.start,
+                bb_lower_cache.data() + range.start, window_ms,
+                visible_start_ms, candle_duration_ms, candle_right,
+                candle_area_h, bollinger.upper_color, bollinger.fill_opacity);
+        }
+    }
+
+    // 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;
+    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);
+    }
+    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,
+            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);
+    }
 
     // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
     //      candles. They share the candle price scale and don't reserve a pane.
@@ -184,6 +229,28 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         }
     }
 
+    // 5.65. Bollinger Band lines — upper, lower, then the basis last so it
+    //       reads on top where the bands pinch. Same price scale as the
+    //       candles; the fill went down in 4.7.
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        const std::size_t sz = candles.size();
+        if (bb_upper_cache.size() == sz && bb_lower_cache.size() == sz &&
+            bb_middle_cache.size() == sz) {
+            const auto stroke = [&](const std::vector<double>& cache,
+                                    uint32_t color, float width) {
+                vroom::ma_overlay::draw(canvas, lay, bounds, visible, n,
+                                        cache.data() + range.start, window_ms,
+                                        visible_start_ms, candle_duration_ms,
+                                        candle_right, candle_area_h, color,
+                                        width);
+            };
+            stroke(bb_upper_cache, bollinger.upper_color, bollinger.upper_width);
+            stroke(bb_lower_cache, bollinger.lower_color, bollinger.lower_width);
+            stroke(bb_middle_cache, bollinger.middle_color, bollinger.middle_width);
+        }
+    }
+
     // 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,

package/cpp/_core_src/chart.h

@@ -54,6 +54,15 @@ struct VroomChart {
     // initial zoom). 0 = legacy "last ~80 candles" behavior.
     float default_candle_px = 0.f;
 
+    // Render mode: 0 = candlesticks (default), 1 = line chart (close polyline).
+    int chart_type = 0;
+
+    // Candle↔line morph blend, driven per-frame by the JS animation loop.
+    // `morph_collapse` folds candles toward their close; `morph_fade` crossfades
+    // candles→line. Both 0 = candles, both 1 = line. set_chart_type snaps them.
+    float morph_collapse = 0.f;
+    float morph_fade = 0.f;
+
     // Cached y-axis width in pixels, sized to fit the widest formatted price
     // label. 0 = uncomputed; layout() falls back to a width ratio.
     float axis_width_px = 0.f;
@@ -126,10 +135,36 @@ 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;
+    // Bollinger Bands overlay (price pane; no pane reserved). Caches aligned to
+    // `candles` (NaN warmup), recomputed lazily by ensure_bollinger() when
+    // bollinger_dirty. Defaults: 20-period SMA of close, ±2σ, blue bands /
+    // orange basis, 10% fill.
+    VroomBollinger bollinger{0, 20, 2.f, 0, 0,
+                             0xff2962ff, 1.f,   // upper: blue
+                             0xffff6d00, 1.f,   // middle: orange
+                             0xff2962ff, 1.f,   // lower: blue
+                             1, 0.1f};
+    std::vector<double> bb_middle_cache;
+    std::vector<double> bb_upper_cache;
+    std::vector<double> bb_lower_cache;
+    bool bollinger_dirty = true;
+
+    // --- drawings (annotations) --------------------------------------------
+    // Committed drawings, anchored in data space so they track the candles on
+    // pan/zoom. Drawn on the price pane above candles/overlays.
+    //
+    // Mirrors the public VroomDrawing but *owns* its points, so a pencil path
+    // (kind 2) can carry a variable number of them. For line/box `points` is
+    // empty and only a/b are used; for pencil a/b mirror the first/last point.
+    struct StoredDrawing {
+        VroomDrawPoint              a{};
+        VroomDrawPoint              b{};
+        uint32_t                    color = 0xff2962ff;
+        float                       width = 2.f;
+        int32_t                     kind = 0;
+        std::vector<VroomDrawPoint> points;  // pencil path (kind 2)
+    };
+    std::vector<StoredDrawing> 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.
@@ -143,6 +178,16 @@ struct VroomChart {
     bool           draft_guide = false;
     uint32_t       draft_color = 0xff2962ff;
     float          draft_width = 2.f;
+    int32_t        draft_kind = 0;  // 0 = line, 1 = box, 2 = pencil (VroomDrawing)
+    // Freehand stroke in progress (draft_kind 2), grown one point at a time.
+    std::vector<VroomDrawPoint> draft_points;
+
+    // Selection/editing state for committed drawings. selected_drawing indexes
+    // `drawings` (or -1); its endpoints render as handles. grabbed_endpoint is
+    // 0 (A) or 1 (B) while that handle is being dragged (rendered 50% larger),
+    // else -1.
+    int32_t        selected_drawing = -1;
+    int32_t        grabbed_endpoint = -1;
 
     // --- liquidity bands (order-book depth overlay) ------------------------
     // Resting-order bands anchored in price space, drawn behind the candles and
@@ -191,6 +236,10 @@ struct VroomChart {
     // Recomputes the VWAP cache when vwap_dirty and VWAP is enabled.
     void ensure_vwap();
 
+    // Recomputes the Bollinger Band caches when bollinger_dirty and the
+    // indicator is enabled.
+    void ensure_bollinger();
+
     // The main drawing pass. Calls into the labels and candles modules.
     void draw_chart(SkCanvas* canvas);