Options
All
  • Public
  • Public/Protected
  • All
Menu

API Documentation for SciChart.js - v3.3.567

Go to JavaScript Charting Documentation
Go to JavaScript Chart Examples
Go to SciChart.js on Github

Index

Enumerations

Classes

Interfaces

Type aliases

Variables

Functions

Object literals

Type aliases

NumberArray

NumberArray: number[] | Float64Array

RequiredOwnProps

RequiredOwnProps<Type, BaseType>: Required<Omit<Type, keyof BaseType>>

Copies own properties of an interface or copies all of its props if base type is not provided. Makes all of the props required.

Type parameters

  • Type: BaseType

  • BaseType

SuspendedInstance

SuspendedInstance: { id: string; suspendCount: number; suspendable: ISuspendable }

Internal type used to track suspendable instances and number of nested suspend calls

Type declaration

SvgStringTemplate

SvgStringTemplate: (x1: number, y1: number, x2: number, y2: number) => string

Function signature for the SVG builder function

Type declaration

    • (x1: number, y1: number, x2: number, y2: number): string
    • Parameters

      • x1: number
      • y1: number
      • x2: number
      • y2: number

      Returns string

TAdvancedTextProperties

TAdvancedTextProperties: { multilineAlignment?: EMultiLineAlignment; rotation?: number }

Type declaration

  • Optional multilineAlignment?: EMultiLineAlignment

    Horizontal text alignment for multiline text.

  • Optional rotation?: number

    Text rotation in degrees.

TAdvancedTextStyle

Defines text style with advanced options

TAnimationDefinition

TAnimationDefinition: { options?: IFadeAnimationOptions; type: Fade } | { options?: IScaleAnimationOptions; type: Scale } | { options?: ISweepAnimationOptions; type: Sweep } | { options?: IWaveAnimationOptions; type: Wave } | { customType?: string; options?: IBaseAnimationOptions; type: Custom }

Definition of an animation, comprising a EAnimationType and the relevant options

TAnnotationDefinition

Definition of an annotation, comprising a EAnnotationType and the relevant options

TArgb

TArgb: { blue: number; green: number; opacity: number; red: number }

Type declaration

  • blue: number
  • green: number
  • opacity: number
  • red: number

TAxisCubeState

TAxisCubeState: { xVisibleMax: number; xVisibleMin: number; xWorldDimension: number; yVisibleMax: number; yVisibleMin: number; yWorldDimension: number; zVisibleMax: number; zVisibleMin: number; zWorldDimension: number }

A type class to contain information about the current state of 3D Axis Cube, such is Visible Range or World Dimensions.

Type declaration

  • xVisibleMax: number
  • xVisibleMin: number
  • xWorldDimension: number
  • yVisibleMax: number
  • yVisibleMin: number
  • yWorldDimension: number
  • zVisibleMax: number
  • zVisibleMin: number
  • zWorldDimension: number

TAxisDefinition

TAxisDefinition: { options?: INumericAxisOptions; type: NumericAxis } | { options?: ILogarithmicAxisOptions; type: LogarithmicAxis } | { options?: ICategoryAxisOptions; type: CategoryAxis } | { options?: IDateTimeNumericAxisOptions; type: DateTimeNumericAxis }

Definition of an AxisBase2D, comprising a EAxisType and the relevant options

TAxisTitleStyle

TAxisTitleStyle: TTextStyle & { rotation?: number }

TAxisViewRects

TAxisViewRects: { axisRendererViewRect: Rect; axisTitleRendererViewRect: Rect }

Type declaration

  • axisRendererViewRect: Rect
  • axisTitleRendererViewRect: Rect

TBorder

TBorder: { border?: number; borderBottom?: number; borderLeft?: number; borderRight?: number; borderTop?: number; color?: string }

A Border applied to the series viewport, axes or the entire chart surface

Type declaration

  • Optional border?: number
  • Optional borderBottom?: number
  • Optional borderLeft?: number
  • Optional borderRight?: number
  • Optional borderTop?: number
  • Optional color?: string

TCachedLabelStyle

TCachedLabelStyle: TTextStyle & { extras?: string; providerId: string; rotation?: number }

TCameraState

TCameraState: { height?: number; pitch?: number; radius?: number; width?: number; yaw?: number }

Type declaration

  • Optional height?: number
  • Optional pitch?: number
  • Optional radius?: number
  • Optional width?: number
  • Optional yaw?: number

TCategoryCoordCalc

TCellSizeMapper

TCellSizeMapper: (index: number) => number

Type declaration

    • (index: number): number
    • Parameters

      • index: number

      Returns number

TChartTitleStyle

TChartTitleStyle: TAdvancedTextStyle & { alignment?: ETextAlignment; placeWithinChart?: boolean; position?: ETitlePosition }

Defines text style and positioning options used for Chart Title rendering

TCheckedChangedArgs

TCheckedChangedArgs: { isChecked: boolean; series: IRenderableSeries }

Type args for the LegendModifier.isCheckedChanged callback

Type declaration

TCommonTextStyle

Defines text style which allows to switch between Native / Non-native text rendering

TContourLineStyle

TContourLineStyle: { color?: string; strokeThickness?: number }

A type class to contain information about contour line styles

remarks

A contour line is drawn using the UniformContoursRenderableSeries with a 2D array of data

  • Set the color as an HTML Color code to define the color
  • Set the strokeThickness to change the thickness of the contour line

Type declaration

  • Optional color?: string
  • Optional strokeThickness?: number

TCoord

TCoord: xCoord | yCoord

TCursorTooltipDataTemplate

TCursorTooltipDataTemplate: (seriesInfos: SeriesInfo[], tooltipTitle: string) => string[]

Type declaration

    • (seriesInfos: SeriesInfo[], tooltipTitle: string): string[]
    • Parameters

      Returns string[]

TCursorTooltipSvgTemplate

TCursorTooltipSvgTemplate: (seriesInfos: SeriesInfo[], svgAnnotation: CursorTooltipSvgAnnotation) => string

Type declaration

TDataLabel

TDataLabel: { color?: number; dataX: number; dataY: number; position: Point; rect: Rect; text: string }

Type declaration

  • Optional color?: number
  • dataX: number
  • dataY: number
  • position: Point

    The start point for text drawing. This is not the top left of the text rectangle, since the y value for text is on the alphabetic baseline Difference is bounds.GetLineBounds(0).m_fHeight

  • rect: Rect

    The Rectangle that contains the label, relative to the seriesViewRect

  • text: string

TDataLabelProviderDefinition

TDataLabelProviderDefinition: { options?: IDataLabelProviderOptions; type: Default } | { options?: ILineSeriesDataLabelProviderOptions; type: Line } | { options?: IColumnSeriesDataLabelProviderOptions; type: Column } | { options?: IBaseDataLabelProviderOptions; type: Text } | { options?: IHeatmapDataLabelProviderOptions; type: Heatmap } | { options?: IContoursDataLabelProviderOptions; type: Contours } | { options?: IBandSeriesDataLabelProviderOptions; type: Band } | { options?: IBubbleSeriesDataLabelProviderOptions; type: Bubble } | { options?: IHeatmapDataLabelProviderOptions; type: NonUniformHeatmap } | { customType: string; options?: IBaseDataLabelProviderOptions; type: Custom }

TDataLabelStyle

TDataLabelStyle: { fontFamily?: string; fontSize?: number; lineSpacing?: number; multiLineAlignment?: EMultiLineAlignment; padding?: Thickness }

A type class to contain information about data label styles

remarks
  • Set the fontFamily as a string to set the font
  • Set the fontSize as you would in HTML/CSS
  • Set the color as an HTML Color code to define the color

Type declaration

  • Optional fontFamily?: string
  • Optional fontSize?: number
  • Optional lineSpacing?: number
  • Optional multiLineAlignment?: EMultiLineAlignment
  • Optional padding?: Thickness

TDataSeriesDefinition

TDataSeriesDefinition: { options: TSeriesDataDefinition; type: EDataSeriesType }

Type declaration

TDpiChangedEventArgs

TDpiChangedEventArgs: { newValue: number; oldValue: number }

Type arguments to DpiHelper.dpiChanged event

Type declaration

  • newValue: number

    The new Dpi scaling factor

  • oldValue: number

    The previous Dpi scaling factor

TDrawFunction

TDrawFunction: () => void

Type declaration

    • (): void
    • Returns void

TEasingFn

TEasingFn: (time: number) => number

An easing function used in animations through SciChart. See easing for a list of values

Type declaration

    • (time: number): number
    • Parameters

      • time: number

      Returns number

TEffectDefinition

TEffectDefinition: { options?: IGlowEffectOptions; type: Glow } | { options?: IShadowEffectOptions; type: Shadow }

Definition of a shader effect, comprising a EShaderEffectType and the relevant options

TElement

TElement: { arg: NumberArray | any[]; name: string }

Type declaration

TFilterDefinition

TFilterDefinition: { options?: IXyFilterOptions; type: XyLinearTrend } | { options?: IXyMovingAverageFilterOptions; type: XyMovingAverage } | { options: IXyRatioFilterOptions; type: XyRatio } | { options?: IXyScaleOffsetFilterOptions; type: XyScaleOffset } | { options?: IXyyScaleOffsetFilterOptions; type: XyyScaleOffset } | { options?: IXyzScaleOffsetFilterOptions; type: XyzScaleOffset } | { options?: IHlcScaleOffsetFilterOptions; type: HlcScaleOffset } | { options?: IOhlcScaleOffsetFilterOptions; type: OhlcScaleOffset }

Definition of a data filter

TFormatLabelFn

TFormatLabelFn: (dataValue: number) => string

Formats a data-value into a string for display

param

The data-value (e.g. a numeric value)

Type declaration

    • (dataValue: number): string
    • Parameters

      • dataValue: number

      Returns string

TGradientStop

TGradientStop: { color: string; offset: number }

A Gradient stop applied to gradients on lines, fills thoughout SciChart

Type declaration

  • color: string

    The gradient stop color as an HTML color code

  • offset: number

    The gradient offset. Allowable values are in the range 0 to 1

TGridLineStyle

TGridLineStyle: { color?: string; strokeDashArray?: number[]; strokeThickness?: number }

A type class to contain information about gridline styles

remarks

A grid line is the X Y axis grid inside the chart

  • Set the color as an HTML Color code to define the color
  • Set the strokeThickness to change the thickness of the grid line
  • Set the strokeDashArray to define dash pattern, e.g. [2,2] will have a 2-pixel long dash every 2 pixels

Type declaration

  • Optional color?: string
  • Optional strokeDashArray?: number[]
  • Optional strokeThickness?: number

THeatmapLegend

THeatmapLegend: { heatmapLegend: HeatmapLegend; wasmContext: TSciChart }

Type declaration

THlcSeriesData

THlcSeriesData: { closeDataId?: number | string; highDataId?: number | string; lowDataId?: number | string; xDataId?: number | string } & IHlcDataSeriesOptions & { filter?: TFilterDefinition }

Definition of Open, High, Low, Close data

THoveredChangedCallback

THoveredChangedCallback: (args: HoveredChangedArgs) => void

The type of the callback function

Type declaration

TInnerLayoutStrategyDefinition

TInnerLayoutStrategyDefinition: { customType?: string; options?: IInnerAxisLayoutStrategyOptions; type: ELayoutStrategyType }

Type declaration

TLabelProviderDefinition

TLabelProviderDefinition: { options?: ILabelOptions; type: Numeric } | { options?: ILabelOptions; type: Date } | { options?: ILabelOptions; type: Logarithmic } | { options?: {}; type: SmartDate } | { options?: ITextLabelOptions; type: Text } | { options?: ILabelOptions; type: Pie }

Definition of a LabelProviderBase2D, comprising a ELabelProviderType and the relevant options

TLayoutAxisPartsWithStrategyFunc

TLayoutAxisPartsWithStrategyFunc: (axisRendererWidth: number, axisRendererHeight: number, axisTitleRendererWidth: number, axisTitleRendererHeight: number, axisRect: Rect, border: TBorder) => TAxisViewRects

Type declaration

    • (axisRendererWidth: number, axisRendererHeight: number, axisTitleRendererWidth: number, axisTitleRendererHeight: number, axisRect: Rect, border: TBorder): TAxisViewRects
    • Parameters

      • axisRendererWidth: number
      • axisRendererHeight: number
      • axisTitleRendererWidth: number
      • axisTitleRendererHeight: number
      • axisRect: Rect
      • border: TBorder

      Returns TAxisViewRects

TLayoutManagerDefinition

TLayoutManagerDefinition: { options?: ILayoutManagerOptions; type: Default } | { options?: ICentralAxesLayoutManagerOptions; type: CentralAxes } | { options?: ILayoutManagerOptions; type: Synchronised }

TLegendItem

TLegendItem: { checked: boolean; color: string; gradient?: GradientParams; id: string; name: string; showMarker?: boolean }

Type declaration

  • checked: boolean
  • color: string
  • Optional gradient?: GradientParams
  • id: string
  • name: string
  • Optional showMarker?: boolean

TLinearColorMap

TLinearColorMap: { GradientStops: TGradientStop[]; Maximum: number; Minimum: number; Mode: EColorMapMode }

Type declaration

TModifierDefinition

TModifierDefinition: { options?: ICursorModifierOptions; type: Cursor } | { options?: IDataPointSelectionModifierOptions; type: DataPointSelection } | { options?: ILegendModifierOptions; type: Legend } | { options?: IMouseWheelZoomModifierOptions; type: MouseWheelZoom } | { options?: IPinchZoomModifierOptions; type: PinchZoom } | { options?: IRolloverModifierOptions; type: Rollover } | { options?: IVerticalSliceOptions; type: VerticalSlice } | { options?: IRubberBandXyZoomModifierOptions; type: RubberBandXYZoom } | { options?: ISeriesSelectionModifierOptions; type: SeriesSelection } | { options?: IXAxisDragModifierOptions; type: XAxisDrag } | { options?: IYAxisDragModifierOptions; type: YAxisDrag } | { options?: IZoomExtentsModifierOptions; type: ZoomExtents } | { options?: IZoomPanModifierOptions; type: ZoomPan } | { options?: IRangeSelectionModifierOptions; type: OverviewRangeSelection } | { customType?: string; options?: IChartModifierBaseOptions; type: Custom }

Definition of a 2d chart modifier, comprising a EChart2DModifierType and the relevant options

TModifierKeys

TModifierKeys: { altKey: boolean; ctrlKey: boolean; shiftKey: boolean }

Type to store whether modifier keys (Control, Shift, Alt) are pressed or not

Type declaration

  • altKey: boolean
  • ctrlKey: boolean
  • shiftKey: boolean

TModifierMouseArgsParams

TModifierMouseArgsParams: { altKey?: boolean; button?: number; ctrlKey?: boolean; isActiveSubChartEvent?: boolean; isMaster?: boolean; modifierGroup?: string; mousePoint?: Point; mouseWheelDelta?: number; nativeEvent?: MouseEvent; pointerId?: number; pointerType?: string; shiftKey?: boolean; target?: Element }

Type declaration

  • Optional altKey?: boolean
  • Optional button?: number
  • Optional ctrlKey?: boolean
  • Optional isActiveSubChartEvent?: boolean
  • Optional isMaster?: boolean
  • Optional modifierGroup?: string
  • Optional mousePoint?: Point
  • Optional mouseWheelDelta?: number
  • Optional nativeEvent?: MouseEvent
  • Optional pointerId?: number
  • Optional pointerType?: string
  • Optional shiftKey?: boolean
  • Optional target?: Element

TNativeCache

TNativeCache: { keyCache: Map<string, FontKey>; rect: SCRTRectVertex; textBounds: TSRTextBounds; vecColorVertex: VectorColorVertex; vecRects: VectorRectVertex; vector4: TSRVector4; vertex: SCRTColorVertex }

Type declaration

  • keyCache: Map<string, FontKey>
  • rect: SCRTRectVertex
  • textBounds: TSRTextBounds
  • vecColorVertex: VectorColorVertex
  • vecRects: VectorRectVertex
  • vector4: TSRVector4
  • vertex: SCRTColorVertex

TNativeTextStyle

TNativeTextStyle: TTextStyleBase & { useNativeText: true }

Defines properties of text rendered via Native Text API

TOhlcSeriesData

TOhlcSeriesData: { closeDataId?: number | string; highDataId?: number | string; lowDataId?: number | string; openDataId?: number | string; xDataId?: number | string } & IOhlcDataSeriesOptions & { filter?: TFilterDefinition }

Definition of Open, High, Low, Close data

TOuterLayoutStrategyDefinition

TOuterLayoutStrategyDefinition: { customType?: string; options?: any; type: ELayoutStrategyType }

Type declaration

TPaletteProviderDefinition

TPaletteProviderDefinition: { options: GradientParams; type: Gradient } | { options: ISelectedPointOptions; type: DataPointSelection } | { customType: string; options?: any; type: Custom }

Definition of a palette provider, comprising a EPaletteProviderType and the relevant options

TPalettingState

TPalettingState: { gradientPaletting: boolean; lastCount?: number; lastResamplingHash?: number; lastStartIndex?: number; originalBrushColor?: number; originalPenColor?: number; originalPenGradient?: boolean; paletteStartIndex?: number; paletteTextureCache?: PaletteCache; palettedColors: UIntVector; palettedColorsHashCode: number; requiresUpdate: boolean }

Type declaration

  • gradientPaletting: boolean
  • Optional lastCount?: number
  • Optional lastResamplingHash?: number
  • Optional lastStartIndex?: number
  • Optional originalBrushColor?: number
  • Optional originalPenColor?: number
  • Optional originalPenGradient?: boolean
  • Optional paletteStartIndex?: number
  • Optional paletteTextureCache?: PaletteCache
  • palettedColors: UIntVector
  • palettedColorsHashCode: number
  • requiresUpdate: boolean

TPerformanceDetailType

TPerformanceDetailType: { contextId?: string; relatedId?: string }

Type declaration

  • Optional contextId?: string
  • Optional relatedId?: string

TPointMarkerArgb

TPointMarkerArgb: { fill: number; stroke: number }

Type declaration

  • fill: number
  • stroke: number

TPointMarkerDefinition

TPointMarkerDefinition: { options?: IPointMarkerOptions; type: Cross } | { options?: IPointMarkerOptions; type: Ellipse } | { options?: ISpritePointMarkerOptions; type: Sprite } | { options?: IPointMarkerOptions; type: Square } | { options?: IPointMarkerOptions; type: Triangle } | { options?: IPointMarkerOptions; type: X } | { customType?: string; options?: IPointMarkerOptions; type: Custom }

Definition of a pointmarker, comprising a EPointMarkerType and the relevant options

TPositionPoperties

TPositionPoperties: { coordPropertyName: TCoord; shiftPropertyName: TShift; sizePropertyName: TSize }

Type declaration

TPriceBar

TPriceBar: {}

Type declaration

TRenderLayers

TRenderLayers: {}

Defines Render Layers 1,2,3,4 which are used to compose rendering

Type declaration

TRolloverLegendSvgTemplate

TRolloverLegendSvgTemplate: (seriesInfos: SeriesInfo[], svgAnnotation: RolloverLegendSvgAnnotation) => string

Type declaration

TRolloverTooltipDataTemplate

TRolloverTooltipDataTemplate: (seriesInfo: SeriesInfo, tooltipTitle: string, tooltipLabelX: string, tooltipLabelY: string) => string[]

Type declaration

    • (seriesInfo: SeriesInfo, tooltipTitle: string, tooltipLabelX: string, tooltipLabelY: string): string[]
    • Parameters

      • seriesInfo: SeriesInfo
      • tooltipTitle: string
      • tooltipLabelX: string
      • tooltipLabelY: string

      Returns string[]

TRolloverTooltipSvgTemplate

TRolloverTooltipSvgTemplate: (id: string, seriesInfo: SeriesInfo, rolloverTooltip: RolloverTooltipSvgAnnotation) => string

Type declaration

TSciChart

TSciChart: TWasmContext

TSciChart3D

TSciChart3D: TWasmContext

TSciChartConfig

TSciChartConfig: { dataUrl?: string; testWasm?: TSciChart | TSciChart3D; wasmUrl?: string }

Type declaration

  • Optional dataUrl?: string
  • Optional testWasm?: TSciChart | TSciChart3D

    Internal testing use only

  • Optional wasmUrl?: string

TSciChartDestination

TSciChartDestination: { canvasElementId: string; height: number; sciChartSurface: ISciChartSurfaceBase; width: number }

Type declaration

TSciChartSurfaceCanvases

TSciChartSurfaceCanvases: { aspect?: number; disableAspect?: boolean; domCanvas2D?: HTMLCanvasElement; domCanvasWebGL?: HTMLCanvasElement; domChartRoot?: HTMLDivElement; domDivContainer?: HTMLDivElement; domSvgAdornerLayer?: SVGSVGElement; domSvgContainer?: SVGSVGElement }

Type declaration

  • Optional aspect?: number
  • Optional disableAspect?: boolean
  • Optional domCanvas2D?: HTMLCanvasElement
  • Optional domCanvasWebGL?: HTMLCanvasElement
  • Optional domChartRoot?: HTMLDivElement
  • Optional domDivContainer?: HTMLDivElement
  • Optional domSvgAdornerLayer?: SVGSVGElement
  • Optional domSvgContainer?: SVGSVGElement

TSelectionChangedCallback

TSelectionChangedCallback: (args: SelectionChangedArgs) => void

The type of the callback function

Type declaration

TSeriesDataDefinition

Definition of series data, which can take various shapes

TSeriesDefinition

TSeriesDefinition: { options?: IBandRenderableSeriesOptions; type: BandSeries; xyyData?: TXyySeriesData } | { options?: IBubbleRenderableSeriesOptions; type: BubbleSeries; xyzData?: TXyzSeriesData } | { options?: IColumnRenderableSeriesOptions; type: ColumnSeries; xyData?: TXySeriesData } | { options?: IImpulseRenderableSeries; type: ImpulseSeries; xyData?: TXySeriesData } | { ohlcData?: TOhlcSeriesData; options?: ICandlestickRenderableSeriesOptions; type: CandlestickSeries } | { options?: IFastLineRenderableSeriesOptions; type: LineSeries; xyData?: TXySeriesData } | { options?: IMountainRenderableSeriesOptions; type: MountainSeries; xyData?: TXySeriesData } | { hlcData?: THlcSeriesData; options?: IFastErrorBarsRenderableSeriesOptions; type: ErrorBarsSeries } | { ohlcData?: TOhlcSeriesData; options?: IOhlcRenderableSeriesOptions; type: OhlcSeries } | { options?: IXyScatterRenderableSeriesOptions; type: ScatterSeries; xyData?: TXySeriesData } | { options?: IXyTextDataSeriesOptions; type: TextSeries; xyTextData?: TXyTextSeriesData } | { options?: ISplineBandRenderableSeriesOptions; type: SplineBandSeries; xyyData?: TXyySeriesData } | { options?: ISplineLineRenderableSeriesOptions; type: SplineLineSeries; xyData?: TXySeriesData } | { options?: ISplineMountainRenderableSeriesOptions; type: SplineMountainSeries; xyData?: TXySeriesData } | { heatmapData?: IUniformHeatmapSeriesOptions; options?: IHeatmapRenderableSeriesOptions; type: UniformHeatmapSeries } | { heatmapData?: INonUniformHeatmapSeriesOptions; options?: INonUniformHeatmapRenderableSeriesOptions; type: NonUniformHeatmapSeries } | { heatmapData?: IUniformHeatmapSeriesOptions; options?: IContoursRenderableSeriesOptions; type: UniformContoursSeries } | { options?: IStackedColumnRenderableSeriesOptions; type: StackedColumnSeries; xyData?: TXySeriesData } | { options?: IStackedMountainRenderableSeriesOptions; type: StackedMountainSeries; xyData?: TXySeriesData } | { options?: IStackedColumnCollectionOptions; series?: TSeriesDefinition[]; type: StackedColumnCollection } | { options?: IBaseStackedCollectionOptions; series?: TSeriesDefinition[]; type: StackedMountainCollection } | { customType?: string; options?: IBaseRenderableSeriesOptions; type: Custom }

Definition of a renderable series, comprising a ESeriesType, the relevant options, and an optional data object whose type depends on the series type

TSeriesHoverChangedCallback

TSeriesHoverChangedCallback: (sourceSeries: IRenderableSeries, isHovered: boolean) => void

The type of the callback

Type declaration

TSeriesRenderPassInfo

TSeriesRenderPassInfo: { indicesRange: NumberRange; pointSeries: IPointSeries; renderableSeries: IRenderableSeries; resamplingHash: number }

Type declaration

TSeriesSelectionChangedCallback

TSeriesSelectionChangedCallback: (sourceSeries: IRenderableSeries, isSelected: boolean) => void

The type of the callback

Type declaration

TSeriesVisibleChangedCallback

TSeriesVisibleChangedCallback: (sourceSeries: IRenderableSeries, isVisible: boolean) => void

The type of the callback

Type declaration

TSharedDataDefinition

TSharedDataDefinition: Record<number | string, number[]>

Shared data that can be used in ISciChart2DDefinition or directly in chartBuilder.buildSeries or chartBuilder.buildDataSeries

TShift

TSize

TSize: width | height

TStackedAxisLength

TStackedAxisLength: number | string

Length defined as an absolute number or percentage

TSurfaceDefinition

TSurfaceDefinition: ISciChart2DDefinition | { options?: ISciChart2DDefinition; type?: Default2D } | { options?: ISciChartPieDefinition; type?: Pie2D }

TTextStyle

TTextStyle: { alignment?: ELabelAlignment; color?: string; fontFamily?: string; fontSize?: number; fontStyle?: string; fontWeight?: string; multilineAlignment?: EMultiLineAlignment; padding?: Thickness }

A type class to contain information about Axis Label text styles

remarks
  • Set the fontFamily as a string to set the font
  • Set the fontSize as you would in HTML/CSS
  • Set the fontWeight and fontStyle as you would in HTML/CSS
  • Set the color as an HTML Color code to define the color

Type declaration

  • Optional alignment?: ELabelAlignment

    Horizontal label alignment for vertical axes. Default Auto.

    privateremarks

    This property should only be used for axis labels. So the current type definition should be changed in future versions, specifically this property may be renamed or removed. In other cases, e.g. for multiline text alignment use TTextStyle.multilineAlignment

  • Optional color?: string
  • Optional fontFamily?: string
  • Optional fontSize?: number
  • Optional fontStyle?: string
  • Optional fontWeight?: string
  • Optional multilineAlignment?: EMultiLineAlignment

    Horizontal text alignment for multiline text.

  • Optional padding?: Thickness

    Padding is left 4, right 4, top 2, bottom 0 by default. This is because there is natural space below the text baseline. If you are using text labels rather than just numbers, or when using native text, you may want to increase the bottom padding.

TTextStyleBase

TTextStyleBase: { color?: string; fontFamily?: string; fontSize?: number; lineSpacing?: number; padding?: Thickness }

Defines common properties of text to render

Type declaration

  • Optional color?: string
  • Optional fontFamily?: string
  • Optional fontSize?: number
  • Optional lineSpacing?: number

    Line spacing to use if text is wrapped. This is a multiple of the line height and defaults to 1.1

  • Optional padding?: Thickness

TTextureTextStyle

TTextureTextStyle: TTextStyleBase & { fontStyle?: string; fontWeight?: string; useNativeText?: false }

Defines properties of text rendered as a texture

TTickLineStyle

TTickLineStyle: { color?: string; strokeThickness?: number; tickSize?: number }

A type class to contain information about Tick line styles

remarks

A tick line is the small 3 pixel line outside the axis.

  • Set the tickSize to define the size of this tick in pixels.
  • Set the color as an HTML Color code to define the color
  • Set the strokeThickness to change the thickness of the tick line

Type declaration

  • Optional color?: string
  • Optional strokeThickness?: number
  • Optional tickSize?: number

TTickObject

TTickObject: { majorTickCoords: number[]; majorTickLabels: string[]; majorTicks: number[]; minorTickCoords: number[]; minorTicks: number[] }

A type which contains info about major, minor tick coordinates, labels and values. Used when drawing the axis gridlines

Type declaration

  • majorTickCoords: number[]

    The major tick coordinates

  • majorTickLabels: string[]

    The major tick label strings

  • majorTicks: number[]

    The major tick numeric values

  • minorTickCoords: number[]

    The minor tick coordinates

  • minorTicks: number[]

    The minor tick numeric values

TTooltip3DDataTemplate

TTooltip3DDataTemplate: (seriesInfo: SeriesInfo3D, svgAnnotation: TooltipSvgAnnotation3D) => string[]

Type declaration

TTooltip3DSvgTemplate

TTooltip3DSvgTemplate: (seriesInfo: SeriesInfo3D, svgAnnotation: TooltipSvgAnnotation3D) => string

Type declaration

TWebAssemblyChart

TWebAssemblyChart: { sciChartSurface: SciChartSurface; wasmContext: TSciChart }

Type declaration

TWebAssemblyChart3D

TWebAssemblyChart3D: { sciChart3DSurface: SciChart3DSurface; wasmContext: TSciChart3D }

Type declaration

TXySeriesData

TXySeriesData: { xDataId?: number | string; yDataId?: number | string } & IXyDataSeriesOptions & { filter?: TFilterDefinition }

Definition of XY data

TXyTextSeriesData

TXyTextSeriesData: { xDataId?: number | string; yDataId?: number | string } & IXyTextDataSeriesOptions & { filter?: TFilterDefinition }

Definition of XYText data

TXyySeriesData

TXyySeriesData: { xDataId?: number | string; y1DataId?: number | string; yDataId?: number | string } & IXyyDataSeriesOptions & { filter?: TFilterDefinition }

Definition of XYY data

TXyzSeriesData

TXyzSeriesData: { xDataId?: number | string; yDataId?: number | string; zDataId?: number | string } & IXyzDataSeriesOptions & { filter?: TFilterDefinition }

Definition of XYZ data

TZoomExtentsCallback

TZoomExtentsCallback: (sciChartSurface: SciChartSurface) => boolean

A function to execute when zoomExtents is activated. If this exists and returns false, the builtin behaviour is ignored;

Type declaration

TfilterFunction

TfilterFunction: (index: number, y: number) => number

Type declaration

    • (index: number, y: number): number
    • Parameters

      • index: number
      • y: number

      Returns number

Variables

Const AUTO_COLOR

AUTO_COLOR: "auto" = "auto"

Const DebugForDpi

DebugForDpi: boolean = false

Const FIFTY_DAYS

FIFTY_DAYS: number = 60 * 60 * 24 * 50

Const FIVE_DAYS

FIVE_DAYS: number = 60 * 60 * 24 * 5

Const MIN_LOG_AXIS_VALUE

MIN_LOG_AXIS_VALUE: 1e-10 = 1e-10

Const MIN_SERIES_AREA_SIZE

MIN_SERIES_AREA_SIZE: 10 = 10

Const ONE_HOUR

ONE_HOUR: number = 60 * 60

Const buildStamp

buildStamp: "2023-10-30T00:00:00" = "2023-10-30T00:00:00"

Let cleanupWasmContext

cleanupWasmContext: () => void

Type declaration

    • (): void
    • Returns void

Const constructorMap

constructorMap: Map<string, { func: Function; wasm?: boolean }> = new Map<string,{ wasm?: boolean; func: Function }>()

Const defaultSelectionAnnotationSvgString

defaultSelectionAnnotationSvgString: "<svg width="50" height="50" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="fill:transparent"></rect></svg>" = `<svg width="50" height="50" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="fill:transparent"></rect></svg>`

Const defaultUnSelectedAnnotationSvgString

defaultUnSelectedAnnotationSvgString: "<svg width="50" height="50" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="fill:black"></rect></svg>" = `<svg width="50" height="50" preserveAspectRatio="none" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="fill:black"></rect></svg>`

Let devCount

devCount: number = 1

Let hasSent

hasSent: boolean = false

Let isDev

isDev: boolean = false

Const labelCacheByTextAndStyle

labelCacheByTextAndStyle: Map<string, LabelInfo> = new Map<string, LabelInfo>()

Let lastStyleId

lastStyleId: number = 0

Let lastUsed

lastUsed: number = 0

Const libraryVersion

libraryVersion: "3.2.0000" = "3.2.0000"

Let licenseType

licenseType: LicenseType = LicenseType.NoLicense

Const loaderCss

loaderCss: ".scichart_loader {display: inline-block;position: relative;width: 80px;height: 80px;top: 50%;transform: translateY(-50%);}.scichart_loader div {animation: scichart_loader 1.2s cubic-bezier(0.5, 0, 0.5, 1) infinite;transform-origin: 40px 40px;}.scichart_loader div span {display: block;position: absolute;width: 7px;height: 7px;border-radius: 50%;margin: -4px 0 0 -4px;}.scichart_loader div:nth-child(1) {animation-delay: -0.036s;}.scichart_loader div:nth-child(1) span {top: 63px;left: 63px;}.scichart_loader div:nth-child(2) {animation-delay: -0.072s;}.scichart_loader div:nth-child(2) span {top: 68px;left: 56px;}.scichart_loader div:nth-child(3) {animation-delay: -0.108s;}.scichart_loader div:nth-child(3) span {top: 71px;left: 48px;}.scichart_loader div:nth-child(4) {animation-delay: -0.144s;}.scichart_loader div:nth-child(4) span {top: 72px;left: 40px;}.scichart_loader div:nth-child(5) {animation-delay: -0.18s;}.scichart_loader div:nth-child(5) span {top: 71px;left: 32px;}.scichart_loader div:nth-child(6) {animation-delay: -0.216s;}.scichart_loader div:nth-child(6) span {top: 68px;left: 24px;}.scichart_loader div:nth-child(7) {animation-delay: -0.252s;}.scichart_loader div:nth-child(7) span {top: 63px;left: 17px;}.scichart_loader div:nth-child(8) {animation-delay: -0.288s;}.scichart_loader div:nth-child(8) span {top: 56px;left: 12px;}@keyframes scichart_loader {0% {transform: rotate(0deg);}100% {transform: rotate(360deg);}}" = `.scichart_loader {display: inline-block;position: relative;width: 80px;height: 80px;top: 50%;transform: translateY(-50%);}.scichart_loader div {animation: scichart_loader 1.2s cubic-bezier(0.5, 0, 0.5, 1) infinite;transform-origin: 40px 40px;}.scichart_loader div span {display: block;position: absolute;width: 7px;height: 7px;border-radius: 50%;margin: -4px 0 0 -4px;}.scichart_loader div:nth-child(1) {animation-delay: -0.036s;}.scichart_loader div:nth-child(1) span {top: 63px;left: 63px;}.scichart_loader div:nth-child(2) {animation-delay: -0.072s;}.scichart_loader div:nth-child(2) span {top: 68px;left: 56px;}.scichart_loader div:nth-child(3) {animation-delay: -0.108s;}.scichart_loader div:nth-child(3) span {top: 71px;left: 48px;}.scichart_loader div:nth-child(4) {animation-delay: -0.144s;}.scichart_loader div:nth-child(4) span {top: 72px;left: 40px;}.scichart_loader div:nth-child(5) {animation-delay: -0.18s;}.scichart_loader div:nth-child(5) span {top: 71px;left: 32px;}.scichart_loader div:nth-child(6) {animation-delay: -0.216s;}.scichart_loader div:nth-child(6) span {top: 68px;left: 24px;}.scichart_loader div:nth-child(7) {animation-delay: -0.252s;}.scichart_loader div:nth-child(7) span {top: 63px;left: 17px;}.scichart_loader div:nth-child(8) {animation-delay: -0.288s;}.scichart_loader div:nth-child(8) span {top: 56px;left: 12px;}@keyframes scichart_loader {0% {transform: rotate(0deg);}100% {transform: rotate(360deg);}}`

Let maxSize

maxSize: number = 200

Let minAge

minAge: number = 1000 * 60

Const objectCache

objectCache: Map<string, TNativeCache> = new Map<string, TNativeCache>()

Let orderId

orderId: string = ""

Const precision

precision: 100 = 100

Let productCode

productCode: string = ""

Let rect

rect: SCRTRectVertex

Let result

result: boolean

Const sciChartConfig

sciChartConfig: TSciChartConfig

Const sciChartConfig3D

sciChartConfig3D: TSciChartConfig

Const sessionTime

sessionTime: number = 60 * 60 * 1000

Const styleCache

styleCache: Record<string, { style: TCachedLabelStyle; uses: number }>

Const superScript_map

superScript_map: string[] = ["\u2070","\u00B9","\u00B2","\u00B3","\u2074","\u2075","\u2076","\u2077","\u2078","\u2079"]

Let telemetryEnabled

telemetryEnabled: boolean = false

Functions

Const adjustTooltipPosition

  • Relocate the tooltip so that it is always within the seriesViewRect

    Parameters

    Returns void

Const adjustTooltipPosition3D

  • Relocate the tooltip so that it is always within the seriesViewRect

    Parameters

    Returns void

animateAny

  • animateAny<T>(durationMs: number, from: T, to: T, onAnimate: (intermediateValue: T) => void, interpolate: (start: T, end: T, interpolationFactor: number) => T, onCompleted: () => void, easingFn: TEasingFn): AnimationToken
  • deprecated

    Instead create an GenericAnimation and pass it to sciChartSurface.addAnimation

    Type parameters

    • T

    Parameters

    • durationMs: number
    • from: T
    • to: T
    • onAnimate: (intermediateValue: T) => void
        • (intermediateValue: T): void
        • Parameters

          • intermediateValue: T

          Returns void

    • interpolate: (start: T, end: T, interpolationFactor: number) => T
        • (start: T, end: T, interpolationFactor: number): T
        • Parameters

          • start: T
          • end: T
          • interpolationFactor: number

          Returns T

    • onCompleted: () => void
        • (): void
        • Returns void

    • easingFn: TEasingFn

    Returns AnimationToken

Const animationUpdate

appendRangeFifo

  • appendRangeFifo(source: any[], target: any[], fifoCapacity: number, startIndex: number): appendRangeFifo
  • Helper function to append an array to a target array, treating the target as a circular buffer

    Parameters

    • source: any[]
    • target: any[]
    • fifoCapacity: number
    • startIndex: number

    Returns appendRangeFifo

applyOpacityToHtmlColor

  • Applies the given opacity to an html color code or name, returning an html color code.

    Parameters

    • color: string
    • opacity: number

    Returns applyOpacityToHtmlColor

Const areArraysEqual

  • areArraysEqual(leftArray: number[], rightArray: number[]): boolean
  • Parameters

    • leftArray: number[]
    • rightArray: number[]

    Returns boolean

arrayRemove

  • arrayRemove<T>(array: T[], item: T): T[]
  • Type parameters

    • T

    Parameters

    • array: T[]
    • item: T

    Returns T[]

Const base64Id

  • base64Id(maxLength?: number): string
  • Generate random base64 id string. The default length is 22 which is 132-bits so almost the same as a GUID but as base64

    Parameters

    • Default value maxLength: number = 22

      Optional value to specify the length of the id to be generated, defaults to 22

    Returns string

Const build2DChart

  • build2DChart(divElementId: string | HTMLDivElement, definition: ISciChart2DDefinition | string): Promise<{ sciChartSurface: SciChartSurface; wasmContext: { CategoryCoordinateCalculatorDouble: {}; DoubleRange: {} & {}; DoubleVector: {}; FlippedCategoryCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorSingle: {}; FlippedLogarithmicCoordinateCalculator: {}; FloatVector: {}; IntVector: {}; LinearCoordinateCalculatorDouble: {}; LinearCoordinateCalculatorSingle: {}; LogarithmicCoordinateCalculator: {}; NiceDoubleScale: { CalculateTickSpacing: (min: number, max: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; NiceNum: (range: number, round: boolean) => number }; NiceLogScale: { CalculateLowPrecisionTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; CalculateTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange }; NumberUtil: { Constrain: (value: number, lowerBound: number, upperBound: number) => number; FindIndex: (inputValues: SCRTDoubleVector, value: number, searchMode: SCRTFindIndexSearchMode, dataIsSortedAscending: boolean) => number; IsDivisibleBy: (value: number, divisor: number) => boolean; IsPowerOf: (value: number, power: number, logBase: number) => boolean; LinearInterpolateI: (from: number, to: number, ratio: number) => number; Log: (value: number, logBase: number) => number; MinMax: (inputValues: SCRTDoubleVector) => DoubleRange; MinMaxWithIndex: (inputValues: SCRTDoubleVector, startIndex: number, count: number) => DoubleRange; RoundDown: (value: number, nearest: number) => number; RoundDownPower: (value: number, power: number, logBase: number) => number; RoundToDigits: (value: number, decimals: number) => number; RoundUp: (value: number, nearest: number) => number; RoundUpPower: (value: number, power: number, logBase: number) => number }; ResamplingArgs: {}; ResamplingData: { CategoryData: ResamplingData; LinearData: ResamplingData; UnevenlySpacedData: ResamplingData; UnsortedData: ResamplingData }; ResamplingMode: { Auto: ResamplingMode; Max: ResamplingMode; Mid: ResamplingMode; Min: ResamplingMode; MinMax: ResamplingMode; MinOrMax: ResamplingMode; None: ResamplingMode }; SCRTAnimationHelperFade: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperScale: (yValues: SCRTDoubleVector, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperSweep: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperWave: (yValues: SCRTDoubleVector, durationFraction: number, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTBandDrawingParams: {}; SCRTBandSeriesDrawingProvider: {}; SCRTBrush: {}; SCRTBubbleSeriesDrawingProvider: {}; SCRTCandleType: { CandleStick: SCRTCandleType; OHLC: SCRTCandleType }; SCRTCandlestickSeriesDrawingProvider: {}; SCRTColorVertex: {} & {}; SCRTColumnDrawingParams: {}; SCRTColumnSeriesDrawingProvider: {}; SCRTColumnVertex: {}; SCRTContourParams: {}; SCRTCopyToDestinationInterface: { implement: (wrapper: SCRTCopyToDestinationInterfaceWrapper) => SCRTCopyToDestinationInterface }; SCRTCreateBitmapTexture: (width: number, height: number, textureFormat: eTSRTextureFormat) => TSRTexture; SCRTCreateDahedPen: (color: number, thickness: number, antialiased: boolean, dashPattern: FloatVector) => SCRTPen; SCRTCreatePalette: (colors: IntVector) => SCRTPalette; SCRTCredentials: { ApplyLicenseResponse: (response: string) => number; Dump: () => string; GetAllowDebugging: () => boolean; GetBuildStamp: () => string; GetDeveloperCount: () => number; GetEncrypted: (stringToEncrypt: string) => string; GetEncryptedOrderId: () => string; GetExpiryDate: () => string; GetLicenseChallenge: () => string; GetLicenseDaysRemaining: () => number; GetLicenseErrors: () => string; GetLicenseType: () => SCRTLicenseType; GetOrderId: () => string; GetProductCode: () => string; HasFeature: (feature: string) => SCRTLicenseType; Hash256Encode64: (stringToHash: string) => string; RequiresValidation: () => boolean; ResetRuntimeLicense: () => void; SetRuntimeLicenseKeyW: (licenseKey: string) => boolean }; SCRTDoLeakCheck: () => void; SCRTDoubleArrayOperations: {}; SCRTDoubleArraysXyResampleOutput: {}; SCRTDoubleResampler: {}; SCRTDoubleResamplerMergeIndicesParams: {}; SCRTDoubleVector: {} & {}; SCRTFifoVector: {}; SCRTFileLoadCallbackInterface: { implement: (wrapper: SCRTFileLoadCallbackInterfaceWrapper) => SCRTFileLoadCallbackInterface }; SCRTFillTextureAbgr: (texture: TSRTexture, width: number, height: number, pixels: IntVector) => void; SCRTFillTextureFloat32: (texture: TSRTexture, width: number, height: number, pixels: SCRTFloatVector) => TSRVector4; SCRTFillVectorSequential: (SCRTFillVectorSequential: SCRTDoubleVector, count: number) => void; SCRTFindIndexSearchMode: { Exact: SCRTFindIndexSearchMode; Nearest: SCRTFindIndexSearchMode; RoundDown: SCRTFindIndexSearchMode; RoundUp: SCRTFindIndexSearchMode }; SCRTFloatVector: {}; SCRTFontKey: {}; SCRTFrameRenderer2D: {}; SCRTGetGlobalSampleChartInterface: () => SCRTSampleChartInterface; SCRTGetMainRenderContext2D: () => SCRTRenderContext; SCRTGetScreenHeight: () => number; SCRTGetScreenWidth: () => number; SCRTGlowEffect: {}; SCRTHeatmapDrawingParams: {}; SCRTHeatmapSeriesDrawingProvider: {}; SCRTHitTestHelper: { GetNearestXyPoint: (xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, isSorted: boolean, xHitCoord: number, yHitCoord: number, hitTestRadius: number) => DoubleRange }; SCRTInitEngine2D: () => void; SCRTLicenseType: { LICENSE_TYPE_COMMUNITY: SCRTLicenseType; LICENSE_TYPE_FULL: SCRTLicenseType; LICENSE_TYPE_FULL_EXPIRED: SCRTLicenseType; LICENSE_TYPE_INVALID_DEVELOPER_LICENSE: SCRTLicenseType; LICENSE_TYPE_INVALID_LICENSE: SCRTLicenseType; LICENSE_TYPE_NO_LICENSE: SCRTLicenseType; LICENSE_TYPE_REQUIRES_VALIDATION: SCRTLicenseType; LICENSE_TYPE_SUBSCRIPTION_EXPIRED: SCRTLicenseType; LICENSE_TYPE_TRIAL: SCRTLicenseType; LICENSE_TYPE_TRIAL_EXPIRED: SCRTLicenseType }; SCRTLineDrawingParams: {}; SCRTLineGapMode: { CloseGaps: SCRTLineGapMode; Default: SCRTLineGapMode; DrawGaps: SCRTLineGapMode }; SCRTLineSeriesDrawingProvider: {}; SCRTLineType: { Digital: SCRTLineType; List: SCRTLineType; Nan: SCRTLineType; Strip: SCRTLineType }; SCRTMemCopy: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMemMove: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMountainDrawingParams: {}; SCRTMountainSeriesDrawingProvider: {}; SCRTMultiplyColorVectorOpacity: (originalVector: IntVector, resultVector: IntVector, factor: number) => void; SCRTOhlcDrawingParams: {}; SCRTPalette: {} & { GetNoOverrideColorCode: () => number }; SCRTPen: {}; SCRTPointDrawingParams: {}; SCRTRectVertex: {} & {}; SCRTRegisterFile: (fileName: string, url: string, callback: SCRTFileLoadCallbackInterface) => void; SCRTSampleChartInterface: { implement: (wrapper: SCRTSampleChartInterfaceWrapper) => SCRTSampleChartInterface }; SCRTScatterSeriesDrawingProvider: {}; SCRTSeriesEffectType: { Glow: SCRTSeriesEffectType }; SCRTSetActiveDoubleVector: (SCRTSetActiveDoubleVector: SCRTDoubleVector, doubleVector: number) => void; SCRTSetActiveTexture: (texture: TSRTexture) => void; SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void; SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void; SCRTSetGlobalSampleChartInterface: (param0: SCRTSampleChartInterface) => void; SCRTSetMainWindowSize: (width: number, height: number) => void; SCRTSetTextureLinearSamplerEnabled: (texture: TSRTexture, enabled: boolean) => void; SCRTSetWaterMarkProperties: (properties: SCRTWaterMarkProperties) => void; SCRTShadowEffect: {}; SCRTShutdownEngine2D: () => void; SCRTSolidBrush: {}; SCRTSplineHelperCubicSpline: (xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xsValues: SCRTDoubleVector, ysValues: SCRTDoubleVector, initialSize: number, interpolationPoints: number, containsNAN: boolean) => void; SCRTSpriteType: { FixedSize: SCRTSpriteType; Normal: SCRTSpriteType }; SCRTStackedColumnDrawingParams: {}; SCRTStackedColumnSeriesDrawingProvider: {}; SCRTSurfaceDestination: { implement: (wrapper: SCRTSurfaceDestinationWrapper) => SCRTSurfaceDestination }; SCRTTextureBrush: {}; SCRTWaterMarkProperties: {}; SCRTXvaluesProvider: {}; StringVector: {}; TSRCamera: {}; TSRRequestCanvasDraw: (canvasID: string) => void; TSRRequestDraw: () => void; TSRRequestExit: () => void; TSRSetDrawRequestsEnabled: (enabled: boolean) => void; TSRTextBounds: {}; TSRTextLineBounds: {}; TSRVector2: {} & {}; TSRVector3: {} & {}; TSRVector4: {} & {}; UIntVector: {}; VectorColorVertex: {}; VectorColumnVertex: {}; VectorRectVertex: {}; WStringVector: {}; canvas: HTMLCanvasElement; canvas2D: HTMLCanvasElement; eSCRTBlendMode: { BlendAdditiveAlpha: eSCRTBlendMode; BlendAdditiveColor: eSCRTBlendMode; BlendAdditiveOneAlpha: eSCRTBlendMode; BlendDefault: eSCRTBlendMode; BlendDisabled: eSCRTBlendMode }; eSCRTBrushMappingMode: { PerPrimitive: eSCRTBrushMappingMode; PerScreen: eSCRTBrushMappingMode }; eTSRCameraProjectionMode: { CAMERA_PROJECTIONMODE_ORTHOGONAL: eTSRCameraProjectionMode; CAMERA_PROJECTIONMODE_PERSPECTIVE: eTSRCameraProjectionMode }; eTSRMetaDataType: { BitFlags: eTSRMetaDataType; Core: eTSRMetaDataType; Defined: eTSRMetaDataType; DynamicDefined: eTSRMetaDataType; Enum: eTSRMetaDataType; Unknown: eTSRMetaDataType }; eTSRPlatform: { Android: eTSRPlatform; Linux: eTSRPlatform; Mac: eTSRPlatform; Web: eTSRPlatform; Windows: eTSRPlatform; iOS: eTSRPlatform }; eTSRRendererType: { TSR_RENDERER_TYPE_D3D11: eTSRRendererType; TSR_RENDERER_TYPE_D3D11_LEVEL10: eTSRRendererType; TSR_RENDERER_TYPE_D3D12: eTSRRendererType; TSR_RENDERER_TYPE_D3D9: eTSRRendererType; TSR_RENDERER_TYPE_GL: eTSRRendererType; TSR_RENDERER_TYPE_GLES2: eTSRRendererType; TSR_RENDERER_TYPE_GLES3: eTSRRendererType; TSR_RENDERER_TYPE_METAL: eTSRRendererType; TSR_RENDERER_TYPE_UNDEFINED: eTSRRendererType; TSR_RENDERER_TYPE_VULKAN: eTSRRendererType }; eTSRTextAlignMode: { Center: eTSRTextAlignMode; Left: eTSRTextAlignMode; Right: eTSRTextAlignMode }; eTSRTextureFormat: { TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat; TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat }; eVariableUsage: { Array: eVariableUsage; Blob: eVariableUsage; DynamicArray: eVariableUsage; Normal: eVariableUsage; Pointer: eVariableUsage; Vector: eVariableUsage; VectorOfPointers: eVariableUsage } } }>
  • Construct a chart with SciChartSurface using a ISciChart2DDefinition which can be pure data.

    remarks

    This method is async and must be awaited

    Parameters

    Returns Promise<{ sciChartSurface: SciChartSurface; wasmContext: { CategoryCoordinateCalculatorDouble: {}; DoubleRange: {} & {}; DoubleVector: {}; FlippedCategoryCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorSingle: {}; FlippedLogarithmicCoordinateCalculator: {}; FloatVector: {}; IntVector: {}; LinearCoordinateCalculatorDouble: {}; LinearCoordinateCalculatorSingle: {}; LogarithmicCoordinateCalculator: {}; NiceDoubleScale: { CalculateTickSpacing: (min: number, max: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; NiceNum: (range: number, round: boolean) => number }; NiceLogScale: { CalculateLowPrecisionTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; CalculateTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange }; NumberUtil: { Constrain: (value: number, lowerBound: number, upperBound: number) => number; FindIndex: (inputValues: SCRTDoubleVector, value: number, searchMode: SCRTFindIndexSearchMode, dataIsSortedAscending: boolean) => number; IsDivisibleBy: (value: number, divisor: number) => boolean; IsPowerOf: (value: number, power: number, logBase: number) => boolean; LinearInterpolateI: (from: number, to: number, ratio: number) => number; Log: (value: number, logBase: number) => number; MinMax: (inputValues: SCRTDoubleVector) => DoubleRange; MinMaxWithIndex: (inputValues: SCRTDoubleVector, startIndex: number, count: number) => DoubleRange; RoundDown: (value: number, nearest: number) => number; RoundDownPower: (value: number, power: number, logBase: number) => number; RoundToDigits: (value: number, decimals: number) => number; RoundUp: (value: number, nearest: number) => number; RoundUpPower: (value: number, power: number, logBase: number) => number }; ResamplingArgs: {}; ResamplingData: { CategoryData: ResamplingData; LinearData: ResamplingData; UnevenlySpacedData: ResamplingData; UnsortedData: ResamplingData }; ResamplingMode: { Auto: ResamplingMode; Max: ResamplingMode; Mid: ResamplingMode; Min: ResamplingMode; MinMax: ResamplingMode; MinOrMax: ResamplingMode; None: ResamplingMode }; SCRTAnimationHelperFade: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperScale: (yValues: SCRTDoubleVector, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperSweep: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperWave: (yValues: SCRTDoubleVector, durationFraction: number, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTBandDrawingParams: {}; SCRTBandSeriesDrawingProvider: {}; SCRTBrush: {}; SCRTBubbleSeriesDrawingProvider: {}; SCRTCandleType: { CandleStick: SCRTCandleType; OHLC: SCRTCandleType }; SCRTCandlestickSeriesDrawingProvider: {}; SCRTColorVertex: {} & {}; SCRTColumnDrawingParams: {}; SCRTColumnSeriesDrawingProvider: {}; SCRTColumnVertex: {}; SCRTContourParams: {}; SCRTCopyToDestinationInterface: { implement: (wrapper: SCRTCopyToDestinationInterfaceWrapper) => SCRTCopyToDestinationInterface }; SCRTCreateBitmapTexture: (width: number, height: number, textureFormat: eTSRTextureFormat) => TSRTexture; SCRTCreateDahedPen: (color: number, thickness: number, antialiased: boolean, dashPattern: FloatVector) => SCRTPen; SCRTCreatePalette: (colors: IntVector) => SCRTPalette; SCRTCredentials: { ApplyLicenseResponse: (response: string) => number; Dump: () => string; GetAllowDebugging: () => boolean; GetBuildStamp: () => string; GetDeveloperCount: () => number; GetEncrypted: (stringToEncrypt: string) => string; GetEncryptedOrderId: () => string; GetExpiryDate: () => string; GetLicenseChallenge: () => string; GetLicenseDaysRemaining: () => number; GetLicenseErrors: () => string; GetLicenseType: () => SCRTLicenseType; GetOrderId: () => string; GetProductCode: () => string; HasFeature: (feature: string) => SCRTLicenseType; Hash256Encode64: (stringToHash: string) => string; RequiresValidation: () => boolean; ResetRuntimeLicense: () => void; SetRuntimeLicenseKeyW: (licenseKey: string) => boolean }; SCRTDoLeakCheck: () => void; SCRTDoubleArrayOperations: {}; SCRTDoubleArraysXyResampleOutput: {}; SCRTDoubleResampler: {}; SCRTDoubleResamplerMergeIndicesParams: {}; SCRTDoubleVector: {} & {}; SCRTFifoVector: {}; SCRTFileLoadCallbackInterface: { implement: (wrapper: SCRTFileLoadCallbackInterfaceWrapper) => SCRTFileLoadCallbackInterface }; SCRTFillTextureAbgr: (texture: TSRTexture, width: number, height: number, pixels: IntVector) => void; SCRTFillTextureFloat32: (texture: TSRTexture, width: number, height: number, pixels: SCRTFloatVector) => TSRVector4; SCRTFillVectorSequential: (SCRTFillVectorSequential: SCRTDoubleVector, count: number) => void; SCRTFindIndexSearchMode: { Exact: SCRTFindIndexSearchMode; Nearest: SCRTFindIndexSearchMode; RoundDown: SCRTFindIndexSearchMode; RoundUp: SCRTFindIndexSearchMode }; SCRTFloatVector: {}; SCRTFontKey: {}; SCRTFrameRenderer2D: {}; SCRTGetGlobalSampleChartInterface: () => SCRTSampleChartInterface; SCRTGetMainRenderContext2D: () => SCRTRenderContext; SCRTGetScreenHeight: () => number; SCRTGetScreenWidth: () => number; SCRTGlowEffect: {}; SCRTHeatmapDrawingParams: {}; SCRTHeatmapSeriesDrawingProvider: {}; SCRTHitTestHelper: { GetNearestXyPoint: (xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, isSorted: boolean, xHitCoord: number, yHitCoord: number, hitTestRadius: number) => DoubleRange }; SCRTInitEngine2D: () => void; SCRTLicenseType: { LICENSE_TYPE_COMMUNITY: SCRTLicenseType; LICENSE_TYPE_FULL: SCRTLicenseType; LICENSE_TYPE_FULL_EXPIRED: SCRTLicenseType; LICENSE_TYPE_INVALID_DEVELOPER_LICENSE: SCRTLicenseType; LICENSE_TYPE_INVALID_LICENSE: SCRTLicenseType; LICENSE_TYPE_NO_LICENSE: SCRTLicenseType; LICENSE_TYPE_REQUIRES_VALIDATION: SCRTLicenseType; LICENSE_TYPE_SUBSCRIPTION_EXPIRED: SCRTLicenseType; LICENSE_TYPE_TRIAL: SCRTLicenseType; LICENSE_TYPE_TRIAL_EXPIRED: SCRTLicenseType }; SCRTLineDrawingParams: {}; SCRTLineGapMode: { CloseGaps: SCRTLineGapMode; Default: SCRTLineGapMode; DrawGaps: SCRTLineGapMode }; SCRTLineSeriesDrawingProvider: {}; SCRTLineType: { Digital: SCRTLineType; List: SCRTLineType; Nan: SCRTLineType; Strip: SCRTLineType }; SCRTMemCopy: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMemMove: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMountainDrawingParams: {}; SCRTMountainSeriesDrawingProvider: {}; SCRTMultiplyColorVectorOpacity: (originalVector: IntVector, resultVector: IntVector, factor: number) => void; SCRTOhlcDrawingParams: {}; SCRTPalette: {} & { GetNoOverrideColorCode: () => number }; SCRTPen: {}; SCRTPointDrawingParams: {}; SCRTRectVertex: {} & {}; SCRTRegisterFile: (fileName: string, url: string, callback: SCRTFileLoadCallbackInterface) => void; SCRTSampleChartInterface: { implement: (wrapper: SCRTSampleChartInterfaceWrapper) => SCRTSampleChartInterface }; SCRTScatterSeriesDrawingProvider: {}; SCRTSeriesEffectType: { Glow: SCRTSeriesEffectType }; SCRTSetActiveDoubleVector: (SCRTSetActiveDoubleVector: SCRTDoubleVector, doubleVector: number) => void; SCRTSetActiveTexture: (texture: TSRTexture) => void; SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void; SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void; SCRTSetGlobalSampleChartInterface: (param0: SCRTSampleChartInterface) => void; SCRTSetMainWindowSize: (width: number, height: number) => void; SCRTSetTextureLinearSamplerEnabled: (texture: TSRTexture, enabled: boolean) => void; SCRTSetWaterMarkProperties: (properties: SCRTWaterMarkProperties) => void; SCRTShadowEffect: {}; SCRTShutdownEngine2D: () => void; SCRTSolidBrush: {}; SCRTSplineHelperCubicSpline: (xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xsValues: SCRTDoubleVector, ysValues: SCRTDoubleVector, initialSize: number, interpolationPoints: number, containsNAN: boolean) => void; SCRTSpriteType: { FixedSize: SCRTSpriteType; Normal: SCRTSpriteType }; SCRTStackedColumnDrawingParams: {}; SCRTStackedColumnSeriesDrawingProvider: {}; SCRTSurfaceDestination: { implement: (wrapper: SCRTSurfaceDestinationWrapper) => SCRTSurfaceDestination }; SCRTTextureBrush: {}; SCRTWaterMarkProperties: {}; SCRTXvaluesProvider: {}; StringVector: {}; TSRCamera: {}; TSRRequestCanvasDraw: (canvasID: string) => void; TSRRequestDraw: () => void; TSRRequestExit: () => void; TSRSetDrawRequestsEnabled: (enabled: boolean) => void; TSRTextBounds: {}; TSRTextLineBounds: {}; TSRVector2: {} & {}; TSRVector3: {} & {}; TSRVector4: {} & {}; UIntVector: {}; VectorColorVertex: {}; VectorColumnVertex: {}; VectorRectVertex: {}; WStringVector: {}; canvas: HTMLCanvasElement; canvas2D: HTMLCanvasElement; eSCRTBlendMode: { BlendAdditiveAlpha: eSCRTBlendMode; BlendAdditiveColor: eSCRTBlendMode; BlendAdditiveOneAlpha: eSCRTBlendMode; BlendDefault: eSCRTBlendMode; BlendDisabled: eSCRTBlendMode }; eSCRTBrushMappingMode: { PerPrimitive: eSCRTBrushMappingMode; PerScreen: eSCRTBrushMappingMode }; eTSRCameraProjectionMode: { CAMERA_PROJECTIONMODE_ORTHOGONAL: eTSRCameraProjectionMode; CAMERA_PROJECTIONMODE_PERSPECTIVE: eTSRCameraProjectionMode }; eTSRMetaDataType: { BitFlags: eTSRMetaDataType; Core: eTSRMetaDataType; Defined: eTSRMetaDataType; DynamicDefined: eTSRMetaDataType; Enum: eTSRMetaDataType; Unknown: eTSRMetaDataType }; eTSRPlatform: { Android: eTSRPlatform; Linux: eTSRPlatform; Mac: eTSRPlatform; Web: eTSRPlatform; Windows: eTSRPlatform; iOS: eTSRPlatform }; eTSRRendererType: { TSR_RENDERER_TYPE_D3D11: eTSRRendererType; TSR_RENDERER_TYPE_D3D11_LEVEL10: eTSRRendererType; TSR_RENDERER_TYPE_D3D12: eTSRRendererType; TSR_RENDERER_TYPE_D3D9: eTSRRendererType; TSR_RENDERER_TYPE_GL: eTSRRendererType; TSR_RENDERER_TYPE_GLES2: eTSRRendererType; TSR_RENDERER_TYPE_GLES3: eTSRRendererType; TSR_RENDERER_TYPE_METAL: eTSRRendererType; TSR_RENDERER_TYPE_UNDEFINED: eTSRRendererType; TSR_RENDERER_TYPE_VULKAN: eTSRRendererType }; eTSRTextAlignMode: { Center: eTSRTextAlignMode; Left: eTSRTextAlignMode; Right: eTSRTextAlignMode }; eTSRTextureFormat: { TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat; TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat }; eVariableUsage: { Array: eVariableUsage; Blob: eVariableUsage; DynamicArray: eVariableUsage; Normal: eVariableUsage; Pointer: eVariableUsage; Vector: eVariableUsage; VectorOfPointers: eVariableUsage } } }>

Const buildAnnotations

Const buildAxes

Const buildAxis

Const buildChart

  • Builds an entire chart from a definition that can be pure data.

    Parameters

    • divElementId: string | HTMLDivElement

      The Div Element ID where the SciChartSurface will reside

    • definition: string | TSurfaceDefinition

      a or a string which will be parsed to it.

    Returns Promise<TWebAssemblyChart | SciChartPieSurface>

Const buildDataSeries

Const buildFilter

Const buildModifier

Const buildModifiers

Const buildPieChart

Const buildSeries

Const calcAnnotationBordersForAxisMarker

  • calcAnnotationBordersForAxisMarker(isVerticalChart: boolean, x1: number, y1: number, horizontalAxis: AxisBase2D, verticalAxis: AxisBase2D, textureWidth: number, viewRect: Rect, xPosition: number, yPosition: number, textureHeight: number, annotationMarginXDirection: number, annotationMarginYDirection: number, isHorizontalAxisAlignmentReversed: boolean, isVerticalAxisAlignmentReversed: boolean): { x1: number; x2: number; y1: number; y2: number }
  • Calculates annotation borders for AxisMarkerAnnotation

    Parameters

    • isVerticalChart: boolean

      the vertical chart flag

    • x1: number

      the X1 data value of the annotation

    • y1: number

      the Y1 data value of the annotation

    • horizontalAxis: AxisBase2D

      the horizontal axis

    • verticalAxis: AxisBase2D

      the vertical axis

    • textureWidth: number

      the texture width

    • viewRect: Rect

      the seriesViewRect

    • xPosition: number

      the X position of the texture on the SciChartSurface, the left-top corner position on the canvas

    • yPosition: number

      the Y position of the texture on the SciChartSurface, the left-top corner position on the canvas

    • textureHeight: number

      the texture width

    • annotationMarginXDirection: number

      the texture margin in X direction

    • annotationMarginYDirection: number

      the texture margin in Y direction

    • isHorizontalAxisAlignmentReversed: boolean

      if true EAxisAlignment.Top, otherwise EAxisAlignment.Bottom

    • isVerticalAxisAlignmentReversed: boolean

      if true EAxisAlignment.Left, otherwise EAxisAlignment.Right

    Returns { x1: number; x2: number; y1: number; y2: number }

    • x1: number
    • x2: number
    • y1: number
    • y2: number

Const calcAverageForArray

  • calcAverageForArray(ar: number[], averageNum: number, index?: number): number
  • Parameters

    • ar: number[]
    • averageNum: number
    • Optional index: number

    Returns number

Const calcAverageForDoubleVector

  • calcAverageForDoubleVector(doubleVector: SCRTDoubleVector, averageNum: number, index?: number): number
  • description

    Calculates average for DoubleVector

    Parameters

    • doubleVector: SCRTDoubleVector
    • averageNum: number

      number of values to respect for the average

    • Optional index: number

      index of the latest value to include, by default equals to length-1 of DoubleVector

    Returns number

Const calcCrossProduct

  • calcCrossProduct(xA: number, yA: number, xB: number, yB: number, xC: number, yC: number): number
  • Parameters

    • xA: number
    • yA: number
    • xB: number
    • yB: number
    • xC: number
    • yC: number

    Returns number

Const calcDistance

  • calcDistance(x1: number, y1: number, x2: number, y2: number): number
  • Parameters

    • x1: number
    • y1: number
    • x2: number
    • y2: number

    Returns number

Const calcDistanceFromLine

  • calcDistanceFromLine(x: number, y: number, startX: number, startY: number, endX: number, endY: number): number
  • Parameters

    • x: number
    • y: number
    • startX: number
    • startY: number
    • endX: number
    • endY: number

    Returns number

Const calcDistanceFromLineSegment

  • calcDistanceFromLineSegment(x: number, y: number, startX: number, startY: number, endX: number, endY: number): number
  • Parameters

    • x: number
    • y: number
    • startX: number
    • startY: number
    • endX: number
    • endY: number

    Returns number

Const calcDotProduct

  • calcDotProduct(v1x: number, v1y: number, v2x: number, v2y: number, v3x: number, v3y: number): number
  • Parameters

    • v1x: number
    • v1y: number
    • v2x: number
    • v2y: number
    • v3x: number
    • v3y: number

    Returns number

Const calcNewApex

  • calcNewApex(x1: number, y1: number, x2: number, y2: number, isVertical: boolean): { x1y1: { x: number; y: number }; x1y2: { x: number; y: number }; x2y1: { x: number; y: number }; x2y2: { x: number; y: number } }
  • Parameters

    • x1: number
    • y1: number
    • x2: number
    • y2: number
    • isVertical: boolean

    Returns { x1y1: { x: number; y: number }; x1y2: { x: number; y: number }; x2y1: { x: number; y: number }; x2y2: { x: number; y: number } }

    • x1y1: { x: number; y: number }
      • x: number
      • y: number
    • x1y2: { x: number; y: number }
      • x: number
      • y: number
    • x2y1: { x: number; y: number }
      • x: number
      • y: number
    • x2y2: { x: number; y: number }
      • x: number
      • y: number

Const calcTooltipSize

  • calcTooltipSize(valuesWithLabels: string[], fontSize?: number): { height: number; width: number }
  • Calculate the width and height of the tooltip based on the content array

    Parameters

    • valuesWithLabels: string[]
    • Default value fontSize: number = 13

    Returns { height: number; width: number }

    • height: number
    • width: number

Const calculateAbsoluteRenderLayer

  • calculateAbsoluteRenderLayer(offset: number, step: number, relativeRenderLayer: EDefaultRenderLayer): number
  • Parameters

    • offset: number

      layer z-order offset of the surface

    • step: number

      specifies the capacity of layers that could be potentially added between the default chart layers

    • relativeRenderLayer: EDefaultRenderLayer

      layer number relative to the specific surface layers

    Returns number

    absolute order of the layer on the chart (considering parent chart and previous subChart surface layers)

Const calculateCellCoordinates

  • calculateCellCoordinates(inputArr: number[], dimension: number, startInd: number, count: number, inc: number, offset: number): any[]
  • Calculates absolute coordinates of the heatmap cells

    Parameters

    • inputArr: number[]

      relative cell sizes

    • dimension: number

      texture size

    • startInd: number
    • count: number
    • inc: number
    • offset: number

    Returns any[]

Const calculateHeatmapTexture

  • calculateHeatmapTexture(colorDataParams: IGetColorDataParams, intVector: UIntVector, heatTextureCache: TextureCache, precision: number): TSRTexture
  • Parameters

    • colorDataParams: IGetColorDataParams
    • intVector: UIntVector
    • heatTextureCache: TextureCache
    • precision: number

    Returns TSRTexture

Const calculateMaxGroupSize

  • calculateMaxGroupSize(outerLayoutSizes: Record<string, number>): number
  • Parameters

    • outerLayoutSizes: Record<string, number>

    Returns number

Const calculateOffsets

  • calculateOffsets(heatmapRect: Rect, isVerticalChart: boolean, xCellSizes: number[], yCellSizes: number[], horStartInd: number, horCellCount: number, horInc: number, vertStartInd: number, vertCellCount: number, vertInc: number, seriesViewRect: Rect): { horCellOffsets: any[]; vertCellOffsets: any[] }
  • Parameters

    • heatmapRect: Rect
    • isVerticalChart: boolean
    • xCellSizes: number[]
    • yCellSizes: number[]
    • horStartInd: number
    • horCellCount: number
    • horInc: number
    • vertStartInd: number
    • vertCellCount: number
    • vertInc: number
    • seriesViewRect: Rect

    Returns { horCellOffsets: any[]; vertCellOffsets: any[] }

    • horCellOffsets: any[]
    • vertCellOffsets: any[]

chartReviver

  • The reviver function needed when parsing definitions to JSON

    Parameters

    • key: string
    • value: any

    Returns chartReviver

Const checkAreEqualTextStyles

Const checkBuildStamp

Const checkCanDraw

  • Checks if can draw, is used not to draw when {@link BaseAnimation} has delay

    Parameters

    Returns boolean

Const checkIsAnimationRunning

  • Checks if the animation is running

    Parameters

    Returns boolean

Const checkIsNaN

  • checkIsNaN(value: number): boolean
  • Parameters

    • value: number

    Returns boolean

Const checkLocalStorageIsUndefined

  • checkLocalStorageIsUndefined(): boolean
  • Returns boolean

Const checkStyle

  • Parameters

    Returns boolean

Const checkTextStyleEqual

Const clearCacheByStyle

  • clearCacheByStyle(styleId: string): void
  • Parameters

    • styleId: string

    Returns void

clearLicensingDebug

configure2DSurface

Const configureChart

  • Configures an existing surface using a definition. This is useful if you need to use the wasmContext in methods or classes you use in your definition

    Parameters

    Returns void

Const convertColor

  • convertColor(htmlColor: string, opacity?: number): string
  • Parameters

    • htmlColor: string
    • Default value opacity: number = 1

    Returns string

    rgbColor, for example "0xff00ff00" - green

Const convertLabelAlignmentToTextAlignment

Const convertMultiLineAlignment

  • Parameters

    Returns eTSRTextAlignMode

  • Parameters

    Returns eTSRTextAlignMode

Const convertRgbToHexColor

  • convertRgbToHexColor(r: number, g: number, b: number): string
  • Converts individual R,G, and B components to HEX Color

    Parameters

    • r: number
    • g: number
    • b: number

    Returns string

    argbColor, for example "0xff00ff00" - green

Const convertSearchMode

  • Converts ESearchMode (typescript friendly Enum) to SCRTFindIndexSearchMode which is required by the webassembly engine

    Parameters

    Returns SCRTFindIndexSearchMode

Const convertToHtmlPx

  • convertToHtmlPx(value: number): string
  • Parameters

    • value: number

    Returns string

Const convertToPixel

  • convertToPixel(red: number, green: number, blue: number, opacity: number): number
  • Parameters

    • red: number

      number value from 0 to 255

    • green: number

      number value from 0 to 255

    • blue: number

      number value from 0 to 255

    • opacity: number

      number value from 0 to 255

    Returns number

    pixel in hex format: opacity, red, green, blue. For example: "0xff0000ff" - blue pixel with no opacity

Const convertToRelativeHtmlSize

  • convertToRelativeHtmlSize(value: number): string
  • Parameters

    • value: number

    Returns string

Const copyDoubleVector

  • copyDoubleVector(source: SCRTDoubleVector, target: SCRTDoubleVector, wasmContext: TSciChart): void
  • Parameters

    • source: SCRTDoubleVector
    • target: SCRTDoubleVector
    • wasmContext: TSciChart

    Returns void

Const copyVector

  • copyVector(sourceVector: SCRTDoubleVector, targetVector: SCRTDoubleVector): void
  • Parameters

    • sourceVector: SCRTDoubleVector
    • targetVector: SCRTDoubleVector

    Returns void

countUnique

  • Parameters

    • iterable: string[]

    Returns countUnique

Const createBrushInCache

  • createBrushInCache(cache: BrushCache, fill: string, opacity: number, textureHeightRatio?: number, textureWidthRatio?: number, fillGradientLinear?: GradientParams): SCRTBrush
  • Creates a native {@link SCRTBrush} brush from html color code string passed in and caches it

    Parameters

    • cache: BrushCache

      The object that will store a brush

    • fill: string

      The HTML Color code

    • opacity: number

      The opacity factor.

    • Optional textureHeightRatio: number

      The height ratio of the main canvas to the WebGl canvas.

    • Optional textureWidthRatio: number

      The width ratio of the main canvas to the WebGl canvas.

    • Optional fillGradientLinear: GradientParams

      The gradient params.

    Returns SCRTBrush

    new or existing instance of {@link SCRTBrush}}

Const createChartDestination

  • createChartDestination(canvas: HTMLCanvasElement): { canvas: HTMLCanvasElement; GetHeight: any; GetID: any; GetWidth: any }
  • Parameters

    • canvas: HTMLCanvasElement

    Returns { canvas: HTMLCanvasElement; GetHeight: any; GetID: any; GetWidth: any }

    • canvas: HTMLCanvasElement
    • GetHeight: function
      • GetHeight(): any
      • Returns any

    • GetID: function
      • GetID(): any
      • Returns any

    • GetWidth: function
      • GetWidth(): any
      • Returns any

Const createColorMap

  • createColorMap(originalGradientStops: TGradientStop[], precision: number): any[]
  • Parameters

    Returns any[]

Const createDataSeries

Const createHitTestInfo

  • Parameters

    • renderableSeries: IRenderableSeries
    • xCoordinateCalculator: CoordinateCalculatorBase
    • yCoordinateCalculator: CoordinateCalculatorBase
    • isVerticalChart: boolean
    • dataSeries: BaseDataSeries
    • xNativeValues: SCRTDoubleVector
    • yNativeValues: SCRTDoubleVector
    • xHitCoord: number

      the X coordinate on the screen relative to seriesViewRect, X and Y swapped for vertical charts

    • yHitCoord: number

      the Y coordinate on the screen relative to seriesViewRect, X and Y swapped for vertical charts

    • nearestPointIndex: number
    • hitTestRadius: number
    • Optional distance: number

    Returns HitTestInfo

createImageAsync

  • createImageAsync(src: string): Promise<HTMLImageElement>
  • Helper function to create an HTML Image {@link HTMLImageElement} asychronously by passing in the string image source

    remarks

    Returns a promise, await this to get the image element

    Parameters

    • src: string

    Returns Promise<HTMLImageElement>

createImagesArrayAsync

  • createImagesArrayAsync(images: string[]): Promise<HTMLImageElement[]>
  • Helper function to create an HTML Images {@link HTMLImageElement} asychronously by passing in the string array

    Parameters

    • images: string[]

    Returns Promise<HTMLImageElement[]>

Const createNativeRect

  • createNativeRect(webAssemblyContext: TSciChart, xTopLeft: number, yTopLeft: number, xBottomRight: number, yBottomRight: number): SCRTRectVertex
  • Helper function to create a {@link SCRTRectVertex} native rectangle vertex

    Parameters

    • webAssemblyContext: TSciChart

      The SciChart 2D WebAssembly Context containing native methods and access to our WebGL2 Engine and WebAssembly numerical methods

    • xTopLeft: number
    • yTopLeft: number
    • xBottomRight: number
    • yBottomRight: number

    Returns SCRTRectVertex

Const createPenInCache

  • createPenInCache(penCache: Pen2DCache, stroke: string, strokeThickness: number, opacity: number, strokeDashArray?: number[], antiAliased?: boolean): SCRTPen
  • Creates a native {@link SCRTPen} Pen from html color code string passed in and caches it

    Parameters

    • penCache: Pen2DCache

      The object that will store a pen

    • stroke: string

      The HTML Color code

    • strokeThickness: number

      The strokethickness in pixels

    • opacity: number

      The opacity factor

    • Optional strokeDashArray: number[]

      the StrokeDashArray which defines any dash e.g. [2,2] means dash for 2pts, gap for 2pts (or undefined = solid line).

    • Optional antiAliased: boolean

    Returns SCRTPen

    the new or existing instance of {@link SCRTPen}}

Const createPointMarker

Const createSCRTPen

  • createSCRTPen(wasmContext: TSciChart, htmlColorCode: string, strokeThickness: number, opacity: number, strokeDashArray?: number[], antiAliased?: boolean): SCRTPen
  • Helper function to create a {@link SCRTPen} native pen access to our WebGL2 Engine and WebAssembly numerical methods

    Parameters

    • wasmContext: TSciChart

      The SciChart WebAssembly Context containing native methods and access to our WebGL2 WebAssembly Drawing Engine

    • htmlColorCode: string

      Html color code in the format "#fff", "#ff0000", "rgba(255,255,0,1)", "#11333333"

    • strokeThickness: number

      the stroke thickness of the pen in pixels

    • opacity: number

      The opacity factor

    • Optional strokeDashArray: number[]

      the StrokeDashArray which defines any dash e.g. [2,2] means dash for 2pts, gap for 2pts (or undefined = solid line).

    • Default value antiAliased: boolean = true

    Returns SCRTPen

Const createSingle3dInternal

Const createSolidBrush

  • createSolidBrush(wasmContext: TSciChart, htmlColorCode: string, opacity: number): SCRTBrush
  • Helper function to create a {@link SCRTBrush} native solid color brushes

    Parameters

    • wasmContext: TSciChart
    • htmlColorCode: string

      Html color code in the format "#fff", "#ff0000", "rgba(255,255,0,1)", "#11333333"

    • opacity: number

    Returns SCRTBrush

Const createSvg

  • createSvg(svgString: string, svgRoot: Node): SVGElement
  • All svg creation is run through this funciton so it can be mocked for tests

    Parameters

    • svgString: string
    • svgRoot: Node

    Returns SVGElement

Const createType

  • Parameters

    Returns any

Const deleteCache

  • Parameters

    Returns void

deleteSafe

  • deleteSafe<T>(object: T): T

Const drawAxisMarkerAnnotation

  • drawAxisMarkerAnnotation(currentAxis: AxisBase2D, renderContext: WebGlRenderContext2D, displayValue: string, markerCoordinate: number, x1Coord: number, y1Coord: number, textStyle: TTextStyle, fill: string, opacity: number, image: HTMLImageElement, imageWidth: number, imageHeight: number): { textureHeight: number; textureWidth: number; xPosition: number; yPosition: number }
  • Parameters

    • currentAxis: AxisBase2D
    • renderContext: WebGlRenderContext2D
    • displayValue: string
    • markerCoordinate: number
    • x1Coord: number
    • y1Coord: number
    • textStyle: TTextStyle
    • fill: string
    • opacity: number
    • image: HTMLImageElement
    • imageWidth: number
    • imageHeight: number

    Returns { textureHeight: number; textureWidth: number; xPosition: number; yPosition: number }

    • textureHeight: number
    • textureWidth: number
    • xPosition: number
    • yPosition: number

Const drawBorder

  • drawBorder(renderContext: WebGlRenderContext2D, webAssemblyContext2D: TSciChart, solidBrushCacheBorder: SolidBrushCache, borderRect: Rect, leftBorder: number, topBorder: number, rightBorder: number, bottomBorder: number, color: string): void
  • Parameters

    • renderContext: WebGlRenderContext2D
    • webAssemblyContext2D: TSciChart
    • solidBrushCacheBorder: SolidBrushCache
    • borderRect: Rect
    • leftBorder: number
    • topBorder: number
    • rightBorder: number
    • bottomBorder: number
    • color: string

    Returns void

Const drawLineAnnotation

Const drawModifiersAxisLabel

  • Parameters

    Returns Rect

Const ensureRegistrations

  • ensureRegistrations(): void
  • This is just something to call to ensure that all the registrations are run before a surface is created

    Returns void

Const fillMetadata

  • Parameters

    Returns IPointMetadata[][]

Const fillNoisySinewave

  • fillNoisySinewave(pointCount: number, xMax: number, frequency: number, amplitude: number, noiseAmplitude: number, dataSeries: XyDataSeries): void
  • Parameters

    • pointCount: number
    • xMax: number
    • frequency: number
    • amplitude: number
    • noiseAmplitude: number
    • dataSeries: XyDataSeries

    Returns void

Const formatNumber

  • formatNumber(dataValue: number, numericFormat: ENumericFormat, precision: number): string
  • Parameters

    Returns string

Const formatNumber2Digits

  • formatNumber2Digits(value: number): string
  • description

    Formats value always to have 2 decimal digits, e.g. 12.45, 14.20, 17.00

    Parameters

    • value: number

    Returns string

Const formatUnixDateToHumanString

  • formatUnixDateToHumanString(unixTimestamp: number, locale?: string): string
  • Result 11/23/2018

    Parameters

    • unixTimestamp: number
    • Default value locale: string = "en-US"

    Returns string

Const formatUnixDateToHumanStringDD

  • formatUnixDateToHumanStringDD(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringDDMM

  • formatUnixDateToHumanStringDDMM(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringDDMMHHMM

  • formatUnixDateToHumanStringDDMMHHMM(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringDDMMYY

  • formatUnixDateToHumanStringDDMMYY(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringHHMM

  • formatUnixDateToHumanStringHHMM(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringHHMMSS

  • formatUnixDateToHumanStringHHMMSS(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringMMM

  • formatUnixDateToHumanStringMMM(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringMMMDD

  • formatUnixDateToHumanStringMMMDD(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const formatUnixDateToHumanStringYYYY

  • formatUnixDateToHumanStringYYYY(unixTimestamp: number): string
  • Parameters

    • unixTimestamp: number

    Returns string

Const freeCache

  • Parameters

    Returns IDeletable

Const freeStyle

  • freeStyle(styleId: string): void
  • Parameters

    • styleId: string

    Returns void

Const fromTsrVector4

  • fromTsrVector4(tsrColor: TSRVector4): TArgb
  • Parameters

    • tsrColor: TSRVector4

    Returns TArgb

Const generateBooleanHash

  • generateBooleanHash(value: boolean): number
  • Parameters

    • value: boolean

    Returns number

Const generateCombinedHash

  • generateCombinedHash(hashes: number[]): number
  • Parameters

    • hashes: number[]

    Returns number

Const generateGuid

  • generateGuid(): string
  • description

    Generates GUID/UUID RFC4122 version 4 compliant

    Returns string

Const generateHash

  • generateHash(s: string): number
  • Parameters

    • s: string

    Returns number

Const generateNumberHash

  • generateNumberHash(value: number): number
  • Parameters

    • value: number

    Returns number

Const generateObjectHash

  • generateObjectHash(obj: any): number
  • Parameters

    • obj: any

    Returns number

Const getActiveAxes

  • Parameters

    Returns AxisBase2D[]

Const getAdjustedRotation

  • getAdjustedRotation(rotation: number, position: ETitlePosition): number
  • Parameters

    Returns number

Const getAllFontKeys

  • Parameters

    Returns SCRTFontKey[]

getArraysEqual

  • getArraysEqual<T>(a: T[], b: T[]): boolean
  • Type parameters

    • T

    Parameters

    • a: T[]
    • b: T[]

    Returns boolean

Const getAttributeFromString

  • getAttributeFromString(str: string, attributeName: string): number
  • Parameters

    • str: string
    • attributeName: string

    Returns number

getAxis3dById

getAxisById

getAxisGeneric

Const getCache

  • getCache(wasmContext: TSciChart | TSciChart3D): { keyCache: Map<string, FontKey>; rect: SCRTRectVertex; textBounds: TSRTextBounds; vecColorVertex: VectorColorVertex; vecRects: VectorRectVertex; vector4: TSRVector4; vertex: SCRTColorVertex }
  • Parameters

    Returns { keyCache: Map<string, FontKey>; rect: SCRTRectVertex; textBounds: TSRTextBounds; vecColorVertex: VectorColorVertex; vecRects: VectorRectVertex; vector4: TSRVector4; vertex: SCRTColorVertex }

    • keyCache: Map<string, FontKey>
    • rect: SCRTRectVertex
    • textBounds: TSRTextBounds
    • vecColorVertex: VectorColorVertex
    • vecRects: VectorRectVertex
    • vector4: TSRVector4
    • vertex: SCRTColorVertex

Const getColor

  • getColor(yIndex: number, xIndex: number, colorPalette: number[], opacity: number, zValues: number[][], webAssemblyContext: TSciChart, colorMin: number, colorMax: number, arrayWidth: number, arrayHeight: number, fillValuesOutOfRange: boolean, precision: number): number
  • Parameters

    • yIndex: number
    • xIndex: number
    • colorPalette: number[]
    • opacity: number
    • zValues: number[][]
    • webAssemblyContext: TSciChart
    • colorMin: number
    • colorMax: number
    • arrayWidth: number
    • arrayHeight: number
    • fillValuesOutOfRange: boolean
    • precision: number

    Returns number

Const getColorDataForTexture

  • getColorDataForTexture(params: IGetColorDataParams, _colorData: UIntVector, precision: number): UIntVector
  • Parameters

    Returns UIntVector

Const getCoordinateWithCoordinateMode

Const getDataSeriesDefinition

Const getDataSeriesFromRenderableSeriesDefinition

getDescriptorsEqual

  • Returns true if descriptors are deeply equal, else false

    Parameters

    Returns boolean

Const getDevCount

  • getDevCount(): number
  • Returns number

Const getFontKey

  • get a fontKey required to aquire a native font

    Parameters

    • webAssemblyContext: TSciChart | TSciChart3D
    • labelStyle: TTextStyle
    • Default value advanced: boolean = false
    • Default value transformed: boolean = false

      set true to get an alternative instance of the font which can be used multiple times while transformations are in effect, without disrupting global font rendering

    Returns SCRTFontKey

Const getFontString

  • getFontString(fontStyle: string, fontWeight: string, fontSize: number, fontFamily: string): string
  • Creates the font string, which is used to set font on CanvasRenderingContext2D

    Parameters

    • fontStyle: string

      The font style

    • fontWeight: string

      The font weight

    • fontSize: number

      The font size in pixels

    • fontFamily: string

      The font family

    Returns string

Const getFunction

  • getFunction(baseType: EBaseType, type: string): Function
  • Parameters

    Returns Function

getHorizontalAxisRequiredSize

  • Parameters

    Returns number

Const getIncludedAxis

  • Parameters

    • allAxes: AxisBase2D[]
    • axisMap: Map<string, boolean>

    Returns AxisBase2D[]

Const getInterpolatedColor

  • getInterpolatedColor(htmlColor1: string, htmlColor2: string, coef: number): number
  • Parameters

    • htmlColor1: string
    • htmlColor2: string
    • coef: number

    Returns number

Const getIsDev

  • getIsDev(): boolean
  • Returns boolean

Const getIsHorizontal

  • Parameters

    Returns boolean

getIsLicenseDebug

  • getIsLicenseDebug(): boolean
  • Returns boolean

Const getIsVertical

  • Parameters

    Returns boolean

Const getKey

  • Parameters

    Returns string

Const getLabel

  • getLabel(text: string, styleId: string): LabelInfo
  • Parameters

    • text: string
    • styleId: string

    Returns LabelInfo

Const getLabelCoordinates

  • getLabelCoordinates(currentAxis: AxisBase2D, labelPlacement: ELabelPlacement, x1Coord: number, x2Coord: number, y1Coord: number, y2Coord: number, textureHeight: number, textureWidth: number, horizontalAlignment?: EHorizontalAlignment, verticalAlignment?: EVerticalAlignment): { xPosition: number; yPosition: number }
  • Calculates coordinates of the annotation label. The coordinates are defined as an absolute position on the whole SciChartSurface.

    Parameters

    Returns { xPosition: number; yPosition: number }

    • xPosition: number
    • yPosition: number

Const getLabelValue

  • getLabelValue(currentAxis: AxisBase2D, labelCoord: number): string
  • Parameters

    Returns string

Const getLegendContainerHtml

  • getLegendContainerHtml(placement: ELegendPlacement, textColor: string, backgroundColor: string, margin: Thickness, body: string, isExternal?: boolean): string
  • Parameters

    • placement: ELegendPlacement
    • textColor: string
    • backgroundColor: string
    • margin: Thickness
    • body: string
    • Default value isExternal: boolean = false

    Returns string

Const getLegendItemHtml

  • Parameters

    Returns string

Const getLicenseType

  • getLicenseType(): LicenseType
  • Returns LicenseType

getLicenseWizardMaxPort

  • getLicenseWizardMaxPort(): number
  • Returns number

getLicenseWizardPort

  • getLicenseWizardPort(): number
  • Returns number

Const getLineCoordinates

  • getLineCoordinates(x1Coord: number, y1Coord: number, x2Coord: number, y2Coord: number, labelHeight: number, labelWidth: number, labelPlacement: ELabelPlacement, currentAxis: AxisBase2D): { x1LineCoord: number; x2LineCoord: number; y1LineCoord: number; y2LineCoord: number }
  • Calculates annotation line coordinates accordingly to axis alignment and label placement. Returns coordinates relative to seriesViewRect.

    Parameters

    • x1Coord: number
    • y1Coord: number
    • x2Coord: number
    • y2Coord: number
    • labelHeight: number
    • labelWidth: number
    • labelPlacement: ELabelPlacement
    • currentAxis: AxisBase2D

    Returns { x1LineCoord: number; x2LineCoord: number; y1LineCoord: number; y2LineCoord: number }

    • x1LineCoord: number
    • x2LineCoord: number
    • y1LineCoord: number
    • y2LineCoord: number

getLineStylesEqual

  • Parameters

    Returns boolean

Const getMaxSize

  • getMaxSize(): number
  • Returns number

Const getMinAge

  • getMinAge(): number
  • Returns number

Const getMonthString

  • getMonthString(month: number): string
  • Parameters

    • month: number

    Returns string

Const getNativeRect

  • getNativeRect(wasmContext: TSciChart, xTopLeft: number, yTopLeft: number, xBottomRight: number, yBottomRight: number): SCRTRectVertex
  • Parameters

    • wasmContext: TSciChart
    • xTopLeft: number
    • yTopLeft: number
    • xBottomRight: number
    • yBottomRight: number

    Returns SCRTRectVertex

Const getNativeTextSize

  • getNativeTextSize(text: string, nativeFont: SCRTFont, textStyle: TNativeTextStyle, webAssemblyContext: TSciChart, rotation?: number): { deltaX: number; deltaY: number; nativeLineSpacing: number; textHeight: number; textWidth: number }
  • Parameters

    • text: string
    • nativeFont: SCRTFont
    • textStyle: TNativeTextStyle
    • webAssemblyContext: TSciChart
    • Default value rotation: number = 0

    Returns { deltaX: number; deltaY: number; nativeLineSpacing: number; textHeight: number; textWidth: number }

    • deltaX: number
    • deltaY: number
    • nativeLineSpacing: number
    • textHeight: number
    • textWidth: number

Const getNearestNonUniformHeatmapPoint

Const getNearestPoint

  • getNearestPoint(webassemblyContext: TSciChart, xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, isSorted: boolean, xHitCoord: number, yHitCoord: number, hitTestRadius: number): { distance: number; nearestPointIndex: number }
  • Parameters

    Returns { distance: number; nearestPointIndex: number }

    • distance: number
    • nearestPointIndex: number

Const getNearestUniformHeatmapPoint

  • Parameters

    Returns { xIndex: number; yIndex: number; zValue: number }

    • xIndex: number
    • yIndex: number
    • zValue: number

Const getNearestXPoint

  • Parameters

    Returns number

Const getNearestXyPoint

  • Parameters

    Returns { distance: number; nearestPointIndex: number }

    • distance: number
    • nearestPointIndex: number

Const getNearestXyyPoint

  • Parameters

    Returns { distance: number; nearestPointIndex: number }

    • distance: number
    • nearestPointIndex: number

Const getNextRandomPriceBarFactory

  • getNextRandomPriceBarFactory(startDateTimestamp: number, candleIntervalMinutes: number, simulateDateGap: boolean, startPrice: number): (Anonymous function)
  • Parameters

    • startDateTimestamp: number
    • candleIntervalMinutes: number
    • simulateDateGap: boolean
    • startPrice: number

    Returns (Anonymous function)

Const getNoisySinewave

  • getNoisySinewave(pointCount: number, xMax: number, frequency: number, amplitude: number, noiseAmplitude: number): number[][]
  • Parameters

    • pointCount: number
    • xMax: number
    • frequency: number
    • amplitude: number
    • noiseAmplitude: number

    Returns number[][]

Const getOrderId

  • getOrderId(): string
  • Returns string

Const getProductCode

  • getProductCode(): string
  • Returns string

Const getRandomInRange

  • getRandomInRange(min: number, max: number, decimalPlaces: number): number
  • Return random number in range [min, max]

    Parameters

    • min: number
    • max: number
    • decimalPlaces: number

    Returns number

getRubberBandRect

  • Given the starting and end mouse-point, computes a rectangle to perform zoom over. Takes into account the xyDirection

    Parameters

    • pointFrom: Point

      the starting point of the mouse

    • pointTo: Point

      the end point of the mouse

    • xyDirection: EXyDirection

      the XyDirection

    • viewportRect: Rect

    Returns Rect

Const getScrtBrushFromCache

  • getScrtBrushFromCache(cache: BrushCache): SCRTBrush
  • Retrieves a native {@link SCRTBrush} Brush from the provided {@link BrushCache} cache object. The retrieved entity is a wrapper around {@link SCRTPen}

    Parameters

    • cache: BrushCache

      The object that stores a brush

    Returns SCRTBrush

    new or existing instance of {@link SCRTBrush}}

Const getScrtPenFromCache

  • getScrtPenFromCache(penCache: Pen2DCache): SCRTPen
  • Retrieves a native {@link SCRTPen} Pen from the provided {@link Pen2DCache} cache object

    Parameters

    • penCache: Pen2DCache

      The object that stores a pen

    Returns SCRTPen

    the new or existing instance of {@link SCRTPen}}

Const getSharedWasmContext

  • getSharedWasmContext(): Promise<{ CategoryCoordinateCalculatorDouble: {}; DoubleRange: {} & {}; DoubleVector: {}; FlippedCategoryCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorSingle: {}; FlippedLogarithmicCoordinateCalculator: {}; FloatVector: {}; IntVector: {}; LinearCoordinateCalculatorDouble: {}; LinearCoordinateCalculatorSingle: {}; LogarithmicCoordinateCalculator: {}; NiceDoubleScale: { CalculateTickSpacing: (min: number, max: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; NiceNum: (range: number, round: boolean) => number }; NiceLogScale: { CalculateLowPrecisionTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; CalculateTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange }; NumberUtil: { Constrain: (value: number, lowerBound: number, upperBound: number) => number; FindIndex: (inputValues: SCRTDoubleVector, value: number, searchMode: SCRTFindIndexSearchMode, dataIsSortedAscending: boolean) => number; IsDivisibleBy: (value: number, divisor: number) => boolean; IsPowerOf: (value: number, power: number, logBase: number) => boolean; LinearInterpolateI: (from: number, to: number, ratio: number) => number; Log: (value: number, logBase: number) => number; MinMax: (inputValues: SCRTDoubleVector) => DoubleRange; MinMaxWithIndex: (inputValues: SCRTDoubleVector, startIndex: number, count: number) => DoubleRange; RoundDown: (value: number, nearest: number) => number; RoundDownPower: (value: number, power: number, logBase: number) => number; RoundToDigits: (value: number, decimals: number) => number; RoundUp: (value: number, nearest: number) => number; RoundUpPower: (value: number, power: number, logBase: number) => number }; ResamplingArgs: {}; ResamplingData: { CategoryData: ResamplingData; LinearData: ResamplingData; UnevenlySpacedData: ResamplingData; UnsortedData: ResamplingData }; ResamplingMode: { Auto: ResamplingMode; Max: ResamplingMode; Mid: ResamplingMode; Min: ResamplingMode; MinMax: ResamplingMode; MinOrMax: ResamplingMode; None: ResamplingMode }; SCRTAnimationHelperFade: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperScale: (yValues: SCRTDoubleVector, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperSweep: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperWave: (yValues: SCRTDoubleVector, durationFraction: number, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTBandDrawingParams: {}; SCRTBandSeriesDrawingProvider: {}; SCRTBrush: {}; SCRTBubbleSeriesDrawingProvider: {}; SCRTCandleType: { CandleStick: SCRTCandleType; OHLC: SCRTCandleType }; SCRTCandlestickSeriesDrawingProvider: {}; SCRTColorVertex: {} & {}; SCRTColumnDrawingParams: {}; SCRTColumnSeriesDrawingProvider: {}; SCRTColumnVertex: {}; SCRTContourParams: {}; SCRTCopyToDestinationInterface: { implement: (wrapper: SCRTCopyToDestinationInterfaceWrapper) => SCRTCopyToDestinationInterface }; SCRTCreateBitmapTexture: (width: number, height: number, textureFormat: eTSRTextureFormat) => TSRTexture; SCRTCreateDahedPen: (color: number, thickness: number, antialiased: boolean, dashPattern: FloatVector) => SCRTPen; SCRTCreatePalette: (colors: IntVector) => SCRTPalette; SCRTCredentials: { ApplyLicenseResponse: (response: string) => number; Dump: () => string; GetAllowDebugging: () => boolean; GetBuildStamp: () => string; GetDeveloperCount: () => number; GetEncrypted: (stringToEncrypt: string) => string; GetEncryptedOrderId: () => string; GetExpiryDate: () => string; GetLicenseChallenge: () => string; GetLicenseDaysRemaining: () => number; GetLicenseErrors: () => string; GetLicenseType: () => SCRTLicenseType; GetOrderId: () => string; GetProductCode: () => string; HasFeature: (feature: string) => SCRTLicenseType; Hash256Encode64: (stringToHash: string) => string; RequiresValidation: () => boolean; ResetRuntimeLicense: () => void; SetRuntimeLicenseKeyW: (licenseKey: string) => boolean }; SCRTDoLeakCheck: () => void; SCRTDoubleArrayOperations: {}; SCRTDoubleArraysXyResampleOutput: {}; SCRTDoubleResampler: {}; SCRTDoubleResamplerMergeIndicesParams: {}; SCRTDoubleVector: {} & {}; SCRTFifoVector: {}; SCRTFileLoadCallbackInterface: { implement: (wrapper: SCRTFileLoadCallbackInterfaceWrapper) => SCRTFileLoadCallbackInterface }; SCRTFillTextureAbgr: (texture: TSRTexture, width: number, height: number, pixels: IntVector) => void; SCRTFillTextureFloat32: (texture: TSRTexture, width: number, height: number, pixels: SCRTFloatVector) => TSRVector4; SCRTFillVectorSequential: (SCRTFillVectorSequential: SCRTDoubleVector, count: number) => void; SCRTFindIndexSearchMode: { Exact: SCRTFindIndexSearchMode; Nearest: SCRTFindIndexSearchMode; RoundDown: SCRTFindIndexSearchMode; RoundUp: SCRTFindIndexSearchMode }; SCRTFloatVector: {}; SCRTFontKey: {}; SCRTFrameRenderer2D: {}; SCRTGetGlobalSampleChartInterface: () => SCRTSampleChartInterface; SCRTGetMainRenderContext2D: () => SCRTRenderContext; SCRTGetScreenHeight: () => number; SCRTGetScreenWidth: () => number; SCRTGlowEffect: {}; SCRTHeatmapDrawingParams: {}; SCRTHeatmapSeriesDrawingProvider: {}; SCRTHitTestHelper: { GetNearestXyPoint: (xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, isSorted: boolean, xHitCoord: number, yHitCoord: number, hitTestRadius: number) => DoubleRange }; SCRTInitEngine2D: () => void; SCRTLicenseType: { LICENSE_TYPE_COMMUNITY: SCRTLicenseType; LICENSE_TYPE_FULL: SCRTLicenseType; LICENSE_TYPE_FULL_EXPIRED: SCRTLicenseType; LICENSE_TYPE_INVALID_DEVELOPER_LICENSE: SCRTLicenseType; LICENSE_TYPE_INVALID_LICENSE: SCRTLicenseType; LICENSE_TYPE_NO_LICENSE: SCRTLicenseType; LICENSE_TYPE_REQUIRES_VALIDATION: SCRTLicenseType; LICENSE_TYPE_SUBSCRIPTION_EXPIRED: SCRTLicenseType; LICENSE_TYPE_TRIAL: SCRTLicenseType; LICENSE_TYPE_TRIAL_EXPIRED: SCRTLicenseType }; SCRTLineDrawingParams: {}; SCRTLineGapMode: { CloseGaps: SCRTLineGapMode; Default: SCRTLineGapMode; DrawGaps: SCRTLineGapMode }; SCRTLineSeriesDrawingProvider: {}; SCRTLineType: { Digital: SCRTLineType; List: SCRTLineType; Nan: SCRTLineType; Strip: SCRTLineType }; SCRTMemCopy: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMemMove: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMountainDrawingParams: {}; SCRTMountainSeriesDrawingProvider: {}; SCRTMultiplyColorVectorOpacity: (originalVector: IntVector, resultVector: IntVector, factor: number) => void; SCRTOhlcDrawingParams: {}; SCRTPalette: {} & { GetNoOverrideColorCode: () => number }; SCRTPen: {}; SCRTPointDrawingParams: {}; SCRTRectVertex: {} & {}; SCRTRegisterFile: (fileName: string, url: string, callback: SCRTFileLoadCallbackInterface) => void; SCRTSampleChartInterface: { implement: (wrapper: SCRTSampleChartInterfaceWrapper) => SCRTSampleChartInterface }; SCRTScatterSeriesDrawingProvider: {}; SCRTSeriesEffectType: { Glow: SCRTSeriesEffectType }; SCRTSetActiveDoubleVector: (SCRTSetActiveDoubleVector: SCRTDoubleVector, doubleVector: number) => void; SCRTSetActiveTexture: (texture: TSRTexture) => void; SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void; SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void; SCRTSetGlobalSampleChartInterface: (param0: SCRTSampleChartInterface) => void; SCRTSetMainWindowSize: (width: number, height: number) => void; SCRTSetTextureLinearSamplerEnabled: (texture: TSRTexture, enabled: boolean) => void; SCRTSetWaterMarkProperties: (properties: SCRTWaterMarkProperties) => void; SCRTShadowEffect: {}; SCRTShutdownEngine2D: () => void; SCRTSolidBrush: {}; SCRTSplineHelperCubicSpline: (xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xsValues: SCRTDoubleVector, ysValues: SCRTDoubleVector, initialSize: number, interpolationPoints: number, containsNAN: boolean) => void; SCRTSpriteType: { FixedSize: SCRTSpriteType; Normal: SCRTSpriteType }; SCRTStackedColumnDrawingParams: {}; SCRTStackedColumnSeriesDrawingProvider: {}; SCRTSurfaceDestination: { implement: (wrapper: SCRTSurfaceDestinationWrapper) => SCRTSurfaceDestination }; SCRTTextureBrush: {}; SCRTWaterMarkProperties: {}; SCRTXvaluesProvider: {}; StringVector: {}; TSRCamera: {}; TSRRequestCanvasDraw: (canvasID: string) => void; TSRRequestDraw: () => void; TSRRequestExit: () => void; TSRSetDrawRequestsEnabled: (enabled: boolean) => void; TSRTextBounds: {}; TSRTextLineBounds: {}; TSRVector2: {} & {}; TSRVector3: {} & {}; TSRVector4: {} & {}; UIntVector: {}; VectorColorVertex: {}; VectorColumnVertex: {}; VectorRectVertex: {}; WStringVector: {}; canvas: HTMLCanvasElement; canvas2D: HTMLCanvasElement; eSCRTBlendMode: { BlendAdditiveAlpha: eSCRTBlendMode; BlendAdditiveColor: eSCRTBlendMode; BlendAdditiveOneAlpha: eSCRTBlendMode; BlendDefault: eSCRTBlendMode; BlendDisabled: eSCRTBlendMode }; eSCRTBrushMappingMode: { PerPrimitive: eSCRTBrushMappingMode; PerScreen: eSCRTBrushMappingMode }; eTSRCameraProjectionMode: { CAMERA_PROJECTIONMODE_ORTHOGONAL: eTSRCameraProjectionMode; CAMERA_PROJECTIONMODE_PERSPECTIVE: eTSRCameraProjectionMode }; eTSRMetaDataType: { BitFlags: eTSRMetaDataType; Core: eTSRMetaDataType; Defined: eTSRMetaDataType; DynamicDefined: eTSRMetaDataType; Enum: eTSRMetaDataType; Unknown: eTSRMetaDataType }; eTSRPlatform: { Android: eTSRPlatform; Linux: eTSRPlatform; Mac: eTSRPlatform; Web: eTSRPlatform; Windows: eTSRPlatform; iOS: eTSRPlatform }; eTSRRendererType: { TSR_RENDERER_TYPE_D3D11: eTSRRendererType; TSR_RENDERER_TYPE_D3D11_LEVEL10: eTSRRendererType; TSR_RENDERER_TYPE_D3D12: eTSRRendererType; TSR_RENDERER_TYPE_D3D9: eTSRRendererType; TSR_RENDERER_TYPE_GL: eTSRRendererType; TSR_RENDERER_TYPE_GLES2: eTSRRendererType; TSR_RENDERER_TYPE_GLES3: eTSRRendererType; TSR_RENDERER_TYPE_METAL: eTSRRendererType; TSR_RENDERER_TYPE_UNDEFINED: eTSRRendererType; TSR_RENDERER_TYPE_VULKAN: eTSRRendererType }; eTSRTextAlignMode: { Center: eTSRTextAlignMode; Left: eTSRTextAlignMode; Right: eTSRTextAlignMode }; eTSRTextureFormat: { TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat; TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat }; eVariableUsage: { Array: eVariableUsage; Blob: eVariableUsage; DynamicArray: eVariableUsage; Normal: eVariableUsage; Pointer: eVariableUsage; Vector: eVariableUsage; VectorOfPointers: eVariableUsage } }>
  • Returns Promise<{ CategoryCoordinateCalculatorDouble: {}; DoubleRange: {} & {}; DoubleVector: {}; FlippedCategoryCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorDouble: {}; FlippedLinearCoordinateCalculatorSingle: {}; FlippedLogarithmicCoordinateCalculator: {}; FloatVector: {}; IntVector: {}; LinearCoordinateCalculatorDouble: {}; LinearCoordinateCalculatorSingle: {}; LogarithmicCoordinateCalculator: {}; NiceDoubleScale: { CalculateTickSpacing: (min: number, max: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; NiceNum: (range: number, round: boolean) => number }; NiceLogScale: { CalculateLowPrecisionTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange; CalculateTickSpacing: (min: number, max: number, logBase: number, minorsPerMajor: number, maxTicks: number) => DoubleRange }; NumberUtil: { Constrain: (value: number, lowerBound: number, upperBound: number) => number; FindIndex: (inputValues: SCRTDoubleVector, value: number, searchMode: SCRTFindIndexSearchMode, dataIsSortedAscending: boolean) => number; IsDivisibleBy: (value: number, divisor: number) => boolean; IsPowerOf: (value: number, power: number, logBase: number) => boolean; LinearInterpolateI: (from: number, to: number, ratio: number) => number; Log: (value: number, logBase: number) => number; MinMax: (inputValues: SCRTDoubleVector) => DoubleRange; MinMaxWithIndex: (inputValues: SCRTDoubleVector, startIndex: number, count: number) => DoubleRange; RoundDown: (value: number, nearest: number) => number; RoundDownPower: (value: number, power: number, logBase: number) => number; RoundToDigits: (value: number, decimals: number) => number; RoundUp: (value: number, nearest: number) => number; RoundUpPower: (value: number, power: number, logBase: number) => number }; ResamplingArgs: {}; ResamplingData: { CategoryData: ResamplingData; LinearData: ResamplingData; UnevenlySpacedData: ResamplingData; UnsortedData: ResamplingData }; ResamplingMode: { Auto: ResamplingMode; Max: ResamplingMode; Mid: ResamplingMode; Min: ResamplingMode; MinMax: ResamplingMode; MinOrMax: ResamplingMode; None: ResamplingMode }; SCRTAnimationHelperFade: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperScale: (yValues: SCRTDoubleVector, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperSweep: (yValues: SCRTDoubleVector, progress: number, ysValues: SCRTDoubleVector) => number; SCRTAnimationHelperWave: (yValues: SCRTDoubleVector, durationFraction: number, zeroLine: number, progress: number, ysValues: SCRTDoubleVector) => number; SCRTBandDrawingParams: {}; SCRTBandSeriesDrawingProvider: {}; SCRTBrush: {}; SCRTBubbleSeriesDrawingProvider: {}; SCRTCandleType: { CandleStick: SCRTCandleType; OHLC: SCRTCandleType }; SCRTCandlestickSeriesDrawingProvider: {}; SCRTColorVertex: {} & {}; SCRTColumnDrawingParams: {}; SCRTColumnSeriesDrawingProvider: {}; SCRTColumnVertex: {}; SCRTContourParams: {}; SCRTCopyToDestinationInterface: { implement: (wrapper: SCRTCopyToDestinationInterfaceWrapper) => SCRTCopyToDestinationInterface }; SCRTCreateBitmapTexture: (width: number, height: number, textureFormat: eTSRTextureFormat) => TSRTexture; SCRTCreateDahedPen: (color: number, thickness: number, antialiased: boolean, dashPattern: FloatVector) => SCRTPen; SCRTCreatePalette: (colors: IntVector) => SCRTPalette; SCRTCredentials: { ApplyLicenseResponse: (response: string) => number; Dump: () => string; GetAllowDebugging: () => boolean; GetBuildStamp: () => string; GetDeveloperCount: () => number; GetEncrypted: (stringToEncrypt: string) => string; GetEncryptedOrderId: () => string; GetExpiryDate: () => string; GetLicenseChallenge: () => string; GetLicenseDaysRemaining: () => number; GetLicenseErrors: () => string; GetLicenseType: () => SCRTLicenseType; GetOrderId: () => string; GetProductCode: () => string; HasFeature: (feature: string) => SCRTLicenseType; Hash256Encode64: (stringToHash: string) => string; RequiresValidation: () => boolean; ResetRuntimeLicense: () => void; SetRuntimeLicenseKeyW: (licenseKey: string) => boolean }; SCRTDoLeakCheck: () => void; SCRTDoubleArrayOperations: {}; SCRTDoubleArraysXyResampleOutput: {}; SCRTDoubleResampler: {}; SCRTDoubleResamplerMergeIndicesParams: {}; SCRTDoubleVector: {} & {}; SCRTFifoVector: {}; SCRTFileLoadCallbackInterface: { implement: (wrapper: SCRTFileLoadCallbackInterfaceWrapper) => SCRTFileLoadCallbackInterface }; SCRTFillTextureAbgr: (texture: TSRTexture, width: number, height: number, pixels: IntVector) => void; SCRTFillTextureFloat32: (texture: TSRTexture, width: number, height: number, pixels: SCRTFloatVector) => TSRVector4; SCRTFillVectorSequential: (SCRTFillVectorSequential: SCRTDoubleVector, count: number) => void; SCRTFindIndexSearchMode: { Exact: SCRTFindIndexSearchMode; Nearest: SCRTFindIndexSearchMode; RoundDown: SCRTFindIndexSearchMode; RoundUp: SCRTFindIndexSearchMode }; SCRTFloatVector: {}; SCRTFontKey: {}; SCRTFrameRenderer2D: {}; SCRTGetGlobalSampleChartInterface: () => SCRTSampleChartInterface; SCRTGetMainRenderContext2D: () => SCRTRenderContext; SCRTGetScreenHeight: () => number; SCRTGetScreenWidth: () => number; SCRTGlowEffect: {}; SCRTHeatmapDrawingParams: {}; SCRTHeatmapSeriesDrawingProvider: {}; SCRTHitTestHelper: { GetNearestXyPoint: (xCoordinateCalculator: CoordinateCalculator, yCoordinateCalculator: CoordinateCalculator, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, isSorted: boolean, xHitCoord: number, yHitCoord: number, hitTestRadius: number) => DoubleRange }; SCRTInitEngine2D: () => void; SCRTLicenseType: { LICENSE_TYPE_COMMUNITY: SCRTLicenseType; LICENSE_TYPE_FULL: SCRTLicenseType; LICENSE_TYPE_FULL_EXPIRED: SCRTLicenseType; LICENSE_TYPE_INVALID_DEVELOPER_LICENSE: SCRTLicenseType; LICENSE_TYPE_INVALID_LICENSE: SCRTLicenseType; LICENSE_TYPE_NO_LICENSE: SCRTLicenseType; LICENSE_TYPE_REQUIRES_VALIDATION: SCRTLicenseType; LICENSE_TYPE_SUBSCRIPTION_EXPIRED: SCRTLicenseType; LICENSE_TYPE_TRIAL: SCRTLicenseType; LICENSE_TYPE_TRIAL_EXPIRED: SCRTLicenseType }; SCRTLineDrawingParams: {}; SCRTLineGapMode: { CloseGaps: SCRTLineGapMode; Default: SCRTLineGapMode; DrawGaps: SCRTLineGapMode }; SCRTLineSeriesDrawingProvider: {}; SCRTLineType: { Digital: SCRTLineType; List: SCRTLineType; Nan: SCRTLineType; Strip: SCRTLineType }; SCRTMemCopy: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMemMove: (destPtr: number, sourcePtr: number, count: number) => void; SCRTMountainDrawingParams: {}; SCRTMountainSeriesDrawingProvider: {}; SCRTMultiplyColorVectorOpacity: (originalVector: IntVector, resultVector: IntVector, factor: number) => void; SCRTOhlcDrawingParams: {}; SCRTPalette: {} & { GetNoOverrideColorCode: () => number }; SCRTPen: {}; SCRTPointDrawingParams: {}; SCRTRectVertex: {} & {}; SCRTRegisterFile: (fileName: string, url: string, callback: SCRTFileLoadCallbackInterface) => void; SCRTSampleChartInterface: { implement: (wrapper: SCRTSampleChartInterfaceWrapper) => SCRTSampleChartInterface }; SCRTScatterSeriesDrawingProvider: {}; SCRTSeriesEffectType: { Glow: SCRTSeriesEffectType }; SCRTSetActiveDoubleVector: (SCRTSetActiveDoubleVector: SCRTDoubleVector, doubleVector: number) => void; SCRTSetActiveTexture: (texture: TSRTexture) => void; SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void; SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void; SCRTSetGlobalSampleChartInterface: (param0: SCRTSampleChartInterface) => void; SCRTSetMainWindowSize: (width: number, height: number) => void; SCRTSetTextureLinearSamplerEnabled: (texture: TSRTexture, enabled: boolean) => void; SCRTSetWaterMarkProperties: (properties: SCRTWaterMarkProperties) => void; SCRTShadowEffect: {}; SCRTShutdownEngine2D: () => void; SCRTSolidBrush: {}; SCRTSplineHelperCubicSpline: (xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xsValues: SCRTDoubleVector, ysValues: SCRTDoubleVector, initialSize: number, interpolationPoints: number, containsNAN: boolean) => void; SCRTSpriteType: { FixedSize: SCRTSpriteType; Normal: SCRTSpriteType }; SCRTStackedColumnDrawingParams: {}; SCRTStackedColumnSeriesDrawingProvider: {}; SCRTSurfaceDestination: { implement: (wrapper: SCRTSurfaceDestinationWrapper) => SCRTSurfaceDestination }; SCRTTextureBrush: {}; SCRTWaterMarkProperties: {}; SCRTXvaluesProvider: {}; StringVector: {}; TSRCamera: {}; TSRRequestCanvasDraw: (canvasID: string) => void; TSRRequestDraw: () => void; TSRRequestExit: () => void; TSRSetDrawRequestsEnabled: (enabled: boolean) => void; TSRTextBounds: {}; TSRTextLineBounds: {}; TSRVector2: {} & {}; TSRVector3: {} & {}; TSRVector4: {} & {}; UIntVector: {}; VectorColorVertex: {}; VectorColumnVertex: {}; VectorRectVertex: {}; WStringVector: {}; canvas: HTMLCanvasElement; canvas2D: HTMLCanvasElement; eSCRTBlendMode: { BlendAdditiveAlpha: eSCRTBlendMode; BlendAdditiveColor: eSCRTBlendMode; BlendAdditiveOneAlpha: eSCRTBlendMode; BlendDefault: eSCRTBlendMode; BlendDisabled: eSCRTBlendMode }; eSCRTBrushMappingMode: { PerPrimitive: eSCRTBrushMappingMode; PerScreen: eSCRTBrushMappingMode }; eTSRCameraProjectionMode: { CAMERA_PROJECTIONMODE_ORTHOGONAL: eTSRCameraProjectionMode; CAMERA_PROJECTIONMODE_PERSPECTIVE: eTSRCameraProjectionMode }; eTSRMetaDataType: { BitFlags: eTSRMetaDataType; Core: eTSRMetaDataType; Defined: eTSRMetaDataType; DynamicDefined: eTSRMetaDataType; Enum: eTSRMetaDataType; Unknown: eTSRMetaDataType }; eTSRPlatform: { Android: eTSRPlatform; Linux: eTSRPlatform; Mac: eTSRPlatform; Web: eTSRPlatform; Windows: eTSRPlatform; iOS: eTSRPlatform }; eTSRRendererType: { TSR_RENDERER_TYPE_D3D11: eTSRRendererType; TSR_RENDERER_TYPE_D3D11_LEVEL10: eTSRRendererType; TSR_RENDERER_TYPE_D3D12: eTSRRendererType; TSR_RENDERER_TYPE_D3D9: eTSRRendererType; TSR_RENDERER_TYPE_GL: eTSRRendererType; TSR_RENDERER_TYPE_GLES2: eTSRRendererType; TSR_RENDERER_TYPE_GLES3: eTSRRendererType; TSR_RENDERER_TYPE_METAL: eTSRRendererType; TSR_RENDERER_TYPE_UNDEFINED: eTSRRendererType; TSR_RENDERER_TYPE_VULKAN: eTSRRendererType }; eTSRTextAlignMode: { Center: eTSRTextAlignMode; Left: eTSRTextAlignMode; Right: eTSRTextAlignMode }; eTSRTextureFormat: { TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat; TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat }; eVariableUsage: { Array: eVariableUsage; Blob: eVariableUsage; DynamicArray: eVariableUsage; Normal: eVariableUsage; Pointer: eVariableUsage; Vector: eVariableUsage; VectorOfPointers: eVariableUsage } }>

Const getStocksDataFactory

  • getStocksDataFactory(STEP: number, RANDOM_MIN: number, RANDOM_MAX: number): (Anonymous function)
  • Creates function to generate stock data

    Parameters

    • STEP: number
    • RANDOM_MIN: number
    • RANDOM_MAX: number

    Returns (Anonymous function)

Const getStyleId

  • Parameters

    Returns string

Const getSubTypes

  • Parameters

    Returns string[]

getTArgbEqual

  • Parameters

    Returns boolean

Const getTelemetry

  • getTelemetry(): boolean
  • Returns boolean

Const getTextBounds

  • Parameters

    Returns TSRTextBounds

getTextStylesEqual

  • Parameters

    Returns boolean

getUniqueValues

  • Parameters

    • array: string[]

    Returns getUniqueValues

Const getUserCookie

  • getUserCookie(): { sessionId: string; sessionStart: number; userId: string }
  • Returns { sessionId: string; sessionStart: number; userId: string }

    • sessionId: string
    • sessionStart: number
    • userId: string

Const getValueWithCoordinateMode

Const getVector4

  • getVector4(wasmContext: TSciChart | TSciChart3D, x: number, y: number, z: number, w: number): TSRVector4
  • Parameters

    Returns TSRVector4

Const getVectorColorVertex

  • getVectorColorVertex(wasmContext: TSciChart, maxSize?: number): VectorColorVertex
  • Parameters

    • wasmContext: TSciChart
    • Default value maxSize: number = 100

    Returns VectorColorVertex

Const getVectorRectVertex

  • getVectorRectVertex(wasmContext: TSciChart, maxSize?: number): VectorRectVertex
  • Returns an empty vector of Rectangles

    Parameters

    • wasmContext: TSciChart
    • Default value maxSize: number = 100

    Returns VectorRectVertex

Const getVertex

  • getVertex(wasmContext: TSciChart, x: number, y: number, colour?: number): SCRTColorVertex
  • Parameters

    • wasmContext: TSciChart
    • x: number
    • y: number
    • Optional colour: number

    Returns SCRTColorVertex

getVerticalAxisRequiredSize

  • Parameters

    Returns number

Const getWebGlBrushFromCache

  • getWebGlBrushFromCache(cache: BrushCache): WebGlBrush
  • Retrieves a native WebGlBrush Brush from the provided {@link BrushCache} cache object

    Parameters

    • cache: BrushCache

    Returns WebGlBrush

    new or existing instance of WebGlPen}

Const getWebGlPenFromCache

  • getWebGlPenFromCache(penCache: Pen2DCache): WebGlPen
  • Retrieves a native WebGlPen Pen from the provided {@link Pen2DCache} cache object. The retrieved entity is a wrapper around {@link SCRTPen}

    Parameters

    • penCache: Pen2DCache

      The object that stores a pen

    Returns WebGlPen

    the new or existing instance of WebGlPen}

Const getWindowedYRange

  • getWindowedYRange(webAssemblyContext: TSciChart, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis: boolean, isSorted: boolean, minSearchMode?: ESearchMode, maxSearchMode?: ESearchMode): NumberRange
  • Parameters

    • webAssemblyContext: TSciChart
    • xValues: SCRTDoubleVector
    • yValues: SCRTDoubleVector
    • xRange: NumberRange
    • getPositiveRange: boolean
    • isXCategoryAxis: boolean
    • isSorted: boolean
    • Default value minSearchMode: ESearchMode = ESearchMode.RoundUp
    • Default value maxSearchMode: ESearchMode = ESearchMode.RoundDown

    Returns NumberRange

Const getXRange

  • Parameters

    • range: NumberRange
    • count: number
    • widthFraction: number

    Returns NumberRange

Const guardSameLengthZValuesAndMetadata

  • guardSameLengthZValuesAndMetadata(zValues: number[][], metadata: IPointMetadata[][]): void
  • Parameters

    Returns void

Const handleInvalidAxisAlignment

  • handleInvalidAxisAlignment(alignment: never): never
  • Parameters

    • alignment: never

    Returns never

Const hasAllProperties

  • hasAllProperties(obj: any, props: string[]): boolean
  • Parameters

    • obj: any
    • props: string[]

    Returns boolean

hasOwnProperty

  • hasOwnProperty<X, Y>(obj: X, prop: Y): obj is X & Record<Y, unknown>
  • Type parameters

    • X: {}

    • Y: PropertyKey

    Parameters

    • obj: X
    • prop: Y

    Returns obj is X & Record<Y, unknown>

htmlToElement

  • Parameters

    • html: string

    Returns htmlToElement

Const initializeChartEngine2D

Const interpolateColor

  • interpolateColor(from: number, to: number, progress: number): number
  • Interpolates colors

    Parameters

    • from: number
    • to: number
    • progress: number

    Returns number

Const interpolateLinear

  • interpolateLinear(x: number, x1: number, y1: number, x2: number, y2: number): number
  • Parameters

    • x: number
    • x1: number
    • y1: number
    • x2: number
    • y2: number

    Returns number

Const interpolateNumber

  • interpolateNumber(from: number, to: number, progress: number): number
  • Interpolates numbers

    Parameters

    • from: number
    • to: number
    • progress: number

    Returns number

isArraySorted

  • isArraySorted(arr: NumberArray, ascending?: boolean): boolean
  • returns true if the array is sorted

    Parameters

    • arr: NumberArray

      The array

    • Default value ascending: boolean = true

      If True checks for sorted ascending, if False for descending

    Returns boolean

Const isConstructor

  • isConstructor(someObj: any): boolean
  • Parameters

    • someObj: any

    Returns boolean

isNumberArray

  • Parameters

    • a: any

    Returns isNumberArray

isRealNumber

  • isRealNumber(number: number): boolean
  • returns true if the number is a real number (not NAN, not Infinite)

    Parameters

    • number: number

    Returns boolean

isTypedArray

  • Parameters

    • a: any

    Returns isTypedArray

layoutAxisParts

layoutAxisPartsBottomStrategy

  • layoutAxisPartsBottomStrategy(axisRendererWidth: number, axisRendererHeight: number, axisTitleRendererWidth: number, axisTitleRendererHeight: number, containerBounds: Rect): TAxisViewRects
  • Parameters

    • axisRendererWidth: number
    • axisRendererHeight: number
    • axisTitleRendererWidth: number
    • axisTitleRendererHeight: number
    • containerBounds: Rect

    Returns TAxisViewRects

layoutAxisPartsLeftStrategy

  • layoutAxisPartsLeftStrategy(axisRendererWidth: number, axisRendererHeight: number, axisTitleRendererWidth: number, axisTitleRendererHeight: number, containerBounds: Rect): TAxisViewRects
  • Parameters

    • axisRendererWidth: number
    • axisRendererHeight: number
    • axisTitleRendererWidth: number
    • axisTitleRendererHeight: number
    • containerBounds: Rect

    Returns TAxisViewRects

layoutAxisPartsRightStrategy

  • layoutAxisPartsRightStrategy(axisRendererWidth: number, axisRendererHeight: number, axisTitleRendererWidth: number, axisTitleRendererHeight: number, containerBounds: Rect): TAxisViewRects
  • Parameters

    • axisRendererWidth: number
    • axisRendererHeight: number
    • axisTitleRendererWidth: number
    • axisTitleRendererHeight: number
    • containerBounds: Rect

    Returns TAxisViewRects

layoutAxisPartsTopStrategy

  • layoutAxisPartsTopStrategy(axisRendererWidth: number, axisRendererHeight: number, axisTitleRendererWidth: number, axisTitleRendererHeight: number, containerBounds: Rect): TAxisViewRects
  • Parameters

    • axisRendererWidth: number
    • axisRendererHeight: number
    • axisTitleRendererWidth: number
    • axisTitleRendererHeight: number
    • containerBounds: Rect

    Returns TAxisViewRects

linearColorMapLerp

  • Linearly interpolates a data-value in a TLinearColorMap, which specifies Gradient Stops, Data Minimum and Maximum and color stepping mode

    Parameters

    Returns number

Const logDoubleVector

  • logDoubleVector(vector: SCRTDoubleVector, name?: string, precision?: number): void
  • Parameters

    • vector: SCRTDoubleVector
    • Optional name: string
    • Default value precision: number = 2

    Returns void

Const logToBase

  • logToBase(n: number, base: number): number
  • Parameters

    • n: number
    • base: number

    Returns number

Const makeCacheKey

  • makeCacheKey(text: string, styleId: string): string
  • Parameters

    • text: string
    • styleId: string

    Returns string

makeIncArray

  • makeIncArray(length: number, multiplier?: number, map?: (n: number, index?: number) => number): makeIncArray
  • Helper method for generating an array of a given length, where the values are the indicies An optional multiplier and map function can be applied.

    Parameters

    • length: number
    • Optional multiplier: number
    • Optional map: (n: number, index?: number) => number
        • (n: number, index?: number): number
        • Parameters

          • n: number
          • Optional index: number

          Returns number

    Returns makeIncArray

Const measureTextHeight

  • measureTextHeight(fontSizePx: number): number
  • Parameters

    • fontSizePx: number

    Returns number

Const measureTextWidth

  • measureTextWidth(ctx: CanvasRenderingContext2D, text: string): number
  • Parameters

    • ctx: CanvasRenderingContext2D
    • text: string

    Returns number

memoize

  • memoize<ResultType, ParamsListType>(heavyCalculationFunction: (...params: ParamsListType) => ResultType, equalityComparisonFunction?: (params: ParamsListType, prevParams: ParamsListType) => boolean): memoize
  • Type parameters

    • ResultType

    • ParamsListType: any[]

    Parameters

    • heavyCalculationFunction: (...params: ParamsListType) => ResultType
        • (...params: ParamsListType): ResultType
        • Parameters

          • Rest ...params: ParamsListType

          Returns ResultType

    • Optional equalityComparisonFunction: (params: ParamsListType, prevParams: ParamsListType) => boolean
        • (params: ParamsListType, prevParams: ParamsListType): boolean
        • Parameters

          • params: ParamsListType
          • prevParams: ParamsListType

          Returns boolean

    Returns memoize

Const numericHashCode

  • numericHashCode(hash: number, value: number): number
  • Parameters

    • hash: number
    • value: number

    Returns number

Const parseArgbToHtmlColor

  • parseArgbToHtmlColor(argbColor: number): string
  • Converts color from ARGB number format into HTML string format #FFFFFFFF

    Parameters

    • argbColor: number

      color in ARGB format

    Returns string

Const parseCacheKey

  • parseCacheKey(key: string): { styleId: string; text: string }
  • Parameters

    • key: string

    Returns { styleId: string; text: string }

    • styleId: string
    • text: string

parseColorToHexStringAbgr

  • parseColorToHexStringAbgr(input: string, opacityOverride?: number): string
  • Parse colors and convert them to hex string in ABGR format to use in c++ Examples: "#fff", "#ff0000", "rgba(255,255,0,1)", "#11333333"

    Parameters

    • input: string
    • Optional opacityOverride: number

    Returns string

parseColorToHexStringArgb

  • parseColorToHexStringArgb(input: string, opacityOverride?: number): string
  • Parse colors and convert them to hex string to use in c++ Examples: "#fff", "#ff0000", "rgba(255,255,0,1)", "#11333333"

    Parameters

    • input: string
    • Optional opacityOverride: number

    Returns string

parseColorToTArgb

  • parseColorToTArgb(input: string): TArgb
  • Converts an HTML color code to TArgb

    Parameters

    • input: string

    Returns TArgb

parseColorToUIntArgb

  • parseColorToUIntArgb(input: string, opacity?: number): number
  • Parameters

    • input: string
    • Optional opacity: number

    Returns number

Const parsePc

  • parsePc(value: string, containerSize: number): number
  • Parameters

    • value: string
    • containerSize: number

    Returns number

Const parseSize

  • parseSize(value: number | string, containerSize: number): number
  • Parameters

    • value: number | string
    • containerSize: number

    Returns number

Const parseTArgbToHtmlColor

  • parseTArgbToHtmlColor(targb: TArgb): string
  • Useful for debugging purposes. Converts TArgb to HTML Color code e.g. '#FF112233'=RGBA

    Parameters

    Returns string

Const pruneCache

  • pruneCache(): void
  • Returns void

Const registerFunction

  • registerFunction<T>(baseType: EBaseType, type: string, constructor: T, overWrite?: boolean): void
  • Register a pure function

    Type parameters

    • T: Function

    Parameters

    • baseType: EBaseType

      The base type for, which indicates where the function will be used, Either OptionFunction or OnCreated

    • type: string

      The name of the function

    • constructor: T

      the function to register

    • Default value overWrite: boolean = false

      Whether to override an existing registration for the type name. Default false.

    Returns void

Const registerType

  • registerType<T>(baseType: EBaseType, type: string, constructor: (options?: any) => T, overWrite?: boolean): void
  • Register a function that returns an object of the specified type.

    Type parameters

    • T: object

    Parameters

    • baseType: EBaseType

      The EBaseType of the object that is being registered.

    • type: string

      The name of the type, which should be a subtype of the baseType. For custom types, use the actual type name, not the "Custom" value on the subType enum.

    • constructor: (options?: any) => T

      A function that takes an optional options argument and returns an instance of the desired type.

        • (options?: any): T
        • Parameters

          • Optional options: any

          Returns T

    • Default value overWrite: boolean = false

      Whether to override an existing registration for the type. Default false.

    Returns void

Const registerWasmType

  • registerWasmType<T>(baseType: EBaseType, type: string, constructor: (wasmContext: TSciChart | TSciChart3D, options?: any) => T, overWrite?: boolean): void
  • Register a function that requires a webAssemblyContext to return an object of the specified type.

    Type parameters

    • T: object

    Parameters

    • baseType: EBaseType

      The EBaseType of the object that is being registered.

    • type: string

      The name of the type, which should be a subtype of the baseType. For custom types, use the actual type name, not the "Custom" value on the subType enum.

    • constructor: (wasmContext: TSciChart | TSciChart3D, options?: any) => T

      A function that takes a SciChart 2D WebAssembly Context or SciChart 3D WebAssembly Context and an optional options argument and returns an instance of the desired type.

    • Default value overWrite: boolean = false

      Whether to override an existing registration for the type. Default false.

    Returns void

Const resetAxes

  • Parameters

    Returns void

Const resetCache

  • resetCache(): void
  • Returns void

Const runIfValue

  • runIfValue(value: any, fn: (value: any) => any): any
  • Parameters

    • value: any
    • fn: (value: any) => any
        • (value: any): any
        • Parameters

          • value: any

          Returns any

    Returns any

Const scaleAxes

  • scaleAxes(axes: AxisBase2D[], initialVisibleRanges: NumberRange[], delta: number, isMoreThanHalf: boolean): void
  • Parameters

    Returns void

Const sendTelemetry

  • sendTelemetry(): void
  • Returns void

Const setDevCount

  • setDevCount(value: number): void
  • Parameters

    • value: number

    Returns void

Const setIsDev

  • setIsDev(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

setIsLicenseDebug

  • Parameters

    • value: boolean

    Returns setIsLicenseDebug

Const setLabel

  • setLabel(text: string, styleId: string, label: LabelInfo): void
  • Parameters

    • text: string
    • styleId: string
    • label: LabelInfo

    Returns void

Const setLicenseType

  • setLicenseType(value: LicenseType): void
  • Parameters

    • value: LicenseType

    Returns void

Const setMaxSize

  • setMaxSize(size: number): void
  • Parameters

    • size: number

    Returns void

Const setMinAge

  • setMinAge(ageInMs: number): void
  • Parameters

    • ageInMs: number

    Returns void

Const setOrderId

  • setOrderId(value: string): void
  • Parameters

    • value: string

    Returns void

Const setProductCode

  • setProductCode(value: string): void
  • Parameters

    • value: string

    Returns void

Const setSplineAnimationVectors

  • Parameters

    Returns void

Const setSplineBandAnimationVectors

  • setSplineBandAnimationVectors(wasmContext: TSciChart, animation: SeriesAnimation, ds: XyyDataSeries, animationDS: XyyDataSeries, xSplineValues: SCRTDoubleVector, ySplineValues: SCRTDoubleVector, y1SplineValues: SCRTDoubleVector, isCategoryAxis: boolean, interpolationPoints: number): void
  • Parameters

    Returns void

Const setTelemetry

  • setTelemetry(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

Const setUserCookie

  • setUserCookie(userId: string, sessionId: string, sessionStart: number): void
  • Parameters

    • userId: string
    • sessionId: string
    • sessionStart: number

    Returns void

Const shouldSendTelemetry

  • shouldSendTelemetry(): boolean
  • Returns boolean

stringOccurrences

  • stringOccurrences(str: string, subStr: string, allowOverlapping?: boolean): stringOccurrences
  • Parameters

    • str: string
    • subStr: string
    • Default value allowOverlapping: boolean = false

    Returns stringOccurrences

Const stripAutoColor

  • stripAutoColor(val: string): string
  • Parameters

    • val: string

    Returns string

subArray

  • Parameters

    • array: NumberArray
    • Optional startIndex: number
    • Optional endIndex: number

    Returns subArray

Const switchData

  • switchData(field: EDataSeriesField, x: any, closey: any, openy1z?: any, high?: any, low?: any): any
  • Parameters

    • field: EDataSeriesField
    • x: any
    • closey: any
    • Optional openy1z: any
    • Optional high: any
    • Optional low: any

    Returns any

Const testHasExcluded

  • testHasExcluded(axisMap: Map<string, boolean>): boolean
  • Parameters

    • axisMap: Map<string, boolean>

    Returns boolean

Const testIsHitForBand

  • testIsHitForBand(isDigitalLine: boolean, xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, xValues: SCRTDoubleVector, getYValue: (index: number) => number, getY1Value: (index: number) => number, pointIndex: number, xHitCoord: number, yHitCoord: number, dataSeries: BaseDataSeries): { isHit: boolean; secondPointIndex: number }
  • Parameters

    • isDigitalLine: boolean
    • xCoordinateCalculator: CoordinateCalculatorBase
    • yCoordinateCalculator: CoordinateCalculatorBase
    • xValues: SCRTDoubleVector
    • getYValue: (index: number) => number
        • (index: number): number
        • Parameters

          • index: number

          Returns number

    • getY1Value: (index: number) => number
        • (index: number): number
        • Parameters

          • index: number

          Returns number

    • pointIndex: number
    • xHitCoord: number
    • yHitCoord: number
    • dataSeries: BaseDataSeries

    Returns { isHit: boolean; secondPointIndex: number }

    • isHit: boolean
    • secondPointIndex: number

Const testIsHitForColumn

Const testIsHitForErrorBars

  • Parameters

    Returns { highValue: number; isHit: boolean; lowValue: number }

    • highValue: number
    • isHit: boolean
    • lowValue: number

Const testIsHitForImpulse

Const testIsHitForLine

  • testIsHitForLine(xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, pointIndex: number, xHitCoord: number, yHitCoord: number, hitTestRadius: number, dataSeries: BaseDataSeries): { isHit: boolean; secondPointIndex: number }
  • Parameters

    • xCoordinateCalculator: CoordinateCalculatorBase
    • yCoordinateCalculator: CoordinateCalculatorBase
    • xValues: SCRTDoubleVector
    • yValues: SCRTDoubleVector
    • pointIndex: number
    • xHitCoord: number

      The X coordinate, isVertical property is already taken into account

    • yHitCoord: number

      The Y coordinate, isVertical property is already taken into account

    • hitTestRadius: number
    • dataSeries: BaseDataSeries

    Returns { isHit: boolean; secondPointIndex: number }

    • isHit: boolean
    • secondPointIndex: number

Const testIsHitForMountain

  • Parameters

    Returns { isHit: boolean; secondPointIndex: number }

    • isHit: boolean
    • secondPointIndex: number

Const testIsHitForOHLC

Const testIsHitForPoint

  • Parameters

    Returns boolean

Const testIsInBounds

  • testIsInBounds(x: number, y: number, left: number, bottom: number, right: number, top: number, radius?: number): boolean
  • Parameters

    • x: number
    • y: number
    • left: number
    • bottom: number
    • right: number
    • top: number
    • Default value radius: number = 0

    Returns boolean

Const testIsInInterval

  • testIsInInterval(x: number, intervalStart: number, intervalEnd: number, radius?: number): boolean
  • Tests if X is within radius from the [intervalStart, intervalEnd] interval, intervalStart, intervalEnd values might not be sorted

    Parameters

    • x: number
    • intervalStart: number
    • intervalEnd: number
    • Default value radius: number = 0

    Returns boolean

Const testIsInXBounds

  • testIsInXBounds(xHitTestPoint: number, xDataPointCoord: number, maxDistance: number): boolean
  • Parameters

    • xHitTestPoint: number
    • xDataPointCoord: number
    • maxDistance: number

    Returns boolean

Const testIsOverAxes

  • Parameters

    Returns boolean

Const toHex

  • toHex(value: number): toHex
  • toHex(value: number): string
  • Converts a UINT color number to a 8-digit hex code e.g. #FFAABBCC

    Parameters

    • value: number

    Returns toHex

  • Parameters

    • value: number

    Returns string

Const toScientific

  • toScientific(value: number, precision: number, logarithmicBase: number): string
  • Parameters

    • value: number
    • precision: number
    • logarithmicBase: number

    Returns string

Const toSuperScript

  • toSuperScript(value: number): string
  • Parameters

    • value: number

    Returns string

Const translateDataValueRectToAbsolute

Const translateFromCanvasToSeriesViewRect

  • translateFromCanvasToSeriesViewRect(point: Point, seriesViewRect: Rect, allowValuesOutOfBounds?: boolean): Point
  • Translates from canvas to seriesViewRect screen coordinates

    Parameters

    • point: Point
    • seriesViewRect: Rect
    • Default value allowValuesOutOfBounds: boolean = false

      will translate even if the point is outside of the seriesViewRect

    Returns Point

Const translateFromCanvasToSeriesViewRectX

  • translateFromCanvasToSeriesViewRectX(x: number, seriesViewRect: Rect, allowValuesOutOfBounds?: boolean): number
  • Parameters

    • x: number
    • seriesViewRect: Rect
    • Default value allowValuesOutOfBounds: boolean = false

    Returns number

Const translateFromCanvasToSeriesViewRectY

  • translateFromCanvasToSeriesViewRectY(y: number, seriesViewRect: Rect, allowValuesOutOfBounds?: boolean): number
  • Parameters

    • y: number
    • seriesViewRect: Rect
    • Default value allowValuesOutOfBounds: boolean = false

    Returns number

Const translateFromSeriesViewRectToCanvas

  • translateFromSeriesViewRectToCanvas(point: Point, seriesViewRect: Rect, allowValuesOutOfBounds?: boolean): Point
  • Translates from seriesViewRect to canvas screen coordinates

    Parameters

    • point: Point
    • seriesViewRect: Rect
    • Default value allowValuesOutOfBounds: boolean = false

      will translate even if the point is outside of the seriesViewRect

    Returns Point

Const translateFromSeriesViewRectToCanvasX

  • translateFromSeriesViewRectToCanvasX(x: number, seriesViewRect: Rect, allowValuesOutOfBounds?: boolean): number
  • Parameters

    • x: number
    • seriesViewRect: Rect
    • Default value allowValuesOutOfBounds: boolean = false

    Returns number

Const translateFromSeriesViewRectToCanvasY

  • translateFromSeriesViewRectToCanvasY(y: number, seriesViewRect: Rect, allowValuesOutOfBounds?: boolean): number
  • Parameters

    • y: number
    • seriesViewRect: Rect
    • Default value allowValuesOutOfBounds: boolean = false

    Returns number

Const translateToNotScaled

  • translateToNotScaled(value: number): number
  • Parameters

    • value: number

    Returns number

uintArgbColorIsTransparent

  • uintArgbColorIsTransparent(argbColor: number): boolean
  • Parameters

    • argbColor: number

    Returns boolean

uintArgbColorLerp

  • uintArgbColorLerp(from: number, to: number, ratio: number): number
  • Linearly interpolates between two colors based on the ratio passed in. E.g. Ratio = 0.0f returns From color, ratio = 1.0f returns To Color. Ratio = 0.5f returns a mix of the two Works for 32 bit colors

    Parameters

    • from: number

      the start color, for example 0x0000ffff (format ARGB)

    • to: number

      the end color, for example 0xffffffff

    • ratio: number

      the value between 0 and 1

    Returns number

uintArgbColorLerp24bit

  • uintArgbColorLerp24bit(from: number, to: number, ratio: number): number
  • Linearly interpolates between two colors based on the ratio passed in. E.g. Ratio = 0.0f returns From color, ratio = 1.0f returns To Color. Ratio = 0.5f returns a mix of the two. Works only for numbers not more than 24 bit

    Parameters

    • from: number

      the start color, for example 0xff0000

    • to: number

      the end color, for example 0x00ff00

    • ratio: number

      the value between 0 and 1

    Returns number

uintArgbColorMultiplyOpacity

  • uintArgbColorMultiplyOpacity(argbColor: number, opacity: number): number
  • Parameters

    • argbColor: number
    • opacity: number

    Returns number

uintArgbColorOverrideOpacity

  • uintArgbColorOverrideOpacity(argbColor: number, opacity: number): number
  • Parameters

    • argbColor: number
    • opacity: number

    Returns number

uintArgbColorToAbgr

  • uintArgbColorToAbgr(argbColor: number): number
  • Parameters

    • argbColor: number

    Returns number

updateAxisLayoutState

  • Parameters

    Returns void

updateLeftAndRightChartLayoutState

  • updateLeftAndRightChartLayoutState(chartLayoutState: ChartLayoutState, additionalLeftSize?: number, additionalRightSize?: number): void
  • Parameters

    • chartLayoutState: ChartLayoutState
    • Default value additionalLeftSize: number = 0
    • Default value additionalRightSize: number = 0

    Returns void

Const updateSplineAnimationProperties

  • updateSplineAnimationProperties(wasmContext: TSciChart, animation: SeriesAnimation, progress: number, dataSeries: BaseDataSeries, xSplineValues: SCRTDoubleVector, ySplineValues: SCRTDoubleVector): void
  • Parameters

    Returns void

Const updateSplineBandAnimationProperties

  • updateSplineBandAnimationProperties(wasmContext: TSciChart, animation: SeriesAnimation, progress: number, dataSeries: XyyDataSeries, xSplineValues: SCRTDoubleVector, ySplineValues: SCRTDoubleVector, y1SplineValues: SCRTDoubleVector): void
  • Parameters

    • wasmContext: TSciChart
    • animation: SeriesAnimation
    • progress: number
    • dataSeries: XyyDataSeries
    • xSplineValues: SCRTDoubleVector
    • ySplineValues: SCRTDoubleVector
    • y1SplineValues: SCRTDoubleVector

    Returns void

updateTopAndBottomChartLayoutState

  • updateTopAndBottomChartLayoutState(chartLayoutState: ChartLayoutState, additionalTopSize?: number, additionalBottomSize?: number): void
  • Parameters

    • chartLayoutState: ChartLayoutState
    • Default value additionalTopSize: number = 0
    • Default value additionalBottomSize: number = 0

    Returns void

Const updateTsrVector4

  • updateTsrVector4(color: TArgb, tsrColor: TSRVector4): void
  • Converts a color in TArgb format to TSRVector4 (RGBA -> x,y,z,w) for use in 3D Engine

    Parameters

    • color: TArgb
    • tsrColor: TSRVector4

    Returns void

Const wrapNativeText

  • wrapNativeText(text: string, maxWidth: number, font: SCRTFont, textBounds: TSRTextBounds): string
  • Wrap a string by adding newline characters, splitting on spaces and wrapping to a maximum size

    Parameters

    • text: string
    • maxWidth: number
    • font: SCRTFont
    • textBounds: TSRTextBounds

    Returns string

Const wrapText

  • wrapText(text: string, maxLength: number): string[]
  • Convert a string into an array of lines by splitting on spaces and wrapping to a maximum number of characters

    Parameters

    • text: string
    • maxLength: number

    Returns string[]

Const zeroArray2D

  • zeroArray2D(dimensions: number[]): number[][]
  • description

    creates a 2-dimensional array filled with zeros

    Parameters

    • dimensions: number[]

    Returns number[][]

Object literals

Const animationHelpers

animationHelpers: object

animationUpdate

animationUpdate: animationUpdate

checkCanDraw

checkCanDraw: checkCanDraw

checkIsAnimationRunning

checkIsAnimationRunning: checkIsAnimationRunning

copyVector

copyVector: copyVector

createPointMarker

createPointMarker: createPointMarker

interpolateColor

interpolateColor: interpolateColor

interpolateNumber

interpolateNumber: interpolateNumber

setSplineAnimationVectors

setSplineAnimationVectors: setSplineAnimationVectors

setSplineBandAnimationVectors

setSplineBandAnimationVectors: setSplineBandAnimationVectors

updateSplineAnimationProperties

updateSplineAnimationProperties: updateSplineAnimationProperties

updateSplineBandAnimationProperties

updateSplineBandAnimationProperties: updateSplineBandAnimationProperties

Const annotationHelpers

annotationHelpers: object

calcNewApex

calcNewApex: calcNewApex

createSvg

createSvg: createSvg

Const autoReverseEasing

autoReverseEasing: object

Reversable functions that go from 0..1..0 used throughout SciChart when animations are used

linear

  • linear(t: number): number
  • No easing acceleration like linear, but it does reverse from 0..1..0

    Parameters

    • t: number

    Returns number

Const chartBuilder

chartBuilder: object

build2DChart

build2DChart: build2DChart
inheritdoc

buildAnnotations

buildAnnotations: buildAnnotations
inheritdoc

buildAxes

buildAxes: buildAxes
inheritdoc

buildChart

buildChart: buildChart
inheritdoc

buildDataSeries

buildDataSeries: buildDataSeries
inheritdoc

buildModifiers

buildModifiers: buildModifiers
inheritdoc

buildPieChart

buildPieChart: buildPieChart
inheritdoc

buildSeries

buildSeries: buildSeries
inheritdoc

chartReviver

chartReviver: chartReviver
inheritdoc

configureChart

configureChart: configureChart
inheritdoc

registerFunction

registerFunction: registerFunction
inheritdoc

registerType

registerType: registerType
inheritdoc

registerWasmType

registerWasmType: registerWasmType
inheritdoc

Const easing

easing: object

Easing functions used throughout SciChart when animations are used

cubic

  • cubic(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

elastic

  • elastic(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inCirc

  • inCirc(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inCubic

  • inCubic(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inExpo

  • inExpo(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inOutCirc

  • inOutCirc(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inOutCubic

  • inOutCubic(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inOutExpo

  • inOutExpo(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inOutQuad

  • inOutQuad(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inOutQuart

  • inOutQuart(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inOutQuint

  • inOutQuint(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inOutSine

  • inOutSine(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inQuad

  • inQuad(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inQuart

  • inQuart(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inQuint

  • inQuint(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

inSine

  • inSine(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

linear

  • linear(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

outCirc

  • outCirc(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

outCubic

  • outCubic(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

outExpo

  • outExpo(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

outQuad

  • outQuad(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

outQuart

  • outQuart(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

outQuint

  • outQuint(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

outSine

  • outSine(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

quadratic

  • quadratic(t: number): number
  • inheritdoc

    Parameters

    • t: number

    Returns number

Const handler

handler: object

construct

  • Returns handler

Const hashUtils

hashUtils: object

generateBooleanHash

generateBooleanHash: generateBooleanHash

generateCombinedHash

generateCombinedHash: generateCombinedHash

generateHash

generateHash: generateHash

generateNumberHash

generateNumberHash: generateNumberHash

generateObjectHash

generateObjectHash: generateObjectHash

Const hitTestHelpers

hitTestHelpers: object

createHitTestInfo

createHitTestInfo: createHitTestInfo

getNearestNonUniformHeatmapPoint

getNearestNonUniformHeatmapPoint: getNearestNonUniformHeatmapPoint

getNearestPoint

getNearestPoint: getNearestPoint

getNearestUniformHeatmapPoint

getNearestUniformHeatmapPoint: getNearestUniformHeatmapPoint

getNearestXPoint

getNearestXPoint: getNearestXPoint

getNearestXyPoint

getNearestXyPoint: getNearestXyPoint

getNearestXyyPoint

getNearestXyyPoint: getNearestXyyPoint

testIsHitForBand

testIsHitForBand: testIsHitForBand

testIsHitForColumn

testIsHitForColumn: testIsHitForColumn

testIsHitForErrorBars

testIsHitForErrorBars: testIsHitForErrorBars

testIsHitForImpulse

testIsHitForImpulse: testIsHitForImpulse

testIsHitForLine

testIsHitForLine: testIsHitForLine

testIsHitForMountain

testIsHitForMountain: testIsHitForMountain

testIsHitForOHLC

testIsHitForOHLC: testIsHitForOHLC

testIsHitForPoint

testIsHitForPoint: testIsHitForPoint

Const labelCache

labelCache: object

A global cache for labels, used by all labelProviders, to reduce the amount of time spent creating label textures.

checkStyle

checkStyle: checkStyle

Check if a text style matches the one for the given id

freeStyle

freeStyle: freeStyle

Notify the cache that a style is no longer used. Linked labels are only deleted when there are no remaining uses, and then only after minAge has passed.

getLabel

getLabel: getLabel

Get a label from the cache. Returns undefined if none found.

getMaxSize

getMaxSize: getMaxSize

Get the maximum number of labels allowed to be stored in the cache. Used when calling pruneCache

getMinAge

getMinAge: getMinAge

Get the minimum age (time since last used) of labels in the cache. This prevents recently used labels from being pruned, or removed when style is freed

getStyleId

getStyleId: getStyleId

Get an identifier for the given text style. Returns an existing identifier if a matching style exists in the cache

pruneCache

pruneCache: pruneCache

Remove old labels from the cache, if there are more than MaxSize.

resetCache

resetCache: resetCache

Completely clears and resets the cache. Testing use only

setLabel

setLabel: setLabel

Add a label to the cache

setMaxSize

setMaxSize: setMaxSize

Set the maximum number of labels allowed to be stored in the cache. Used when calling pruneCache

setMinAge

setMinAge: setMinAge

Set the minimum age (time since last used) of labels in the cache. This prevents recently used labels from being pruned, or removed when style is freed

Const licenseManager2dState

licenseManager2dState: object

getDevCount

getDevCount: getDevCount

getIsDev

getIsDev: getIsDev

getLicenseType

getLicenseType: getLicenseType

getOrderId

getOrderId: getOrderId

getProductCode

getProductCode: getProductCode

getTelemetry

getTelemetry: getTelemetry

setDevCount

setDevCount: setDevCount

setIsDev

setIsDev: setIsDev

setLicenseType

setLicenseType: setLicenseType

setOrderId

setOrderId: setOrderId

setProductCode

setProductCode: setProductCode

setTelemetry

setTelemetry: setTelemetry

Const localStorageApi

localStorageApi: object

clearLicensingDebug

clearLicensingDebug: clearLicensingDebug

getIsLicenseDebug

getIsLicenseDebug: getIsLicenseDebug

getLicenseWizardMaxPort

getLicenseWizardMaxPort: getLicenseWizardMaxPort

getLicenseWizardPort

getLicenseWizardPort: getLicenseWizardPort

setIsLicenseDebug

setIsLicenseDebug: setIsLicenseDebug

Const testLayoutManager

testLayoutManager: object

layoutAxisPartsBottomStrategy

layoutAxisPartsBottomStrategy: layoutAxisPartsBottomStrategy

layoutAxisPartsLeftStrategy

layoutAxisPartsLeftStrategy: layoutAxisPartsLeftStrategy

layoutAxisPartsRightStrategy

layoutAxisPartsRightStrategy: layoutAxisPartsRightStrategy

layoutAxisPartsTopStrategy

layoutAxisPartsTopStrategy: layoutAxisPartsTopStrategy

updateAxisLayoutState

updateAxisLayoutState: updateAxisLayoutState

Generated using TypeDoc