The contracts for chart drawing tools: the tool interface and base class, the time/price anchor model, the per-frame render context, hit-test geometry helpers, the discovery attributes/descriptors, and the line/placement enums. All types live under SabrTrader.Pipeline.Drawing (Fibonacci helpers under SabrTrader.Pipeline.Drawing.Tools).

Drawing tools: SabrTrader.Pipeline.Drawing

IDrawingTool INTERFACE

One placed instance of a drawing tool (trend line, ray, horizontal line, …). State, render, and hit-test all live on the tool; the chart's drawing layer owns the list and coordinates the lifecycle. Most authors derive from DrawingToolBase rather than implementing this directly.

IDrawingTool.cspublic interface IDrawingTool
{
    Guid Id { get; }
    string ToolName { get; }
    ChartPanelKey PanelId { get; set; }
    bool IsSelected { get; set; }
    bool IsPlaced { get; set; }
    bool IsLocked { get; set; }
    int AnchorCount { get; }
    int MaxAnchorCount { get; }
    DrawingPlacementMode PlacementMode { get; }
    bool CanAddAnchor { get; }
    IReadOnlyList<DrawingAnchor> Anchors { get; }
    DrawingAnchorCoordinates AnchorCoordinates => DrawingAnchorCoordinates.TimeAndPrice;
    bool UsesCornerAndSideHandles => false;
    ChartColor Color { get; set; }
    double LineWidthPx { get; set; }
    LineStyle LineStyle { get; set; }
    DrawingScope Scope { get; set; }
    DrawingVisibility Visibility => DrawingVisibility.Everywhere;
    int ZOrder { get; set; }
    void SetAnchor(int index, DrawingAnchor anchor);
    void AddAnchor(DrawingAnchor anchor);
    bool RemoveLastAnchor();
    void Move(TimeSpan dTime, double dPrice);
    void OnRender(IDrawingToolRenderContext ctx);
    bool HitTest(double pixelX, double pixelY, IDrawingToolRenderContext ctx, double tolerancePx = 6);
}

DrawingToolBase

Default IDrawingTool base. Anchor storage, identity, selection, default styling (Color / LineWidth / LineStyle), the Scope, Locked and Visibility settings, the stack position, and reading the metadata attribute for ToolName all live in the base, so a subclass only implements OnRender + HitTest. Two construction modes: fixed-anchor (base(anchorCount: N)) pre-allocates N slots and runs DrawingPlacementMode.FixedAnchors; variable-anchor (base(mode, maxAnchorCount, initialAnchorCount)) starts at the initial count and grows via AddAnchor.

The interface members (Id, ToolName, PanelId, IsSelected, IsPlaced, AnchorCount, MaxAnchorCount, PlacementMode, CanAddAnchor, Anchors, SetAnchor, AddAnchor, RemoveLastAnchor) are all implemented by the base. The example below is a box that resizes from its corners and side midpoints.

AcmeRectangle.csusing SabrTrader.Pipeline.Drawing;

[DrawingToolMetadata("Acme Rectangle", Category = "Shapes", AnchorCount = 2)]
public sealed class AcmeRectangle : DrawingToolBase
{
    public AcmeRectangle() : base(anchorCount: 2) { }

    public override bool UsesCornerAndSideHandles => true;

    public override void OnRender(IDrawingToolRenderContext ctx)
    {
        var p1 = ctx.AnchorToPixel(Anchors[0]);
        var p2 = ctx.AnchorToPixel(Anchors[1]);
        DrawLine(ctx, p1.X, p1.Y, p2.X, p1.Y);
        DrawLine(ctx, p2.X, p1.Y, p2.X, p2.Y);
        DrawLine(ctx, p2.X, p2.Y, p1.X, p2.Y);
        DrawLine(ctx, p1.X, p2.Y, p1.X, p1.Y);
        if (ctx.IsSelected) AxisAlignedBoxResize.DrawHandles(ctx, p1.X, p1.Y, p2.X, p2.Y);
    }

    public override bool HitTest(double px, double py, IDrawingToolRenderContext ctx, double tol = 6)
    {
        var p1 = ctx.AnchorToPixel(Anchors[0]);
        var p2 = ctx.AnchorToPixel(Anchors[1]);
        return DrawingGeometry.DistanceToRectangleOutline(px, py, p1.X, p1.Y, p2.X, p2.Y) <= tol;
    }
}

DrawingAnchor

A single anchor point: a (time, price) pair in the bar series' canonical timeline. Anchors are bar-index-independent, so a tool survives live bar updates, scroll, replays, and bar-type changes. Time-only tools ignore Price; price-only tools ignore Time; the unused coordinate is stored as a sentinel and never read.

DrawingAnchor.cspublic readonly record struct DrawingAnchor(DateTime Time, double Price)
{
    public static DrawingAnchor PriceOnly(double price);   // Time = DateTime.MinValue
    public static DrawingAnchor TimeOnly(DateTime time);   // Price = double.NaN
}

DrawingGeometry

Static 2-D geometry helpers for hit tests. All inputs are pixel coordinates, so call them after converting anchors via IDrawingToolRenderContext.AnchorToPixel. Outline helpers return a non-negative distance; compare it against the tool's pixel tolerance.

IDrawingToolRenderContext INTERFACE

Per-frame context handed to OnRender and HitTest. Encapsulates the renderer, viewport, plot-area rectangle, selection state, and time→pixel conversion. All the plumbing lives here so tool authors write almost-trivial render/hit-test methods. The instrument-metadata members default to null/identity so headless and test shims need not supply them.

Visual order, resize grips & text

Drawings that own their grips

A drawing implements IDrawingToolGrips when it is resized through grips of its own instead of by dragging its stored anchors. The built-in Position Sizing tool does: its target is calculated, not stored, and its stop, entry and target each move without dragging the others along. The chart asks for a grip only while the drawing is selected and unlocked, shows the grip's resize cursor over it, and reports the pointer for as long as the grip is held. The chart offers no anchor drag for such a drawing: every resize runs through DragGrip, and pressing anywhere else on the drawing moves it as a whole. The drawing paints its grips itself, from OnRender while ctx.IsSelected (for example with ctx.DrawHandle). Guide with an example: Own grips and trade plans.

Drawings that describe a trade

A drawing implements IDrawingToolTradePlan when it describes a trade: a side, an entry, a stop and a target with a size, as a position-sizing box does. The chart then offers to place that trade as an order from the drawing's own menu. A tool that does not implement the interface is never offered. The drawing only describes the trade. The host's trader places it, through IDrawingTradePlanPlacer, which the host implements and the chart calls. The menu item appears only when the host has a trader, the drawing sits in the price panel of the chart's primary series, and TryGetTradePlan returns true.

Per-timeframe visibility

On which charts a drawing shows. A DrawingVisibility holds one DrawingTimeframeRule per DrawingTimeframeUnit; the chart classifies itself as a DrawingTimeframe and paints and hit-tests only the drawings whose visibility IsVisibleOn it. DrawingToolBase exposes it as the editable, saved Visibility property, so a tool deriving from it has nothing to implement. Guide with an example: Per-timeframe visibility.

Discovery: attributes & descriptors

DrawingToolMetadataAttribute

Marks a class as a discoverable drawing tool, read at assembly-scan time to populate the toolbar menu, hotkeys, icons, and anchor-count requirements. One per tool class; no registration boilerplate. [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)].

DrawingToolPropertyAttribute

Marks a tool property as user-editable in the generic properties dialog. Opt-in: infrastructure properties stay hidden. DrawingToolBase already annotates Color, Line Width, Line Style, Attach to (Scope), Locked and Visibility, so every subclass surfaces those by default; decorate your own for extra editors. Annotated values are saved with the drawing when the property type is bool, string, a number (int, long, float, double, decimal), an enum, ChartColor, FibLevelSet or DrawingVisibility. Constraints are advisory (the dialog enforces them; programmatic writes are not clamped). [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)].

Enums

LineStyle

Stroke style for drawing-tool segments. Mirrors PlotStyle's line variants.

DrawingPlacementMode

How a tool gathers its anchors during placement. The chart's interaction state machine dispatches on this value; each mode has a distinct user gesture.

DrawingScope

Where a placed drawing is shown. Surfaced on IDrawingTool.Scope as an "Attach to" [DrawingToolProperty]; each member's [Description] is the dropdown label the editor renders in place of the raw name.

ElliottDegree

Wave degree for Elliott-wave labelling tools, largest to smallest. Each member's [Description] is its dropdown label (with the notation shown in parentheses). ElliottDegrees.Label(ElliottDegree degree, string key) formats a single wave label for a degree and key.

Fibonacci levels: SabrTrader.Pipeline.Drawing.Tools

FibLevels

Standard Fibonacci ratios used by the Fib retracement / extension / channel / wedge / fan family. Centralised so changing a default updates every tool at once. Static fields are the raw ratio ladders; the Default*Set() factories build a ready-to-edit FibLevelSet.

FibLevel: one configurable level (a sealed class):

FibLevelSet: ordered, mutable collection of levels; inherits ObservableCollection<FibLevel> so the properties dialog's list editor binds to it directly: