The plot outputs an indicator publishes (lines, OHLC candles, threshold levels), the platform-neutral colour type and its named palette, the low-level drawing surface for custom render passes, and the viewport that maps bars/prices to pixels. Namespaces: SabrTrader.Pipeline.Plots, SabrTrader.Pipeline.Indicators.Builtin (PlotColors), SabrTrader.Pipeline.Charts.Rendering and SabrTrader.Pipeline.Charts.Viewport.

Plots (SabrTrader.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, Semantics, IncludeInDataWindow, IsCustomRendered, IsUserConfigurable and PerBarColors have interface default impls, so a custom IPlot only has to provide the core members. IndicatorBase.AddPlot stamps the owner fields at registration time.

Plot

The default IPlot implementation (sealed class). Construct one per output column in the indicator's constructor or OnInit and add it with 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,
//          IncludeInDataWindow, IsCustomRendered, IsUserConfigurable,
//          PerBarColors, 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.

PlotColors

A static class of named ChartColor constants (public static readonly fields) in SabrTrader.Pipeline.Indicators.Builtin: the platform's own palette, so an indicator picks a default colour that matches the built-ins instead of hard-coding a hex value. The names follow the HTML colour names.

PlotColorsusing SabrTrader.Pipeline.Indicators.Builtin;   // PlotColors
using SabrTrader.Pipeline.Plots;

AddPlot(new Plot("Signal", _signal, PlotStyle.Line, PlotColors.DodgerBlue, lineWidthPx: 2));

Members: Aqua, Black, Blue, BlueViolet, Brown, Chocolate, CornflowerBlue, Crimson, Cyan, DarkCyan, DarkGoldenrod, DarkGray, DarkGreen, DarkOrange, DarkRed, DarkSeaGreen, DeepSkyBlue, DimGray, DodgerBlue, ForestGreen, Gold, Goldenrod, Gray, Green, HotPink, IndianRed, Indigo, LightBlue, LightGray, Lime, LimeGreen, Magenta, Maroon, MediumOrchid, MediumPurple, MediumSeaGreen, Navy, Olive, Orange, OrangeRed, Pink, PowderBlue, Purple, Red, RoyalBlue, SaddleBrown, Sienna, Silver, SlateBlue, SteelBlue, Tan, Teal, Transparent, White, Yellow.

PlotDashPattern

The repeating stroke pattern a patterned PlotStyle or LineStyle paints with, as alternating on / off lengths in pixels: IntervalsPx[0] painted, [1] skipped, [2] painted, and so on. An indicator that strokes its own lines in a CUSTOM render pass (pivot lines, a developing trace, a level) resolves the style through For, so the settings dialog's style picker means the same thing there as it does in the chart's standard plot pass. CustomLineRenderer strokes a pattern on any IChartRenderer. The struct is immutable and thread-safe: the intervals are copied on construction. default is the empty pattern (PeriodPx 0), which strokes solid.

PlotDashPattern.cspublic readonly struct PlotDashPattern : IEquatable<PlotDashPattern>
{
    // Alternating on / off lengths in pixels. Throws ArgumentException when IsValid is false.
    public PlotDashPattern(params ReadOnlySpan<double> intervalsPx);

    public ReadOnlySpan<double> IntervalsPx { get; }   // starts with an on length; empty for default
    public double PeriodPx { get; }                    // length of one full repetition; 0 for default

    public static PlotDashPattern Dashed { get; }       // 6 px on / 4 px off
    public static PlotDashPattern Dotted { get; }       // 2 px on / 4 px off
    public static PlotDashPattern DashDot { get; }      // 6 on / 4 off / 2 on / 4 off
    public static PlotDashPattern DashDotDot { get; }   // 6 on / 4 off / 2 on / 4 off / 2 on / 4 off

    // null when the style strokes solid. Dots shares Dotted's pattern for hand-drawn long
    // lines; the standard plot pass keeps them distinct (Dots is a marker at each bar).
    public static PlotDashPattern? For(PlotStyle style);
    public static PlotDashPattern? For(LineStyle style);

    // True for an even number (at least two) of finite, non-negative lengths with a positive total.
    public static bool IsValid(ReadOnlySpan<double> intervalsPx);
}

IsValid is the one rule for a strokeable pattern: the constructor applies it, and so does a renderer that accepts raw intervals (IPolylineRenderer.DrawDashedPolyline). Two patterns are equal when their intervals are equal. Build a pattern of your own from its lengths:

Custom pattern// 8 px on, 3 px off, 2 px on, 3 px off; PeriodPx is 16.
var longDashDot = new PlotDashPattern(8, 3, 2, 3);
CustomLineRenderer.DrawStyledLine(ctx.Renderer, x0, y, x1, y, color, 1.5, longDashDot);

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), for indicator-side candles such as a cumulative delta study. The ctor sets Style to PlotStyle.Candle; Color maps to BullishColor, so code that reads a single colour gets a sensible one. LineWidthPx 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 panel: a fixed Y value with no time component (RSI 30/70, Stochastic 20/80, ADX 20/40; the equivalent of NinjaTrader's AddLine()).

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);

public IndicatorLine(
    string name, double value, ChartColor color,
    double lineWidthPx, PlotStyle style,
    bool participatesInAutoScale, bool isParameterDriven);
// name null/whitespace -> ArgumentException; lineWidthPx <= 0 -> ArgumentOutOfRangeException

The second ctor sets IsParameterDriven; every argument is required so a call never binds ambiguously. IndicatorBase.AddLine has matching overloads.

ChartColor

Platform-neutral RGBA colour (8-bit per channel), declared as a readonly record struct. Each renderer converts it to its own native colour type.

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

Rendering (SabrTrader.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 a renderer implementation is single-threaded.

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, and fall back to the core primitive when the check fails.

CustomLineRenderer (static class, same namespace). DrawSegment(IChartRenderer renderer, double x0, double y0, double x1, double y1, ChartColor color, double widthPx, PlotStyle style) strokes one short segment honouring a PlotStyle (solid for Line and every non-patterned style, otherwise the pattern PlotDashPattern.For gives it) over the core DrawLine primitive. LineStyle ToLineStyle(PlotStyle style) maps a plot style to the SabrTrader.Pipeline.Drawing.LineStyle that the DrawLine overload takes, for one long line (a price line, a pivot): Dashed, Dotted, DashDot and DashDotDot map across, Dots maps to Dotted, and every other style maps to Solid.

All four are stateless, allocate nothing and are safe from any render thread. They stroke the fixed plot pattern (Dashed is always 6 px on, 4 px off). The IChartRenderer.DrawLine overload that takes a LineStyle is the drawing-tool stroke: its dash and dot lengths scale with the stroke width.

Per-bar coloured dashed line// One continuous rhythm across segments whose colour changes per bar:
if (PlotDashPattern.For(plot.Style) is { } dash)
{
    double phase = 0;
    for (int i = first + 1; i <= last; i++)
        phase = CustomLineRenderer.DrawSegment(renderer, x[i - 1], y[i - 1], x[i], y[i],
                                               colorOf(i), plot.LineWidthPx, in dash, phase);
}

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.

Viewport (SabrTrader.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.

ChartPanelKey

A readonly struct identifying one panel of one data series: ChartPanelKey(int seriesIndex, string panelId) with SeriesIndex (0 = primary series) and PanelId ("main" for the price panel, otherwise the subpanel id). IsMain is true for any series' main panel; the constant MainPanelName = "main" and the static Main (series 0, main panel, equal to default) cover the common case. ToCanonicalString() / FromCanonicalString(string?) convert to and from the stored form: the bare panel id for series 0, "s{N}:{PanelId}" for series N; null or empty parses to Main. Use the canonical string when you save anything panel-scoped.

ChartViewport

Immutable (sealed class): rescaling and resizing 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);

Chart trader panels (SabrTrader.Pipeline.Panels)

The declarative controls an indicator or strategy contributes as a chart trader tab (IChartPanelProvider, ChartPanel, PanelSurface and the ChartPanel* element types) are listed in the Indicators reference.