scichart 2.2.2417 → 3.0.0-beta.230

package/Charting/Visuals/RenderableSeries/DataLabels/TextDataLabelProvider.js

@@ -0,0 +1,167 @@
+"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.TextDataLabelProvider = void 0;
+var Point_1 = require("../../../../Core/Point");
+var Rect_1 = require("../../../../Core/Rect");
+var NativeObject_1 = require("../../Helpers/NativeObject");
+var BaseDataLabelProvider_1 = require("./BaseDataLabelProvider");
+var DataLabelProviderType_1 = require("../../../../types/DataLabelProviderType");
+var DataLabelState_1 = require("./DataLabelState");
+var TextPosition_1 = require("../../../../types/TextPosition");
+/**
+ * A DataLabelProvider sepcifically designed to work with {@link FastTextRenderableSeries } or any series that uses an {@link XYTextDataSeries }
+ * Text is taken directly from the textValues on the dataSeries and placed at the x,y coordinates (anchored top, left)
+ */
+var TextDataLabelProvider = /** @class */ (function (_super) {
+    __extends(TextDataLabelProvider, _super);
+    function TextDataLabelProvider(options) {
+        var _this = this;
+        var _a, _b, _c;
+        _this = _super.call(this, __assign(__assign({}, options), { style: __assign({ fontFamily: "Arial", fontSize: 12 }, options === null || options === void 0 ? void 0 : options.style) })) || this;
+        _this.type = DataLabelProviderType_1.EDataLabelProviderType.Text;
+        /**
+         * If your labels are all the same size, or you are not changing the alignment, you can set this false to gain performance
+         */
+        _this.calculateTextBounds = true;
+        _this.horizontalTextPositionProperty = TextPosition_1.EHorizontalTextPosition.Right;
+        _this.verticalTextPositionProperty = TextPosition_1.EVerticalTextPosition.Top;
+        _this.calculateTextBounds = (_a = options === null || options === void 0 ? void 0 : options.calculateTextBounds) !== null && _a !== void 0 ? _a : _this.calculateTextBounds;
+        _this.horizontalTextPositionProperty = (_b = options === null || options === void 0 ? void 0 : options.horizontalTextPosition) !== null && _b !== void 0 ? _b : _this.horizontalTextPosition;
+        _this.verticalTextPositionProperty = (_c = options === null || options === void 0 ? void 0 : options.verticalTextPosition) !== null && _c !== void 0 ? _c : _this.verticalTextPosition;
+        return _this;
+    }
+    Object.defineProperty(TextDataLabelProvider.prototype, "horizontalTextPosition", {
+        /**
+         * Gets or sets the horizontal text position for the label
+         * For more control, override getPosition
+         */
+        get: function () {
+            return this.horizontalTextPositionProperty;
+        },
+        set: function (value) {
+            this.horizontalTextPositionProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextDataLabelProvider.prototype, "verticalTextPosition", {
+        /**
+         * Gets or sets the vertical text position for the label
+         * For more control, override getPosition
+         */
+        get: function () {
+            return this.verticalTextPositionProperty;
+        },
+        set: function (value) {
+            this.verticalTextPositionProperty = value;
+            this.invalidateParent();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextDataLabelProvider.prototype.getPosition = function (state, textBounds) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var x = state.xCoord();
+        if (this.horizontalTextPosition === TextPosition_1.EHorizontalTextPosition.Center) {
+            x -= textBounds.m_fWidth / 2;
+        }
+        else if (this.horizontalTextPosition === TextPosition_1.EHorizontalTextPosition.Left) {
+            x -= textBounds.m_fWidth + ((_b = (_a = this.style.padding) === null || _a === void 0 ? void 0 : _a.right) !== null && _b !== void 0 ? _b : 0);
+        }
+        else {
+            x += (_d = (_c = this.style.padding) === null || _c === void 0 ? void 0 : _c.right) !== null && _d !== void 0 ? _d : 0;
+        }
+        var yOffset = textBounds.m_fHeight - textBounds.GetLineBounds(0).m_fHeight;
+        var y = state.yCoord() - yOffset;
+        if (this.verticalTextPosition === TextPosition_1.EVerticalTextPosition.Center) {
+            y += textBounds.m_fHeight / 2;
+        }
+        else if (this.verticalTextPosition === TextPosition_1.EVerticalTextPosition.Bottom) {
+            y += textBounds.m_fHeight + ((_f = (_e = this.style.padding) === null || _e === void 0 ? void 0 : _e.top) !== null && _f !== void 0 ? _f : 0);
+        }
+        else {
+            y -= (_h = (_g = this.style.padding) === null || _g === void 0 ? void 0 : _g.bottom) !== null && _h !== void 0 ? _h : 0;
+        }
+        return new Point_1.Point(x, y);
+    };
+    TextDataLabelProvider.prototype.getColor = function (state, text) {
+        return state.color;
+    };
+    TextDataLabelProvider.prototype.generateDataLabels = function (renderContext, renderPassData) {
+        var _a, _b, _c, _d, _e;
+        // clear any previous labels
+        this.dataLabels = [];
+        if (!this.style || !this.style.fontFamily || !this.style.fontSize) {
+            return;
+        }
+        var textSeries = this.parentSeries.dataSeries;
+        if (!textSeries || !textSeries.textValues) {
+            console.warn("TextDataLabelProvider requires an XyTextDataSeries");
+            return;
+        }
+        var state = new DataLabelState_1.DataLabelState(renderContext, renderPassData, this.style, this.color, renderPassData.pointSeries.yValues, this.parentSeries);
+        var bounds = (0, NativeObject_1.getTextBounds)(this.webAssemblyContext);
+        var indexes = renderPassData.pointSeries.indexes;
+        if (textSeries) {
+            state.font.CalculateStringBounds((_a = textSeries.textValues[0]) !== null && _a !== void 0 ? _a : "", bounds, (_c = (_b = this.style) === null || _b === void 0 ? void 0 : _b.lineSpacing) !== null && _c !== void 0 ? _c : 2);
+            for (var i = 0; i < indexes.size(); i++) {
+                state.index = i;
+                var index = indexes.get(state.index);
+                var text = textSeries.textValues[index];
+                if (this.calculateTextBounds) {
+                    state.font.CalculateStringBounds(text !== null && text !== void 0 ? text : "", bounds, (_e = (_d = this.style) === null || _d === void 0 ? void 0 : _d.lineSpacing) !== null && _e !== void 0 ? _e : 2);
+                }
+                var position = this.getPosition(state, bounds);
+                var firstLineHeight = bounds.GetLineBounds(0).m_fHeight;
+                var label = {
+                    text: text,
+                    position: position,
+                    rect: new Rect_1.Rect(position.x, position.y - firstLineHeight, bounds.m_fWidth, bounds.m_fHeight),
+                    color: this.getColor(state, text),
+                    dataX: state.xCoord(),
+                    dataY: state.yCoord()
+                };
+                this.dataLabels.push(label);
+            }
+        }
+    };
+    TextDataLabelProvider.prototype.toJSON = function () {
+        var json = _super.prototype.toJSON.call(this);
+        var options = {
+            calculateTextBounds: this.calculateTextBounds,
+            horizontalTextPosition: this.horizontalTextPosition,
+            verticalTextPosition: this.verticalTextPosition
+        };
+        Object.assign(json.options, options);
+        return json;
+    };
+    return TextDataLabelProvider;
+}(BaseDataLabelProvider_1.BaseDataLabelProvider));
+exports.TextDataLabelProvider = TextDataLabelProvider;

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

@@ -15,7 +15,6 @@ export declare class BandSeriesDrawingProvider extends BaseSeriesDrawingProvider
     private strokePenY1Cache;
     private fillBrushCache;
     private fillBrushY1Cache;
-    private ySelector;
     private y1Selector;
     /**
      * Creates an instance of the {@link BandSeriesDrawingProvider}

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

@@ -36,8 +36,7 @@ var BandSeriesDrawingProvider = /** @class */ (function (_super) {
      * @param parentSeries the parent {@link BaseBandRenderableSeries} which this drawing provider is attached to
      */
     function BandSeriesDrawingProvider(webAssemblyContext, parentSeries, ySelector, y1Selector) {
-        var _this = _super.call(this, webAssemblyContext, parentSeries) || this;
-        _this.ySelector = ySelector !== null && ySelector !== void 0 ? ySelector : (function (ps) { return ps.yValues; });
+        var _this = _super.call(this, webAssemblyContext, parentSeries, ySelector) || this;
         _this.y1Selector = y1Selector !== null && y1Selector !== void 0 ? y1Selector : (function (ps) { return ps.y1Values; });
         _this.linesPenCache = new Pen2DCache_1.Pen2DCache(webAssemblyContext);
         _this.strokePenY1Cache = new Pen2DCache_1.Pen2DCache(webAssemblyContext);

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

@@ -1,8 +1,9 @@
 import { IDeletable } from "../../../../Core/IDeletable";
-import { SCRTBrush, TSciChart, UIntVector } from "../../../../types/TSciChart";
+import { SCRTBrush, SCRTDoubleVector, TSciChart, UIntVector } from "../../../../types/TSciChart";
 import { PaletteCache } from "../../../Drawing/PaletteCache";
 import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
 import { IPointMetadata } from "../../../Model/IPointMetadata";
+import { IPointSeries } from "../../../Model/PointSeries/IPointSeries";
 import { RenderPassData } from "../../../Services/RenderPassData";
 import { TDpiChangedEventArgs } from "../../TextureManager/DpiHelper";
 import { IRenderableSeries } from "../IRenderableSeries";
@@ -48,6 +49,8 @@ export declare abstract class BaseSeriesDrawingProvider<T extends IRenderableSer
      * The Colour Paletting State object.
      */
     protected palettingState: TPalettingState;
+    protected xSelector: (ds: IPointSeries) => SCRTDoubleVector;
+    protected ySelector: (ds: IPointSeries) => SCRTDoubleVector;
     private parentDataSeries;
     /**
      * Creates an instance of the {@link BaseSeriesDrawingProvider}
@@ -55,7 +58,7 @@ export declare abstract class BaseSeriesDrawingProvider<T extends IRenderableSer
      * access to our WebGL2 Engine and WebAssembly numerical methods
      * @param parentSeries the parent {@link IRenderableSeries | Renderable Series} which this drawing provider is attached to
      */
-    protected constructor(webAssemblyContext: TSciChart, parentSeries: T);
+    protected constructor(webAssemblyContext: TSciChart, parentSeries: T, ySelector?: (ps: IPointSeries) => SCRTDoubleVector, xSelector?: (ps: IPointSeries) => SCRTDoubleVector);
     /**
      * Helper function to apply color-paletting to a {@link UIntVector} - where each element in the vector
      * is an ARGB color that defines stroke of the series

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

@@ -21,12 +21,14 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
      * access to our WebGL2 Engine and WebAssembly numerical methods
      * @param parentSeries the parent {@link IRenderableSeries | Renderable Series} which this drawing provider is attached to
      */
-    function BaseSeriesDrawingProvider(webAssemblyContext, parentSeries) {
+    function BaseSeriesDrawingProvider(webAssemblyContext, parentSeries, ySelector, xSelector) {
         var _a;
         Guard_1.Guard.notNull(webAssemblyContext, "webAssemblyContext");
         Guard_1.Guard.notNull(parentSeries, "parentSeries");
         this.webAssemblyContext = webAssemblyContext;
         this.parentSeries = parentSeries;
+        this.ySelector = ySelector !== null && ySelector !== void 0 ? ySelector : (function (ps) { return ps.yValues; });
+        this.xSelector = xSelector !== null && xSelector !== void 0 ? xSelector : (function (ps) { return ps.xValues; });
         this.palettingState = {
             palettedColors: undefined,
             palettedColorsHashCode: 0,
@@ -44,7 +46,7 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
      * @returns the new {@link UIntVector} with ARGB colors
      */
     BaseSeriesDrawingProvider.prototype.applyStrokePaletting = function (strokePen) {
-        var _a;
+        var _a, _b, _c;
         if (this.parentSeries.hasStrokePaletteProvider()) {
             var strokeColorArgb = (0, colorUtil_1.uintArgbColorMultiplyOpacity)((0, parseColor_1.parseColorToUIntArgb)(this.parentSeries.stroke), this.parentSeries.opacity);
             if (isNaN(strokeColorArgb)) {
@@ -54,6 +56,11 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
             }
             var strokePaletteProvider = this.parentSeries.paletteProvider;
             var dataSeries = this.parentSeries.dataSeries;
+            var renderPassData = this.parentSeries.getCurrentRenderPassData();
+            var pointSeries = renderPassData === null || renderPassData === void 0 ? void 0 : renderPassData.pointSeries;
+            var xValues = (_a = pointSeries === null || pointSeries === void 0 ? void 0 : pointSeries.xValues) !== null && _a !== void 0 ? _a : dataSeries.getNativeXValues();
+            var yValues = (_b = pointSeries === null || pointSeries === void 0 ? void 0 : pointSeries.yValues) !== null && _b !== void 0 ? _b : dataSeries.getNativeYValues();
+            var dataSize = pointSeries ? pointSeries.indexes.size() : xValues.size();
             if (!this.palettingState.palettedColors ||
                 this.palettingState.palettedColors.size() !== dataSeries.count()) {
                 (0, Deleter_1.deleteSafe)(this.palettingState.palettedColors);
@@ -63,10 +70,9 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
             strokePen.m_bGradient = strokePaletteProvider.strokePaletteMode === IPaletteProvider_1.EStrokePaletteMode.GRADIENT;
             // For paletted series, we must pass 0xFFFFFFFF (white) to pen line
             strokePen.m_uiColor = 0xffffffff;
-            var xValues = dataSeries.getNativeXValues();
-            var yValues = dataSeries.getNativeYValues();
-            for (var index = 0; index < dataSeries.count(); index++) {
-                var overrideColor = strokePaletteProvider.overrideStrokeArgb(xValues.get(index), yValues.get(index), index, this.parentSeries.opacity, dataSeries.getMetadataAt(index));
+            for (var index = 0; index < dataSize; index++) {
+                var originalDataIndex = pointSeries ? pointSeries.indexes.get(index) : index;
+                var overrideColor = strokePaletteProvider.overrideStrokeArgb(xValues.get(index), yValues.get(index), index, this.parentSeries.opacity, dataSeries.getMetadataAt(originalDataIndex));
                 this.parentSeries.pushPalettedColors(overrideColor ? overrideColor : strokeColorArgb, this.palettingState);
             }
         }
@@ -75,7 +81,7 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
                 strokePen.m_uiColor = this.palettingState.originalPenColor;
                 this.palettingState.originalPenColor = undefined;
             }
-            (_a = this.palettingState.palettedColors) === null || _a === void 0 ? void 0 : _a.clear();
+            (_c = this.palettingState.palettedColors) === null || _c === void 0 ? void 0 : _c.clear();
         }
         // Due to pass-by-pointer limitations of WASM binding, we pass an empty vector rather than null
         if (!this.palettingState.palettedColors) {
@@ -126,25 +132,26 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
                 this.palettingState.paletteTextureCache.reset();
             }
             // 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);
-            //     }
-            // }
+            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;
+                    }
+                    //console.log("strokePen.m_bGradient", strokePen.m_bGradient);
+                }
+                if (fillBrush) {
+                    this.palettingState.originalBrushColor = fillBrush.GetColor();
+                    fillBrush.SetColor(0xffffffff);
+                }
+            }
             // Override stroke and fill colors
             var hashCode = 0;
             for (var index = 0; index < dataSize; index++) {
@@ -172,20 +179,20 @@ var BaseSeriesDrawingProvider = /** @class */ (function () {
             this.palettingState.paletteTextureCache.reset();
             (_e = this.palettingState.palettedColors) === null || _e === void 0 ? void 0 : _e.clear();
             // 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;
-            // }
+            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) {

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

@@ -64,7 +64,7 @@ var BubbleSeriesDrawingProvider = /** @class */ (function (_super) {
         // Paletting per point
         _super.prototype.applyStrokeFillPaletting.call(this, this.parentSeries.stroke, undefined, undefined, undefined, this.parentSeries.opacity);
         args.SetPalettedColors(this.palettingState.palettedColors);
-        args.zMultiplier = DpiHelper_1.DpiHelper.PIXEL_RATIO;
+        args.zMultiplier = this.parentSeries.zMultiplier * DpiHelper_1.DpiHelper.PIXEL_RATIO;
         var nativeContext = renderContext.getNativeContext();
         this.drawPoints(nativeContext, isCategoryAxis ? pointSeries.indexes : xValues, yValues, zValues, renderPassData.xCoordinateCalculator.nativeCalculator, renderPassData.yCoordinateCalculator.nativeCalculator, args, this.parentSeries.parentSurface.seriesViewRect);
         args.delete();

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

@@ -36,4 +36,5 @@ export declare class ColumnSeriesDrawingProvider extends BaseSeriesDrawingProvid
      * @inheritDoc
      */
     onSeriesPropertyChange(propertyName: string): void;
+    private createBrush;
 }

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

@@ -19,6 +19,7 @@ exports.ColumnSeriesDrawingProvider = void 0;
 var Deleter_1 = require("../../../../Core/Deleter");
 var BrushCache_1 = require("../../../Drawing/BrushCache");
 var Pen2DCache_1 = require("../../../Drawing/Pen2DCache");
+var SciChartSurfaceBase_1 = require("../../SciChartSurfaceBase");
 var constants_1 = require("../constants");
 var BaseSeriesDrawingProvider_1 = require("./BaseSeriesDrawingProvider");
 /**
@@ -45,7 +46,7 @@ var ColumnSeriesDrawingProvider = /** @class */ (function (_super) {
         if (strokeThickness === 0) {
             (0, Pen2DCache_1.createPenInCache)(_this.strokePenFillColoredCache, fill, 1, opacity);
         }
-        (0, BrushCache_1.createBrushInCache)(_this.fillBrushCache, fill, opacity);
+        _this.createBrush();
         return _this;
     }
     /**
@@ -70,10 +71,12 @@ var ColumnSeriesDrawingProvider = /** @class */ (function (_super) {
         args.verticalChart = renderPassData.isVerticalChart;
         args.zeroLineY = this.parentSeries.zeroLineY;
         args.columnWidth = this.parentSeries.getDataPointWidth(renderPassData.xCoordinateCalculator, this.parentSeries.dataPointWidth);
+        args.bottomRadius = this.parentSeries.cornerRadius;
         var strokePenCache = this.strokePenCache;
         // ISSUE: If the strokeThickness property is not provided,
         // the fill will be disappeared with large zoom (when the column width will be small or zero)
-        if (args.columnWidth === 0 && strokeThickness === 0) {
+        if (args.columnWidth === 1 && strokeThickness === 0) {
+            args.columnWidth = 0;
             strokePenCache = this.strokePenFillColoredCache;
         }
         var linesPen = (0, Pen2DCache_1.getScrtPenFromCache)(strokePenCache);
@@ -87,7 +90,7 @@ var ColumnSeriesDrawingProvider = /** @class */ (function (_super) {
         args.viewportWidth = viewRect.width;
         args.viewportHeight = viewRect.height;
         // Paletting per point
-        _super.prototype.applyStrokeFillPaletting.call(this, this.parentSeries.stroke, linesPen, this.parentSeries.fill, fillBrush, this.parentSeries.opacity);
+        _super.prototype.applyStrokeFillPaletting.call(this, this.parentSeries.stroke, linesPen, this.parentSeries.fill, fillBrush, this.parentSeries.opacity, false, this.parentSeries.fillLinearGradient !== undefined);
         args.SetPalettedColors(this.palettingState.palettedColors);
         var isCategoryAxis = renderPassData.xCoordinateCalculator.isCategoryCoordinateCalculator;
         var xValues = pointSeries.xValues;
@@ -116,16 +119,26 @@ var ColumnSeriesDrawingProvider = /** @class */ (function (_super) {
             (0, Pen2DCache_1.createPenInCache)(this.strokePenCache, stroke, strokeThickness, opacity);
         }
         if (propertyName === constants_1.PROPERTY.FILL || propertyName === constants_1.PROPERTY.OPACITY) {
-            (0, BrushCache_1.createBrushInCache)(this.fillBrushCache, fill, opacity);
+            this.createBrush();
         }
         if (strokeThickness === 0 &&
             (propertyName === constants_1.PROPERTY.STROKE_THICKNESS ||
                 propertyName === constants_1.PROPERTY.STROKE ||
                 propertyName === constants_1.PROPERTY.OPACITY ||
                 propertyName === constants_1.PROPERTY.FILL)) {
-            (0, Pen2DCache_1.createPenInCache)(this.strokePenFillColoredCache, fill, strokeThickness, opacity);
+            (0, Pen2DCache_1.createPenInCache)(this.strokePenFillColoredCache, fill, 1, opacity);
         }
     };
+    ColumnSeriesDrawingProvider.prototype.createBrush = function () {
+        var _a = this.parentSeries, fill = _a.fill, opacity = _a.opacity, fillLinearGradient = _a.fillLinearGradient, parentSurface = _a.parentSurface;
+        var textureHeightRatio = (parentSurface === null || parentSurface === void 0 ? void 0 : parentSurface.isCopyCanvasSurface)
+            ? parentSurface.domCanvas2D.height / SciChartSurfaceBase_1.SciChartSurfaceBase.domMasterCanvas.height
+            : 1;
+        var textureWidthRatio = (parentSurface === null || parentSurface === void 0 ? void 0 : parentSurface.isCopyCanvasSurface)
+            ? parentSurface.domCanvas2D.width / SciChartSurfaceBase_1.SciChartSurfaceBase.domMasterCanvas.width
+            : 1;
+        return (0, BrushCache_1.createBrushInCache)(this.fillBrushCache, fill, opacity, textureHeightRatio, textureWidthRatio, fillLinearGradient);
+    };
     return ColumnSeriesDrawingProvider;
 }(BaseSeriesDrawingProvider_1.BaseSeriesDrawingProvider));
 exports.ColumnSeriesDrawingProvider = ColumnSeriesDrawingProvider;

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

@@ -10,7 +10,6 @@ import { BaseSeriesDrawingProvider } from "./BaseSeriesDrawingProvider";
  */
 export declare class ErrorSeriesDrawingProvider extends BaseSeriesDrawingProvider<FastErrorBarsRenderableSeries> {
     private linesPenCache;
-    private vertices;
     /**
      * Creates an instance of the {@link BandSeriesDrawingProvider}
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} containing native methods and

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

@@ -24,6 +24,7 @@ var ErrorMode_1 = require("../../../../types/ErrorMode");
 var Pen2DCache_1 = require("../../../Drawing/Pen2DCache");
 var WebGlRenderContext2D_1 = require("../../../Drawing/WebGlRenderContext2D");
 var LogarithmicAxis_1 = require("../../Axis/LogarithmicAxis");
+var NativeObject_1 = require("../../Helpers/NativeObject");
 var constants_1 = require("../constants");
 var BaseSeriesDrawingProvider_1 = require("./BaseSeriesDrawingProvider");
 /**
@@ -44,7 +45,6 @@ var ErrorSeriesDrawingProvider = /** @class */ (function (_super) {
     function ErrorSeriesDrawingProvider(webAssemblyContext, parentSeries) {
         var _this = _super.call(this, webAssemblyContext, parentSeries) || this;
         _this.linesPenCache = new Pen2DCache_1.Pen2DCache(webAssemblyContext);
-        _this.vertices = new _this.webAssemblyContext.VectorColorVertex();
         return _this;
         // this.args = new webAssemblyContext.SCRTLineDrawingParams();
         // this.xLineCoordinates = new this.webAssemblyContext.SCRTDoubleVector();
@@ -72,7 +72,6 @@ var ErrorSeriesDrawingProvider = /** @class */ (function (_super) {
     ErrorSeriesDrawingProvider.prototype.delete = function () {
         // this.nativeDrawingProvider = deleteSafe(this.nativeDrawingProvider);
         this.linesPenCache = (0, Deleter_1.deleteSafe)(this.linesPenCache);
-        this.vertices = (0, Deleter_1.deleteSafe)(this.vertices);
         // this.args = deleteSafe(this.args);
         _super.prototype.delete.call(this);
     };
@@ -85,7 +84,7 @@ var ErrorSeriesDrawingProvider = /** @class */ (function (_super) {
             return;
         }
         var pointSeries = renderPassData.pointSeries;
-        this.vertices.clear();
+        var vertices = (0, NativeObject_1.getVectorColorVertex)(this.webAssemblyContext);
         // this.xLineCoordinates.clear();
         // this.yLineCoordinates.clear();
         // this.args.Reset();
@@ -151,15 +150,15 @@ var ErrorSeriesDrawingProvider = /** @class */ (function (_super) {
                 var capEnd = xCoord + halfRange;
                 // main line
                 if (this.parentSeries.drawConnector) {
-                    this.addLineVertices(xCoord, isNaN(highValue) ? yCoord : highCoord, xCoord, isNaN(lowValue) ? yCoord : lowCoord);
+                    this.addLineVertices(vertices, xCoord, isNaN(highValue) ? yCoord : highCoord, xCoord, isNaN(lowValue) ? yCoord : lowCoord);
                 }
                 if (hasHighCap && !shouldDrawHighErrorToLimit && this.parentSeries.drawWhiskers) {
                     // top whiskers
-                    this.addLineVertices(capStart, highCoord, capEnd, highCoord);
+                    this.addLineVertices(vertices, capStart, highCoord, capEnd, highCoord);
                 }
                 if (hasLowCap && !shouldDrawLowErrorToLimit && this.parentSeries.drawWhiskers) {
                     // bottom whiskers
-                    this.addLineVertices(capStart, lowCoord, capEnd, lowCoord);
+                    this.addLineVertices(vertices, capStart, lowCoord, capEnd, lowCoord);
                 }
             }
         }
@@ -189,20 +188,20 @@ var ErrorSeriesDrawingProvider = /** @class */ (function (_super) {
                 var capEnd = yCoord + halfRange;
                 // main line
                 if (this.parentSeries.drawConnector) {
-                    this.addLineVertices(isNaN(lowValue) ? xCoord : lowCoord, yCoord, isNaN(highValue) ? xCoord : highCoord, yCoord);
+                    this.addLineVertices(vertices, isNaN(lowValue) ? xCoord : lowCoord, yCoord, isNaN(highValue) ? xCoord : highCoord, yCoord);
                 }
                 if (hasHighCap && !shouldDrawHighErrorToLimit && this.parentSeries.drawWhiskers) {
                     // top whiskers
-                    this.addLineVertices(highCoord, capStart, highCoord, capEnd);
+                    this.addLineVertices(vertices, highCoord, capStart, highCoord, capEnd);
                 }
                 if (hasLowCap && !shouldDrawLowErrorToLimit && this.parentSeries.drawWhiskers) {
                     // bottom whiskers
-                    this.addLineVertices(lowCoord, capStart, lowCoord, capEnd);
+                    this.addLineVertices(vertices, lowCoord, capStart, lowCoord, capEnd);
                 }
             }
         }
         // this.nativeDrawingProvider.DrawLinesVec(nativeContext, xValues, yValues, xCoordCalc, yCoordCalc, args);
-        renderContext.drawLinesNative(this.vertices, linesPen, WebGlRenderContext2D_1.ELineDrawMode.DiscontinuousLine);
+        renderContext.drawLinesNative(vertices, linesPen, WebGlRenderContext2D_1.ELineDrawMode.DiscontinuousLine);
     };
     /**
      * @inheritDoc
@@ -224,28 +223,16 @@ var ErrorSeriesDrawingProvider = /** @class */ (function (_super) {
             (0, Pen2DCache_1.createPenInCache)(this.linesPenCache, stroke, strokeThickness, opacity, strokeDashArray);
         }
     };
-    ErrorSeriesDrawingProvider.prototype.addLineVertices = function (x1, y1, x2, y2) {
+    ErrorSeriesDrawingProvider.prototype.addLineVertices = function (vertices, x1, y1, x2, y2) {
         var isVerticalChart = this.parentSeries.xAxis.isVerticalChart;
-        var vertex1;
-        var vertex2;
         if (isVerticalChart) {
-            vertex1 = new this.webAssemblyContext.SCRTColorVertex(y1, x1);
-            vertex2 = new this.webAssemblyContext.SCRTColorVertex(y2, x2);
+            vertices.push_back((0, NativeObject_1.getVertex)(this.webAssemblyContext, y1, x1));
+            vertices.push_back((0, NativeObject_1.getVertex)(this.webAssemblyContext, y2, x2));
         }
         else {
-            vertex1 = new this.webAssemblyContext.SCRTColorVertex(x1, y1);
-            vertex2 = new this.webAssemblyContext.SCRTColorVertex(x2, y2);
+            vertices.push_back((0, NativeObject_1.getVertex)(this.webAssemblyContext, x1, y1));
+            vertices.push_back((0, NativeObject_1.getVertex)(this.webAssemblyContext, x2, y2));
         }
-        this.vertices.push_back(vertex1);
-        this.vertices.push_back(vertex2);
-        vertex1.delete();
-        vertex2.delete();
-        // this.xLineCoordinates.push_back(x1);
-        // this.yLineCoordinates.push_back(x2);
-        // this.xLineCoordinates.push_back(y1);
-        // this.yLineCoordinates.push_back(y2);
-        // this.xLineCoordinates.push_back(NaN);
-        // this.yLineCoordinates.push_back(NaN);
     };
     return ErrorSeriesDrawingProvider;
 }(BaseSeriesDrawingProvider_1.BaseSeriesDrawingProvider));

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

@@ -1,9 +1,20 @@
-import { TSciChart } from "../../../../types/TSciChart";
-import { WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { SCRTDoubleVector, TSciChart } from "../../../../types/TSciChart";
+import { ELineDrawMode, WebGlRenderContext2D } from "../../../Drawing/WebGlRenderContext2D";
+import { IPointSeries } from "../../../Model/PointSeries/IPointSeries";
 import { RenderPassData } from "../../../Services/RenderPassData";
 import { TDpiChangedEventArgs } from "../../TextureManager/DpiHelper";
-import { BaseLineRenderableSeries } from "../BaseLineRenderableSeries";
+import { BaseLineRenderableSeries, ELineType } from "../BaseLineRenderableSeries";
 import { BaseSeriesDrawingProvider } from "./BaseSeriesDrawingProvider";
+export interface ILineSeriesDrawingProviderProperties {
+    stroke?: string;
+    strokeThickness?: number;
+    opacity?: number;
+    strokeDashArray?: number[];
+    isDigitalLine: boolean;
+    drawNaNAs: ELineDrawMode;
+    lineType: ELineType;
+    containsNaN: boolean;
+}
 /**
  * Used internally - a drawing provider performs drawing for a {@link FastLineRenderableSeries} using
  * our WebAssembly WebGL rendering engine
@@ -18,7 +29,7 @@ export declare class LineSeriesDrawingProvider extends BaseSeriesDrawingProvider
      * access to our WebGL2 Engine and WebAssembly numerical methods
      * @param parentSeries the parent {@link FastLineRenderableSeries} which this drawing provider is attached to
      */
-    constructor(webAssemblyContext: TSciChart, parentSeries: BaseLineRenderableSeries);
+    constructor(webAssemblyContext: TSciChart, parentSeries: BaseLineRenderableSeries, ySelector?: (ps: IPointSeries) => SCRTDoubleVector, xSelector?: (ps: IPointSeries) => SCRTDoubleVector);
     /**
      * @inheritDoc
      */
@@ -27,6 +38,8 @@ export declare class LineSeriesDrawingProvider extends BaseSeriesDrawingProvider
      * @inheritDoc
      */
     onSeriesPropertyChange(propertyName: string): void;
+    /** A mapping function to get the pen properties from the parent series */
+    getProperties(parentSeries: BaseLineRenderableSeries): ILineSeriesDrawingProviderProperties;
     /**
      * @inheritDoc
      */