react-native-vroom-chart 0.14.0 → 0.16.0

package/cpp/VroomChartHostObject.cpp

@@ -42,7 +42,7 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(39);
+  out.reserve(42);
   out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
@@ -57,6 +57,7 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "getVisiblePriceEnvelope"));
   out.push_back(jsi::PropNameID::forAscii(rt, "preservePriceEnvelope"));
   out.push_back(jsi::PropNameID::forAscii(rt, "beginIntervalMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "beginStreamMorph"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setIntervalMorph"));
   out.push_back(jsi::PropNameID::forAscii(rt, "pan"));
   out.push_back(jsi::PropNameID::forAscii(rt, "translate"));
@@ -71,9 +72,12 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "getCrosshairInfo"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setRSI"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setMACD"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setATR"));
   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, "setIchimoku"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setFairValueGaps"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVolume"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVolumeCollapse"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setAxisCollapse"));
@@ -82,6 +86,9 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "hitTestPriceLine"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLineHover"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLineDrag"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setFootprints"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "hitTestFootprint"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setFootprintHover"));
   out.push_back(jsi::PropNameID::forAscii(rt, "render"));
   return out;
 }
@@ -507,6 +514,24 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "beginStreamMorph") {
+    // beginStreamMorph() — capture the visible geometry so the next setCandles
+    // can ease a live tick into place. Leaves the axes alone, and continues
+    // from the shape on screen when one is still animating. Call before
+    // setCandles.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "beginStreamMorph"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_begin_stream_morph(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "setIntervalMorph") {
     // setIntervalMorph(t) — advance the capture toward the new candles. `t` is
     // pre-eased progress: 0 = the captured frame, 1 = settled (capture freed).
@@ -758,7 +783,8 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
   if (name == "setRSI") {
     // setRSI({enabled, period, upperBand, lowerBand, maPeriod, maKind,
     // maVisible, lineColor, lineWidth, lineVisible, maColor, maWidth,
-    // bandColor, bandsVisible}) — configures the RSI pane. No render; the next
+    // bandColor, bandsVisible, extremeFill}) — configures the RSI pane. No
+    // render; the next
     // render() picks it up.
     return jsi::Function::createFromHostFunction(
         rt,
@@ -794,6 +820,8 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
               s.getProperty(rt2, "bandColor").asNumber());
           cfg.bands_visible =
               s.getProperty(rt2, "bandsVisible").asBool() ? 1 : 0;
+          cfg.extreme_fill =
+              s.getProperty(rt2, "extremeFill").asBool() ? 1 : 0;
           vroom_chart_set_rsi(chart_, &cfg);
           return jsi::Value::undefined();
         });
@@ -860,6 +888,34 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setATR") {
+    // setATR({enabled, period, smoothing, lineColor, lineWidth}) — configures
+    // the ATR pane. No render; the next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setATR"),
+        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);
+          VroomATR cfg{};
+          cfg.enabled = s.getProperty(rt2, "enabled").asBool() ? 1 : 0;
+          cfg.period = static_cast<int32_t>(
+              s.getProperty(rt2, "period").asNumber());
+          cfg.smoothing = static_cast<int32_t>(
+              s.getProperty(rt2, "smoothing").asNumber());
+          cfg.line_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "lineColor").asNumber());
+          cfg.line_width = static_cast<float>(
+              s.getProperty(rt2, "lineWidth").asNumber());
+          vroom_chart_set_atr(chart_, &cfg);
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "setOverlays") {
     // setOverlays([{ kind, period, source, color, width }, ...]) — replaces the
     // full set of MA/EMA overlay lines. No render; the next render() picks it up.
@@ -969,6 +1025,123 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setIchimoku") {
+    // setIchimoku({enabled, tenkanPeriod, kijunPeriod, senkouBPeriod,
+    // displacement, <line>Color/<line>Width/<line>Enabled for tenkan, kijun,
+    // senkouA, senkouB and chikou, cloudEnabled, bullishCloudColor,
+    // bearishCloudColor, cloudOpacity}) — the Ichimoku overlay. No render; the
+    // next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setIchimoku"),
+        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);
+          const auto num = [&](const char* k) {
+            return s.getProperty(rt2, k).asNumber();
+          };
+          const auto flag = [&](const char* k) {
+            return s.getProperty(rt2, k).asBool() ? 1 : 0;
+          };
+          VroomIchimoku cfg{};
+          cfg.enabled = flag("enabled");
+          cfg.tenkan_period = static_cast<int32_t>(num("tenkanPeriod"));
+          cfg.kijun_period = static_cast<int32_t>(num("kijunPeriod"));
+          cfg.senkou_b_period = static_cast<int32_t>(num("senkouBPeriod"));
+          cfg.displacement = static_cast<int32_t>(num("displacement"));
+          cfg.tenkan_color = static_cast<uint32_t>(num("tenkanColor"));
+          cfg.tenkan_width = static_cast<float>(num("tenkanWidth"));
+          cfg.tenkan_enabled = flag("tenkanEnabled");
+          cfg.kijun_color = static_cast<uint32_t>(num("kijunColor"));
+          cfg.kijun_width = static_cast<float>(num("kijunWidth"));
+          cfg.kijun_enabled = flag("kijunEnabled");
+          cfg.senkou_a_color = static_cast<uint32_t>(num("senkouAColor"));
+          cfg.senkou_a_width = static_cast<float>(num("senkouAWidth"));
+          cfg.senkou_a_enabled = flag("senkouAEnabled");
+          cfg.senkou_b_color = static_cast<uint32_t>(num("senkouBColor"));
+          cfg.senkou_b_width = static_cast<float>(num("senkouBWidth"));
+          cfg.senkou_b_enabled = flag("senkouBEnabled");
+          cfg.chikou_color = static_cast<uint32_t>(num("chikouColor"));
+          cfg.chikou_width = static_cast<float>(num("chikouWidth"));
+          cfg.chikou_enabled = flag("chikouEnabled");
+          cfg.cloud_enabled = flag("cloudEnabled");
+          cfg.bullish_cloud_color =
+              static_cast<uint32_t>(num("bullishCloudColor"));
+          cfg.bearish_cloud_color =
+              static_cast<uint32_t>(num("bearishCloudColor"));
+          cfg.cloud_opacity = static_cast<float>(num("cloudOpacity"));
+          vroom_chart_set_ichimoku(chart_, &cfg);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setFairValueGaps") {
+    // setFairValueGaps({enabled, maxBarsBack, waitForClose, fillType,
+    // deleteAfterFill, extendBoxes, boxLength, bullishColor, bearishColor,
+    // opacity, borderEnabled, borderStyle, borderWidth, bullishBorderColor,
+    // bearishBorderColor, labelsEnabled, label, labelDistance, labelColor,
+    // labelFontSize, showInverse, inverseBullishColor, inverseBearishColor,
+    // inverseLabel}) — the Fair Value Gap overlay. No render; the next
+    // render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setFairValueGaps"),
+        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);
+          const auto num = [&](const char* k) {
+            return s.getProperty(rt2, k).asNumber();
+          };
+          const auto flag = [&](const char* k) {
+            return s.getProperty(rt2, k).asBool() ? 1 : 0;
+          };
+          VroomFairValueGaps cfg{};
+          cfg.enabled = flag("enabled");
+          cfg.max_bars_back = static_cast<int32_t>(num("maxBarsBack"));
+          cfg.wait_for_close = flag("waitForClose");
+          cfg.fill_type = static_cast<int32_t>(num("fillType"));
+          cfg.delete_after_fill = flag("deleteAfterFill");
+          cfg.extend_boxes = flag("extendBoxes");
+          cfg.box_length = static_cast<int32_t>(num("boxLength"));
+          cfg.bullish_color = static_cast<uint32_t>(num("bullishColor"));
+          cfg.bearish_color = static_cast<uint32_t>(num("bearishColor"));
+          cfg.opacity = static_cast<float>(num("opacity"));
+          cfg.border_enabled = flag("borderEnabled");
+          cfg.border_style = static_cast<int32_t>(num("borderStyle"));
+          cfg.border_width = static_cast<float>(num("borderWidth"));
+          cfg.bullish_border_color =
+              static_cast<uint32_t>(num("bullishBorderColor"));
+          cfg.bearish_border_color =
+              static_cast<uint32_t>(num("bearishBorderColor"));
+          cfg.labels_enabled = flag("labelsEnabled");
+          // Held alive until the setter, which copies them.
+          const std::string label =
+              s.getProperty(rt2, "label").asString(rt2).utf8(rt2);
+          cfg.label = label.c_str();
+          cfg.label_distance = static_cast<int32_t>(num("labelDistance"));
+          cfg.label_color = static_cast<uint32_t>(num("labelColor"));
+          cfg.label_font_size = static_cast<float>(num("labelFontSize"));
+          cfg.show_inverse = flag("showInverse");
+          cfg.inverse_bullish_color =
+              static_cast<uint32_t>(num("inverseBullishColor"));
+          cfg.inverse_bearish_color =
+              static_cast<uint32_t>(num("inverseBearishColor"));
+          const std::string inverse_label =
+              s.getProperty(rt2, "inverseLabel").asString(rt2).utf8(rt2);
+          cfg.inverse_label = inverse_label.c_str();
+          vroom_chart_set_fair_value_gaps(chart_, &cfg);
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "setVolume") {
     // setVolume({enabled, heightFrac, opacity, radiusPx, upColor, downColor})
     // — the volume bars. Negative floats / zero colors inherit the theme. No
@@ -1189,6 +1362,120 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setFootprints") {
+    // setFootprints({ prints: [{ timeMs, side }, ...], radiusPx, gapPx, marginPx,
+    // hoverBoost }) — replaces the full set of executed-trade badges. The core
+    // buckets them onto candles itself, so raw fill times are what to pass. No
+    // render; the next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setFootprints"),
+        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 cfg = args[0].asObject(rt2);
+          auto prints_val = cfg.getProperty(rt2, "prints");
+          if (!prints_val.isObject()) return jsi::Value::undefined();
+          auto prints_obj = prints_val.asObject(rt2);
+          if (!prints_obj.isArray(rt2)) return jsi::Value::undefined();
+          auto arr = prints_obj.asArray(rt2);
+          const size_t len = arr.size(rt2);
+          std::vector<VroomFootprint> prints(len);
+          for (size_t i = 0; i < len; ++i) {
+            auto f = arr.getValueAtIndex(rt2, i).asObject(rt2);
+            prints[i].time_ms =
+                static_cast<int64_t>(f.getProperty(rt2, "timeMs").asNumber());
+            prints[i].side =
+                static_cast<int32_t>(f.getProperty(rt2, "side").asNumber());
+          }
+          VroomFootprintStyle style{};
+          style.radius_px = static_cast<float>(
+              cfg.getProperty(rt2, "radiusPx").asNumber());
+          style.gap_px = static_cast<float>(
+              cfg.getProperty(rt2, "gapPx").asNumber());
+          style.margin_px = static_cast<float>(
+              cfg.getProperty(rt2, "marginPx").asNumber());
+          style.hover_boost = static_cast<float>(
+              cfg.getProperty(rt2, "hoverBoost").asNumber());
+          vroom_chart_set_footprints(chart_, prints.data(), prints.size(), &style);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "hitTestFootprint") {
+    // hitTestFootprint(x, y) -> { side, candleTimeMs, x, y, radius, pane,
+    // indices } | null. `indices` addresses the array last passed to
+    // setFootprints and covers *both* sides of that candle, so one call fills a
+    // tooltip; `pane` is the plot rect, for deciding which side of the badge that
+    // tooltip fits on. No rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "hitTestFootprint"),
+        2,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::null();
+          VroomFootprintHit hit{};
+          if (!vroom_chart_hit_test_footprint(
+                  chart_, static_cast<float>(args[0].asNumber()),
+                  static_cast<float>(args[1].asNumber()), &hit)) {
+            return jsi::Value::null();
+          }
+
+          const int32_t n =
+              vroom_chart_footprints_at(chart_, hit.candle_time_ms, nullptr, 0);
+          std::vector<int32_t> idx(static_cast<size_t>(n > 0 ? n : 0));
+          if (n > 0) {
+            vroom_chart_footprints_at(chart_, hit.candle_time_ms, idx.data(), n);
+          }
+          jsi::Array indices(rt2, idx.size());
+          for (size_t i = 0; i < idx.size(); ++i) {
+            indices.setValueAtIndex(rt2, i, jsi::Value(idx[i]));
+          }
+
+          jsi::Object pane(rt2);
+          pane.setProperty(rt2, "left", hit.pane_left);
+          pane.setProperty(rt2, "top", hit.pane_top);
+          pane.setProperty(rt2, "right", hit.pane_right);
+          pane.setProperty(rt2, "bottom", hit.pane_bottom);
+
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "side", hit.side);
+          obj.setProperty(rt2, "candleTimeMs",
+                          static_cast<double>(hit.candle_time_ms));
+          obj.setProperty(rt2, "x", hit.center_x);
+          obj.setProperty(rt2, "y", hit.center_y);
+          obj.setProperty(rt2, "radius", hit.radius);
+          obj.setProperty(rt2, "pane", std::move(pane));
+          obj.setProperty(rt2, "indices", std::move(indices));
+          return obj;
+        });
+  }
+
+  if (name == "setFootprintHover") {
+    // setFootprintHover(candleTimeMs, side) — highlight one badge; side -1
+    // clears. Touch has no hover, so on RN this tracks the tapped badge.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setFootprintHover"),
+        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_footprint_hover(
+              chart_, static_cast<int64_t>(args[0].asNumber()),
+              static_cast<int32_t>(args[1].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "render") {
     return jsi::Function::createFromHostFunction(
         rt,

package/cpp/_core_include/vroom/vroom_chart.h

@@ -69,6 +69,80 @@ typedef struct VroomBollinger {
     float    fill_opacity;  // 0..1, multiplied into upper_color's alpha
 } VroomBollinger;
 
+// Ichimoku Kinko Hyo overlay drawn on the price pane: five lines plus the cloud
+// (kumo) shaded between the two leading spans. No pane is reserved.
+//
+// Three of the lines are drawn away from the bar they were computed on:
+// senkou A/B lead by `displacement` slots (so the cloud runs past the newest
+// candle into empty time) and chikou lags by the same. Displacement is applied
+// at draw time, so changing it re-renders without recomputing the series.
+typedef struct VroomIchimoku {
+    int32_t  enabled;            // 0/1
+    int32_t  tenkan_period;      // conversion lookback (clamped >= 1; default 9)
+    int32_t  kijun_period;       // base lookback (clamped >= 1; default 26)
+    int32_t  senkou_b_period;    // span B lookback (clamped >= 1; default 52)
+    int32_t  displacement;       // slots the cloud leads / chikou lags (>= 0; default 26)
+    uint32_t tenkan_color;       // 0xAARRGGBB
+    float    tenkan_width;       // stroke px
+    int32_t  tenkan_enabled;     // 0/1
+    uint32_t kijun_color;
+    float    kijun_width;
+    int32_t  kijun_enabled;
+    uint32_t senkou_a_color;
+    float    senkou_a_width;
+    int32_t  senkou_a_enabled;
+    uint32_t senkou_b_color;
+    float    senkou_b_width;
+    int32_t  senkou_b_enabled;
+    uint32_t chikou_color;
+    float    chikou_width;
+    int32_t  chikou_enabled;
+    int32_t  cloud_enabled;      // 0/1: shade between the leading spans
+    uint32_t bullish_cloud_color;  // where senkou A is above senkou B
+    uint32_t bearish_cloud_color;  // where senkou A is below senkou B
+    float    cloud_opacity;      // 0..1, multiplied into the cloud color's alpha
+} VroomIchimoku;
+
+// Fair Value Gap overlay drawn on the price pane: shaded boxes over three-candle
+// imbalances, where candle i-1 and i+1's wicks fail to overlap and leave a band
+// of price that was skipped. Bullish when candles[i-1].high < candles[i+1].low,
+// bearish when candles[i-1].low > candles[i+1].high. No pane is reserved.
+//
+// Each box is anchored to the middle bar's open time and spans the untouched
+// price range; it runs `box_length` slots right, or to the pane edge when
+// `extend_boxes`. Only enabled, max_bars_back, wait_for_close and fill_type
+// recompute — geometry and style are applied at draw time.
+//
+// With `show_inverse`, a filled gap draws a second box of the opposite polarity
+// starting where the first one ends, lasting until price reclaims the band.
+typedef struct VroomFairValueGaps {
+    int32_t  enabled;             // 0/1
+    int32_t  max_bars_back;       // bars to scan (clamped >= 0; default 300)
+    int32_t  wait_for_close;      // 0/1: withhold a gap until its 3rd bar closes
+    int32_t  fill_type;           // 0 = close through the far edge, 1 = wick
+    int32_t  delete_after_fill;   // 0/1: hide a gap once filled (else truncate it)
+    int32_t  extend_boxes;        // 0/1: run boxes to the pane edge
+    int32_t  box_length;          // box width in slots (clamped >= 1; default 20)
+    uint32_t bullish_color;       // 0xAARRGGBB fill where the gap is bullish
+    uint32_t bearish_color;       // fill where the gap is bearish
+    float    opacity;             // 0..1, multiplied into the fill color's alpha
+    int32_t  border_enabled;      // 0/1: stroke the box outline
+    int32_t  border_style;        // 0 = solid, 1 = dotted, 2 = dashed
+    float    border_width;        // stroke px
+    uint32_t bullish_border_color;
+    uint32_t bearish_border_color;
+    int32_t  labels_enabled;      // 0/1: draw `label` on each box
+    const char* label;            // UTF-8, copied by the setter; NULL = "FVG"
+    int32_t  label_distance;      // slots of clearance, extend_boxes only (>= 0)
+    uint32_t label_color;         // alpha 0 falls back to the box's border color
+    float    label_font_size;     // px; <= 0 falls back to the axis font size
+    int32_t  show_inverse;        // 0/1: keep drawing a filled gap, polarity flipped
+    uint32_t inverse_bullish_color;  // fill where the inverted zone is bullish,
+                                     // i.e. where a bearish gap was violated
+    uint32_t inverse_bearish_color;  // fill where a bullish gap was violated
+    const char* inverse_label;    // UTF-8, copied by the setter; NULL = "iFVG"
+} VroomFairValueGaps;
+
 // MACD, drawn in its own pane below the candles: the difference between a fast
 // and a slow moving average of `source`, a signal line smoothing that
 // difference, and a histogram of the gap between the two.
@@ -128,8 +202,29 @@ typedef struct VroomRSI {
     float    ma_width;
     uint32_t band_color;     // both dashed rules; 0 inherits the default gray
     int32_t  bands_visible;  // 0/1
+    // Shade where the line sits past a band, fading out at the rule and
+    // deepening toward the end of the scale. Takes its colors from
+    // VROOM_COLOR_ACCENT_BULL / _BEAR, and never reaches full opacity. 0/1.
+    int32_t  extreme_fill;
 } VroomRSI;
 
+// Average True Range, drawn in its own pane below the candles: a single line
+// measuring volatility in price units. True Range is the widest of the bar's
+// own high-low span and the two gaps from its extremes to the previous close,
+// smoothed over `period` bars.
+//
+// The style fields carry the same inherit sentinel as VroomMACD: a fully
+// transparent color falls back to the built-in default and a non-positive width
+// falls back to 1.5.
+typedef struct VroomATR {
+    int32_t  enabled;    // 0/1
+    int32_t  period;     // lookback in candles (clamped >= 1; default 14)
+    int32_t  smoothing;  // 0 = Wilder's RMA, 1 = SMA, 2 = EMA
+
+    uint32_t line_color;  // 0 inherits the default teal
+    float    line_width;  // stroke px; <= 0 inherits 1.5
+} VroomATR;
+
 // Session VWAP, drawn as a single line on the price pane. The session resets
 // each UTC day shifted by `reset_offset_min` minutes, and the line lifts its pen
 // at each reset. Color 0 inherits the default cyan; a non-positive width
@@ -257,6 +352,53 @@ typedef struct VroomPriceLineStyle {
     float    hover_boost;       // brightness multiplier for the hovered segment (1 = flat)
 } VroomPriceLineStyle;
 
+// ---- Footprints (executed-trade badges) -----------------------------------
+
+typedef enum {
+    VROOM_FOOTPRINT_BUY = 0,   // position entry — "+" badge in the bull color
+    VROOM_FOOTPRINT_SELL = 1,  // position exit  — "-" badge in the bear color
+} VroomFootprintSide;
+
+// A single executed trade, drawn as a circular badge above the candle it fell in.
+//
+// `time_ms` is the raw execution time, *not* a bar-open time: the core buckets
+// each footprint into whichever candle's window contains it, so one array renders
+// correctly at every interval and re-groups by itself when the candles change.
+// Order is irrelevant — the core sorts within each bucket.
+//
+// Only the fields the renderer needs live here; a host's per-trade payload (id,
+// price, size) stays on the host side and is rejoined via the indices reported by
+// vroom_chart_footprints_at.
+typedef struct VroomFootprint {
+    int64_t time_ms;
+    int32_t side;  // VroomFootprintSide
+} VroomFootprint;
+
+// Layout/style shared by every footprint badge.
+typedef struct VroomFootprintStyle {
+    float radius_px;   // badge radius; <= 0 falls back to 9
+    float gap_px;      // vertical gap between the two stacked badges; < 0 => 4
+    float margin_px;   // gap between the candle's high and the first badge; < 0 => 8
+    float hover_boost; // brightness multiplier for the hovered badge (1 = flat)
+} VroomFootprintStyle;
+
+// The badge under a pixel, as reported by vroom_chart_hit_test_footprint.
+typedef struct VroomFootprintHit {
+    int64_t candle_time_ms;  // bar-open time of the candle the badge sits on
+    int32_t side;            // VroomFootprintSide — which of the candle's two badges
+    float   center_x;        // badge center, in the same px space as the hit test
+    float   center_y;
+    float   radius;
+    // The plot rect the badge was clipped to — same px space, axis strips
+    // excluded. Reported because a host placing its own tooltip has no other way
+    // to know it: the surface it measures includes the price and time axes, so
+    // sizing against that overstates the room next to a badge near the edge.
+    float   pane_left;
+    float   pane_top;
+    float   pane_right;
+    float   pane_bottom;
+} VroomFootprintHit;
+
 // 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 {
@@ -428,10 +570,26 @@ void vroom_chart_preserve_price_envelope(VroomChart* chart,
 // to 1. No-op when nothing is visible.
 void vroom_chart_begin_interval_morph(VroomChart* chart, int32_t mode);
 
-// Advances the interval morph started by vroom_chart_begin_interval_morph. `t`
-// (clamped to 0..1) is the eased progress: 0 renders the captured geometry
-// pixel-identically to the pre-swap frame, 1 renders the new candles and
-// releases the capture. Driven per-frame by the host animation loop.
+// Captures the same geometry for a live update to the series already shown —
+// a tick to the in-progress bar. Always a transform, and unlike the interval
+// morph it leaves the axes alone: the interval hasn't changed, so the ticks
+// between the labels are still the right ones and must not be faded.
+//
+// Restarting one that is still running continues from the shape on screen
+// rather than from the data under it, so ticks arriving faster than the
+// animation lands stay smooth instead of snapping back each time.
+//
+// Call before set_candles, then drive vroom_chart_set_interval_morph from 0 to
+// 1. No-op when nothing is visible. Not for an update that appends a bar: slots
+// pair from the right edge, so a new bar would shift every candle onto its
+// neighbour's geometry — advance the visible range instead and let the series
+// translate.
+void vroom_chart_begin_stream_morph(VroomChart* chart);
+
+// Advances the morph started by either begin_*_morph above. `t` (clamped to
+// 0..1) is the eased progress: 0 renders the captured geometry pixel-identically
+// to the pre-swap frame, 1 renders the new candles and releases the capture.
+// Driven per-frame by the host animation loop.
 void vroom_chart_set_interval_morph(VroomChart* chart, float t);
 
 void vroom_chart_pan(VroomChart* chart, float dx_px, float dy_px);
@@ -534,6 +692,11 @@ void vroom_chart_set_rsi(VroomChart* chart, const VroomRSI* cfg);
 // re-render.
 void vroom_chart_set_macd(VroomChart* chart, const VroomMACD* cfg);
 
+// Configures the ATR indicator (its own pane below the candles, stacking in
+// enable order like RSI and MACD). Period and smoothing changes recompute the
+// series; color and width changes only re-render.
+void vroom_chart_set_atr(VroomChart* chart, const VroomATR* cfg);
+
 // Replaces the full set of moving-average overlay lines (SMA/EMA) drawn on the
 // price pane. Pass count 0 to clear them. Overlays don't reserve a pane.
 void vroom_chart_set_overlays(VroomChart* chart, const VroomOverlay* overlays,
@@ -549,6 +712,23 @@ void vroom_chart_set_vwap(VroomChart* chart, const VroomVWAP* cfg);
 // changes only re-render; enabled/period/mult/source/basis changes recompute.
 void vroom_chart_set_bollinger(VroomChart* chart, const VroomBollinger* cfg);
 
+// Configures the Ichimoku overlay (five price-pane lines + the cloud between
+// the leading spans; no pane is reserved). Only enabled and the three periods
+// recompute; style, visibility and displacement changes just re-render.
+//
+// Enabling it also pulls the view forward so the leading spans, which sit past
+// the newest candle, are on screen — the same future gap the default framing
+// reserves when the indicator is already on at set_candles time.
+void vroom_chart_set_ichimoku(VroomChart* chart, const VroomIchimoku* cfg);
+
+// Configures the Fair Value Gap overlay (shaded imbalance boxes on the price
+// pane; no pane is reserved). Only enabled, max_bars_back, wait_for_close and
+// fill_type recompute; box geometry, style and labels just re-render.
+//
+// `cfg->label` is copied, so the caller may free it as soon as this returns.
+void vroom_chart_set_fair_value_gaps(VroomChart* chart,
+                                     const VroomFairValueGaps* cfg);
+
 // Configures the volume bars. Render-only — the bars come straight off each
 // candle's volume, so nothing is recomputed. Bars are enabled by default; pass
 // a config with `enabled` 0 to hide them.
@@ -689,6 +869,43 @@ void vroom_chart_set_price_line_hover(VroomChart* chart, int32_t index,
 void vroom_chart_set_price_line_drag(VroomChart* chart, int32_t index,
                                      double price);
 
+// Replaces the full set of footprints and their shared style. Pass count 0 to
+// clear; `style` may be null when count is 0.
+//
+// Footprints are grouped onto candles by timestamp, so at most two badges render
+// per candle: one for that bar's buys and one for its sells, however many trades
+// went into each. When a candle has both, they stack upward with `gap_px` between
+// them, the side whose latest trade came first sitting nearest the bar. Badges sit
+// above the candle's high, clipped to the price pane, and re-group on their own
+// whenever the candles change (a new interval, more history) — the host never
+// re-buckets anything.
+void vroom_chart_set_footprints(VroomChart* chart, const VroomFootprint* prints,
+                                size_t count,
+                                const VroomFootprintStyle* style);
+
+// Hit-tests pixel (x_px, y_px) against the footprint badges. On a hit fills *out
+// with the badge's candle, side and pixel geometry and returns true; returns false
+// on a miss (out untouched). `out` may be null to test without reading the hit.
+// When two badges overlap the nearest center wins.
+bool vroom_chart_hit_test_footprint(VroomChart* chart, float x_px, float y_px,
+                                    VroomFootprintHit* out);
+
+// Fills `out_indices` with the indices — into the array last passed to
+// vroom_chart_set_footprints — of every footprint bucketed into the candle opening
+// at `candle_time_ms`, *both* sides, ascending by time. Returns the total count,
+// which may exceed `max` (only the first `max` are written), or 0 when that candle
+// has no footprints. Pass a null `out_indices` with max 0 to size the buffer first.
+//
+// This is how a host rejoins a hit badge to its own trade objects: hit-test to get
+// the candle, then map these indices back through the array it supplied.
+int32_t vroom_chart_footprints_at(VroomChart* chart, int64_t candle_time_ms,
+                                  int32_t* out_indices, int32_t max);
+
+// Marks one footprint badge as hovered so it renders highlighted. `side` -1
+// clears the hover; `candle_time_ms` and `side` match vroom_chart_hit_test_footprint.
+void vroom_chart_set_footprint_hover(VroomChart* chart, int64_t candle_time_ms,
+                                     int32_t side);
+
 // 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 live preview (a guideline for a line, or a preview