Interface WidgetContext

interface WidgetContext {
    alerts?: AlertController;
    bus: WidgetBus<WidgetBusEvents>;
    chart: Chart;
    chartTheme: ChartTheme;
    document: Document;
    draw: DrawingController;
    drawingTemplates?: DrawingTemplates;
    history?: ChartHistory;
    intervals?: readonly string[];
    keymap: Keymap;
    locale: undefined | string;
    objects?: ChartObjects;
    overlays: OverlayStack;
    root: HTMLElement;
    settingsDefaults?: Readonly<ChartSettingsValues>;
    storage: WidgetStorage;
    symbolSearch?: SymbolSearch;
    theme: WidgetThemeName;
    tips: TipController;
    translate?: WidgetTranslator;
    interval(): string;
    openOverlay(el: HTMLElement, opts?: OverlayOptions): () => void;
    status(text: string, kind?: "error" | "info"): void;
    symbol(): { exchange: string; symbol: string };
    toast(message: string, kind?: ToastKind): ToastHandle;
}

Properties

alerts? bus chart chartTheme document draw drawingTemplates? history? intervals? keymap locale objects? overlays root settingsDefaults? storage symbolSearch? theme tips translate?

Methods

interval openOverlay status symbol toast

Properties

Optional Readonlyalerts

alerts?: AlertController

Trader alerts owned by the widget, optional for custom contexts.

Readonlybus

bus: WidgetBus<WidgetBusEvents>

Readonlychart

chart: Chart

ReadonlychartTheme

chartTheme: ChartTheme

The engine palette the chart is drawing with.

Readonlydocument

document: Document

Readonlydraw

draw: DrawingController

Optional ReadonlydrawingTemplates

drawingTemplates?: DrawingTemplates

Saved drawing looks, when the host gave the widget a template store: the properties dialog and the floating toolbar offer them.

Optional Readonlyhistory

history?: ChartHistory

The chart-wide undo timeline. Every undo and redo control goes through it when it is there; a custom context without one falls back to the drawing controller's own history.

Optional Readonlyintervals

intervals?: readonly string[]

The intervals the host serves, when it named them (WidgetOptions.intervals): a study's timeframe select offers these.

Readonlykeymap

keymap: Keymap

Readonlylocale

locale: undefined | string

Optional Readonlyobjects

objects?: ChartObjects

Live inventory owned by the widget, optional for custom contexts.

Readonlyoverlays

overlays: OverlayStack

The overlay stack behind openOverlay, for a module that needs to ask what is open.

Readonlyroot

root: HTMLElement

The .oac-widget element every piece of chrome lives in.

Optional ReadonlysettingsDefaults

settingsDefaults?: Readonly<ChartSettingsValues>

Settings the widget starts at a value of its own rather than the engine's, keyed as the settings schema keys them (since 2.6.3). The dialog's Restore returns to these, so it lands where a fresh widget starts: the drag that moves time alone, not the engine's time and price.

Readonlystorage

storage: WidgetStorage

Per-widget persisted preferences; enabled is false when persist is off.

Optional ReadonlysymbolSearch

symbolSearch?: SymbolSearch

Configured instrument lookup, shared by the header and indicator inputs.

Readonlytheme

theme: WidgetThemeName

dark or light, following the chart theme in force.

Readonlytips

tips: TipController

Hover labels for controls.

Optional Readonlytranslate

translate?: WidgetTranslator

Methods

interval

openOverlay

  • openOverlay(el: HTMLElement, opts?: OverlayOptions): () => void

  • Show el over the widget: positioned from opts.anchor (or centred as a dialog), focus-trapped, closed by Escape and by a press outside. Returns the closer.

    Parameters

    Returns () => void

status

  • status(text: string, kind?: "error" | "info"): void

  • Put a transient message on the status line.

    Parameters

    • text: string
    • Optionalkind: "error" | "info"

    Returns void

symbol

  • symbol(): { exchange: string; symbol: string }

  • The current symbol and interval, for dialogs that name them.

    Returns { exchange: string; symbol: string }

toast

Settings

Member Visibility

On This Page

Properties
Methods