scichart 3.0.301 → 3.1.329

package/Charting/Drawing/Pen2DCache.d.ts

@@ -65,4 +65,4 @@ export declare const getScrtPenFromCache: (penCache: Pen2DCache) => SCRTPen;
  * @param strokeDashArray the StrokeDashArray which defines any dash e.g. [2,2] means dash for 2pts, gap for 2pts (or undefined = solid line).
  * @returns the new or existing instance of {@link SCRTPen}}
  */
-export declare const createPenInCache: (penCache: Pen2DCache, stroke: string, strokeThickness: number, opacity: number, strokeDashArray?: number[]) => SCRTPen;
+export declare const createPenInCache: (penCache: Pen2DCache, stroke: string, strokeThickness: number, opacity: number, strokeDashArray?: number[], antiAliased?: boolean) => SCRTPen;

package/Charting/Drawing/Pen2DCache.js

@@ -119,13 +119,14 @@ exports.getScrtPenFromCache = getScrtPenFromCache;
  * @param strokeDashArray the StrokeDashArray which defines any dash e.g. [2,2] means dash for 2pts, gap for 2pts (or undefined = solid line).
  * @returns the new or existing instance of {@link SCRTPen}}
  */
-var createPenInCache = function (penCache, stroke, strokeThickness, opacity, strokeDashArray) {
+var createPenInCache = function (penCache, stroke, strokeThickness, opacity, strokeDashArray, antiAliased) {
     Guard_1.Guard.notNull(penCache, "penCache");
     var cachedPen = penCache.create({
         stroke: stroke,
         strokeThickness: strokeThickness,
         opacity: opacity,
-        strokeDashArray: strokeDashArray
+        strokeDashArray: strokeDashArray,
+        antiAliased: antiAliased
     });
     return cachedPen.scrtPen;
 };

package/Charting/Services/ChartTitleRenderer.d.ts

@@ -0,0 +1,37 @@
+import { Rect } from "../../Core/Rect";
+import { Thickness } from "../../Core/Thickness";
+import { TChartTitleStyle } from "../../types/TextStyle";
+import { WebGlRenderContext2D } from "../Drawing/WebGlRenderContext2D";
+import { IChartTitleRenderer, TitleRendererBase } from "./TitleRenderer";
+/**
+ * Draws a chart title
+ */
+export declare class ChartTitleRenderer extends TitleRendererBase<TChartTitleStyle> implements IChartTitleRenderer {
+    protected titleOffsetProperty: Thickness;
+    /**
+     * Defines a padding reserved for space taken by a title
+     */
+    get titleOffset(): Thickness;
+    /**
+     * Calculates {@link ChartTitleRenderer.titleOffset}
+     */
+    measure(title: string | string[], originalTextStyle: Required<TChartTitleStyle>, renderContext: WebGlRenderContext2D): void;
+    /**
+     * Calculates {@link ChartTitleRenderer.viewRect} of the title
+     * @param chartViewRect - the container area which is used as an origin for title layout calculation
+     */
+    layout(chartViewRect: Rect): void;
+    /**
+     * Performs rendering of the title
+     */
+    draw(renderContext: WebGlRenderContext2D): void;
+    protected getTitleTexture(): import("../Visuals/TextureManager/TextureManager").TTextureObject;
+    /**
+     * Calculates width and hight of the title text
+     */
+    protected getTextSize(title: string | string[], textStyle: TChartTitleStyle, renderContext: WebGlRenderContext2D): void;
+    /**
+     * Calculates the {@link ChartTitleRenderer.titleOffset}
+     */
+    protected getTitleOffset(title: string | string[], textStyle: TChartTitleStyle): Thickness;
+}

package/Charting/Services/ChartTitleRenderer.js

@@ -0,0 +1,176 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChartTitleRenderer = void 0;
+var Thickness_1 = require("../../Core/Thickness");
+var TextStyle_1 = require("../../types/TextStyle");
+var text_1 = require("../../utils/text");
+var SciChartSurfaceBase_1 = require("../Visuals/SciChartSurfaceBase");
+var TitleRenderer_1 = require("./TitleRenderer");
+/**
+ * Draws a chart title
+ */
+var ChartTitleRenderer = /** @class */ (function (_super) {
+    __extends(ChartTitleRenderer, _super);
+    function ChartTitleRenderer() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.titleOffsetProperty = Thickness_1.Thickness.fromNumber(0);
+        return _this;
+    }
+    Object.defineProperty(ChartTitleRenderer.prototype, "titleOffset", {
+        /**
+         * Defines a padding reserved for space taken by a title
+         */
+        get: function () {
+            return this.titleOffsetProperty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Calculates {@link ChartTitleRenderer.titleOffset}
+     */
+    ChartTitleRenderer.prototype.measure = function (title, originalTextStyle, renderContext) {
+        var _a;
+        var shouldUpdateTextSize = title !== this.text ||
+            !(0, TextStyle_1.areEqualTextStyles)(originalTextStyle, this.originalTextStyle) ||
+            ((_a = this.originalTextStyle) === null || _a === void 0 ? void 0 : _a.position) !== originalTextStyle.position;
+        this.text = title;
+        if (title) {
+            if (!this.useCache || !this.texture || shouldUpdateTextSize) {
+                // recalculate cached text size info or texture
+                this.originalTextStyle = __assign({}, originalTextStyle);
+                this.textStyle = (0, TextStyle_1.adjustTextStyle)(originalTextStyle);
+                this.getTextSize(title, this.textStyle, renderContext);
+            }
+            else {
+                // update text style properties that only affect placement
+                this.textStyle.alignment = originalTextStyle.alignment;
+                this.textStyle.placeWithinChart = originalTextStyle.placeWithinChart;
+            }
+        }
+        this.titleOffsetProperty = this.getTitleOffset(title, this.textStyle);
+    };
+    /**
+     * Calculates {@link ChartTitleRenderer.viewRect} of the title
+     * @param chartViewRect - the container area which is used as an origin for title layout calculation
+     */
+    ChartTitleRenderer.prototype.layout = function (chartViewRect) {
+        if (!this.text) {
+            this.viewRectProperty = undefined;
+            return;
+        }
+        this.viewRectProperty = this.getViewRect(this.text, chartViewRect, this.textStyle.position, this.textStyle.alignment);
+    };
+    /**
+     * Performs rendering of the title
+     */
+    ChartTitleRenderer.prototype.draw = function (renderContext) {
+        if (!this.text) {
+            return;
+        }
+        if (SciChartSurfaceBase_1.DebugForDpi) {
+            console.log("ChartTitleRenderer.draw fontSize: ".concat(this.textStyle.fontSize));
+        }
+        var _a = this.textStyle, useNativeText = _a.useNativeText, position = _a.position, lineSpacing = _a.lineSpacing;
+        this.drawInternal(renderContext, useNativeText, position, lineSpacing);
+        if (this.drawDebug) {
+            this.drawTitleDebugViewRect(renderContext);
+        }
+    };
+    ChartTitleRenderer.prototype.getTitleTexture = function () {
+        var position = this.textStyle.position;
+        var adjRotation = 0;
+        // let adjRotation = this.textStyle.rotation;
+        if (position === TextStyle_1.ETitlePosition.Left) {
+            adjRotation += -90;
+        }
+        else if (position === TextStyle_1.ETitlePosition.Right) {
+            adjRotation += 90;
+        }
+        // TODO try using rotation property here
+        var titleText = Array.isArray(this.text) ? this.text : this.text.split("\n");
+        var texture = this.textureManager.createTextTexture(titleText, 
+        // @ts-ignore mismatch with TTextStyle
+        this.textStyle, 
+        // { ...this.textStyle, padding: new Thickness(0, 0, 0, 0) },
+        adjRotation, this.textStyle.lineSpacing);
+        return texture;
+    };
+    /**
+     * Calculates width and hight of the title text
+     */
+    ChartTitleRenderer.prototype.getTextSize = function (title, textStyle, renderContext) {
+        if (title === void 0) { title = ""; }
+        var hasHorizontalPlacement = (0, TextStyle_1.getIsHorizontalPlacement)(textStyle.position);
+        if (textStyle.useNativeText) {
+            // @ts-ignore mismatch with TTextStyle
+            var nativeFont = renderContext.getFont(textStyle, !hasHorizontalPlacement);
+            var titleString = Array.isArray(title) ? title.join("\n") : title;
+            var _a = (0, text_1.getNativeTextSize)(titleString, nativeFont, textStyle, this.webAssemblyContext), textHeight = _a.textHeight, textWidth = _a.textWidth, nativeLineSpacing = _a.nativeLineSpacing, firstLineAscent = _a.firstLineAscent;
+            this.textHeight = textHeight;
+            this.textWidth = textWidth;
+            this.nativeLineSpacing = nativeLineSpacing;
+            this.firstLineAscent = firstLineAscent;
+            this.desiredHeightProperty = hasHorizontalPlacement ? this.textHeight : this.textWidth;
+            this.desiredWidthProperty = hasHorizontalPlacement ? this.textWidth : this.textHeight;
+        }
+        else {
+            // current title texture doesn't include paddings, so they should be added here
+            var texture = this.getTitleTexture();
+            this.texture = texture;
+            this.desiredHeightProperty = texture.textureHeight;
+            this.desiredWidthProperty = texture.textureWidth;
+            this.textHeight = hasHorizontalPlacement ? this.desiredHeightProperty : this.desiredWidthProperty;
+            this.textWidth = hasHorizontalPlacement ? this.desiredWidthProperty : this.desiredHeightProperty;
+        }
+    };
+    /**
+     * Calculates the {@link ChartTitleRenderer.titleOffset}
+     */
+    ChartTitleRenderer.prototype.getTitleOffset = function (title, textStyle) {
+        if (!title || textStyle.placeWithinChart) {
+            return Thickness_1.Thickness.fromNumber(0);
+        }
+        var height = this.textHeight;
+        switch (textStyle.position) {
+            case TextStyle_1.ETitlePosition.Top:
+                return new Thickness_1.Thickness(height, 0, 0, 0);
+            case TextStyle_1.ETitlePosition.Bottom:
+                return new Thickness_1.Thickness(0, 0, height, 0);
+            case TextStyle_1.ETitlePosition.Left:
+                return new Thickness_1.Thickness(0, 0, 0, height);
+            case TextStyle_1.ETitlePosition.Right:
+                return new Thickness_1.Thickness(0, height, 0, 0);
+            default:
+                return (0, TextStyle_1.handleInvalidChartTitlePosition)(textStyle.position);
+        }
+    };
+    return ChartTitleRenderer;
+}(TitleRenderer_1.TitleRendererBase));
+exports.ChartTitleRenderer = ChartTitleRenderer;

package/Charting/Services/SciChartRenderer.d.ts

@@ -41,5 +41,11 @@ export declare class SciChartRenderer {
     private tryPerformAutoRangeOn;
     private onParentSurfaceRendered;
     private updateWatermark;
-    private getViewportRect;
+    private getViewportSvgRect;
+    private scheduleTitleDraw;
+    private measureTitle;
+    private layoutTitle;
+    private getChartViewRect;
+    private getAbsoluteLayer;
+    private drawDebugSurfaceRect;
 }

package/Charting/Services/SciChartRenderer.js

@@ -20,12 +20,16 @@ var hash_1 = require("../../utils/hash");
 var WebGlRenderContext2D_1 = require("../Drawing/WebGlRenderContext2D");
 var ResamplingParams_1 = require("../Numerics/Resamplers/ResamplingParams");
 var IAnnotation_1 = require("../Visuals/Annotations/IAnnotation");
+var SciChartSurface_1 = require("../Visuals/SciChartSurface");
 var SciChartSurfaceBase_1 = require("../Visuals/SciChartSurfaceBase");
 var DpiHelper_1 = require("../Visuals/TextureManager/DpiHelper");
 var RenderPassData_1 = require("./RenderPassData");
 var RenderPassInfo_1 = require("./RenderPassInfo");
 var SvgClippingMode_1 = require("../../types/SvgClippingMode");
 var WatermarkPosition_1 = require("../../types/WatermarkPosition");
+var NativeObject_1 = require("../Visuals/Helpers/NativeObject");
+var createNativeRect_1 = require("../Visuals/Helpers/createNativeRect");
+var parseColor_1 = require("../../utils/parseColor");
 /**
  * A class used internally in SciChart to perform layout, arrangement, data-preparation and rendering on the Cartesian 2D {@link SciChartSurface}
  */
@@ -122,23 +126,26 @@ var SciChartRenderer = /** @class */ (function () {
         this.sciChartSurface.onAnimate(timeElapsed);
         renderContext.enqueueLayeredDraw(function () {
             _this.sciChartSurface.updateBackground();
-        }, (0, WebGlRenderContext2D_1.calculateAbsoluteRenderLayer)(this.sciChartSurface.layersOffset, this.sciChartSurface.stepBetweenLayers, DefaultRenderLayer_1.EDefaultRenderLayer.AxisBandsLayer));
+        }, this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.AxisBandsLayer));
         // Step 2 autorange
         this.sciChartSurface.updateStackedCollectionAccumulatedVectors();
         this.sciChartSurface.xAxes.asArray().forEach(function (axis) { return _this.tryPerformAutoRangeOn(axis, _this.sciChartSurface); });
         this.sciChartSurface.yAxes.asArray().forEach(function (axis) { return _this.tryPerformAutoRangeOn(axis, _this.sciChartSurface); });
         // Step 3 layout
-        var seriesViewRect = this.sciChartSurface.layoutManager.layoutChart(renderContext.viewportSize);
-        var viewportSvgRect = this.getViewportRect(renderContext.viewportSize, seriesViewRect);
+        var titleOffset = this.measureTitle(renderContext);
+        var seriesViewRect = this.sciChartSurface.layoutManager.layoutChart(renderContext.viewportSize, titleOffset);
+        var viewportSvgRect = this.getViewportSvgRect(renderContext.viewportSize, seriesViewRect);
         this.sciChartSurface.setCoordSvgTranslation(seriesViewRect.x - viewportSvgRect.x, seriesViewRect.y - viewportSvgRect.y);
         this.updateSvgCanvasSize(viewportSvgRect);
+        this.layoutTitle(seriesViewRect);
+        this.scheduleTitleDraw(renderContext);
         // Step 4 prepare render data
         var _a = this.prepareAxesRenderData(), xAxesById = _a.xAxesById, yAxesById = _a.yAxesById;
         var renderPassInfo = this.prepareSeriesRenderData(seriesViewRect, xAxesById);
         // Draw seriesViewRect border
         renderContext.enqueueLayeredDraw(function () {
             _this.sciChartSurface.drawBorder(renderContext);
-        }, (0, WebGlRenderContext2D_1.calculateAbsoluteRenderLayer)(this.sciChartSurface.layersOffset, this.sciChartSurface.stepBetweenLayers, DefaultRenderLayer_1.EDefaultRenderLayer.AxisBandsLayer));
+        }, this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.AxisBandsLayer));
         // Step 5 Draw X, Y axis and gridlines
         if (this.sciChartSurface.debugRendering) {
             this.drawDebugAxes(this.sciChartSurface, renderContext);
@@ -157,14 +164,14 @@ var SciChartRenderer = /** @class */ (function () {
                 el.type === IAnnotation_1.EAnnotationType.RenderContextAxisMarkerAnnotation ||
                 el.type === IAnnotation_1.EAnnotationType.RenderContextNativeTextAnnotation);
         });
-        var annotationsBelowLayer = (0, WebGlRenderContext2D_1.calculateAbsoluteRenderLayer)(this.sciChartSurface.layersOffset, this.sciChartSurface.stepBetweenLayers, DefaultRenderLayer_1.EDefaultRenderLayer.AnnotationsBelowSeriesLayer);
+        var annotationsBelowLayer = this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.AnnotationsBelowSeriesLayer);
         renderContext.enqueueLayeredDraw(function () {
             _this.drawRenderContextAnnotations(renderContextAnnotations, xAxesById, yAxesById, IAnnotation_1.EAnnotationLayer.BelowChart, renderContext, seriesViewRect);
         }, annotationsBelowLayer);
-        var seriesLayer = (0, WebGlRenderContext2D_1.calculateAbsoluteRenderLayer)(this.sciChartSurface.layersOffset, this.sciChartSurface.stepBetweenLayers, DefaultRenderLayer_1.EDefaultRenderLayer.SeriesLayer);
+        var seriesLayer = this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.SeriesLayer);
         // Step 7 Draw series. Queue series rendering after grid lines and bands, but before the axes
         renderContext.enqueueLayeredDraw(function () { return _this.drawSeries(_this.sciChartSurface, renderPassInfo, renderContext); }, seriesLayer);
-        var annotationsAboveLayer = (0, WebGlRenderContext2D_1.calculateAbsoluteRenderLayer)(this.sciChartSurface.layersOffset, this.sciChartSurface.stepBetweenLayers, DefaultRenderLayer_1.EDefaultRenderLayer.AnnotationsAboveSeriesLayer);
+        var annotationsAboveLayer = this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.AnnotationsAboveSeriesLayer);
         // Step 8 Draw annotations above the series
         renderContext.enqueueLayeredDraw(function () {
             _this.drawRenderContextAnnotations(renderContextAnnotations, xAxesById, yAxesById, IAnnotation_1.EAnnotationLayer.AboveChart, renderContext, seriesViewRect);
@@ -180,7 +187,12 @@ var SciChartRenderer = /** @class */ (function () {
         });
         this.drawSvgAnnotations(svgAnnotations, xAxesById, yAxesById, this.sciChartSurface.getCoordSvgTranslation());
         // Update watermark
-        this.updateWatermark(renderContext, seriesViewRect);
+        if (!this.sciChartSurface.isSubSurface) {
+            this.updateWatermark(renderContext, seriesViewRect);
+        }
+        else if (renderContext.doDraw) {
+            this.updateWatermark(renderContext, this.sciChartSurface.parentSurface.seriesViewRect);
+        }
         // Step 10 Call OnParentSurfaceRendered
         this.onParentSurfaceRendered();
         if (!app_1.IS_TEST_ENV) {
@@ -472,7 +484,7 @@ var SciChartRenderer = /** @class */ (function () {
         }
         this.sciChartSurface.updateWatermark(left, bottom);
     };
-    SciChartRenderer.prototype.getViewportRect = function (viewportSize, seriesViewRect) {
+    SciChartRenderer.prototype.getViewportSvgRect = function (viewportSize, seriesViewRect) {
         switch (this.sciChartSurface.svgClippingMode) {
             case SvgClippingMode_1.ESvgClippingMode.SeriesViewRect:
                 return seriesViewRect;
@@ -489,6 +501,45 @@ var SciChartRenderer = /** @class */ (function () {
                 return seriesViewRect;
         }
     };
+    SciChartRenderer.prototype.scheduleTitleDraw = function (renderContext) {
+        var _this = this;
+        renderContext.enqueueLayeredDraw(function () {
+            _this.sciChartSurface.chartTitleRenderer.draw(renderContext);
+        }, this.getAbsoluteLayer(DefaultRenderLayer_1.EDefaultRenderLayer.AnnotationsAboveSeriesLayer));
+    };
+    SciChartRenderer.prototype.measureTitle = function (renderContext) {
+        this.sciChartSurface.chartTitleRenderer.measure(this.sciChartSurface.title, this.sciChartSurface.titleStyle, renderContext);
+        return this.sciChartSurface.chartTitleRenderer.titleOffset;
+    };
+    SciChartRenderer.prototype.layoutTitle = function (seriesViewRect) {
+        // current surface area which will contain title
+        var chartViewRect = this.sciChartSurface.titleStyle.placeWithinChart
+            ? seriesViewRect
+            : this.getChartViewRect();
+        // title position calculation
+        this.sciChartSurface.chartTitleRenderer.layout(chartViewRect);
+    };
+    SciChartRenderer.prototype.getChartViewRect = function () {
+        var viewportSize = this.sciChartSurface.renderSurface.viewportSize;
+        if (SciChartSurface_1.SciChartSurface.isSubSurface(this.sciChartSurface)) {
+            var viewportRect = new Rect_1.Rect(0, 0, viewportSize.width, viewportSize.height);
+            var sub = this.sciChartSurface;
+            viewportRect = sub.getSubChartRect();
+            return viewportRect;
+        }
+        return new Rect_1.Rect(0, 0, viewportSize.width, viewportSize.height);
+    };
+    SciChartRenderer.prototype.getAbsoluteLayer = function (relativeRenderLayer) {
+        return (0, WebGlRenderContext2D_1.calculateAbsoluteRenderLayer)(this.sciChartSurface.layersOffset, this.sciChartSurface.stepBetweenLayers, relativeRenderLayer);
+    };
+    SciChartRenderer.prototype.drawDebugSurfaceRect = function (renderContext, viewRect, wasmContext) {
+        var vecRects = (0, NativeObject_1.getVectorRectVertex)(wasmContext);
+        var brush = new wasmContext.SCRTSolidBrush((0, parseColor_1.parseColorToUIntArgb)("rgba(0,255,0,0.7)"), false);
+        var nativeRect = (0, createNativeRect_1.createNativeRect)(wasmContext, 0, 0, viewRect.width, viewRect.height);
+        vecRects.push_back(nativeRect);
+        renderContext.drawRects(vecRects, brush, viewRect.left, viewRect.top);
+        brush.delete();
+    };
     return SciChartRenderer;
 }());
 exports.SciChartRenderer = SciChartRenderer;

package/Charting/Services/TitleRenderer.d.ts

@@ -0,0 +1,91 @@
+import { ICacheable } from "../../Core/ICacheable";
+import { IDeletable } from "../../Core/IDeletable";
+import { Rect } from "../../Core/Rect";
+import { Thickness } from "../../Core/Thickness";
+import { ETextAlignment, ETitlePosition, TChartTitleStyle } from "../../types/TextStyle";
+import { WebGlRenderContext2D } from "../Drawing/WebGlRenderContext2D";
+import { TTextStyle } from "../Visuals/Axis/AxisCore";
+import { TSciChart } from "../Visuals/SciChartSurface";
+import { INotifyOnDpiChanged, TDpiChangedEventArgs } from "../Visuals/TextureManager/DpiHelper";
+import { TextureManager, TTextureObject } from "../Visuals/TextureManager/TextureManager";
+export interface ITitleRenderer extends IDeletable, ICacheable, INotifyOnDpiChanged {
+    viewRect: Rect;
+    measure(...params: any[]): void;
+    draw(...params: any[]): void;
+    layout(viewRectOrigin: Rect): void;
+}
+export interface IChartTitleRenderer extends ITitleRenderer {
+    titleOffset: Thickness;
+    measure(title: string | string[], originalTextStyle: Required<TChartTitleStyle>, renderContext: WebGlRenderContext2D): void;
+}
+export declare class TitleRendererBase<TextStyleType extends TTextStyle | TChartTitleStyle> implements ITitleRenderer {
+    /**
+     * Defines a bounding {@link Rect} containing the title text
+     */
+    get viewRect(): Rect;
+    drawDebug: boolean;
+    useCache: boolean;
+    /**
+     * Current title
+     */
+    text: string | string[];
+    protected viewRectProperty: Rect;
+    protected webAssemblyContext: TSciChart;
+    protected textureManager: TextureManager;
+    /**
+     * Adjusted text style for the title
+     */
+    protected textStyle: TextStyleType;
+    /**
+     * Current not adjusted text style for the title
+     */
+    protected originalTextStyle: TextStyleType;
+    /**
+     * The height taken by the text with normal(horizontal) orientation including padding
+     */
+    protected textHeight: number;
+    /**
+     * The width taken by the text with normal(horizontal) orientation including padding
+     */
+    protected textWidth: number;
+    /**
+     * The height taken by the text considering current orientation orientation including padding
+     */
+    protected desiredHeightProperty: number;
+    /**
+     * The width taken by the text considering current orientation orientation including padding
+     */
+    protected desiredWidthProperty: number;
+    /**
+     * The text texture  corresponding to current title and text style.
+     * @remarks The texture is created if {@link textStyle.useNativeText} is set to false
+     */
+    protected texture: TTextureObject;
+    /** The line spacing for native text calculated during measure */
+    protected nativeLineSpacing: number;
+    /** The height of the first line above baseline for native text, calculated during measure*/
+    protected firstLineAscent: number;
+    constructor(webAssemblyContext: TSciChart);
+    measure(...params: any[]): void;
+    layout(originRect: Rect): void;
+    draw(...params: any[]): void;
+    delete(): void;
+    resetCache(): void;
+    invalidateCache(): void;
+    onDpiChanged(args: TDpiChangedEventArgs): void;
+    /**
+     * Performs rendering of the title
+     */
+    protected drawInternal(renderContext: WebGlRenderContext2D, useNativeText: boolean, titlePosition: ETitlePosition, lineSpacing: number): void;
+    protected drawWithNativeText(renderContext: WebGlRenderContext2D, position: ETitlePosition): void;
+    protected drawWithTexture(renderContext: WebGlRenderContext2D, titlePosition: ETitlePosition): void;
+    /**
+     * Calculates the {@link TitleRenderer.viewRect}
+     */
+    protected getViewRect(title: string | string[], originRect: Rect, titlePosition: ETitlePosition, alignment: ETextAlignment): Rect;
+    protected drawTitleDebugViewRect(renderContext: WebGlRenderContext2D): void;
+    /**
+     * Calculates the offset of title text alignment defined by {@link TChartTitleStyle.alignment} or {@link TTextStyle.alignment}
+     */
+    private getAlignmentAdjustmentDelta;
+}