react-native-vroom-chart 0.8.0 → 0.9.1

package/cpp/_core_include/vroom/vroom_chart.h

@@ -294,6 +294,9 @@ typedef enum {
     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_LINE_GRADIENT_OPACITY,   // fill under the line at its strongest (0 disables)
+    VROOM_FLOAT_LINE_TENSION,            // 0..1 line-chart corner smoothing (0 = straight)
+    VROOM_FLOAT_LINE_TIP_DOT,            // 0/1: dot at the line's newest end (default on)
+    VROOM_FLOAT_LINE_TIP_PULSE,          // 0/1: expanding ring around that dot
     VROOM_FLOAT_COUNT_
 } VroomFloatKey;
 
@@ -342,7 +345,8 @@ void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_ms, int64_t
 // 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.
+// set_visible_range still overrides it. A series shorter than the implied window
+// is left-padded with empty slots so bars stay this wide instead of stretching.
 void vroom_chart_set_default_candle_width(VroomChart* chart, float px);
 
 // Chart render mode: 0 = candlesticks (default), 1 = line chart (a polyline

package/cpp/_core_src/chart.cpp

@@ -9,6 +9,8 @@
 
 #include "chart.h"
 
+#include <cmath>
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 #include "include/core/SkCanvas.h"
@@ -34,6 +36,7 @@
 #include "rsi.h"
 #include "rsi_pane.h"
 #include "style_inherit.h"
+#include "tip_pulse.h"
 #include "volume.h"
 #include "vwap.h"
 #include "theme.h"
@@ -191,7 +194,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
             theme.colors[VROOM_COLOR_LINE],
             theme.floats[VROOM_FLOAT_LINE_GRADIENT_OPACITY],
-            fade, morph_src, morph_n, morph_t);
+            fade, morph_src, morph_n, morph_t,
+            theme.floats[VROOM_FLOAT_LINE_TENSION]);
     }
 
     // 4.5. Volume bars — drawn under the candles so candles z-index above.
@@ -239,7 +243,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             canvas, lay, bounds, visible, n, 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],
-            fade, morph_src, morph_n, morph_t);
+            fade, morph_src, morph_n, morph_t,
+            theme.floats[VROOM_FLOAT_LINE_TENSION]);
     }
 
     // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
@@ -303,6 +308,21 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
                           candle_area_h);
 
+    // 5.8. Line-mode tip marker — the dot (and optional pulse) at the newest
+    //      close. Above the overlays so it stays the eye's anchor, but before the
+    //      axis masks, which trim the ring at the price scale.
+    if (fade > 0.f && theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+        vroom::ma_overlay::draw_close_tip(
+            canvas, lay, bounds, visible, n, window_ms, visible_start_ms,
+            candle_duration_ms, candle_right, candle_area_h,
+            theme.colors[VROOM_COLOR_LINE],
+            theme.colors[VROOM_COLOR_BACKGROUND],
+            theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade,
+            theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
+            tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds,
+            morph_src, morph_n, morph_t);
+    }
+
     // 6. Axis backgrounds (mask any candle overflow). The x-axis separator
     //    line is intentionally omitted for now. The bottom strip anchors at
     //    x_axis_top (below any indicator pane) so it never paints over it.
@@ -422,6 +442,17 @@ void VroomChart::begin_frame() {
     last_anim_tick = now;
     anim_started = true;
     last_dt_seconds = dt;
+
+    // Wrapped rather than accumulated: the phase is the only thing anyone reads,
+    // and a chart left open for hours would otherwise lose float precision on it.
+    tip_pulse_elapsed_s =
+        std::fmod(tip_pulse_elapsed_s + dt, vroom::tip_pulse::kPeriodSeconds);
+}
+
+bool VroomChart::tip_pulse_active() const {
+    return morph_fade > 0.f && !candles.empty() &&
+           theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f &&
+           theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f;
 }
 
 void VroomChart::rebuild_chart_picture() {
@@ -433,6 +464,9 @@ void VroomChart::rebuild_chart_picture() {
 }
 
 bool VroomChart::is_animating_now() const {
+    // The pulse never finishes on its own, so this is what keeps the host loops
+    // requeueing frames for it.
+    if (tip_pulse_active()) return true;
     for (const auto& f : y_fades) {
         if (f.opacity != f.target) return true;
     }

package/cpp/_core_src/chart.h

@@ -64,6 +64,12 @@ struct VroomChart {
     float morph_collapse = 0.f;
     float morph_fade = 0.f;
 
+    // Phase of the line-tip pulse, in seconds into its cycle. Unlike every other
+    // animation here this one is core-driven: it loops with no endpoint for the
+    // host to ease toward, so begin_frame advances it from the frame clock and
+    // is_animating_now keeps the host's redraw loop alive (see tip_pulse.h).
+    float tip_pulse_elapsed_s = 0.f;
+
     // Interval morph: the outgoing candle geometry captured when a timeframe
     // switch begins, indexed from the right of the visible slice (slot 0 =
     // newest) — the pairing the preserved slot grid guarantees. Stored as
@@ -307,14 +313,20 @@ struct VroomChart {
     void draw_chart(SkCanvas* canvas);
 
     // Per-frame animation bookkeeping: computes `last_dt_seconds`, which paces
-    // the label fades. Called at the top of draw_chart.
+    // the label fades, and advances `tip_pulse_elapsed_s`. Called at the top of
+    // draw_chart.
     void begin_frame();
 
+    // True when the line tip's pulse ring is on screen and looping. Gated on
+    // line mode and on having data, so a chart that isn't showing the ring can
+    // still go idle.
+    bool tip_pulse_active() const;
+
     // Re-records `chart_picture` by invoking draw_chart on a fresh
     // SkPictureRecorder.
     void rebuild_chart_picture();
 
-    // True if any axis label is mid-fade. Used by the JS-side animation loop
-    // to know when to keep ticking.
+    // True if any axis label is mid-fade, or the tip pulse is running. Used by
+    // the JS-side animation loop to know when to keep ticking.
     bool is_animating_now() const;
 };

package/cpp/_core_src/chart_facade.cpp

@@ -32,6 +32,17 @@ constexpr double kAxisDragSensitivity = 300.0;
 constexpr double kMinCandleBodyPx = 1.5;
 constexpr double kMaxCandleBodyPx = 32.0;
 
+// Trailing gap the default framing leaves between the newest candle and the
+// price axis. The newest bar flush against the axis reads as cramped, and in line
+// mode the tip marker's pulse needs somewhere to expand into — the axis mask
+// (draw_chart step 6) paints over the gutter, so clearance has to come from the
+// time window rather than from right_padding_px.
+//
+// A gap this small is far under the 3/4-window cap, so it neither triggers the
+// pan rubber-band nor gets clamped away; a timeframe switch carries it over in
+// slots (see timeframeWindow in the hosts), which preserves it in pixels.
+constexpr double kRightGapPx = 12.0;
+
 // Hard cap on the future gap (visible_end - last_candle): 3/4 of the window so
 // at least 25% of the chart still shows candles. Never forces an existing larger
 // gap (e.g. from the x-axis drag zoom) to snap back — only limits new growth.
@@ -39,6 +50,21 @@ int64_t max_future_gap(int64_t window_ms, int64_t cur_future) {
     return std::max<int64_t>((window_ms * 3) / 4, cur_future);
 }
 
+// Pan/translate future allowance. A window longer than the data has nowhere
+// useful to scroll, so don't grow the future gap — growing it used to combine
+// with a first-candle start pin and latch the view. Dense series keep the
+// usual 3/4-window rubber-band.
+int64_t pan_max_future(int64_t window_ms, int64_t cur_future,
+                       int64_t first_time, int64_t last_time,
+                       int64_t candle_duration_ms) {
+    const int64_t dur = candle_duration_ms > 0 ? candle_duration_ms : 0;
+    const int64_t data_extent = last_time + dur - first_time;
+    if (data_extent >= 0 && window_ms > data_extent) {
+        return std::max<int64_t>(0, cur_future);
+    }
+    return max_future_gap(window_ms, cur_future);
+}
+
 // Rubber-band a forward (into-future) pan delta: once the current future gap is
 // past the soft cap (window/2), damp the delta quadratically toward zero as it
 // nears the hard cap (3*window/4). Backward (into-past) deltas are unaffected.
@@ -70,27 +96,48 @@ void apply_default_framing(VroomChart* chart) {
     const int64_t right_edge_ms =
         chart->candles.back().time_ms + chart->candle_duration_ms;
 
+    const auto lay = chart->layout();
+    const double usable =
+        lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
+
+    // Places a window of the given width with kRightGapPx of air past the newest
+    // candle. Shifts the window forward rather than widening it, so the framing
+    // keeps whatever candle width it just computed. Falls back to a flush right
+    // edge when the layout isn't measured yet and px can't be converted to time.
+    const auto frame = [&](int64_t window_ms) {
+        const int64_t gap_ms =
+            usable > 0.0 && window_ms > 0
+                ? static_cast<int64_t>((kRightGapPx * static_cast<double>(window_ms)) /
+                                       usable)
+                : 0;
+        chart->visible_end_ms = right_edge_ms + gap_ms;
+        chart->visible_start_ms = chart->visible_end_ms - window_ms;
+    };
+
     // Px-driven framing. Reuses the inversion from vroom_chart_scale_time_axis:
     // body_w = usable × (dur / window) × ratio  →  window = usable × dur × ratio / body_w.
     // Needs a valid layout (width_px); until size is known it falls through to
     // the candle-count default below.
     if (chart->default_candle_px > 0.f) {
-        const auto lay = chart->layout();
-        const double usable =
-            lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
         const double ratio = chart->theme.floats[VROOM_FLOAT_CANDLE_WIDTH_RATIO];
         const double dur = static_cast<double>(chart->candle_duration_ms);
         const double body = std::clamp(static_cast<double>(chart->default_candle_px),
                                        kMinCandleBodyPx, kMaxCandleBodyPx);
         if (usable > 0.0 && ratio > 0.0 && dur > 0.0 && body > 0.0) {
-            int64_t window_ms = static_cast<int64_t>((usable * dur * ratio) / body);
-            const int64_t span =
-                chart->candles.back().time_ms - chart->candles.front().time_ms;
-            window_ms = std::clamp<int64_t>(window_ms, chart->candle_duration_ms,
-                                            span > 0 ? span : window_ms);
-            chart->visible_end_ms = right_edge_ms;
-            chart->visible_start_ms = chart->visible_end_ms - window_ms;
-            return;
+            int64_t window_ms = vroom::window_for_body_width(
+                lay, chart->candle_duration_ms, body);
+            // Floor at one slot so the window is valid. Do NOT clamp to the
+            // data span: a short series would then stretch each bar to fill
+            // the plot, the opposite of a target body width. Empty space on
+            // the left is intentional — same rule as timeframeWindow (width
+            // wins).
+            if (window_ms > 0) {
+                if (window_ms < chart->candle_duration_ms) {
+                    window_ms = chart->candle_duration_ms;
+                }
+                frame(window_ms);
+                return;
+            }
         }
     }
 
@@ -98,8 +145,7 @@ void apply_default_framing(VroomChart* chart) {
     const size_t start_idx = chart->candles.size() > kDefaultVisible
         ? chart->candles.size() - kDefaultVisible
         : 0;
-    chart->visible_start_ms = chart->candles[start_idx].time_ms;
-    chart->visible_end_ms = right_edge_ms;
+    frame(right_edge_ms - chart->candles[start_idx].time_ms);
 }
 
 // On the first manual-y gesture, adopt the on-screen auto-fit bounds so the
@@ -380,30 +426,23 @@ extern "C" void vroom_chart_pan(VroomChart* chart, float dx_px, float /*dy_px*/)
         (-dx_px / usable_px) * static_cast<float>(window_ms));
     if (delta_ms == 0) return;
 
-    // The right edge can overshoot the last candle into empty "future" space.
-    // Free scrolling up to half a window (candles fill >= 50%); from there to
-    // 3/4 of a window (candles fill >= 25%) panning forward is rubber-banded so
-    // it slows and hard-stops at the cap. The x-axis drag zoom can leave a gap
-    // larger than the cap (it zooms in until ~one candle remains), so the cap
-    // never forces it back — it just shrinks naturally as the user scrolls.
-    // Left edge still hard-clamps at the first candle.
+    // Forward pans rubber-band between half and 3/4 of a window of empty
+    // future (see damp_future_delta / max_future_gap). Past clamping lives in
+    // clamp_shifted_time_window: dense series pin start at the first candle;
+    // a window longer than the data keeps empty past instead of latching.
     const int64_t first_time = chart->candles.front().time_ms;
     const int64_t last_time = chart->candles.back().time_ms;
     const int64_t cur_future = chart->visible_end_ms - last_time;
     const int64_t eff_delta = damp_future_delta(delta_ms, cur_future, window_ms);
 
-    int64_t new_start = chart->visible_start_ms + eff_delta;
-    int64_t new_end = chart->visible_end_ms + eff_delta;
-
-    const int64_t max_future = max_future_gap(window_ms, cur_future);
-    if (new_end > last_time + max_future) {
-        new_end = last_time + max_future;
-        new_start = new_end - window_ms;
-    }
-    if (new_start < first_time) {
-        new_start = first_time;
-        new_end = new_start + window_ms;
-    }
+    const auto clamped = vroom::clamp_shifted_time_window(
+        chart->visible_start_ms + eff_delta,
+        chart->visible_end_ms + eff_delta,
+        first_time, last_time, chart->candle_duration_ms,
+        pan_max_future(window_ms, cur_future, first_time, last_time,
+                       chart->candle_duration_ms));
+    const int64_t new_start = clamped.start_ms;
+    const int64_t new_end = clamped.end_ms;
 
     if (new_start == chart->visible_start_ms &&
         new_end == chart->visible_end_ms) {
@@ -443,22 +482,16 @@ extern "C" void vroom_chart_translate(VroomChart* chart, float dx_px, float dy_p
                 const int64_t cur_future = chart->visible_end_ms - last_time;
                 const int64_t eff_delta =
                     damp_future_delta(delta_ms, cur_future, window_ms);
-                int64_t new_start = chart->visible_start_ms + eff_delta;
-                int64_t new_end = chart->visible_end_ms + eff_delta;
-                const int64_t max_future =
-                    max_future_gap(window_ms, cur_future);
-                if (new_end > last_time + max_future) {
-                    new_end = last_time + max_future;
-                    new_start = new_end - window_ms;
-                }
-                if (new_start < first_time) {
-                    new_start = first_time;
-                    new_end = new_start + window_ms;
-                }
-                if (new_start != chart->visible_start_ms ||
-                    new_end != chart->visible_end_ms) {
-                    chart->visible_start_ms = new_start;
-                    chart->visible_end_ms = new_end;
+                const auto clamped = vroom::clamp_shifted_time_window(
+                    chart->visible_start_ms + eff_delta,
+                    chart->visible_end_ms + eff_delta,
+                    first_time, last_time, chart->candle_duration_ms,
+                    pan_max_future(window_ms, cur_future, first_time, last_time,
+                                   chart->candle_duration_ms));
+                if (clamped.start_ms != chart->visible_start_ms ||
+                    clamped.end_ms != chart->visible_end_ms) {
+                    chart->visible_start_ms = clamped.start_ms;
+                    chart->visible_end_ms = clamped.end_ms;
                     changed = true;
                 }
             }
@@ -573,9 +606,9 @@ extern "C" void vroom_chart_scale_time_axis(VroomChart* chart, float dx_px) {
     if (new_window_ms > max_window) new_window_ms = max_window;
 
     // Pivot around the right edge — most-recent visible candle stays put.
+    // A window longer than the data may start before the first candle; that
+    // empty past is how defaultCandleWidth wins, so don't pin start to first.
     int64_t new_start = chart->visible_end_ms - new_window_ms;
-    const int64_t first_time = chart->candles.front().time_ms;
-    if (new_start < first_time) new_start = first_time;
 
     if (new_start == chart->visible_start_ms) return;
     chart->visible_start_ms = new_start;
@@ -755,17 +788,14 @@ extern "C" void vroom_chart_zoom(VroomChart* chart, float scale_x, float scale_y
                 const int64_t last_time = chart->candles.back().time_ms;
                 // Cap the future gap at 3/4 of the (new) window so >= 25% of the
                 // chart still shows candles, without snapping back an existing
-                // larger gap (e.g. from the x-axis drag zoom).
-                const int64_t max_future = max_future_gap(
-                    new_window, chart->visible_end_ms - last_time);
-                if (new_end > last_time + max_future) {
-                    new_end = last_time + max_future;
-                    new_start = new_end - new_window;
-                }
-                if (new_start < first_time) {
-                    new_start = first_time;
-                    new_end = new_start + new_window;
-                }
+                // larger gap (e.g. from the x-axis drag zoom). Past clamping
+                // matches pan: a window longer than the data keeps empty left.
+                const auto clamped = vroom::clamp_shifted_time_window(
+                    new_start, new_end, first_time, last_time,
+                    chart->candle_duration_ms,
+                    max_future_gap(new_window, chart->visible_end_ms - last_time));
+                new_start = clamped.start_ms;
+                new_end = clamped.end_ms;
                 if (new_start != chart->visible_start_ms ||
                     new_end != chart->visible_end_ms) {
                     chart->visible_start_ms = new_start;

package/cpp/_core_src/crosshair.cpp

@@ -21,6 +21,7 @@
 #include "chart.h"
 #include "fonts.h"
 #include "theme.h"
+#include "ticks.h"
 
 namespace vroom::crosshair {
 
@@ -146,7 +147,10 @@ void draw(SkCanvas* canvas,
     if (lay.y_axis_width_px > 0.f) {
         const double price = vroom::y_to_price(lay, bounds, cy);
         char buf[32];
-        std::snprintf(buf, sizeof(buf), "%.2f", price);
+        const int decimals = vroom::price_decimals(
+            vroom::pick_price_interval(bounds.max - bounds.min,
+                                       vroom::price_pane_bottom(lay)));
+        vroom::format_price(buf, sizeof(buf), price, decimals);
         const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
         draw_badge(canvas, font, buf, axis_center_x, cy, badge_fill,
                    SK_ColorWHITE);

package/cpp/_core_src/curve.h

@@ -0,0 +1,67 @@
+// Monotone cubic interpolation — the math behind the line chart's optional
+// corner smoothing (VROOM_FLOAT_LINE_TENSION).
+//
+// Deliberately monotone (Fritsch-Carlson) rather than a plain Catmull-Rom or
+// cardinal spline. An unconstrained spline through the closes overshoots on a
+// sharp reversal, and on a price chart that isn't just ugly — the curve dips
+// below the period's low and draws a price that never traded, next to candles
+// that show the real one during the candle-to-line crossfade. Limiting the
+// tangents keeps every local extreme on an actual data point.
+//
+// Skia-free and header-only so the unit tests can cover it (see
+// tests/test_curve.cpp); ma_overlay.cpp owns the walk and the path emission.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+namespace vroom::curve {
+
+// The two interior control points of a cubic Bezier segment, in whatever space
+// the endpoints were given in (pixels, at every call site here).
+struct Controls {
+    float c1x, c1y;
+    float c2x, c2y;
+};
+
+// Slope of the straight line between two points. Non-increasing x yields 0,
+// which keeps a degenerate span (duplicate timestamps, or the compressed
+// spacing an interval morph can pass through) from producing infinities.
+inline float secant(float x0, float y0, float x1, float y1) {
+    const float h = x1 - x0;
+    return h > 0.f ? (y1 - y0) / h : 0.f;
+}
+
+// Tangent at a point with neighboring secants `d_prev` and `d_next`.
+inline float monotone_tangent(float d_prev, float d_next) {
+    // Opposite signs (or a flat neighbor) mean this point is a local extreme.
+    // A zero tangent is what pins the curve to it instead of sailing past.
+    if (d_prev * d_next <= 0.f) return 0.f;
+    // Fritsch-Carlson: holding the tangent within three times the smaller
+    // neighboring secant is what makes each segment monotone, and is also why
+    // the control points below can never leave the endpoints' y range.
+    const float limit = 3.f * std::min(std::fabs(d_prev), std::fabs(d_next));
+    return std::clamp((d_prev + d_next) * 0.5f, -limit, limit);
+}
+
+// Control points for the segment p0 -> p1, given the tangents chosen for each
+// endpoint and how far to lean into them.
+//
+// `tension` 0 puts both tangents back on the segment's own secant, which lands
+// the controls exactly on its thirds — the cubic *is* the straight line. So the
+// knob is continuous at zero rather than snapping into a curve, and callers can
+// interpolate it without a visible discontinuity.
+inline Controls segment_controls(float x0, float y0,
+                                 float x1, float y1,
+                                 float m0, float m1,
+                                 float tension) {
+    const float d = secant(x0, y0, x1, y1);
+    const float a = d + (m0 - d) * tension;
+    const float b = d + (m1 - d) * tension;
+    const float third = (x1 - x0) / 3.f;
+    return Controls{x0 + third, y0 + a * third,
+                    x1 - third, y1 - b * third};
+}
+
+}  // namespace vroom::curve

package/cpp/_core_src/labels.cpp

@@ -153,13 +153,15 @@ void draw_y_labels(SkCanvas* canvas,
     // Horizontal center of the y-axis container ([width - y_axis_width, width]).
     // Labels (and the price box) center on this so their text shares a column.
     const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+    const int decimals = vroom::price_decimals(
+        vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
 
     for (const auto& f : chart.y_fades) {
         if (f.opacity <= 1e-3f) continue;
         const float y = vroom::price_to_y(lay, bounds, f.price);
 
         char buf[32];
-        std::snprintf(buf, sizeof(buf), "%.2f", f.price);
+        vroom::format_price(buf, sizeof(buf), f.price, decimals);
         const size_t len = std::strlen(buf);
         const float text_w = font.measureText(
             buf, len, SkTextEncoding::kUTF8);
@@ -367,9 +369,12 @@ void recompute_axis_width(VroomChart& chart) {
     }
 
     SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+    const auto lay = chart.layout();
+    const int decimals = vroom::price_decimals(
+        vroom::pick_price_interval(hi - lo, vroom::price_pane_bottom(lay)));
     char buf_hi[32], buf_lo[32];
-    std::snprintf(buf_hi, sizeof(buf_hi), "%.2f", hi);
-    std::snprintf(buf_lo, sizeof(buf_lo), "%.2f", lo);
+    vroom::format_price(buf_hi, sizeof(buf_hi), hi, decimals);
+    vroom::format_price(buf_lo, sizeof(buf_lo), lo, decimals);
     const float w_hi = font.measureText(
         buf_hi, std::strlen(buf_hi), SkTextEncoding::kUTF8);
     const float w_lo = font.measureText(