react-native-vroom-chart 0.15.0 → 0.17.0

package/cpp/_core_src/atr_pane.cpp

@@ -0,0 +1,162 @@
+#include "atr_pane.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkTypeface.h"
+#pragma clang diagnostic pop
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+#include "atr.h"
+#include "chart.h"
+#include "fonts.h"
+#include "line_morph.h"
+#include "pane_series.h"
+#include "price_format.h"
+#include "style_inherit.h"
+#include "theme.h"
+#include "viewport.h"
+
+namespace vroom::atr_pane {
+
+namespace {
+using vroom::style::color_or;
+using vroom::style::width_or;
+
+constexpr SkColor kAtrLine = 0xff26a69a;  // teal
+constexpr SkColor kDivider = 0xff21262d;  // pane separator
+constexpr float kLineWidth = 1.5f;
+}  // namespace
+
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* atr_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom,
+          const vroom::LineMorph* from,
+          float morph_t) {
+    if (!canvas || candle_right <= 0.f) return;
+    const float band_h = pane_bottom - pane_top;
+    if (band_h <= 0.f) return;
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
+    // A fade's outgoing half has no new data at all, so the capture is the whole
+    // frame. Nothing on either side means nothing to paint, shell included.
+    if (n == 0 && vroom::morph_line_count(from, morph_t) == 0) return;
+
+    const VroomATR& cfg = chart.atr;
+
+    // ATR is strictly positive, so the domain runs 0..peak off the bottom edge.
+    // User y-zoom stretches it from there; 1.0 is the default fit.
+    const double scale = vroom::atr::autoscale(atr_visible, n);
+    auto y_for = [&](double v) -> float {
+        return pane_bottom -
+               static_cast<float>(
+                   vroom::atr::band_fraction(v, scale, chart.atr_y_scale)) *
+                   band_h;
+    };
+
+    // The peak the label reports. Mid-morph it eases out of the fit the capture
+    // was taken against, so the number tracks the curve instead of jumping to
+    // the new resolution's peak on the first frame.
+    const double label_scale =
+        (from && morph_t < 1.f)
+            ? from->scale + (scale - from->scale) * static_cast<double>(morph_t)
+            : scale;
+
+    // Mask the band (candles can overflow below the shortened price pane).
+    SkPaint bg;
+    bg.setColor(chart.theme.colors[VROOM_COLOR_BACKGROUND]);
+    canvas->drawRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom),
+                     bg);
+
+    // Pane separator (top edge).
+    SkPaint divider;
+    divider.setColor(kDivider);
+    divider.setStrokeWidth(1.f);
+    canvas->drawLine(0.f, pane_top, candle_right, pane_top, divider);
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom));
+
+    if (atr_visible || from) {
+        SkPaint line;
+        line.setAntiAlias(true);
+        line.setColor(color_or(cfg.line_color, kAtrLine));
+        line.setStyle(SkPaint::kStroke_Style);
+        line.setStrokeWidth(width_or(cfg.line_width, kLineWidth));
+        canvas->drawPath(
+            vroom::pane_series::build_path(
+                lay, visible, n, atr_visible, window_ms, visible_start_ms,
+                candle_duration_ms, pane_top, pane_bottom, from, morph_t, y_for),
+            line);
+    }
+
+    // Caption, top-left of the pane.
+    auto tf = vroom::axis_typeface();
+    if (tf) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        char caption[24];
+        std::snprintf(caption, sizeof(caption), "ATR %d", cfg.period);
+        SkRect cb;
+        font.measureText(caption, std::strlen(caption), SkTextEncoding::kUTF8,
+                         &cb);
+        SkPaint cap_paint;
+        cap_paint.setAntiAlias(true);
+        cap_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        canvas->drawString(caption, 6.f, pane_top + 4.f - cb.fTop, font,
+                           cap_paint);
+    }
+    canvas->restore();
+
+    // Peak label in the y-axis strip — ATR is in price units, so it shares the
+    // price axis's formatting. Hidden with that strip.
+    if (tf && label_scale > 0.0 && lay.y_axis_opacity > 0.f) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        SkPaint text_paint;
+        text_paint.setAntiAlias(true);
+        text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
+        char label[48];
+        vroom::format_price(label, sizeof(label), label_scale, chart.price_fmt);
+        SkRect tb;
+        const float tw = font.measureText(label, std::strlen(label),
+                                          SkTextEncoding::kUTF8, &tb);
+        const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+        const float text_x = axis_center_x - tw * 0.5f;
+        // A series' own peak lands at the top of the padded band whatever the
+        // fit is, so the label's height doesn't move as the morph re-scales —
+        // only the number it reports does. Clamped into the band so a zoomed-in
+        // peak doesn't label another pane.
+        const float half_text = (tb.fBottom - tb.fTop) * 0.5f;
+        const float peak_y = std::clamp(
+            pane_bottom - static_cast<float>(vroom::atr::band_fraction(
+                              label_scale, label_scale, chart.atr_y_scale)) *
+                              band_h,
+            pane_top + half_text, pane_bottom - half_text);
+        const float baseline_y = peak_y - (tb.fTop + tb.fBottom) * 0.5f;
+        canvas->drawString(label, text_x, baseline_y, font, text_paint);
+    }
+}
+
+}  // namespace vroom::atr_pane

package/cpp/_core_src/atr_pane.h

@@ -0,0 +1,48 @@
+// ATR indicator pane — draws the Average True Range line, its caption, and a
+// peak label in the band below the candles. Its own module alongside
+// rsi_pane / macd_pane so the chart orchestrator stays thin.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+class SkCanvas;
+
+namespace vroom {
+struct Layout;
+struct LineMorph;
+}  // namespace vroom
+
+struct VroomChart;
+
+namespace vroom::atr_pane {
+
+// Draws the ATR pane spanning vertically [pane_top, pane_bottom]. `atr_visible`
+// is the cached ATR series aligned with `visible` (NaN where undefined). ATR is
+// strictly positive and unbounded, so the pane fits 0..peak anchored at its
+// bottom edge rather than centering on a reference level.
+//
+// `from` / `morph_t` are the interval morph: the capture holds the curve's
+// outgoing shape indexed from the right (slot 0 = newest), in fractions of the
+// band, so the pane is free to re-fit across the switch without the shape
+// moving. The peak label eases between the two fits. A fade's outgoing half
+// passes n = 0 with morph_t = 0, which paints the capture alone.
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* atr_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom,
+          const LineMorph* from = nullptr,
+          float morph_t = 1.f);
+
+}  // namespace vroom::atr_pane

package/cpp/_core_src/candles.cpp

@@ -9,6 +9,7 @@
 
 #include <algorithm>
 
+#include "color_lerp.h"
 #include "theme.h"
 #include "viewport.h"
 
@@ -21,18 +22,6 @@ inline uint32_t resolve_color(uint32_t color, uint32_t fill) {
     return (color >> 24) == 0 ? fill : color;
 }
 
-// Channel-wise ARGB blend, for a candle that changes direction mid-morph.
-inline uint32_t lerp_argb(uint32_t a, uint32_t b, float t) {
-    uint32_t out = 0;
-    for (int shift = 0; shift < 32; shift += 8) {
-        const float ca = static_cast<float>((a >> shift) & 0xFFu);
-        const float cb = static_cast<float>((b >> shift) & 0xFFu);
-        const auto v = static_cast<uint32_t>(ca + (cb - ca) * t + 0.5f);
-        out |= v << shift;
-    }
-    return out;
-}
-
 inline uint32_t scale_alpha(uint32_t argb, float a) {
     const auto alpha =
         static_cast<uint32_t>(static_cast<float>((argb >> 24) & 0xFFu) * a + 0.5f);
@@ -90,6 +79,7 @@ void draw(SkCanvas* canvas,
 
     const uint32_t fill_bull = theme.colors[VROOM_COLOR_BULL];
     const uint32_t fill_bear = theme.colors[VROOM_COLOR_BEAR];
+    const uint32_t skeleton_color = theme.colors[VROOM_COLOR_SKELETON];
 
     const float body_r = theme.floats[VROOM_FLOAT_CANDLE_RADIUS_PX];
     const bool wick_round = theme.floats[VROOM_FLOAT_WICK_ROUND_CAP] > 0.5f;
@@ -207,10 +197,21 @@ void draw(SkCanvas* canvas,
         bool draw_border = bull ? draw_border_bull : draw_border_bear;
 
         const bool flip = frm && to && frm->bull != bull;
-        if (flip || alpha < 0.999f) {
+        // A slot handed over from the loading skeleton starts grey, whatever its
+        // direction — so it takes the per-slot path from a different origin
+        // color than a flip does, and overrides it when both apply.
+        const bool from_skeleton = frm && to && frm->skeleton;
+        if (flip || from_skeleton || alpha < 0.999f) {
             const auto blend = [&](uint32_t c_bull, uint32_t c_bear) {
                 uint32_t c = bull ? c_bull : c_bear;
-                if (flip) c = lerp_argb(bull ? c_bear : c_bull, c, morph_t);
+                if (from_skeleton) {
+                    // lerp_argb covers the alpha channel too, so the bar's
+                    // opacity rides in on the same blend as its color.
+                    c = lerp_argb(scale_alpha(skeleton_color, frm->skeleton_alpha),
+                                  c, morph_t);
+                } else if (flip) {
+                    c = lerp_argb(bull ? c_bear : c_bull, c, morph_t);
+                }
                 return scale_alpha(c, alpha);
             };
             slot_wick = *wick_p;