The plot outputs an indicator publishes (lines, OHLC candles, threshold levels), the platform-neutral colour type, the low-level drawing surface for custom render passes, and the viewport that maps bars/prices to pixels.

Plots — TradeStrike.Pipeline.Plots

An indicator exposes its renderable outputs as IPlot objects (one per output column). The chart layer reads them and draws; the indicator owns the underlying series. All plot/line types are mutable so the settings dialog can recolour and restyle at runtime without reconstructing the indicator.

IPlot

One renderable output of an indicator. Values[0] is the newest value; double.NaN marks "no value at this bar" (warmup) and is skipped by the renderer.

Default-implemented members. OwnerName, Owner and Semantics have interface default impls, so existing third-party IPlot implementations keep compiling. IndicatorBase.AddPlot stamps them at registration time.

Plot

The default IPlot implementation (sealed class). Construct one per output column in OnInit and add it via IndicatorBase.AddPlot(...). Setters validate eagerly — a blank name or non-positive LineWidthPx throws immediately.

Plot.cspublic Plot(string name, ISeries<double> values, PlotStyle style, ChartColor color, double lineWidthPx);

// Mutable: Name, Style, Color, LineWidthPx, Visible, ShowPriceMarker,
//          OwnerName, Owner, Semantics
// Read-only: Values  (set once in the ctor; IS the indicator's output series)

PlotStyle

How a plot's values are rendered. The chart's plot render pass picks the primitive sequence from this enum.

IOhlcPlot

A specialised IPlot carrying per-bar OHLC data so the renderer can draw candlesticks. The plot's Values series IS the close series (keeps legend / price-marker / crosshair working). The parallel open/high/low series share the same indexing; any NaN at a bar skips that candle.

OhlcPlot

The default IOhlcPlot implementation (sealed class). The big consumer is Cumulative Delta. Style is set to PlotStyle.Candle by the ctor; Color maps to BullishColor so non-OHLC-aware paths see a sane single colour. Note LineWidthPx here is the WICK width.

OhlcPlot.cspublic OhlcPlot(
    string name,
    ISeries<double> openValues,
    ISeries<double> highValues,
    ISeries<double> lowValues,
    ISeries<double> closeValues,   // becomes Values (the close series)
    ChartColor bullishColor,
    ChartColor bearishColor,
    double wickWidthPx = 1.0,        // becomes LineWidthPx; must be > 0
    double bodyFillRatio = 0.7);     // must be in [0, 1]

IIndicatorLine

A horizontal threshold line on an indicator's subgraph — fixed Y-value, no time component (matches NinjaTrader's AddLine(): RSI 30/70, Stochastic 20/80, ADX 20/40).

IndicatorLine

The default IIndicatorLine implementation (sealed class). Add one per threshold via IndicatorBase.AddLine(...).

IndicatorLine.cspublic IndicatorLine(
    string name, double value, ChartColor color,
    double lineWidthPx = 1.0,
    PlotStyle style = PlotStyle.Line,
    bool participatesInAutoScale = true);
// name null/whitespace -> ArgumentException; lineWidthPx <= 0 -> ArgumentOutOfRangeException

ChartColor

Platform-neutral RGBA colour (8-bit per channel), declared as a readonly record struct. The renderer converts to SkiaSharp / Direct2D at the boundary.

ChartColor.cspublic readonly record struct ChartColor(byte R, byte G, byte B, byte A = 255);

Rendering — TradeStrike.Pipeline.Charts.Rendering

The low-level surface a custom render pass writes into, plus the style + geometry value types. Coordinates are already in pixel space (origin top-left, X right, Y down); the renderer knows nothing about bars or prices. Every frame is bracketed by BeginFrame / EndFrame and runs on the render thread, so implementations need not be thread-safe.

IChartRenderer

The core 2D drawing surface (IChartRenderer : IDisposable). Several methods are default-implemented convenience wrappers over the primitives.

Renderer capability interfaces

Optional capabilities a concrete IChartRenderer MAY also implement. Detect each with a single is check on the renderer you already hold; if it isn't supported, fall back to the core primitive. This honours ISP — no existing implementer is forced to change.

Capability detection// Renderer you already hold from the render context:
if (renderer is IPolylineRenderer poly)
    poly.DrawPolyline(points, color, 1.5);
else
    for (int i = 1; i < points.Length; i++)
        renderer.DrawLine(points[i - 1].X, points[i - 1].Y, points[i].X, points[i].Y, color, 1.5);

CandleStyle

User-tunable visual style for candle rendering (sealed class, all init-only). Defaults match the conventional green-up / red-down theme.

Also in this file. ChartCanvasStyle (Background, GridColor, AxisColor, ShowSessionDividers, SessionDividerColor, SessionDividerWidthPx) themes the canvas separately from candles.

CandleGeometry

Pre-computed pixel geometry for one candle (readonly record struct) — the batch-draw analogue of the DrawCandle arguments. All Y values are already viewport-mapped; body top < bottom in screen coords.

CandleGeometry.cspublic readonly record struct CandleGeometry(
    double CenterX,
    double BodyTopY,
    double BodyBottomY,
    double WickTopY,
    double WickBottomY,
    double BodyWidthPx,
    bool Bullish,
    ChartColor? OverrideColor = null);   // non-null = per-bar "paint-bars" colour

AxisStyle

Sizing, colour and label formatting for the price + time axes (sealed class, all init-only). PriceAxisWidthPx / TimeAxisHeightPx double as the canvas margins; set either to 0 to hide that axis.

Also in this file. CrosshairStyle (LineColor, LineWidthPx, LabelForeground, LabelBackground, LabelFontSizePx, FontFamily, Bold, Italic, LabelPaddingPx, PriceFormat) styles the mouse-follow crosshair.

Viewport — TradeStrike.Pipeline.Charts.Viewport

Pure-math description of what's visible plus the transforms between (bar index, price) and (pixel x, pixel y). Bar index 0 is the oldest visible bar; higher price = lower pixel Y.

ChartViewport

Immutable (sealed class) — pan / zoom / rescale return NEW instances, so render code never observes a partially updated state. The ctor validates every argument (positive canvas, non-negative margins, at least one visible bar, maxPrice > minPrice).

ChartViewport.cspublic ChartViewport(
    int canvasWidthPx, int canvasHeightPx,
    int rightMarginPx, int topMarginPx, int bottomMarginPx,
    int firstVisibleBarIdx, int lastVisibleBarIdx,
    double minPrice, double maxPrice,
    int rightInsetPx = 0, int topInsetPx = 0, int bottomInsetPx = 0);

ChartPanelBounds

Pixel rectangle of one chart PANEL within the canvas (the main price panel or an indicator subpanel), declared as a readonly record struct. Same pixel space as ChartViewport.

ChartPanelBounds.cspublic readonly record struct ChartPanelBounds(
    string PanelId,        // "main" for the price panel, else the subpanel id
    double LeftPx,
    double TopPx,
    double WidthPx,
    double HeightPx)
{
    public double BottomPx { get; }   // TopPx + HeightPx
}