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 TradeStrike.Pipeline.Drawing (Fibonacci helpers under TradeStrike.Pipeline.Drawing.Tools).

Drawing tools — TradeStrike.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; }
    string PanelId { get; set; }
    bool IsSelected { get; set; }
    bool IsPlaced { get; set; }
    int AnchorCount { get; }
    int MaxAnchorCount { get; }
    DrawingPlacementMode PlacementMode { get; }
    bool CanAddAnchor { get; }
    IReadOnlyList<DrawingAnchor> Anchors { get; }
    ChartColor Color { get; set; }
    double LineWidthPx { get; set; }
    LineStyle LineStyle { 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), and reading the metadata attribute for ToolName all live in the base — 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.

Rectangle.csusing TradeStrike.Pipeline.Drawing;

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

    public override void OnRender(IDrawingToolRenderContext ctx)
    {
        var p1 = ctx.AnchorToPixel(Anchors[0]);
        var p2 = ctx.AnchorToPixel(Anchors[1]);
        // ... draw the outline via ctx.Renderer ...
        if (ctx.IsSelected) { ctx.DrawHandle(p1.X, p1.Y); ctx.DrawHandle(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 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.

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 / LineWidth / LineStyle, so every subclass surfaces those three by default; decorate your own for extra editors. Constraints are advisory (the dialog enforces them; programmatic writes are not clamped). [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)].

DrawingToolPropertyDescriptor

Reflection metadata for one editable property, consumed by the properties dialog to render editors and write input back onto the live tool. Use Read / Write rather than reflecting yourself so the dialog and headless paths share the same value-coercion contract. (The constructor is internal — instances are produced by the host's discovery.)

DrawingToolDescriptor

Frozen description of a discovered tool type: its metadata plus a factory delegate that builds a fresh instance. A sealed record returned by the host's drawing-tool catalog.

DrawingToolDescriptor.cspublic sealed record DrawingToolDescriptor(
    Type ToolType,
    string Name,
    string Category,
    string? Hotkey,
    string? IconKey,
    int AnchorCount,
    int Order,
    string? Description,
    Func<IDrawingTool> Factory);

DrawingToolPanelIds

Well-known panel-id constants for IDrawingTool.PanelId.

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.

Fibonacci levels — TradeStrike.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 WPF list editor binds directly: