scichart 2.0.0-alpha.1930 → 2.0.0-alpha.1991

package/Charting/Visuals/RenderableSeries/BaseStackedRenderableSeries.js

@@ -485,7 +485,9 @@ var BaseStackedRenderableSeries = /** @class */ (function () {
     BaseStackedRenderableSeries.prototype.toJSON = function (excludeData) {
         var _a;
         if (excludeData === void 0) { excludeData = false; }
-        var options = {};
+        var options = {
+            opacity: this.opacity
+        };
         if (((_a = this.dataSeries) === null || _a === void 0 ? void 0 : _a.type) === IDataSeries_1.EDataSeriesType.Xy) {
             // @ts-ignore
             return { type: this.type, options: options, xyData: this.dataSeries.toJSON(excludeData) };

package/Charting/Visuals/RenderableSeries/DrawingProviders/BandSeriesDrawingProvider.js

@@ -119,7 +119,7 @@ var BandSeriesDrawingProvider = /** @class */ (function (_super) {
         }
         args.count = yDrawValues.size();
         // Paletting per point
-        _super.prototype.applyStrokeFillPaletting.call(this, undefined, undefined, undefined, undefined, undefined, true);
+        _super.prototype.applyStrokeFillPaletting.call(this, undefined, undefined, undefined, undefined, this.parentSeries.opacity, true);
         var paletteTexture = (_a = this.palettingState.paletteTextureCache) === null || _a === void 0 ? void 0 : _a.value;
         if (paletteTexture) {
             args.SetPalette(paletteTexture);

package/Charting/Visuals/RenderableSeries/DrawingProviders/BaseSeriesDrawingProvider.d.ts

@@ -2,10 +2,11 @@ import { IDeletable } from "../../../../Core/IDeletable";
 import { SCRTBrush, TSciChart, UIntVector } from "../../../../types/TSciChart";
 import { PaletteCache } from "../../../Drawing/PaletteCache";
 import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { IPointMetadata } from "../../../Model/IPointMetadata";
 import { RenderPassData } from "../../../Services/RenderPassData";
+import { TDpiChangedEventArgs } from "../../TextureManager/DpiHelper";
 import { IRenderableSeries } from "../IRenderableSeries";
 import { ISeriesDrawingProvider } from "./ISeriesDrawingProvider";
-import { TDpiChangedEventArgs } from "../../TextureManager/DpiHelper";
 /** @ignore */
 export interface ISCRTPen {
     m_bGradient: boolean;
@@ -94,4 +95,9 @@ export declare abstract class BaseSeriesDrawingProvider<T extends IRenderableSer
      */
     onDetachSeries(): void;
     protected seriesHasDataChanges(): void;
+    protected overridePaletteProviderColors(rs: IRenderableSeries, xValue: number, yValue: number, index: number, opacity?: number, metadata?: IPointMetadata): {
+        stroke: number;
+        fill: number;
+    };
+    protected isGradientFillPaletting(rs: IRenderableSeries): boolean;
 }

package/Charting/Visuals/RenderableSeries/DrawingProviders/BaseSeriesDrawingProvider.js

@@ -82,6 +82,7 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
         }
     };
     BaseSeriesDrawingProvider.prototype.applyStrokeFillPaletting = function (stroke, strokePen, fill, fillBrush, opacity, usePalette, resetPenBrushColors) {
+        var _a, _b;
         if (usePalette === void 0) { usePalette = false; }
         if (resetPenBrushColors === void 0) { resetPenBrushColors = true; }
         var hasStrokePaletteProvider = this.parentSeries.hasStrokePaletteProvider();
@@ -93,6 +94,7 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
         if (hasStrokePaletteProvider || hasFillPaletteProvider || hasPointMarkerPaletteProvider) {
             var strokeColor = void 0;
             var fillColor = void 0;
+            // Palette (this.palettingState.paletteTextureCache) is used only for band and mountain series
             if (usePalette) {
                 strokeColor = fillColor = this.webAssemblyContext.SCRTPalette.GetNoOverrideColorCode();
             }
@@ -110,6 +112,7 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
                 throw Error("updatePalette(): fillColor " + fillColor + " cannot be converted to a valid color");
             }
             var dataSeries = this.parentSeries.dataSeries;
+            // Recreate palettedColors if the size changed
             if (!this.palettingState.palettedColors ||
                 this.palettingState.palettedColors.size() !== dataSeries.count()) {
                 Deleter_1.deleteSafe(this.palettingState.palettedColors);
@@ -117,96 +120,75 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
                 this.palettingState.palettedColors.reserve(dataSeries.count() * 2);
                 this.palettingState.paletteTextureCache.reset();
             }
-            if (resetPenBrushColors) {
-                if (strokePen) {
-                    // For paletted series, we must pass 0xFFFFFFFF (white) to pen line
-                    this.palettingState.originalPenColor = strokePen.m_uiColor;
-                    strokePen.m_uiColor = 0xffffffff;
-                    this.palettingState.originalPenGradient = strokePen.m_bGradient;
-                    if (hasStrokePaletteProvider) {
-                        strokePen.m_bGradient = strokePaletteProvider.strokePaletteMode === IPaletteProvider_1.EStrokePaletteMode.GRADIENT;
-                    }
-                    else if (hasPointMarkerPaletteProvider) {
-                        strokePen.m_bGradient =
-                            pointMarkerPaletteProvider.strokePaletteMode === IPaletteProvider_1.EStrokePaletteMode.GRADIENT;
-                    }
-                }
-                if (fillBrush) {
-                    this.palettingState.originalBrushColor = fillBrush.GetColor();
-                    fillBrush.SetColor(0xffffffff);
-                }
-            }
+            // Commented this code out, because I don't know what this code does
+            // if (resetPenBrushColors) {
+            //     if (strokePen) {
+            //         // For paletted series, we must pass 0xFFFFFFFF (white) to pen line
+            //         this.palettingState.originalPenColor = strokePen.m_uiColor;
+            //         strokePen.m_uiColor = 0xffffffff;
+            //         this.palettingState.originalPenGradient = strokePen.m_bGradient;
+            //         if (hasStrokePaletteProvider) {
+            //             strokePen.m_bGradient = strokePaletteProvider.strokePaletteMode === EStrokePaletteMode.GRADIENT;
+            //         } else if (hasPointMarkerPaletteProvider) {
+            //             strokePen.m_bGradient =
+            //                 pointMarkerPaletteProvider.strokePaletteMode === EStrokePaletteMode.GRADIENT;
+            //         }
+            //         console.log("strokePen.m_bGradient", strokePen.m_bGradient);
+            //     }
+            //     if (fillBrush) {
+            //         this.palettingState.originalBrushColor = fillBrush.GetColor();
+            //         fillBrush.SetColor(0xffffffff);
+            //     }
+            // }
+            // Override stroke and fill colors
             var xValues = dataSeries.getNativeXValues();
             var yValues = dataSeries.getNativeYValues();
             var hashCode = 0;
             for (var index = 0; index < dataSeries.count(); index++) {
                 var xValue = xValues.get(index);
                 var yValue = yValues.get(index);
-                var overrideStrokeColor = strokeColor;
-                if (hasStrokePaletteProvider) {
-                    var curStrokeColor = strokePaletteProvider.overrideStrokeArgb(xValue, yValue, index, opacity, dataSeries.getMetadataAt(index));
-                    if (curStrokeColor) {
-                        overrideStrokeColor = curStrokeColor;
-                    }
-                }
-                var overrideFillColor = fillColor;
-                if (hasFillPaletteProvider) {
-                    var curFillColor = fillPaletteProvider.overrideFillArgb(xValue, yValue, index, opacity, dataSeries.getMetadataAt(index));
-                    if (curFillColor) {
-                        overrideFillColor = curFillColor;
-                    }
-                }
-                if (hasPointMarkerPaletteProvider) {
-                    var curFillStrokeColor = pointMarkerPaletteProvider.overridePointMarkerArgb(xValue, yValue, index, opacity, dataSeries.getMetadataAt(index));
-                    if (curFillStrokeColor) {
-                        if (curFillStrokeColor.stroke) {
-                            overrideStrokeColor = curFillStrokeColor.stroke;
-                        }
-                        if (curFillStrokeColor.fill) {
-                            overrideFillColor = curFillStrokeColor.fill;
-                        }
-                    }
-                }
+                var overriddenColors = this.overridePaletteProviderColors(this.parentSeries, xValue, yValue, index, opacity, dataSeries.getMetadataAt(index));
+                var overrideStrokeColor = (_a = overriddenColors.stroke) !== null && _a !== void 0 ? _a : strokeColor;
+                var overrideFillColor = (_b = overriddenColors.fill) !== null && _b !== void 0 ? _b : fillColor;
                 this.palettingState.palettedColors.push_back(overrideStrokeColor);
                 this.palettingState.palettedColors.push_back(overrideFillColor);
                 hashCode = number_1.numericHashCode(hashCode, overrideStrokeColor);
                 hashCode = number_1.numericHashCode(hashCode, overrideFillColor);
             }
+            // Palette is used only for band and mountain series
             if (usePalette) {
                 if (this.palettingState.palettedColorsHashCode !== hashCode) {
                     this.palettingState.paletteTextureCache.reset();
                 }
                 this.palettingState.paletteTextureCache.create(this.palettingState.palettedColors);
+                this.palettingState.palettedColorsHashCode = hashCode;
             }
-            this.palettingState.palettedColorsHashCode = hashCode;
         }
         else {
             this.palettingState.palettedColors = Deleter_1.deleteSafe(this.palettingState.palettedColors);
             this.palettingState.paletteTextureCache.reset();
-            if (strokePen) {
-                if (this.palettingState.originalPenColor) {
-                    strokePen.m_uiColor = this.palettingState.originalPenColor;
-                    this.palettingState.originalPenColor = undefined;
-                }
-                if (this.palettingState.originalPenGradient) {
-                    strokePen.m_bGradient = this.palettingState.originalPenGradient;
-                    this.palettingState.originalPenGradient = undefined;
-                }
-            }
-            if (fillBrush && this.palettingState.originalBrushColor) {
-                fillBrush.SetColor(this.palettingState.originalBrushColor);
-                this.palettingState.originalBrushColor = undefined;
-            }
+            // This was needed for resetPenBrushColors, therefore commented out as well
+            // if (strokePen) {
+            //     if (this.palettingState.originalPenColor) {
+            //         strokePen.m_uiColor = this.palettingState.originalPenColor;
+            //         this.palettingState.originalPenColor = undefined;
+            //     }
+            //     if (this.palettingState.originalPenGradient) {
+            //         strokePen.m_bGradient = this.palettingState.originalPenGradient;
+            //         this.palettingState.originalPenGradient = undefined;
+            //     }
+            // }
+            // if (fillBrush && this.palettingState.originalBrushColor) {
+            //     fillBrush.SetColor(this.palettingState.originalBrushColor);
+            //     this.palettingState.originalBrushColor = undefined;
+            // }
         }
         // Due to pass-by-pointer limitations of WASM binding, we pass an empty vector rather than null
         if (!this.palettingState.palettedColors) {
             this.palettingState.palettedColors = new this.webAssemblyContext.UIntVector();
         }
-        this.palettingState.gradientPaletting =
-            (hasStrokePaletteProvider && strokePaletteProvider.strokePaletteMode === IPaletteProvider_1.EStrokePaletteMode.GRADIENT) ||
-                (hasFillPaletteProvider && fillPaletteProvider.fillPaletteMode === IPaletteProvider_1.EFillPaletteMode.GRADIENT) ||
-                (hasPointMarkerPaletteProvider &&
-                    pointMarkerPaletteProvider.strokePaletteMode === IPaletteProvider_1.EStrokePaletteMode.GRADIENT);
+        // Set gradient for the fill color
+        this.palettingState.gradientPaletting = this.isGradientFillPaletting(this.parentSeries);
     };
     /**
      * Creates a native {@link SCRTBrush} Solid Color Brush from html color code string passed in
@@ -257,6 +239,26 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
     BaseSeriesDrawingProvider.prototype.seriesHasDataChanges = function () {
         // TODO override in derived class.
     };
+    BaseSeriesDrawingProvider.prototype.overridePaletteProviderColors = function (rs, xValue, yValue, index, opacity, metadata) {
+        var stroke;
+        var fill;
+        if (rs.hasStrokePaletteProvider()) {
+            var strokePaletteProvider = rs.paletteProvider;
+            stroke = strokePaletteProvider.overrideStrokeArgb(xValue, yValue, index, opacity, metadata);
+        }
+        if (rs.hasFillPaletteProvider()) {
+            var fillPaletteProvider = rs.paletteProvider;
+            fill = fillPaletteProvider.overrideFillArgb(xValue, yValue, index, opacity, metadata);
+        }
+        return { stroke: stroke, fill: fill };
+    };
+    BaseSeriesDrawingProvider.prototype.isGradientFillPaletting = function (rs) {
+        if (rs.hasFillPaletteProvider()) {
+            var fillPaletteProvider = rs.paletteProvider;
+            return fillPaletteProvider.fillPaletteMode === IPaletteProvider_1.EFillPaletteMode.GRADIENT;
+        }
+        return false;
+    };
     return BaseSeriesDrawingProvider;
 }());
 exports.BaseSeriesDrawingProvider = BaseSeriesDrawingProvider;

package/Charting/Visuals/RenderableSeries/DrawingProviders/BubbleSeriesDrawingProvider.d.ts

@@ -1,7 +1,9 @@
 import { TSciChart } from "../../../../types/TSciChart";
 import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { IPointMetadata } from "../../../Model/IPointMetadata";
 import { RenderPassData } from "../../../Services/RenderPassData";
 import { FastBubbleRenderableSeries } from "../FastBubbleRenderableSeries";
+import { IRenderableSeries } from "../IRenderableSeries";
 import { BaseSeriesDrawingProvider } from "./BaseSeriesDrawingProvider";
 /**
  * Used internally - a drawing provider performs drawing for a {@link FastBubbleRenderableSeries} using
@@ -28,5 +30,10 @@ export declare class BubbleSeriesDrawingProvider extends BaseSeriesDrawingProvid
      * @inheritDoc
      */
     delete(): void;
+    protected overridePaletteProviderColors(rs: IRenderableSeries, xValue: number, yValue: number, index: number, opacity?: number, metadata?: IPointMetadata): {
+        stroke: number;
+        fill: number;
+    };
+    protected isGradientFillPaletting(rs: IRenderableSeries): boolean;
     private drawPoints;
 }

package/Charting/Visuals/RenderableSeries/DrawingProviders/BubbleSeriesDrawingProvider.js

@@ -74,6 +74,18 @@ var BubbleSeriesDrawingProvider = /** @class */ (function (_super) {
         this.nativeDrawingProvider = Deleter_1.deleteSafe(this.nativeDrawingProvider);
         _super.prototype.delete.call(this);
     };
+    BubbleSeriesDrawingProvider.prototype.overridePaletteProviderColors = function (rs, xValue, yValue, index, opacity, metadata) {
+        if (rs.hasPointMarkerPaletteProvider()) {
+            var pointMarkerPaletteProvider = rs.paletteProvider;
+            var colors = pointMarkerPaletteProvider.overridePointMarkerArgb(xValue, yValue, index, opacity, metadata);
+            if (colors)
+                return colors;
+        }
+        return { stroke: undefined, fill: undefined };
+    };
+    BubbleSeriesDrawingProvider.prototype.isGradientFillPaletting = function (rs) {
+        return false;
+    };
     BubbleSeriesDrawingProvider.prototype.drawPoints = function (nativeContext, xValues, yValues, zValues, xCoordCalc, yCoordCalc, args, viewRect) {
         nativeContext.PushMatrix();
         nativeContext.PushState();

package/Charting/Visuals/RenderableSeries/DrawingProviders/MountainSeriesDrawingProvider.d.ts

@@ -1,9 +1,9 @@
 import { TSciChart } from "../../../../types/TSciChart";
 import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
 import { RenderPassData } from "../../../Services/RenderPassData";
+import { TDpiChangedEventArgs } from "../../TextureManager/DpiHelper";
 import { BaseMountainRenderableSeries } from "../BaseMountainRenderableSeries";
 import { BaseSeriesDrawingProvider } from "./BaseSeriesDrawingProvider";
-import { TDpiChangedEventArgs } from "../../TextureManager/DpiHelper";
 /**
  * Used internally - a drawing provider performs drawing for a {@link BaseMountainRenderableSeries} using
  * our WebAssembly WebGL rendering engine
@@ -40,4 +40,5 @@ export declare class MountainSeriesDrawingProvider extends BaseSeriesDrawingProv
      */
     onAttachSeries(): void;
     private createBrush;
+    private createPen;
 }

package/Charting/Visuals/RenderableSeries/DrawingProviders/MountainSeriesDrawingProvider.js

@@ -21,8 +21,6 @@ var Pen2DCache_1 = require("../../../Drawing/Pen2DCache");
 var WebGlRenderContext2D_1 = require("../../../Drawing/WebGlRenderContext2D");
 var constants_1 = require("../constants");
 var BaseSeriesDrawingProvider_1 = require("./BaseSeriesDrawingProvider");
-/** @ignore */
-var TEXTURE_SIZE = 256;
 /**
  * Used internally - a drawing provider performs drawing for a {@link BaseMountainRenderableSeries} using
  * our WebAssembly WebGL rendering engine
@@ -123,8 +121,7 @@ var MountainSeriesDrawingProvider = /** @class */ (function (_super) {
             propertyName === constants_1.PROPERTY.STROKE_DASH_ARRAY ||
             propertyName === constants_1.PROPERTY.STROKE_THICKNESS ||
             propertyName === constants_1.PROPERTY.OPACITY) {
-            var _a = this.parentSeries, stroke = _a.stroke, strokeThickness = _a.strokeThickness, fill = _a.fill, opacity = _a.opacity, strokeDashArray = _a.strokeDashArray;
-            Pen2DCache_1.createPenInCache(this.strokePenCache, stroke, strokeThickness, opacity, strokeDashArray);
+            this.createPen();
         }
         if (propertyName === constants_1.PROPERTY.FILL ||
             propertyName === constants_1.PROPERTY.OPACITY ||
@@ -138,14 +135,17 @@ var MountainSeriesDrawingProvider = /** @class */ (function (_super) {
     MountainSeriesDrawingProvider.prototype.onAttachSeries = function () {
         _super.prototype.onAttachSeries.call(this);
         this.nativeDrawingProvider = new this.webAssemblyContext.SCRTMountainSeriesDrawingProvider();
-        var _a = this.parentSeries, stroke = _a.stroke, strokeThickness = _a.strokeThickness, opacity = _a.opacity, strokeDashArray = _a.strokeDashArray;
-        Pen2DCache_1.createPenInCache(this.strokePenCache, stroke, strokeThickness, opacity, strokeDashArray);
+        this.createPen();
         this.createBrush();
     };
     MountainSeriesDrawingProvider.prototype.createBrush = function () {
         var _a = this.parentSeries, fill = _a.fill, opacity = _a.opacity, fillLinearGradient = _a.fillLinearGradient;
         return BrushCache_1.createBrushInCache(this.fillBrushCache, fill, opacity, fillLinearGradient);
     };
+    MountainSeriesDrawingProvider.prototype.createPen = function () {
+        var _a = this.parentSeries, stroke = _a.stroke, strokeThickness = _a.strokeThickness, opacity = _a.opacity, strokeDashArray = _a.strokeDashArray;
+        return Pen2DCache_1.createPenInCache(this.strokePenCache, stroke, strokeThickness, opacity, strokeDashArray);
+    };
     return MountainSeriesDrawingProvider;
 }(BaseSeriesDrawingProvider_1.BaseSeriesDrawingProvider));
 exports.MountainSeriesDrawingProvider = MountainSeriesDrawingProvider;

package/Charting/Visuals/RenderableSeries/DrawingProviders/PointMarkerDrawingProvider.d.ts

@@ -1,6 +1,7 @@
 import { DoubleVector, TSciChart } from "../../../../types/TSciChart";
 import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
 import { IDataSeries } from "../../../Model/IDataSeries";
+import { IPointMetadata } from "../../../Model/IPointMetadata";
 import { RenderPassData } from "../../../Services/RenderPassData";
 import { IRenderableSeries } from "../IRenderableSeries";
 import { ISpline } from "../ISpline";
@@ -36,6 +37,11 @@ export declare class PointMarkerDrawingProvider extends BaseSeriesDrawingProvide
      * @inheritDoc
      */
     delete(): void;
+    protected overridePaletteProviderColors(rs: IRenderableSeries, xValue: number, yValue: number, index: number, opacity?: number, metadata?: IPointMetadata): {
+        stroke: number;
+        fill: number;
+    };
+    protected isGradientFillPaletting(rs: IRenderableSeries): boolean;
     private drawPoints;
     private pointMarkerXYValuesFromSpline;
 }

package/Charting/Visuals/RenderableSeries/DrawingProviders/PointMarkerDrawingProvider.js

@@ -101,6 +101,18 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
         this.yAnimationPointMarkerValues = Deleter_1.deleteSafe(this.yAnimationPointMarkerValues);
         _super.prototype.delete.call(this);
     };
+    PointMarkerDrawingProvider.prototype.overridePaletteProviderColors = function (rs, xValue, yValue, index, opacity, metadata) {
+        if (rs.hasPointMarkerPaletteProvider()) {
+            var pointMarkerPaletteProvider = rs.paletteProvider;
+            var colors = pointMarkerPaletteProvider.overridePointMarkerArgb(xValue, yValue, index, opacity, metadata);
+            if (colors)
+                return colors;
+        }
+        return { stroke: undefined, fill: undefined };
+    };
+    PointMarkerDrawingProvider.prototype.isGradientFillPaletting = function (rs) {
+        return false;
+    };
     PointMarkerDrawingProvider.prototype.drawPoints = function (nativeContext, xValues, yValues, xCoordCalc, yCoordCalc, args, viewRect) {
         nativeContext.PushMatrix();
         nativeContext.PushState();

package/Charting/Visuals/RenderableSeries/FastBandRenderableSeries.d.ts

@@ -1,7 +1,5 @@
-import { AnimationFiniteStateMachine } from "../../../Core/Animations/AnimationFiniteStateMachine";
 import { ESeriesType } from "../../../types/SeriesType";
 import { TSciChart } from "../../../types/TSciChart";
-import { BaseAnimation } from "./Animations/BaseAnimation";
 import { BaseBandRenderableSeries, IBaseBandRenderableSeriesOptions } from "./BaseBandRenderableSeries";
 /**
  * Optional parameters passed to the constructor of {@link FastBandRenderableSeries}
@@ -38,8 +36,4 @@ export declare class FastBandRenderableSeries extends BaseBandRenderableSeries {
      * @param options optional parameters of type {@link IBandRenderableSeriesOptions} applied when constructing the series type
      */
     constructor(webAssemblyContext: TSciChart, options?: IBandRenderableSeriesOptions);
-    /** @inheritDoc */
-    protected setAnimationVectors(animation: BaseAnimation): void;
-    /** @inheritDoc */
-    protected updateAnimationProperties(progress: number, animationFSM: AnimationFiniteStateMachine): void;
 }

package/Charting/Visuals/RenderableSeries/FastBandRenderableSeries.js

@@ -15,7 +15,6 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastBandRenderableSeries = void 0;
 var SeriesType_1 = require("../../../types/SeriesType");
-var IDataSeries_1 = require("../../Model/IDataSeries");
 var BaseBandRenderableSeries_1 = require("./BaseBandRenderableSeries");
 /**
  * Defines a JavaScript Band-series or High-Low polygon fill chart type in the SciChart's High Performance Real-time
@@ -51,47 +50,6 @@ var FastBandRenderableSeries = /** @class */ (function (_super) {
         _this.type = SeriesType_1.ESeriesType.BandSeries;
         return _this;
     }
-    /** @inheritDoc */
-    FastBandRenderableSeries.prototype.setAnimationVectors = function (animation) {
-        if (animation.isOnStartAnimation) {
-            this.setXFinalAnimationValues(this.getNativeXValues());
-            this.setYFinalAnimationValues(this.getNativeYValues());
-            this.setY1FinalAnimationValues(this.getNativeY1Values());
-        }
-        else if (animation.isDataSeriesAnimation) {
-            var xyyDataSeries = animation.dataSeries;
-            if (xyyDataSeries.type !== IDataSeries_1.EDataSeriesType.Xyy) {
-                throw Error("to animate band chart animation.dataSeries type should be Xyy, but the type is " + xyyDataSeries.type);
-            }
-            this.setXInitialAnimationValues(this.getNativeXValues());
-            this.setYInitialAnimationValues(this.getNativeYValues());
-            this.setY1InitialAnimationValues(this.getNativeY1Values());
-            this.setXFinalAnimationValues(xyyDataSeries.getNativeXValues());
-            this.setYFinalAnimationValues(xyyDataSeries.getNativeYValues());
-            this.setY1FinalAnimationValues(xyyDataSeries.getNativeY1Values());
-            this.validateAnimationValues();
-        }
-    };
-    /** @inheritDoc */
-    FastBandRenderableSeries.prototype.updateAnimationProperties = function (progress, animationFSM) {
-        var animation = animationFSM.animation;
-        animation.updateSeriesProperties(this, animationFSM.initialStyles, animationFSM.animationProgress);
-        if (animation.isOnStartAnimation) {
-            var dataSeries = this.dataSeries;
-            if (dataSeries) {
-                animation.calculateAnimationValues(this.webAssemblyContext, this.yFinalAnimationValues, dataSeries.getNativeYValues(), progress);
-                animation.calculateAnimationValues(this.webAssemblyContext, this.y1FinalAnimationValues, dataSeries.getNativeY1Values(), progress);
-            }
-        }
-        else if (animation.isDataSeriesAnimation) {
-            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.xInitialAnimationValues, this.xFinalAnimationValues, this.getNativeXValues(), progress);
-            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.yInitialAnimationValues, this.yFinalAnimationValues, this.getNativeYValues(), progress);
-            animation.calculateDataSeriesAnimationValues(this.webAssemblyContext, this.y1InitialAnimationValues, this.y1FinalAnimationValues, this.getNativeY1Values(), progress);
-        }
-        if (this.invalidateParentCallback) {
-            this.invalidateParentCallback();
-        }
-    };
     return FastBandRenderableSeries;
 }(BaseBandRenderableSeries_1.BaseBandRenderableSeries));
 exports.FastBandRenderableSeries = FastBandRenderableSeries;

package/Charting/Visuals/RenderableSeries/FastBubbleRenderableSeries.d.ts

@@ -1,8 +1,6 @@
-import { AnimationFiniteStateMachine } from "../../../Core/Animations/AnimationFiniteStateMachine";
 import { ESeriesType } from "../../../types/SeriesType";
 import { DoubleVector, TSciChart } from "../../../types/TSciChart";
 import { IThemeProvider } from "../../Themes/IThemeProvider";
-import { BaseAnimation } from "./Animations/BaseAnimation";
 import { BaseRenderableSeries } from "./BaseRenderableSeries";
 import { IHitTestProvider } from "./HitTest/IHitTestProvider";
 import { IBaseRenderableSeriesOptions } from "./IBaseRenderableSeriesOptions";
@@ -35,14 +33,6 @@ export interface IBubbleRenderableSeriesOptions extends IBaseRenderableSeriesOpt
 export declare class FastBubbleRenderableSeries extends BaseRenderableSeries {
     /** @inheritDoc */
     readonly type = ESeriesType.BubbleSeries;
-    /**
-     * Z vector with initial animation values
-     */
-    protected zInitialAnimationValues: DoubleVector;
-    /**
-     * Z vector with final animation values
-     */
-    protected zFinalAnimationValues: DoubleVector;
     /**
      * Creates an instance of the {@link FastBubbleRenderableSeries}
      * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
@@ -66,11 +56,4 @@ export declare class FastBubbleRenderableSeries extends BaseRenderableSeries {
     getNativeZValues(): DoubleVector;
     /** @inheritDoc */
     protected newHitTestProvider(): IHitTestProvider;
-    /** @inheritDoc */
-    protected setAnimationVectors(animation: BaseAnimation): void;
-    /** @inheritDoc */
-    protected updateAnimationProperties(progress: number, animationFSM: AnimationFiniteStateMachine): void;
-    protected setZInitialAnimationValues(values: DoubleVector): void;
-    protected setZFinalAnimationValues(values: DoubleVector): void;
-    protected validateAnimationValues(): void;
 }