scichart 2.0.2194 → 2.1.0-beta.40

package/Charting/ChartModifiers/CursorModifier.d.ts

@@ -1,6 +1,7 @@
 import { IIncludeSeries } from "../../Core/IIncludeSeries";
 import { Point } from "../../Core/Point";
 import { EChart2DModifierType } from "../../types/ChartModifierType";
+import { EMousePosition } from "../../types/MousePosition";
 import { SeriesInfo } from "../Model/ChartData/SeriesInfo";
 import { IThemeProvider } from "../Themes/IThemeProvider";
 import { CursorTooltipSvgAnnotation } from "../Visuals/Annotations/CursorTooltipSvgAnnotation";
@@ -176,6 +177,9 @@ export declare class CursorModifier extends ChartModifierBase2D implements IIncl
      * @inheritDoc
      */
     getIncludedRenderableSeries(): IRenderableSeries[];
+    /**
+     * Gets or sets the tooltipDataTemplate, which allows to customize content for the tooltip
+     */
     get tooltipDataTemplate(): TCursorTooltipDataTemplate;
     set tooltipDataTemplate(value: TCursorTooltipDataTemplate);
     /**
@@ -184,6 +188,11 @@ export declare class CursorModifier extends ChartModifierBase2D implements IIncl
      * @param mousePoint
      */
     hitTestRenderableSeries(rs: IRenderableSeries, mousePoint: Point): HitTestInfo;
+    /**
+     * Returns current mouse position
+     */
+    getMousePosition(): EMousePosition;
+    /** @inheritDoc */
     toJSON(): {
         type: string;
         options: Required<Omit<IChartModifierBaseOptions, never>>;

package/Charting/ChartModifiers/CursorModifier.js

@@ -300,6 +300,9 @@ var CursorModifier = /** @class */ (function (_super) {
         return allSeries;
     };
     Object.defineProperty(CursorModifier.prototype, "tooltipDataTemplate", {
+        /**
+         * Gets or sets the tooltipDataTemplate, which allows to customize content for the tooltip
+         */
         get: function () {
             return this.tooltipDataTemplateProperty;
         },
@@ -321,6 +324,13 @@ var CursorModifier = /** @class */ (function (_super) {
         }
         return rs.hitTestProvider.hitTestXSlice(mousePoint.x, mousePoint.y);
     };
+    /**
+     * Returns current mouse position
+     */
+    CursorModifier.prototype.getMousePosition = function () {
+        return this.mousePosition;
+    };
+    /** @inheritDoc */
     CursorModifier.prototype.toJSON = function () {
         var json = _super.prototype.toJSON.call(this);
         var options = {

package/Charting/ChartModifiers/DataPointSelectionModifier.js

@@ -410,7 +410,6 @@ var DataPointSelectionModifier = /** @class */ (function (_super) {
                     topYData = yCalc.getDataValue(_this.startPoint.y);
                 }
                 if (rs.dataSeries.type === IDataSeries_1.EDataSeriesType.HeatmapUniform) {
-                    var heatmapSeries = rs.dataSeries;
                     // TODO: Heatmap series
                 }
                 else {

package/Charting/ChartModifiers/RolloverModifier.d.ts

@@ -51,6 +51,24 @@ export declare type TTooltipProps = {
     height: number;
     seriesInfo: SeriesInfo;
 };
+/**
+ * @ignore
+ * Defines the MousePosition enum constants, used by the {@link RolloverModifier}
+ */
+declare enum EMousePosition {
+    /**
+     * The mouse position is outside the main canvas
+     */
+    OutOfCanvas = "OutOfCanvas",
+    /**
+     * The mouse position is in the Axis area
+     */
+    AxisArea = "AxisArea",
+    /**
+     * The mouse position is in the Series area
+     */
+    SeriesArea = "SeriesArea"
+}
 /**
  * Optional parameters used to configure a {@link RolloverModifier} at construct time
  */
@@ -173,10 +191,16 @@ export declare class RolloverModifier extends ChartModifierBase2D implements IIn
      * @param mousePoint
      */
     hitTestRenderableSeries(rs: IRenderableSeries, mousePoint: Point): HitTestInfo;
+    /**
+     * Returns current mouse position
+     */
+    getMousePosition(): EMousePosition;
+    /** @inheritDoc */
     toJSON(): {
         type: string;
         options: Required<Omit<IChartModifierBaseOptions, never>>;
     };
+    /** @inheritDoc */
     protected notifyPropertyChanged(propertyName: string): void;
     private isVerticalChart;
     private removeSeriesAnnotationsFromParentSurface;
@@ -224,3 +248,4 @@ export declare const calcTooltipProps: (index: number, rs: IRenderableSeries, ro
  * @param pixelRatio
  */
 export declare const calcTooltipPositions: (tooltipArray: TTooltipProps[], allowTooltipOverlapping: boolean, tooltipPaddingTop: number, seriesViewRect: Rect, pixelRatio: number) => TTooltipProps[];
+export {};

package/Charting/ChartModifiers/RolloverModifier.js

@@ -346,6 +346,13 @@ var RolloverModifier = /** @class */ (function (_super) {
         }
         return rs.hitTestProvider.hitTestXSlice(mousePoint.x, mousePoint.y);
     };
+    /**
+     * Returns current mouse position
+     */
+    RolloverModifier.prototype.getMousePosition = function () {
+        return this.mousePosition;
+    };
+    /** @inheritDoc */
     RolloverModifier.prototype.toJSON = function () {
         var json = _super.prototype.toJSON.call(this);
         var options = {
@@ -361,6 +368,7 @@ var RolloverModifier = /** @class */ (function (_super) {
         Object.assign(json.options, options);
         return json;
     };
+    /** @inheritDoc */
     RolloverModifier.prototype.notifyPropertyChanged = function (propertyName) {
         _super.prototype.notifyPropertyChanged.call(this, propertyName);
         if (propertyName === constants_1.PROPERTY.X_AXIS_ID) {

package/Charting/Drawing/BrushCache.d.ts

@@ -10,14 +10,18 @@ export declare class BrushCache extends BaseCache<WebGlBrush> {
     private opacity;
     private fillLinearGradient;
     private canvasTexture;
+    private textureHeightRatio;
+    private textureWidthRatio;
     get value(): WebGlBrush;
     /**
      * Creates or fetches a new brush with the specified params
      * @param fill
      * @param opacity
+     * @param textureHeightRatio
+     * @param textureWidthRatio
      * @param fillLinearGradient
      */
-    create(fill: string, opacity: number, fillLinearGradient?: GradientParams): WebGlBrush;
+    create(fill: string, opacity: number, textureHeightRatio?: number, textureWidthRatio?: number, fillLinearGradient?: GradientParams): WebGlBrush;
     invalidateCache(): void;
     reset(): void;
     delete(): void;
@@ -43,7 +47,9 @@ export declare const getScrtBrushFromCache: (cache: BrushCache) => SCRTBrush;
  * @param cache The object that will store a brush
  * @param fill The HTML Color code
  * @param opacity The opacity factor.
+ * @param textureHeightRatio The height ratio of the main canvas to the WebGl canvas.
+ * @param textureWidthRatio The width ratio of the main canvas to the WebGl canvas.
  * @param fillGradientLinear The gradient params.
  * @returns new or existing instance of {@link SCRTBrush}}
  */
-export declare const createBrushInCache: (cache: BrushCache, fill: string, opacity: number, fillGradientLinear?: GradientParams) => SCRTBrush;
+export declare const createBrushInCache: (cache: BrushCache, fill: string, opacity: number, textureHeightRatio?: number, textureWidthRatio?: number, fillGradientLinear?: GradientParams) => SCRTBrush;

package/Charting/Drawing/BrushCache.js

@@ -35,7 +35,7 @@ var BrushCache = /** @class */ (function (_super) {
     Object.defineProperty(BrushCache.prototype, "value", {
         get: function () {
             if (!this.cachedEntity && (this.fill || this.fillLinearGradient)) {
-                this.cachedEntity = this.create(this.fill, this.opacity, this.fillLinearGradient);
+                this.cachedEntity = this.create(this.fill, this.opacity, this.textureHeightRatio, this.textureWidthRatio, this.fillLinearGradient);
             }
             return this.cachedEntity;
         },
@@ -46,18 +46,24 @@ var BrushCache = /** @class */ (function (_super) {
      * Creates or fetches a new brush with the specified params
      * @param fill
      * @param opacity
+     * @param textureHeightRatio
+     * @param textureWidthRatio
      * @param fillLinearGradient
      */
-    BrushCache.prototype.create = function (fill, opacity, fillLinearGradient) {
+    BrushCache.prototype.create = function (fill, opacity, textureHeightRatio, textureWidthRatio, fillLinearGradient) {
         if (this.cachedEntity &&
             fill === this.fill &&
             opacity === this.opacity &&
+            textureHeightRatio === this.textureHeightRatio &&
+            textureWidthRatio === this.textureWidthRatio &&
             fillLinearGradient === this.fillLinearGradient) {
             return this.cachedEntity;
         }
         this.invalidateCache();
         this.fill = fill;
         this.opacity = opacity;
+        this.textureHeightRatio = textureHeightRatio;
+        this.textureWidthRatio = textureWidthRatio;
         this.fillLinearGradient = fillLinearGradient;
         var brush = fillLinearGradient ? this.createGradientBrush() : this.createSolidBrush(fill, opacity);
         return (this.cachedEntity = new WebGlBrush_1.WebGlBrush(brush));
@@ -89,10 +95,10 @@ var BrushCache = /** @class */ (function (_super) {
         this.canvasTexture.clear();
         var ctx = this.canvasTexture.getContext();
         // BEGIN: Drawing gradient rectangle on canvas2D
-        var x1 = convertRelativeToAbsolute(startPoint.x, TEXTURE_SIZE);
-        var y1 = convertRelativeToAbsolute(startPoint.y, TEXTURE_SIZE);
-        var x2 = convertRelativeToAbsolute(endPoint.x, TEXTURE_SIZE);
-        var y2 = convertRelativeToAbsolute(endPoint.y, TEXTURE_SIZE);
+        var x1 = convertRelativeToAbsolute(startPoint.x, TEXTURE_SIZE * this.textureWidthRatio);
+        var y1 = convertRelativeToAbsolute(startPoint.y, TEXTURE_SIZE * this.textureHeightRatio);
+        var x2 = convertRelativeToAbsolute(endPoint.x, TEXTURE_SIZE * this.textureWidthRatio);
+        var y2 = convertRelativeToAbsolute(endPoint.y, TEXTURE_SIZE * this.textureHeightRatio);
         var gradient = ctx.createLinearGradient(x1, y1, x2, y2);
         gradientStops.forEach(function (el) {
             gradient.addColorStop(el.offset, el.color);
@@ -133,12 +139,14 @@ exports.getScrtBrushFromCache = getScrtBrushFromCache;
  * @param cache The object that will store a brush
  * @param fill The HTML Color code
  * @param opacity The opacity factor.
+ * @param textureHeightRatio The height ratio of the main canvas to the WebGl canvas.
+ * @param textureWidthRatio The width ratio of the main canvas to the WebGl canvas.
  * @param fillGradientLinear The gradient params.
  * @returns new or existing instance of {@link SCRTBrush}}
  */
-var createBrushInCache = function (cache, fill, opacity, fillGradientLinear) {
+var createBrushInCache = function (cache, fill, opacity, textureHeightRatio, textureWidthRatio, fillGradientLinear) {
     Guard_1.Guard.notNull(cache, "brushCache");
-    var brush = cache.create(fill, opacity, fillGradientLinear);
+    var brush = cache.create(fill, opacity, textureHeightRatio, textureWidthRatio, fillGradientLinear);
     return brush.scrtBrush;
 };
 exports.createBrushInCache = createBrushInCache;

package/Charting/Drawing/WebGlRenderContext2D.d.ts

@@ -39,6 +39,7 @@ export declare class WebGlRenderContext2D implements IRenderContext2D {
     private readonly layers;
     private readonly webAssemblyContext;
     private readonly effects;
+    private nativeContext;
     /**
      * Creates an instance of the WebGlRenderContext2D
      * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing native methods and access to our WebGL2 Engine

package/Charting/Drawing/WebGlRenderContext2D.js

@@ -43,7 +43,10 @@ var WebGlRenderContext2D = /** @class */ (function () {
      * Get the native {@link SCRTRenderContext} for direct access to SciChart's WebAssembly Visual Xccelerator engine
      */
     WebGlRenderContext2D.prototype.getNativeContext = function () {
-        return this.webAssemblyContext.SCRTGetMainRenderContext2D();
+        if (!this.nativeContext) {
+            this.nativeContext = this.webAssemblyContext.SCRTGetMainRenderContext2D();
+        }
+        return this.nativeContext;
     };
     /**
      * Draw lines: grid lines, etc.

package/Charting/LayoutManager/BaseAxisLayoutStrategy.d.ts

@@ -36,4 +36,6 @@ export declare abstract class BaseAxisLayoutStrategy {
     protected layoutAxesFromTopToBottom(left: number, top: number, right: number, bottom: number, axes: AxisBase2D[]): void;
     protected layoutAxesFromLeftToRight(left: number, top: number, right: number, bottom: number, axes: AxisBase2D[]): void;
     protected layoutAxesFromRightToLeft(left: number, top: number, right: number, bottom: number, axes: AxisBase2D[]): void;
+    protected calculateTotalAxisHeight(axis: AxisBase2D, totalAxisAreaHeight: number): number;
+    protected calculateTotalAxisWidth(axis: AxisBase2D, totalAxisAreaHeight: number): number;
 }

package/Charting/LayoutManager/BaseAxisLayoutStrategy.js

@@ -56,6 +56,39 @@ var BaseAxisLayoutStrategy = /** @class */ (function () {
             (0, AxisLayoutHelpers_1.layoutAxisParts)(axis, _this.layoutAxisPartsStrategy);
         });
     };
+    BaseAxisLayoutStrategy.prototype.calculateTotalAxisHeight = function (axis, totalAxisAreaHeight) {
+        return (parseSize(axis.stackedAxisLength, totalAxisAreaHeight) +
+            axis.axisLayoutState.additionalBottomSize +
+            axis.axisLayoutState.additionalTopSize);
+    };
+    BaseAxisLayoutStrategy.prototype.calculateTotalAxisWidth = function (axis, totalAxisAreaHeight) {
+        return (parseSize(axis.stackedAxisLength, totalAxisAreaHeight) +
+            axis.axisLayoutState.additionalRightSize +
+            axis.axisLayoutState.additionalLeftSize);
+    };
     return BaseAxisLayoutStrategy;
 }());
 exports.BaseAxisLayoutStrategy = BaseAxisLayoutStrategy;
+var parseSize = function (value, containerSize) {
+    if (typeof value === "number") {
+        if (value < 0) {
+            throw new Error("stackedAxisLength must be a positive value!");
+        }
+        return value;
+    }
+    if (value.includes("%")) {
+        return parsePc(value, containerSize);
+    }
+    var parsedValue = parseFloat(value);
+    if (!isNaN(parsedValue)) {
+        return parsedValue;
+    }
+    throw new Error("stackedAxisLength must be a number or a percentage");
+};
+var parsePc = function (value, containerSize) {
+    var parsedPercentageValue = parseFloat(value);
+    if (parsedPercentageValue < 0 || parsedPercentageValue > 100) {
+        throw new Error("stackedAxisLength percentage must be from 0 to 100");
+    }
+    return Math.round((containerSize * parsedPercentageValue) / 10) / 10;
+};

package/Charting/LayoutManager/BottomAlignedOuterHorizontallyStackedAxisLayoutStrategy.js

@@ -50,14 +50,30 @@ var BottomAlignedOuterHorizontallyStackedAxisLayoutStrategy = /** @class */ (fun
     BottomAlignedOuterHorizontallyStackedAxisLayoutStrategy.prototype.layoutAxes = function (left, top, right, bottom, axes) {
         var _this = this;
         var totalAxisAreaWidth = right - left;
-        var singleAxisReservedWidth = totalAxisAreaWidth / axes.length;
         var firstAxis = axes[0];
+        var lastAxis = axes[axes.length - 1];
+        var axesWithDefinedLength = axes.filter(function (axis) { return axis.stackedAxisLength; });
+        var spaceWithoutBorders = axes.reduce(function (acc, axis) { return acc - axis.axisLayoutState.additionalBottomSize - axis.axisLayoutState.additionalTopSize; }, totalAxisAreaWidth +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalLeftSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalRightSize));
+        var totalDefinedAxesLength = axesWithDefinedLength.reduce(function (acc, axis) { return acc + _this.calculateTotalAxisWidth(axis, spaceWithoutBorders); }, 0);
+        var availableSpaceForAxes = totalAxisAreaWidth +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalLeftSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalRightSize) -
+            totalDefinedAxesLength;
+        if (availableSpaceForAxes < 0) {
+            throw new Error("Bottom stacked axes with defined size total ".concat(totalDefinedAxesLength, " pixels which is ").concat(-availableSpaceForAxes, " more than the space available"));
+        }
+        var defaultAxisReservedHeight = availableSpaceForAxes / (axes.length - axesWithDefinedLength.length);
         var leftOffset = left - (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalLeftSize);
         axes.forEach(function (axis) {
             var _a = axis.axisLayoutState, axisSize = _a.axisSize, additionalLeftSize = _a.additionalLeftSize, additionalRightSize = _a.additionalRightSize, additionalTopSize = _a.additionalTopSize;
             var topOffset = top + additionalTopSize;
             var bottomOffset = topOffset + axisSize;
-            var rightOffset = leftOffset + singleAxisReservedWidth - additionalRightSize;
+            var axisReservedHeight = axis.stackedAxisLength
+                ? _this.calculateTotalAxisWidth(axis, spaceWithoutBorders)
+                : defaultAxisReservedHeight;
+            var rightOffset = leftOffset + axisReservedHeight - additionalRightSize;
             leftOffset += additionalLeftSize;
             axis.offset = leftOffset - left;
             axis.axisLength = rightOffset - leftOffset;

package/Charting/LayoutManager/LeftAlignedOuterVerticallyStackedAxisLayoutStrategy.js

@@ -49,15 +49,32 @@ var LeftAlignedOuterVerticallyStackedAxisLayoutStrategy = /** @class */ (functio
     };
     LeftAlignedOuterVerticallyStackedAxisLayoutStrategy.prototype.layoutAxes = function (left, top, right, bottom, axes) {
         var _this = this;
+        // doesn't include top border of the first and bottom border of the last axis
         var totalAxisAreaHeight = bottom - top;
-        var singleAxisReservedHeight = totalAxisAreaHeight / axes.length;
         var firstAxis = axes[0];
+        var lastAxis = axes[axes.length - 1];
+        var axesWithDefinedLength = axes.filter(function (axis) { return axis.stackedAxisLength; });
+        var spaceWithoutBorders = axes.reduce(function (acc, axis) { return acc - axis.axisLayoutState.additionalBottomSize - axis.axisLayoutState.additionalTopSize; }, totalAxisAreaHeight +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalTopSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalBottomSize));
+        var totalDefinedAxesLength = axesWithDefinedLength.reduce(function (acc, axis) { return acc + _this.calculateTotalAxisHeight(axis, spaceWithoutBorders); }, 0);
+        var availableSpaceForAxes = totalAxisAreaHeight +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalTopSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalBottomSize) -
+            totalDefinedAxesLength;
+        if (availableSpaceForAxes < 0) {
+            throw new Error("Left stacked axes with defined size total ".concat(totalDefinedAxesLength, " pixels which is ").concat(-availableSpaceForAxes, " more than the space available"));
+        }
+        var defaultAxisReservedHeight = availableSpaceForAxes / (axes.length - axesWithDefinedLength.length);
         var topOffset = top - (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalTopSize);
         axes.forEach(function (axis) {
             var _a = axis.axisLayoutState, axisSize = _a.axisSize, additionalRightSize = _a.additionalRightSize, additionalBottomSize = _a.additionalBottomSize, additionalTopSize = _a.additionalTopSize;
             var rightOffset = right - additionalRightSize;
             var leftOffset = rightOffset - axisSize;
-            var bottomOffset = topOffset + singleAxisReservedHeight - additionalBottomSize;
+            var axisReservedHeight = axis.stackedAxisLength
+                ? _this.calculateTotalAxisHeight(axis, spaceWithoutBorders)
+                : defaultAxisReservedHeight;
+            var bottomOffset = topOffset + axisReservedHeight - additionalBottomSize;
             topOffset += additionalTopSize;
             axis.offset = topOffset - top;
             axis.axisLength = bottomOffset - topOffset;

package/Charting/LayoutManager/RightAlignedOuterVerticallyStackedAxisLayoutStrategy.js

@@ -50,14 +50,30 @@ var RightAlignedOuterVerticallyStackedAxisLayoutStrategy = /** @class */ (functi
     RightAlignedOuterVerticallyStackedAxisLayoutStrategy.prototype.layoutAxes = function (left, top, right, bottom, axes) {
         var _this = this;
         var totalAxisAreaHeight = bottom - top;
-        var singleAxisReservedHeight = totalAxisAreaHeight / axes.length;
         var firstAxis = axes[0];
+        var lastAxis = axes[axes.length - 1];
+        var axesWithDefinedLength = axes.filter(function (axis) { return axis.stackedAxisLength; });
+        var spaceWithoutBorders = axes.reduce(function (acc, axis) { return acc - axis.axisLayoutState.additionalBottomSize - axis.axisLayoutState.additionalTopSize; }, totalAxisAreaHeight +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalTopSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalBottomSize));
+        var totalDefinedAxesLength = axesWithDefinedLength.reduce(function (acc, axis) { return acc + _this.calculateTotalAxisHeight(axis, spaceWithoutBorders); }, 0);
+        var availableSpaceForAxes = totalAxisAreaHeight +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalTopSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalBottomSize) -
+            totalDefinedAxesLength;
+        if (availableSpaceForAxes < 0) {
+            throw new Error("Right stacked axes with defined size total ".concat(totalDefinedAxesLength, " pixels which is ").concat(-availableSpaceForAxes, " more than the space available"));
+        }
+        var defaultAxisReservedHeight = availableSpaceForAxes / (axes.length - axesWithDefinedLength.length);
         var topOffset = top - (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalTopSize);
         axes.forEach(function (axis) {
             var _a = axis.axisLayoutState, axisSize = _a.axisSize, additionalLeftSize = _a.additionalLeftSize, additionalBottomSize = _a.additionalBottomSize, additionalTopSize = _a.additionalTopSize;
             var leftOffset = left + additionalLeftSize;
             var rightOffset = leftOffset + axisSize;
-            var bottomOffset = topOffset + singleAxisReservedHeight - additionalBottomSize;
+            var axisReservedHeight = axis.stackedAxisLength
+                ? _this.calculateTotalAxisHeight(axis, spaceWithoutBorders)
+                : defaultAxisReservedHeight;
+            var bottomOffset = topOffset + axisReservedHeight - additionalBottomSize;
             topOffset += additionalTopSize;
             axis.offset = topOffset - top;
             axis.axisLength = bottomOffset - topOffset;

package/Charting/LayoutManager/TopAlignedOuterHorizontallyStackedAxisLayoutStrategy.js

@@ -50,14 +50,30 @@ var TopAlignedOuterHorizontallyStackedAxisLayoutStrategy = /** @class */ (functi
     TopAlignedOuterHorizontallyStackedAxisLayoutStrategy.prototype.layoutAxes = function (left, top, right, bottom, axes) {
         var _this = this;
         var totalAxisAreaWidth = right - left;
-        var singleAxisReservedWidth = totalAxisAreaWidth / axes.length;
         var firstAxis = axes[0];
+        var lastAxis = axes[axes.length - 1];
+        var axesWithDefinedLength = axes.filter(function (axis) { return axis.stackedAxisLength; });
+        var spaceWithoutBorders = axes.reduce(function (acc, axis) { return acc - axis.axisLayoutState.additionalBottomSize - axis.axisLayoutState.additionalTopSize; }, totalAxisAreaWidth +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalLeftSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalRightSize));
+        var totalDefinedAxesLength = axesWithDefinedLength.reduce(function (acc, axis) { return acc + _this.calculateTotalAxisWidth(axis, spaceWithoutBorders); }, 0);
+        var availableSpaceForAxes = totalAxisAreaWidth +
+            (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalLeftSize) +
+            (lastAxis === null || lastAxis === void 0 ? void 0 : lastAxis.axisLayoutState.additionalRightSize) -
+            totalDefinedAxesLength;
+        if (availableSpaceForAxes < 0) {
+            throw new Error("Top stacked axes with defined size total ".concat(totalDefinedAxesLength, " pixels which is ").concat(-availableSpaceForAxes, " more than the space available"));
+        }
+        var defaultAxisReservedHeight = availableSpaceForAxes / (axes.length - axesWithDefinedLength.length);
         var leftOffset = left - (firstAxis === null || firstAxis === void 0 ? void 0 : firstAxis.axisLayoutState.additionalLeftSize);
         axes.forEach(function (axis) {
             var _a = axis.axisLayoutState, axisSize = _a.axisSize, additionalLeftSize = _a.additionalLeftSize, additionalRightSize = _a.additionalRightSize, additionalBottomSize = _a.additionalBottomSize;
             var bottomOffset = bottom - additionalBottomSize;
             var topOffset = bottomOffset - axisSize;
-            var rightOffset = leftOffset + singleAxisReservedWidth - additionalRightSize;
+            var axisReservedHeight = axis.stackedAxisLength
+                ? _this.calculateTotalAxisWidth(axis, spaceWithoutBorders)
+                : defaultAxisReservedHeight;
+            var rightOffset = leftOffset + axisReservedHeight - additionalRightSize;
             leftOffset += additionalLeftSize;
             axis.offset = leftOffset - left;
             axis.axisLength = rightOffset - leftOffset;

package/Charting/Model/BaseDataSeries.d.ts

@@ -1,13 +1,19 @@
 import { EventHandler } from "../../Core/EventHandler";
 import { NumberRange } from "../../Core/NumberRange";
-import { DoubleVector, TSciChart } from "../../types/TSciChart";
+import { ESearchMode } from "../../types/SearchMode";
+import { SCRTDoubleVector, TSciChart } from "../../types/TSciChart";
 import { SeriesAnimation } from "../Visuals/RenderableSeries/Animations/SeriesAnimation";
+import { IDataDistributionCalculator } from "./DataDistributionCalculator/IDataDistributionCalculator";
 import { EDataChangeType, EDataSeriesType, EDataSeriesValueType, IDataChangeArgs, IDataSeries } from "./IDataSeries";
 import { IMetadataGenerator, IPointMetadata } from "./IPointMetadata";
 /**
  * Options to pass to the {@link BaseDataSeries} constructor
  */
 export interface IBaseDataSeriesOptions {
+    /**
+     * A unique Id for the {@link IDataSeries}
+     */
+    id?: string;
     /**
      * The DataSeries name, used in legends, tooltips to identify the chart series
      */
@@ -19,6 +25,14 @@ export interface IBaseDataSeriesOptions {
      * algorithms for zooming, panning and ranging and ensure best performance.
      */
     dataIsSortedInX?: boolean;
+    /**
+     * When true, the Data is evenly spaced in X.
+     * @remarks
+     * The user must specify this flag (defaults to true) in order to choose the correct, and
+     * fastest algorithms for drawing, indexing and ranging. If you experience glitches or
+     * strange drawing, it may be because you have set data with uneven spacing in X but not set this flag.
+     */
+    dataEvenlySpacedInX?: boolean;
     /**
      * Gets or sets whether the Y data contains NaN values.
      */
@@ -49,6 +63,10 @@ export declare abstract class BaseDataSeries implements IDataSeries {
     abstract readonly type: EDataSeriesType;
     /** @inheritDoc */
     readonly dataChanged: EventHandler<IDataChangeArgs>;
+    /** @inheritDoc */
+    readonly id: string;
+    /** @inheritDoc */
+    readonly dataDistributionCalculator: IDataDistributionCalculator;
     minXSpacing: number;
     /**
      * If set, these will be included in the serialised definition, so that it can be used with sharedData
@@ -61,28 +79,30 @@ export declare abstract class BaseDataSeries implements IDataSeries {
     /**
      * X vector with initial animation values
      */
-    xInitialAnimationValues: DoubleVector;
+    xInitialAnimationValues: SCRTDoubleVector;
     /**
      * Y vector with initial animation values
      */
-    yInitialAnimationValues: DoubleVector;
+    yInitialAnimationValues: SCRTDoubleVector;
     /**
      * X vector with final animation values
      */
-    xFinalAnimationValues: DoubleVector;
+    xFinalAnimationValues: SCRTDoubleVector;
     /**
      * Y vector with final animation values
      */
-    yFinalAnimationValues: DoubleVector;
-    protected xValues: DoubleVector;
-    protected yValues: DoubleVector;
-    protected indexes: DoubleVector;
+    yFinalAnimationValues: SCRTDoubleVector;
+    protected xValues: SCRTDoubleVector;
+    protected yValues: SCRTDoubleVector;
+    protected indexes: SCRTDoubleVector;
     protected isDeleted: boolean;
     private dataSeriesNameProperty;
     private isSortedProperty;
     private containsNaNProperty;
+    private isEvenlySpacedProperty;
     private metadataProperty;
     private metadataGeneratorProperty;
+    private changeCountProperty;
     /**
      * Creates an instance of {@link BaseDataSeries}
      * @param webAssemblyContext the {@link TSciChart | SciChart WebAssembly Context} containing native methods
@@ -91,7 +111,7 @@ export declare abstract class BaseDataSeries implements IDataSeries {
      */
     protected constructor(webAssemblyContext: TSciChart, options?: IBaseDataSeriesOptions);
     /** @inheritDoc */
-    abstract clear(): void;
+    clear(): void;
     /** @inheritDoc */
     get containsNaN(): boolean;
     /** @inheritDoc */
@@ -101,6 +121,10 @@ export declare abstract class BaseDataSeries implements IDataSeries {
     /** @inheritDoc */
     set isSorted(isSorted: boolean);
     /** @inheritDoc */
+    get isEvenlySpaced(): boolean;
+    /** @inheritDoc */
+    set isEvenlySpaced(isSorted: boolean);
+    /** @inheritDoc */
     get dataSeriesName(): string;
     /** @inheritDoc */
     set dataSeriesName(dataSeriesName: string);
@@ -109,11 +133,11 @@ export declare abstract class BaseDataSeries implements IDataSeries {
     /** @inheritDoc */
     getIsDeleted(): boolean;
     /** @inheritDoc */
-    getNativeIndexes(): DoubleVector;
+    getNativeIndexes(): SCRTDoubleVector;
     /** @inheritDoc */
-    getNativeXValues(): DoubleVector;
+    getNativeXValues(): SCRTDoubleVector;
     /** @inheritDoc */
-    getNativeYValues(): DoubleVector;
+    getNativeYValues(): SCRTDoubleVector;
     /** @inheritDoc */
     delete(): void;
     /**
@@ -126,7 +150,8 @@ export declare abstract class BaseDataSeries implements IDataSeries {
     getXRange(dataSeriesValueType?: EDataSeriesValueType): NumberRange;
     /** @inheritDoc */
     getWindowedYRange(xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis?: boolean, dataSeriesValueType?: EDataSeriesValueType): NumberRange;
-    getIndicesRange(xRange: NumberRange): NumberRange;
+    /** @inheritDoc */
+    getIndicesRange(xRange: NumberRange, isCategoryData?: boolean, downSearchMode?: ESearchMode, upSearchMode?: ESearchMode): NumberRange;
     /** @inheritDoc */
     get hasValues(): boolean;
     /**
@@ -169,6 +194,8 @@ export declare abstract class BaseDataSeries implements IDataSeries {
     updateAnimationProperties(progress: number, animation: SeriesAnimation): void;
     /** @inheritDoc */
     toJSON(excludeData?: boolean): any;
+    /** @inheritDoc */
+    get changeCount(): number;
     protected validateIndex(index: number, message?: string): void;
     protected setMetadataAt(index: number, metadata: IPointMetadata): void;
     protected appendMetadata(metadata: IPointMetadata): void;
@@ -178,8 +205,8 @@ export declare abstract class BaseDataSeries implements IDataSeries {
     protected removeMetadataAt(index: number): void;
     protected removeMetadataRange(startIndex: number, count: number): void;
     protected setMetadata(value: IPointMetadata[]): void;
-    protected getXValues(dataSeriesValueType: EDataSeriesValueType): DoubleVector;
+    protected getXValues(dataSeriesValueType: EDataSeriesValueType): SCRTDoubleVector;
     private fillMetadataIfUndefined;
     private getYValues;
 }
-export declare const getWindowedYRange: (webAssemblyContext: TSciChart, xValues: DoubleVector, yValues: DoubleVector, xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis: boolean, isSorted: boolean) => NumberRange;
+export declare const getWindowedYRange: (webAssemblyContext: TSciChart, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, xRange: NumberRange, getPositiveRange: boolean, isXCategoryAxis: boolean, isSorted: boolean) => NumberRange;