Options
All
  • Public
  • Public/Protected
  • All
Menu

API Documentation for SciChart.js - v3.5.706

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

TAdvancedTextStyle: TCommonTextStyle & TAdvancedTextProperties

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

TAnnotationDefinition: { options?: IAxisMarkerAnnotationOptions; type: RenderContextAxisMarkerAnnotation } | { options?: IBoxAnnotationOptions; type: RenderContextBoxAnnotation } | { options?: ILineAnnotationOptions; type: RenderContextHorizontalLineAnnotation } | { options?: ILineAnnotationOptions; type: RenderContextLineAnnotation } | { options?: ILineAnnotationOptions; type: RenderContextVerticalLineAnnotation } | { options?: ITextAnnotationOptions; type: SVGTextAnnotation } | { options?: ICustomAnnotationOptions; type: SVGCustomAnnotation } | { options?: INativeTextAnnotationOptions; type: RenderContextNativeTextAnnotation }

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

TCategoryCoordCalc: CategoryCoordinateCalculator | FlippedCategoryCoordinateCalculator

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

TCommonTextStyle: TNativeTextStyle | TTextureTextStyle

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 } | { options?: IBaseStackedCollectionOptions; type: StackedCollection } | { 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 used by Guard.arraysSameLengthArr

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

THoverCallback

THoverCallback<TEntityType>: (args: IHoverCallbackArgs<TEntityType>) => void

Type parameters

Type declaration

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?: IAnnotationHoverModifierOptions; type: AnnotationHover } | { 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; domBackgroundSvgContainer?: SVGSVGElement; domCanvas2D?: HTMLCanvasElement; domCanvasWebGL?: HTMLCanvasElement; domChartRoot?: HTMLDivElement; domDivContainer?: HTMLDivElement; domSeriesBackground?: HTMLDivElement; domSvgAdornerLayer?: SVGSVGElement; domSvgContainer?: SVGSVGElement }

Type declaration

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

TSelectionChangedCallback

TSelectionChangedCallback: (args: SelectionChangedArgs) => void

The type of the callback function

Type declaration

TSeriesDataDefinition

TSeriesDataDefinition: TXySeriesData | TXyySeriesData | TXyzSeriesData | THlcSeriesData | TOhlcSeriesData | TXyTextSeriesData | IUniformHeatmapSeriesOptions | INonUniformHeatmapSeriesOptions

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 } | { options?: ISmoothStackedMountainRenderableSeriesOptions; type: SmoothStackedMountainSeries; 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

TShift: xCoordShift | yCoordShift

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 }

TTargetsSelector

TTargetsSelector<TEntityType>: (modifier: PointerEventsMediatorModifier<TEntityType>) => TEntityType[]

Type parameters

Type declaration

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

TTextStyleBase3D

TTextStyleBase3D: { color?: string; fontSize?: number }

Type declaration

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

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 TEN_SECONDS

TEN_SECONDS: 10 = 10

Const buildStamp

buildStamp: "2024-10-02T00:00:00" = "2024-10-02T00: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

Let isStorageAvailable

isStorageAvailable: boolean = undefined

Const labelCacheByTextAndStyle

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

Let lastStyleId

lastStyleId: number = 0

Const libraryVersion

libraryVersion: "3.5.0000" = "3.5.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 bezierTransform

  • bezierTransform(xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, indexes: SCRTDoubleVector, oldX: SCRTDoubleVector, oldY: SCRTDoubleVector, iStart: number, iEnd: number, interpolationPoints: number, curvature: number, y1Values?: SCRTDoubleVector): void

  • Parameters

    • xValues: SCRTDoubleVector
    • yValues: SCRTDoubleVector
    • indexes: SCRTDoubleVector
    • oldX: SCRTDoubleVector
    • oldY: SCRTDoubleVector
    • iStart: number
    • iEnd: number
    • interpolationPoints: number
    • curvature: number
    • Optional y1Values: SCRTDoubleVector

    Returns void

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; Undefined: 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; Undefined: 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
  • calculateMaxGroupSize(outerLayoutSizes: Record<string, number>): number

  • Parameters

    • outerLayoutSizes: Record<string, number>

    Returns 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 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
  • deprecated

    Use copyDoubleVector instead

    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, nextElement?: Element): SVGElement

  • All svg creation is run through this funciton so it can be mocked for tests

    Parameters

    • svgString: string
    • svgRoot: Node
    • Optional nextElement: Element

    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 fitElementToViewRect

  • fitElementToViewRect(element: HTMLElement | SVGSVGElement, viewRect: Rect): void

  • Parameters

    • element: HTMLElement | SVGSVGElement
    • viewRect: Rect

    Returns void

Const fitSvgToViewRect

  • fitSvgToViewRect(svgElement: SVGSVGElement, viewRect: Rect): void

  • Parameters

    • svgElement: SVGSVGElement
    • viewRect: Rect

    Returns void

Const formatNumber

  • 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 formatUnixDateToHumanStringSSms

  • formatUnixDateToHumanStringSSms(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[][]

getOHLCYRange

  • getOHLCYRange(indicesRange: NumberRange, openValues: SCRTDoubleVector, highValues: SCRTDoubleVector, lowValues: SCRTDoubleVector, closeValues: SCRTDoubleVector): getOHLCYRange

  • Parameters

    • indicesRange: NumberRange
    • openValues: SCRTDoubleVector
    • highValues: SCRTDoubleVector
    • lowValues: SCRTDoubleVector
    • closeValues: SCRTDoubleVector

    Returns getOHLCYRange

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; Undefined: 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: