react-native-vroom-chart 0.1.4 → 0.4.0

package/cpp/VroomChartHostObject.cpp

@@ -27,11 +27,15 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(19);
+  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"));
@@ -130,6 +134,25 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setFloat") {
+    // setFloat(keyIndex, value) — keyIndex is a VroomFloatKey (e.g. wick width).
+    // The core bounds-checks the key and marks dirty.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setFloat"),
+        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();
+          const int key = static_cast<int>(args[0].asNumber());
+          vroom_chart_set_float(chart_, static_cast<VroomFloatKey>(key),
+                                static_cast<float>(args[1].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "setVisibleRange") {
     // Pass 0,0 to clear (show all).
     // Timestamps are Number on the JS side — fine for ms-since-epoch since
@@ -150,6 +173,58 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setDefaultCandleWidth") {
+    // setDefaultCandleWidth(px) — target candle body width for initial framing.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setDefaultCandleWidth"),
+        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_default_candle_width(
+              chart_, static_cast<float>(args[0].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
+  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

package/cpp/_core_include/vroom/vroom_chart.h

@@ -55,14 +55,49 @@ typedef struct VroomDrawPoint {
     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
+// side of the book. Anchored in price space, so it scales with the y-axis.
+typedef struct VroomBand {
+    double  min_price;  // bottom of the interval
+    double  max_price;  // top of the interval
+    int32_t side;       // 0 = buy, 1 = sell (selects the color)
+    double  volume;     // total resting size; drives the band's opacity
+} VroomBand;
+
+// Style shared by all liquidity bands. `buy_color`/`sell_color` are 0xAARRGGBB;
+// the alpha is replaced per band by its volume mapped into
+// [min_opacity, max_opacity]. `max_volume <= 0` auto-scales to the largest band.
+// The leftward reach is min(width_px, width_frac * pane_width).
+typedef struct VroomLiquidityStyle {
+    uint32_t buy_color;
+    uint32_t sell_color;
+    double   max_volume;
+    float    min_opacity;
+    float    max_opacity;
+    float    width_px;
+    float    width_frac;
+} VroomLiquidityStyle;
+
 // A continuous data coordinate at a pixel position (no candle snapping). Used to
 // translate a drawing-tool click into a data-space anchor.
 typedef struct VroomCoord {
@@ -89,6 +124,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;
 
@@ -101,6 +137,10 @@ typedef enum {
     VROOM_FLOAT_X_AXIS_HEIGHT_PX,        // bottom strip reserved for time labels
     VROOM_FLOAT_VOLUME_OPACITY,          // volume bar opacity (1=opaque)
     VROOM_FLOAT_INDICATOR_HEIGHT_FRAC,   // below-chart indicator pane, fraction of height
+    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;
 
@@ -131,6 +171,23 @@ void vroom_chart_set_size(VroomChart* chart, float width_px, float height_px, fl
 
 void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_ms, int64_t end_ms);
 
+// Target candle *body* width in px for the default/reset framing. Larger = more
+// zoomed in (fewer candles), smaller = more zoomed out. 0 restores the legacy
+// "most recent ~80 candles" default. Affects initial framing only; an explicit
+// 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,
@@ -272,16 +329,67 @@ 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.
+// Bands render behind the candles, anchored at the inner edge of the price axis
+// and fading left. Pass count 0 to clear; `style` may be null when count is 0.
+void vroom_chart_set_liquidity(VroomChart* chart, const VroomBand* bands,
+                               size_t count, const VroomLiquidityStyle* style);
+
 // 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
@@ -291,6 +399,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/candles.cpp

@@ -30,15 +30,44 @@ 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];
 
+    const float body_r = theme.floats[VROOM_FLOAT_CANDLE_RADIUS_PX];
+    const bool wick_round = theme.floats[VROOM_FLOAT_WICK_ROUND_CAP] > 0.5f;
+
+    constexpr float kBorderWidthPx = 1.f;
+    // 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;
+
     SkPaint bull_paint;
     bull_paint.setAntiAlias(true);
     bull_paint.setColor(fill_bull);
@@ -53,17 +82,19 @@ void draw(SkCanvas* canvas,
         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);
+    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));
 
-    // 1px body outlines. Default sentinel resolves to the fill color, so the
-    // border is invisible until a consumer sets borderBull/borderBear.
+    // 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
+    // the fill color; such borders are skipped entirely (draw_border_* above).
     SkPaint border_bull;
     border_bull.setAntiAlias(true);
     border_bull.setStyle(SkPaint::kStroke_Style);
-    border_bull.setStrokeWidth(1.f);
+    border_bull.setStrokeWidth(kBorderWidthPx);
     border_bull.setColor(
         resolve_color(theme.colors[VROOM_COLOR_BORDER_BULL], fill_bull));
 
@@ -80,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);
@@ -92,9 +131,35 @@ void draw(SkCanvas* canvas,
         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);
-        canvas->drawRect(body, bull ? bull_paint : bear_paint);
-        canvas->drawRect(body, bull ? border_bull : border_bear);
+        // 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);
+        } else {
+            canvas->drawRect(body, fill);
+        }
+
+        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
+        // too small to hold it.
+        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);
+            } else {
+                canvas->drawRect(inner, bp);
+            }
+        }
     }
+
+    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

@@ -23,6 +23,7 @@
 #include "crosshair.h"
 #include "drawings.h"
 #include "labels.h"
+#include "liquidity.h"
 #include "ma.h"
 #include "ma_overlay.h"
 #include "macd.h"
@@ -142,9 +143,33 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::volume::draw(canvas, visible, n, lay, theme,
                         window_ms, visible_start_ms, candle_duration_ms);
 
-    // 5. Candles (wicks + bodies)
-    vroom::candles::draw(canvas, visible, n, lay, theme, bounds,
-                         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
+    //      space, so they scale with the y-axis.
+    vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
+                           candle_area_h);
+
+    // 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.

package/cpp/_core_src/chart.h

@@ -50,6 +50,19 @@ struct VroomChart {
     int64_t visible_start_ms = 0;
     int64_t visible_end_ms = 0;
 
+    // >0: default/reset framing targets this candle *body* width in px (drives
+    // 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;
@@ -122,10 +135,22 @@ 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;
+    // --- 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.
@@ -139,6 +164,22 @@ 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
+    // fading left from the price axis. Empty when the overlay is off.
+    std::vector<VroomBand>   bands;
+    VroomLiquidityStyle      liquidity_style{};
 
     // --- theme --------------------------------------------------------------
     vroom::Theme theme;