The contract surface for building indicators: the IIndicator lifecycle, the IIndicatorContext runtime view, the IndicatorBase base class, the declaration attributes, the cadence enums, the optional render / interaction capability interfaces, and the chart trader panel controls. Namespaces: SabrTrader.Pipeline.Indicators and its .Search and .Statistics sub-namespaces, plus SabrTrader.Pipeline.Panels. Trading hours and sessions (.TradingHours, .Sessions) are in the Alerts & sessions reference; contract rollovers (.ContractRollover) and the series types are in Bars & series; PlotColors (.Builtin) is in Plots & rendering.

IIndicator INTERFACE

The lifecycle contract every indicator implements (it extends IDisposable). The runtime calls the hooks; indicators communicate through child indicators and the shared bar/series storage, and never call each other's hooks. Callbacks are single-threaded per instance: no two hooks fire in parallel for the same indicator.

Lifecycle ordering: OnInit once → OnDataLoaded once (with all historical bars already in storage) → OnBarUpdate per closed/intra-bar event at the Calculate cadence → OnMarketData per live tick (with ProcessesMarketData) → OnDataSeriesReady when an added series finishes backfill → OnDispose once. Live hooks fire only after backfill.

Properties

Lifecycle & child-tree methods

IIndicatorContext INTERFACE

The runtime view an indicator has of its environment, passed to every lifecycle hook. Single-threaded with respect to the indicator. Do not cache it across threads or persist it past a callback. Many members are default-interface methods, so a test stub or third-party host implements only the core members.

Series & per-callback metadata

Resources, orderflow & instrument info

Trading hours, rollovers & diagnostics

Data connection

An indicator can tell whether the chart it runs on has a live data connection, and react when that changes. Read ctx.DataConnection (or the shortcut ctx.IsDataConnected) from any hook, and override OnDataConnectionChanged to hear about transitions. The status follows the chart's data venue as a whole, so it keeps tracking the right connection when the platform replaces a venue session after a reconnect. For a practical walk-through, see Showing the connection state.

DataConnectionStatus.csnamespace SabrTrader.Pipeline.Providers;

public enum DataConnectionStatus
{
    NotApplicable  = 0,
    Disconnected   = 1,
    Connecting     = 2,
    Connected      = 3,
    ConnectionLost = 4,
    Reconnecting   = 5,
    Failed         = 6,
}

Where you get NotApplicable

Only an indicator on a chart follows a data venue. Everywhere else the context reports NotApplicable and OnDataConnectionChanged never fires: backtests and optimizer passes, historical-only analysis, indicators hosted inside a strategy (the strategy reads its own DataConnection), SuperDOM and Market Analyzer column hosts, test rigs, and any third-party IIndicatorContext that keeps the default. Treat NotApplicable like "connected" for display purposes: a "disconnected" badge in a backtest would be wrong.

Delivery rules

• OnDataConnectionChanged runs on the same serialised path as the other callbacks, never concurrently with them, with ctx.IsLive true, so ctx.Alert(...) fires from it.
• Inside the callback, ctx.DataConnection already returns the new status.
• Rapid transitions are coalesced: you always end on the current status, but you may not see every intermediate one (a quick drop and reconnect can arrive as just Connected).
• It fires on transitions only. Read ctx.DataConnection in OnInit for the starting status; the usual pattern is one field set in both places.
• No ticks arrive while the connection is down, so an indicator that draws the status implements IRepaintNotifier and raises RepaintRequested from the callback.
• No opt-in attribute is needed. A child indicator hosted by a composite reads DataConnection from its own context; the callback goes to the indicators the host dispatches to.

IndicatorBase BASE CLASS

The class plugin authors derive from. It implements IIndicator, IIndicatorHost (host-side plumbing, see below), IOrderFlowResolutionAware and IInputSourceAware, and provides empty virtual lifecycle hooks (override only what you need), lazy ContentKey, idempotent Dispose, the parent-owned child tree, and the plot/line registration helpers.

SimpleAverage.csusing System;
using SabrTrader.Pipeline.Indicators;
using SabrTrader.Pipeline.Plots;
using SabrTrader.Pipeline.Series;

[IndicatorDescription("Simple moving average of the input series.")]
[IndicatorCategory(IndicatorCategory.Trend)]
[IndicatorInput(IndicatorInputKind.Scalar)]
[IndicatorPlot("SMA", IsOverlay = true, Kind = PlotKind.Overlay, Unit = PlotValueUnit.Price)]
public sealed class SimpleAverage : IndicatorBase
{
    private readonly ChunkedSeries<double> _sma = new();

    [IndicatorParameter(DisplayName = "Period", MinValue = 1, MaxValue = 500, Step = 1)]
    public int Period { get; set; } = 14;

    public SimpleAverage(IIndicator? parent = null, ISeries<double>? input = null)
        : base(parent, input)
    {
        AddPlot(new Plot("SMA", _sma, PlotStyle.Line, new ChartColor(33, 150, 243), 1.5));
    }

    public override void OnDataLoaded(IIndicatorContext ctx)
    {
        for (int barsAgo = Input.Count - 1; barsAgo >= 0; barsAgo--)
            _sma.Append(Average(barsAgo));
    }

    public override void OnBarUpdate(IIndicatorContext ctx) => _sma.Append(Average(0));

    private double Average(int barsAgo)
    {
        int n = Math.Min(Period, Input.Count - barsAgo);
        double sum = 0;
        for (int i = 0; i < n; i++) sum += Input[barsAgo + i];
        return sum / n;
    }
}

Construction

Every subclass exposes one ctor of the shape Xxx(IIndicator? parent = null, ISeries<double>? input = null, /* params */) : base(parent, input). The base ctor stores Input/Bars and, when parent is non-null, registers as a child. The child's own OnInit/OnDataLoaded are deferred to the first dispatch event so the derived ctor body sets Period, plots, etc. before lifecycle math runs.

protected IndicatorBase(IIndicator? parent = null, ISeries<double>? input = null, IBarSeries? bars = null);

Public & protected members

Overridable virtuals

CalculationMode ENUM

Frequency at which the runtime dispatches OnBarUpdate on the primary series (the same three modes as NinjaTrader). It controls only the bar-callback cadence; raw-tick delivery is the separate ProcessesMarketData opt-in.

CalculationCadence STATIC HELPER

Decides whether a callback fires for a given CalculationMode and update. The indicator runtime and the strategy runner both use it, and a custom host can too.

public static bool ShouldFire(CalculationMode mode, bool isClosed, bool closeChanged);
//  OnBarClose    => isClosed
//  OnPriceChange => isClosed || closeChanged
//  OnEachTick    => true

Attributes

Class- and property-level attributes the framework reads by reflection to compute content keys, render the parameter editor, persist values, and route data. All are Inherited = true except [IndicatorHotkey].

IndicatorParameter (property)

Marks a property as a user-tunable parameter. Constraints are advisory (the editor enforces them; programmatic sets are not clamped).

ParameterLabelSize enum: Normal = 0, Large = 1. ParameterFormat is the readonly record struct the metadata carries the three formatting fields in: ParameterFormat(bool Bold = false, ParameterLabelSize LabelSize = Normal, bool SeparatorBefore = false), with bool IsLarge. Its default value is the plain row. Strategy parameters use the same type.

ParameterEditorKind enum: Auto = 0 (host picks from the CLR type), FilePicker = 1 (path field + Browse), SymbolPicker = 2 (shared instrument picker for a benchmark/comparison symbol), Hidden = 3 (no settings-dialog row; the value still persists and still contributes to the content key), FontPicker = 4 (on a string holding a font family name: the same font list the chart properties use; the box stays editable so a family this machine lacks can still be typed, an empty value keeps the host's default font, and a host without a font list shows a plain text box).

IndicatorPlot (class, repeatable)

Declares a named plot the indicator produces and what its values mean. Declare one per output (MACD line, signal and histogram each get one). IndicatorMetadata.Plots exposes them as PlotDescriptors, with the semantics in PlotDescriptor.Semantics.

Class-level marker & metadata attributes

Enums: IndicatorCategory = Unspecified, Trend, Momentum, Volume, Volatility, OrderFlow, Structure, Custom. IndicatorInputKind = Scalar = 0, Bars = 1, None = 2.

Keyboard shortcuts

An indicator declares the shortcuts it wants, one attribute per action, and implements IIndicatorHotkeyTarget to receive them. The declarations sit on the type, not an instance, so the host reads them from the catalog at start-up and the action can be bound before any chart has the indicator on it, the same way drawing-tool shortcuts work.

hotkeysusing System.Collections.Generic;
using SabrTrader.Pipeline.Indicators;

// Ids are dotted lower-case and PERSISTED in the user's binding file - never rename one.
[IndicatorHotkey("myzones.toggle", "Toggle zones", defaultGesture: "Ctrl+Alt+Z")]
[IndicatorHotkey("myzones.clear", "Clear zones")]   // no default: unbound until the user assigns one
public sealed class MyZones : IndicatorBase, IIndicatorHotkeyTarget
{
    private readonly List<double> _zones = new();
    private bool _show = true;

    public bool InvokeHotkey(string hotkeyId)
    {
        switch (hotkeyId)
        {
            case "myzones.toggle": _show = !_show; return true;
            case "myzones.clear":  _zones.Clear(); return true;
            default:               return false;    // not mine
        }
    }
}

IndicatorHotkeyAttribute(string id, string displayName, string? defaultGesture = null) (AllowMultiple = true, Inherited = false), with read-only Id, DisplayName and DefaultGesture. DisplayName is what the Keyboard Shortcuts dialog shows, and DefaultGesture uses the host's chord syntax (Ctrl+Alt+B); null leaves the action unbound until the user assigns one. When the key is pressed, every indicator on the active chart that implements IIndicatorHotkeyTarget is offered the id, so return false for an id that is not yours and expect other listeners.

Metadata & identity

Reflection-extracted, per-type cached data driving content keys, the parameter editor, and discovery.

Records: ParameterDescriptor(PropertyInfo Property, string Name, string DisplayName, string Description, string Group, int Order, object? MinValue, object? MaxValue, object? Step, ParameterEditorKind Editor = Auto, string FileFilter = "") with init-only ContentKeyDefault, bool IsPrimary, string? VisibleWhen, ParameterFormat Format; PlotDescriptor(string Name, string Description, bool IsOverlay) with init-only Semantics. Both are sealed records the metadata builds; you read them, you never construct them.

IParameterContainerProvider: object ParameterContainer { get; } returns the live settings instance for a [ParameterContainer] indicator; never null once the indicator is constructed.

PlotSemantics

The machine-readable meaning of a plot's value, so a consumer can interpret RSI = 71.6 vs EMA = 5012 without recognising the indicator (a sealed record). PlotSemantics.Default has everything unspecified.

public sealed record PlotSemantics(
    PlotKind Kind, double? RangeMin, double? RangeMax,
    PlotValueUnit Unit, PlotBullishDirection BullishDirection, string? Reference);
// bool HasRange => RangeMin.HasValue && RangeMax.HasValue;

The reflected definition

What the host sees when it inspects an indicator type without instantiating it: the settings dialog, the indicator picker and the AI builder read this rather than your fields. It is produced from your attributes (or served as a premium spec, see below), so indicator code only reads it.

Input sources

IInputSourceAware / IOrderFlowResolutionAware: backing-store contracts (InputSourceDescriptor InputSource { get; set; } and OrderFlowResolution OrderFlowResolution { get; set; }) that IndicatorBase implements so the editor/codec descriptors are synthesized only for the right indicators.

InputPriceType enum (the standard price types plus the volume and open-interest channels): Close = 0, Open = 1, High = 2, Low = 3, Median = 4, Typical = 5, Weighted = 6, OHLC4 = 7, Volume = 8, OpenInterest = 9.

InputSourceDescriptor: a serializable value type (readonly struct) describing where the scalar Input comes from: a price type, or another indicator's plot (a private configured copy). Its canonical string is a frozen, persisted grammar; structural equality is semantic equality.

Optional capability interfaces

An indicator opts into extra host integration by ALSO implementing one of these alongside IIndicator, so only the indicators that need a capability take the dependency.

Search types (SabrTrader.Pipeline.Indicators.Search): IIndicatorCellSearch (above); IndicatorSearchField(string Id, string Name), one searchable field; IndicatorSearchQuery(string FieldId, double MinValue, IndicatorSearchLocation Location = Anywhere, IndicatorSearchDirection Direction = Any, int LookbackBars = 0, int MaxHits = 500), the user's search (LookbackBars = 0 searches all bars); IndicatorSearchHit(int AbsBarIndex, DateTime TimeUtc, double Price, double Value, string Summary), where Summary is what the user reads in the result list. IndicatorSearchLocation enum = Anywhere = 0, High = 1, Low = 2, Body = 3, Wick = 4; IndicatorSearchDirection enum = Any = 0, Up = 1, Down = 2. All are readonly record structs except the enums and the interface.
Statistics types (SabrTrader.Pipeline.Indicators.Statistics): IIndicatorBarStatistics (above); IndicatorStatisticRow(string Id, string Name, string Value, IndicatorStatisticTone Tone), where Value is pre-formatted text so the indicator owns its units; IndicatorStatisticTone enum = Neutral = 0, Positive = 1, Negative = 2 (sets the colour only).

Context structs: ChartClickContext(double X, double Y); ChartMouseMoveContext(double X, double Y) with IsInside + Outside; IndicatorContextMenuLocation(int BarIndex, double Price, DateTime Time, double PixelX, double PixelY). CustomRenderLayer enum = BelowBars = 0, AboveBars = 1 (Layer and PricePanelLayer default to AboveBars). PanelPlacement enum = PriceOverlay = 0, NewSubpanel = 1.

IIndicatorRenderContext & menu items

The per-frame context passed to the render capability methods. Single-threaded (the chart's UI thread); do not cache it across frames.

ToolbarMenuItem hierarchy

A closed record hierarchy (the host pattern-matches the concrete types) reused by both IIndicatorToolbarMenu and IIndicatorContextMenu. The host asks for a fresh list each time the menu opens, so build it on demand and do not cache it.

Helpers

Resolver & ambients

Premium definition seam

Lets the host serve a premium indicator's editor metadata from a cloud spec, or withhold it, per entitlement. A process that installs no source sees local reflection for every type. It is host-side only, and content keys are the same under every verdict.

Alerts

An indicator raises a user-facing alert with ctx.Alert(…), passing an id, a message, an optional sound, an AlertSeverity and a re-arm window. The call is live-only and returns at once; the host routes the alert and delivers it to the channels the user has enabled. Guide: Alerts & channels; types: Alerts & sessions.

Chart trader panels

An indicator or strategy that implements IChartPanelProvider contributes its own tab to the chart trader panel. The contracts live in SabrTrader.Pipeline.Panels. Guides: Indicators › Chart trader panel and Strategies › Chart trader panel.

public interface IChartPanelProvider
{
    ChartPanel? CreateChartPanel();                   // null = contribute no tab
    void OnChartPanelReleased(ChartPanel panel) { }   // the tab is gone; drop your element refs
}

public abstract class PanelSurface                    // shared root of ChartPanel and AddOnView
{
    public IReadOnlyList<ChartPanelElement> Elements { get; }      // structure, fixed for its life
    public event Action<ChartPanelElement>? ElementChanged;       // host-facing
    public void Release();                                        // host-facing
}

public sealed class ChartPanel : PanelSurface
{
    public ChartPanel(string title, params ChartPanelElement[] elements);
    public string Title { get; }                                  // tab header, fixed for its life
}

public abstract class ChartPanelElement
{
    public bool IsEnabled { get; set; }               // greyed out and non-interactive while false
    public bool IsVisible { get; set; }               // out of the layout entirely while false
    public ChartPanelAccent Accent { get; set; }      // Neutral | Positive | Negative | Warning | Info
    protected void Invalidate();                      // tell the host to re-read this element
}

public abstract class ChartPanelContainer : ChartPanelElement   // base of Row and Group
{
    public IReadOnlyList<ChartPanelElement> Children { get; }      // fixed at construction
}

ElementChanged is raised on whichever thread wrote the element; the host marshals and coalesces. Release() is called by the host once the tab has left the screen: it detaches every element (so you can reuse the instances in the next panel you build) and stops ElementChanged. ChartPanelAccent values: Neutral = 0, Positive = 1, Negative = 2, Warning = 3, Info = 4, resolved against the user's theme. Hiding a container hides its children.

The element kinds, all of them writable at any time from any thread:

new ChartPanelButton(string text, Action onClick);
new ChartPanelToggle(string text, Action<bool> onToggled, bool isOn = false);
new ChartPanelCheckBox(string text, Action<bool> onChanged, bool isChecked = false);
new ChartPanelLabel(string caption, string text = "");
new ChartPanelChoice(string caption, IReadOnlyList<string> options, Action<int> onSelected,
                     int selectedIndex = 0);
new ChartPanelNumber(string caption, Action<double> onChanged, double value = 0,
                     double minimum = 0, double maximum = double.MaxValue,
                     double step = 1, int decimals = 0);
new ChartPanelText(string caption, Action<string> onChanged, string text = "");
new ChartPanelSeparator();
new ChartPanelRow(params ChartPanelElement[] children);
new ChartPanelGroup(string caption, params ChartPanelElement[] children);

Setting a value property (Text, IsOn, IsChecked, SelectedIndex, Value) updates the control without raising your callback, so reflecting a state you changed yourself cannot re-enter your own handler. Read-only members: Caption on the captioned kinds, ChartPanelChoice.Options and SelectedOption (the selected text), and ChartPanelNumber.Minimum / Maximum / Step / Decimals.

The host applies user input through ChartPanelButton.Click(), ChartPanelToggle.Toggle(bool), ChartPanelCheckBox.Check(bool), ChartPanelChoice.Select(int), ChartPanelNumber.Commit(double) (clamps and rounds first) and ChartPanelText.Commit(string). Each stores the value and raises your callback on the plugin's callback thread; plugin code uses the value properties instead. An element belongs to one panel at a time: passing it to a second panel throws until the first is released.