react-native-vroom-chart 0.5.0 → 0.7.0

package/cpp/_core_src/macd_pane.cpp

@@ -20,17 +20,29 @@
 
 #include "chart.h"
 #include "fonts.h"
+#include "style_inherit.h"
 #include "theme.h"
 #include "viewport.h"
 
 namespace vroom::macd_pane {
 
 namespace {
+using vroom::style::color_or;
+using vroom::style::width_or;
+
 constexpr SkColor kMacdLine = 0xff2962ff;    // blue MACD line
 constexpr SkColor kSignalLine = 0xffff6d00;  // orange signal line
 constexpr SkColor kZeroLine = 0xff484f58;    // zero reference
 constexpr SkColor kDivider = 0xff21262d;     // pane separator
 constexpr float kPadFrac = 0.85f;            // keep curves off the band edges
+constexpr float kLineWidth = 1.5f;           // default stroke for both lines
+constexpr float kFadedAlpha = 0.5f;          // easing histogram bars
+
+// The easing histogram bars default to their own base color dimmed, which is
+// how the pane read before the colors were configurable.
+SkColor faded_or(uint32_t configured, SkColor base) {
+    return vroom::style::faded_or(configured, base, kFadedAlpha);
+}
 }  // namespace
 
 void draw(SkCanvas* canvas,
@@ -51,23 +63,25 @@ void draw(SkCanvas* canvas,
     const float band_h = pane_bottom - pane_top;
     if (band_h <= 0.f) return;
 
+    const VroomMACD& cfg = chart.macd;
     const float mid = (pane_top + pane_bottom) * 0.5f;
     // User y-zoom scales the amplitude about the zero line (mid). 1.0 = the
     // default auto-fit; >1 zooms in, <1 zooms out.
     const float half =
         band_h * 0.5f * kPadFrac * static_cast<float>(chart.macd_y_scale);
 
-    // Auto-scale symmetric about zero across all visible finite values.
+    // Auto-scale symmetric about zero across the finite values on show, so
+    // hiding a series lets the rest fill the pane.
     double scale = 0.0;
-    auto track = [&](const double* s) {
-        if (!s) return;
+    auto track = [&](const double* s, bool shown) {
+        if (!s || !shown) return;
         for (std::size_t i = 0; i < n; ++i) {
             if (std::isfinite(s[i])) scale = std::max(scale, std::abs(s[i]));
         }
     };
-    track(macd_visible);
-    track(signal_visible);
-    track(hist_visible);
+    track(macd_visible, cfg.line_visible != 0);
+    track(signal_visible, cfg.signal_visible != 0);
+    track(hist_visible, cfg.hist_visible != 0);
 
     auto y_for = [&](double v) -> float {
         if (scale <= 0.0) return mid;
@@ -90,34 +104,44 @@ void draw(SkCanvas* canvas,
     canvas->clipRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom));
 
     // Zero line.
-    SkPaint zero;
-    zero.setAntiAlias(true);
-    zero.setColor(kZeroLine);
-    zero.setStrokeWidth(1.f);
-    canvas->drawLine(0.f, mid, candle_right, mid, zero);
-
-    // Histogram bars: from the zero line to y_for(hist), 4-color (green above /
-    // red below, full alpha when accelerating, half when decelerating).
-    if (hist_visible) {
+    if (cfg.zero_visible) {
+        SkPaint zero;
+        zero.setAntiAlias(true);
+        zero.setColor(color_or(cfg.zero_color, kZeroLine));
+        zero.setStrokeWidth(1.f);
+        canvas->drawLine(0.f, mid, candle_right, mid, zero);
+    }
+
+    // Histogram bars: from the zero line to y_for(hist), 4-color — above or
+    // below zero, each in a building and an easing shade. A bar is building
+    // while it grows away from zero and easing while it falls back toward it.
+    if (hist_visible && cfg.hist_visible) {
         const float body_w =
             vroom::candle_body_width(lay, window_ms, candle_duration_ms);
         const float half_body = body_w * 0.5f;
         const float zero_y = y_for(0.0);
-        const SkColor bull = chart.theme.colors[VROOM_COLOR_ACCENT_BULL];
-        const SkColor bear = chart.theme.colors[VROOM_COLOR_ACCENT_BEAR];
+        const SkColor up =
+            color_or(cfg.hist_up_color, chart.theme.colors[VROOM_COLOR_ACCENT_BULL]);
+        const SkColor down =
+            color_or(cfg.hist_down_color, chart.theme.colors[VROOM_COLOR_ACCENT_BEAR]);
+        const SkColor up_easing = faded_or(cfg.hist_up_fading_color, up);
+        const SkColor down_easing = faded_or(cfg.hist_down_fading_color, down);
         for (std::size_t i = 0; i < n; ++i) {
             const double h = hist_visible[i];
             if (!std::isfinite(h)) continue;
             const bool have_prev = i > 0 && std::isfinite(hist_visible[i - 1]);
             const double prev = have_prev ? hist_visible[i - 1] : h;
-            bool accelerating = true;
+            bool building = true;
             if (have_prev) {
-                accelerating = h >= 0.0 ? h >= prev : h <= prev;
+                building = h >= 0.0 ? h >= prev : h <= prev;
             }
             SkPaint bar;
             bar.setAntiAlias(true);
-            bar.setColor(h >= 0.0 ? bull : bear);
-            bar.setAlphaf(accelerating ? 1.0f : 0.5f);
+            if (h >= 0.0) {
+                bar.setColor(building ? up : up_easing);
+            } else {
+                bar.setColor(building ? down : down_easing);
+            }
             const float cx = vroom::candle_center_x(
                 lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
                 window_ms);
@@ -130,7 +154,7 @@ void draw(SkCanvas* canvas,
     }
 
     // MACD + signal lines.
-    auto stroke_series = [&](const double* series, SkColor color) {
+    auto stroke_series = [&](const double* series, SkColor color, float width) {
         if (!series) return;
         SkPathBuilder path;
         bool pen_down = false;
@@ -155,11 +179,17 @@ void draw(SkCanvas* canvas,
         line.setAntiAlias(true);
         line.setColor(color);
         line.setStyle(SkPaint::kStroke_Style);
-        line.setStrokeWidth(1.5f);
+        line.setStrokeWidth(width);
         canvas->drawPath(path.detach(), line);
     };
-    stroke_series(signal_visible, kSignalLine);
-    stroke_series(macd_visible, kMacdLine);  // MACD over signal
+    if (cfg.signal_visible) {
+        stroke_series(signal_visible, color_or(cfg.signal_color, kSignalLine),
+                      width_or(cfg.signal_width, kLineWidth));
+    }
+    if (cfg.line_visible) {  // MACD over signal
+        stroke_series(macd_visible, color_or(cfg.line_color, kMacdLine),
+                      width_or(cfg.line_width, kLineWidth));
+    }
 
     // Caption, top-left of the pane.
     auto tf = vroom::axis_typeface();
@@ -168,8 +198,8 @@ void draw(SkCanvas* canvas,
         font.setSubpixel(true);
         font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
         char caption[40];
-        std::snprintf(caption, sizeof(caption), "MACD %d %d %d", chart.macd_fast,
-                      chart.macd_slow, chart.macd_signal);
+        std::snprintf(caption, sizeof(caption), "MACD %d %d %d", cfg.fast,
+                      cfg.slow, cfg.signal);
         SkRect cb;
         font.measureText(caption, std::strlen(caption), SkTextEncoding::kUTF8,
                          &cb);

package/cpp/_core_src/price_line_layout.cpp

@@ -0,0 +1,87 @@
+#include "price_line_layout.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace vroom::price_lines {
+
+namespace {
+// A pill's width is its text plus symmetric padding. Zero-width text means the
+// segment is absent, not a padding-only sliver.
+float pill_width(float text_w) {
+    return text_w > 0.f ? text_w + 2.f * kPadH : 0.f;
+}
+}  // namespace
+
+bool contains(const Rect& r, float x, float y) {
+    if (r.empty()) return false;
+    return x >= r.left && x <= r.right && y >= r.top && y <= r.bottom;
+}
+
+GroupLayout layout_group(const LabelMetrics& metrics,
+                         float y,
+                         float pane_right,
+                         const ::VroomPriceLineStyle& style) {
+    GroupLayout out;
+
+    const float body_w = pill_width(metrics.text_w);
+    const float qty_w = pill_width(metrics.quantity_w);
+    // The close button is a square cell, so its icon stays centered whatever the
+    // font size works out to.
+    const float close_w = metrics.closable ? metrics.label_h : 0.f;
+    const float group_w = body_w + qty_w + close_w;
+
+    if (group_w <= 0.f || metrics.label_h <= 0.f || pane_right <= 0.f) {
+        // A bare line: no group, but still report a degenerate span at the
+        // anchor so callers can treat left/right uniformly.
+        out.left = out.right = pane_right;
+        return out;
+    }
+
+    float left = 0.f;
+    switch (style.align) {
+        case 0:  // left
+            left = 0.f;
+            break;
+        case 1:  // center
+            left = (pane_right - group_w) * 0.5f;
+            break;
+        default: {  // right
+            const float frac = std::clamp(style.line_length_frac, 0.f, 1.f);
+            const float right = pane_right - frac * pane_right - kAxisGutter;
+            left = right - group_w;
+            break;
+        }
+    }
+    // Keep the group on-screen: never past the axis, never off the left edge.
+    left = std::min(left, pane_right - group_w);
+    left = std::max(left, 0.f);
+
+    const float top = y - metrics.label_h * 0.5f;
+    const float bottom = top + metrics.label_h;
+
+    float x = left;
+    if (body_w > 0.f) {
+        out.body = Rect{x, top, x + body_w, bottom};
+        x += body_w;
+    }
+    if (qty_w > 0.f) {
+        out.quantity = Rect{x, top, x + qty_w, bottom};
+        x += qty_w;
+    }
+    if (close_w > 0.f) {
+        out.close = Rect{x, top, x + close_w, bottom};
+        x += close_w;
+    }
+
+    out.left = left;
+    out.right = x;
+    return out;
+}
+
+bool hits_line(float line_y, float stroke_width, float y) {
+    const float band = std::max(stroke_width, 1.f) + kLineHitTolerance;
+    return std::fabs(y - line_y) <= band;
+}
+
+}  // namespace vroom::price_lines

package/cpp/_core_src/price_line_layout.h

@@ -0,0 +1,80 @@
+// Price-status-line geometry — pure functions, no Skia, no state.
+//
+// Split out from price_lines.cpp so the rendering pass and the hit-test pass
+// derive their rectangles from the same arithmetic: a label the user can see but
+// not click (or vice versa) is the classic failure mode for this widget. Being
+// Skia-free it also unit-tests without a Skia checkout.
+
+#pragma once
+
+#include "vroom/vroom_chart.h"
+namespace vroom::price_lines {
+
+// Pill padding / corner radius, matching the current-price indicator so a price
+// line and the price badge read as the same family of chrome.
+constexpr float kPadH = 8.f;    // left/right of the text
+constexpr float kPadV = 4.f;    // above/below the text
+constexpr float kCorner = 6.f;  // rounded-pill corner radius
+
+// Extra grab band above and below the stroke, so a 1px line is still an easy
+// target. Matches the tolerance mainstream chart libraries settled on.
+constexpr float kLineHitTolerance = 7.f;
+
+// Gap between the label group and the price axis when right-aligned. Wide enough
+// that the line still shows through it — a couple of dashes reading as "this
+// continues to the badge" rather than one orphaned dot.
+constexpr float kAxisGutter = 12.f;
+
+struct Rect {
+    float left = 0.f;
+    float top = 0.f;
+    float right = 0.f;
+    float bottom = 0.f;
+
+    // Empty rects stand in for absent segments (no quantity, no close button).
+    bool empty() const { return right <= left || bottom <= top; }
+    float width() const { return right - left; }
+};
+
+// True when (x, y) falls inside `r`. Always false for an empty rect.
+bool contains(const Rect& r, float x, float y);
+
+// The text extents a caller measured with the real font, plus which optional
+// segments to reserve room for. `label_h` is the pill height (already including
+// kPadV on both sides).
+struct LabelMetrics {
+    float text_w = 0.f;      // body text width; 0 hides the body pill
+    float quantity_w = 0.f;  // quantity text width; 0 hides the quantity pill
+    float label_h = 0.f;
+    bool  closable = false;  // reserve the trailing square close-button cell
+};
+
+// The laid-out label group, vertically centered on the line. Any of the three
+// segment rects may be empty. `left`/`right` bound whichever segments exist and
+// are equal when the group is empty (a bare line).
+struct GroupLayout {
+    Rect  body;
+    Rect  quantity;
+    Rect  close;
+    float left = 0.f;
+    float right = 0.f;
+
+    bool empty() const { return right <= left; }
+};
+
+// Lays the group out on the line at `y`. `pane_right` is the inner edge of the
+// price axis (the line's right end).
+//
+// `style.align` picks the anchor: 2 (right, the default) parks the group's right
+// edge `style.line_length_frac` of the pane width in from the axis; 1 centers
+// it; 0 pins it to the left edge. The group is clamped into [0, pane_right], so
+// a label wider than the pane starts flush left rather than overflowing.
+GroupLayout layout_group(const LabelMetrics& metrics,
+                         float y,
+                         float pane_right,
+                         const ::VroomPriceLineStyle& style);
+
+// True when `y` is within the grab band of a line drawn at `line_y`.
+bool hits_line(float line_y, float stroke_width, float y);
+
+}  // namespace vroom::price_lines