scichart 2.2.2416 → 3.0.0-beta.224

package/Charting/Themes/IThemeProvider.d.ts

@@ -1,5 +1,7 @@
 import { TGradientStop } from "../../types/TGradientStop";
 import { EThemeProviderType } from "../../types/ThemeProviderType";
+import { TSciChart } from "../../types/TSciChart";
+export declare const AUTO_COLOR = "auto";
 /**
  * @summary The ThemeProvider has properties to define a theme within SciChart's 2D & 3D Charts
  * @decription Applied to a 2D {@link SciChartSurface}, or a 3D {@link SciChart3DSurface}, the ThemeProvider may be
@@ -23,6 +25,18 @@ import { EThemeProviderType } from "../../types/ThemeProviderType";
  * ```
  */
 export interface IThemeProvider {
+    /**
+     * An array of color codes (or GradientStops if you want to control the gaps between colors) which will be used to provide stroke colors.
+     */
+    strokePalette?: string[] | TGradientStop[];
+    /**
+     * An array of color codes (or GradientStops if you want to control the gaps between colors) which will be used to provide fill colors.
+     */
+    fillPalette?: string[] | TGradientStop[];
+    /**
+     * Tells SciChart if the theme has a light or dark background (used for calculating contrasting elements)
+     */
+    isLightBackground?: boolean;
     /**
      * The Background color as an HTML color code
      * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
@@ -133,6 +147,8 @@ export interface IThemeProvider {
      * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
      */
     annotationsGripsBackroundBrush: string;
+    /** The {@link AnnotationBase}  selection box stroke color as an HTML color code */
+    annotationSelectionStroke?: string;
     overviewFillBrush: string;
     scrollbarBackgroundBrush: string;
     scrollbarBorderBrush: string;
@@ -238,11 +254,33 @@ export interface IThemeProvider {
      * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
      */
     axis3DBandsFill: string;
+    /**
+     * get a color from the strokePalette, either directly (if max is less than strokePalette length) or by interpolation
+     * @param index
+     * @param max
+     * @param wasmContext
+     */
+    getStrokeColor?(index: number, max: number, wasmContext: TSciChart): string;
+    /**
+     * get a color from the fillPalette, either directly (if max is less than fillPalette length) or by interpolation
+     * @param index
+     * @param max
+     * @param wasmContext
+     */
+    getFillColor?(index: number, max: number, wasmContext: TSciChart): string;
 }
 /**
  * IThemePartial contains the same fields as IThemeProvider, but all optional, so can provide partial themes to customise an existing theme
  */
 export interface IThemePartial {
+    /**
+     * An array of color codes (or GradientStops if you want to control the gaps between colors) which will be used to provide stroke colors.
+     */
+    strokePalette?: string[] | TGradientStop[];
+    /**
+     * An array of color codes (or GradientStops if you want to control the gaps between colors) which will be used to provide fill colors.
+     */
+    fillPalette?: string[] | TGradientStop[];
     /**
      * The Background color as an HTML color code
      * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
@@ -348,6 +386,8 @@ export interface IThemePartial {
      * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
      */
     annotationsGripsBackroundBrush?: string;
+    /** The {@link AnnotationBase}  selection box stroke color as an HTML color code */
+    annotationSelectionStroke?: string;
     overviewFillBrush?: string;
     scrollbarBackgroundBrush?: string;
     scrollbarBorderBrush?: string;
@@ -473,6 +513,7 @@ export declare abstract class ThemeProvider implements IThemeProvider {
     abstract textAnnotationBackground: string;
     abstract annotationsGripsBorderBrush: string;
     abstract annotationsGripsBackroundBrush: string;
+    annotationSelectionStroke?: string;
     abstract overviewFillBrush: string;
     abstract scrollbarBackgroundBrush: string;
     abstract scrollbarBorderBrush: string;
@@ -499,9 +540,24 @@ export declare abstract class ThemeProvider implements IThemeProvider {
     abstract planeBorderColor: string;
     abstract axisPlaneBackgroundFill: string;
     abstract axis3DBandsFill: string;
+    strokePalette: string[] | TGradientStop[];
+    fillPalette: string[] | TGradientStop[];
+    abstract isLightBackground: boolean;
     protected overrides: IThemePartial;
+    private strokeGradient;
+    private fillGradient;
+    getStrokeColor(index: number, max: number, wasmContext: TSciChart): string;
+    getFillColor(index: number, max: number, wasmContext: TSciChart): string;
     applyOverrides(overrides: IThemePartial): void;
     toJSON(): {
+        /**
+         * An array of color codes (or GradientStops if you want to control the gaps between colors) which will be used to provide stroke colors.
+         */
+        strokePalette?: string[] | TGradientStop[];
+        /**
+         * An array of color codes (or GradientStops if you want to control the gaps between colors) which will be used to provide fill colors.
+         */
+        fillPalette?: string[] | TGradientStop[];
         /**
          * The Background color as an HTML color code
          * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
@@ -607,6 +663,8 @@ export declare abstract class ThemeProvider implements IThemeProvider {
          * @remarks Acceptable values include RGB format e.g. ```#FF0000```, RGBA format e.g. ```#FF000077`` and RGBA format e.g. ```rgba(255,0,0,0.5)```
          */
         annotationsGripsBackroundBrush?: string;
+        /** The {@link AnnotationBase}  selection box stroke color as an HTML color code */
+        annotationSelectionStroke?: string;
         overviewFillBrush?: string;
         scrollbarBackgroundBrush?: string;
         scrollbarBorderBrush?: string;
@@ -709,4 +767,7 @@ export declare abstract class ThemeProvider implements IThemeProvider {
         axis3DBandsFill?: string;
         type: string;
     };
+    private getPaletteColor;
+    private toColor;
 }
+export declare const stripAutoColor: (val: string) => string;

package/Charting/Themes/IThemeProvider.js

@@ -11,10 +11,21 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThemeProvider = void 0;
+exports.stripAutoColor = exports.ThemeProvider = exports.AUTO_COLOR = void 0;
+var parseColor_1 = require("../../utils/parseColor");
+var PaletteFactory_1 = require("../Model/PaletteFactory");
+exports.AUTO_COLOR = "auto";
 var ThemeProvider = /** @class */ (function () {
     function ThemeProvider() {
+        this.strokePalette = [];
+        this.fillPalette = [];
     }
+    ThemeProvider.prototype.getStrokeColor = function (index, max, wasmContext) {
+        return this.getPaletteColor(index, max, wasmContext, true);
+    };
+    ThemeProvider.prototype.getFillColor = function (index, max, wasmContext) {
+        return this.getPaletteColor(index, max, wasmContext, false);
+    };
     ThemeProvider.prototype.applyOverrides = function (overrides) {
         this.overrides = overrides;
         Object.assign(this, overrides);
@@ -22,6 +33,61 @@ var ThemeProvider = /** @class */ (function () {
     ThemeProvider.prototype.toJSON = function () {
         return __assign({ type: this.type }, this.overrides);
     };
+    ThemeProvider.prototype.getPaletteColor = function (index, max, wasmContext, isStroke) {
+        var palette = isStroke ? this.strokePalette : this.fillPalette;
+        if (!palette || palette.length === 0) {
+            throw new Error("".concat(isStroke ? "stroke" : "fill", "Palette must not be empty to use get").concat(isStroke ? "Stroke" : "Fill", "Color"));
+        }
+        if (palette.length < 2) {
+            return this.toColor(palette[0]);
+        }
+        if (index > max) {
+            throw new Error("index must be less than or equal to max");
+        }
+        if (max <= palette.length) {
+            return this.toColor(palette[index]);
+        }
+        var gradient = isStroke ? this.strokeGradient : this.fillGradient;
+        if (!gradient) {
+            var gradientStops = typeof palette[0] === "string"
+                ? palette.map(function (color, i) {
+                    return ({
+                        color: color,
+                        offset: i / palette.length - 1
+                    });
+                })
+                : palette;
+            gradient = PaletteFactory_1.PaletteFactory.createColorMap(wasmContext, gradientStops);
+            if (isStroke) {
+                this.strokeGradient = gradient;
+            }
+            else {
+                this.fillGradient = gradient;
+            }
+        }
+        var lerpFactor = index / max;
+        var mapIndex = wasmContext.NumberUtil.Constrain(Math.round(lerpFactor * (gradient.length - 1)), 0, gradient.length - 1);
+        var result = gradient[mapIndex];
+        return (0, parseColor_1.parseArgbToHtmlColor)(result);
+    };
+    ThemeProvider.prototype.toColor = function (val) {
+        if (typeof val === "string") {
+            return val;
+        }
+        else {
+            return val.color;
+        }
+    };
     return ThemeProvider;
 }());
 exports.ThemeProvider = ThemeProvider;
+var stripAutoColor = function (val) {
+    if (val === exports.AUTO_COLOR) {
+        return "#00000000";
+    }
+    if (val && val.startsWith(exports.AUTO_COLOR)) {
+        return val.substring(exports.AUTO_COLOR.length);
+    }
+    return val;
+};
+exports.stripAutoColor = stripAutoColor;

package/Charting/Themes/SciChartJSDarkTheme.d.ts

@@ -73,6 +73,8 @@ export declare class SciChartJSDarkTheme extends ThemeProvider {
     /** @inheritDoc */
     annotationsGripsBackroundBrush: string;
     /** @inheritDoc */
+    annotationSelectionStroke: string;
+    /** @inheritDoc */
     overviewFillBrush: string;
     /** @inheritDoc */
     scrollbarBackgroundBrush: string;
@@ -127,4 +129,6 @@ export declare class SciChartJSDarkTheme extends ThemeProvider {
     axisPlaneBackgroundFill: string;
     /** @inheritDoc */
     axis3DBandsFill: string;
+    /** @inheritDoc */
+    isLightBackground: boolean;
 }

package/Charting/Themes/SciChartJSDarkTheme.js

@@ -90,9 +90,11 @@ var SciChartJSDarkTheme = /** @class */ (function (_super) {
         /** @inheritDoc */
         _this.textAnnotationBackground = "#42b649AA";
         /** @inheritDoc */
-        _this.annotationsGripsBorderBrush = "#EEEEEEFF";
+        _this.annotationsGripsBorderBrush = "#CDCDCD99";
         /** @inheritDoc */
-        _this.annotationsGripsBackroundBrush = "#FFFFFF33";
+        _this.annotationsGripsBackroundBrush = "#CDCDCD22";
+        /** @inheritDoc */
+        _this.annotationSelectionStroke = "#f00e0e66";
         /** @inheritDoc */
         _this.overviewFillBrush = "#262728BB";
         /** @inheritDoc */
@@ -149,6 +151,8 @@ var SciChartJSDarkTheme = /** @class */ (function (_super) {
         _this.axisPlaneBackgroundFill = "TRANSPARENT";
         /** @inheritDoc */
         _this.axis3DBandsFill = "#202123E1";
+        /** @inheritDoc */
+        _this.isLightBackground = false;
         return _this;
     }
     return SciChartJSDarkTheme;

package/Charting/Themes/SciChartJSDarkv2Theme.js

@@ -54,6 +54,9 @@ var SciChartJSDarkv2Theme = /** @class */ (function (_super) {
         _this.axisBandsFill = "#20212333";
         _this.majorGridLineBrush = "#AAAAAA37";
         _this.minorGridLineBrush = "#77777719";
+        _this.strokePalette = ["#F48420", "#AE408E", "#209FD9", "#264B93"];
+        _this.fillPalette = ["#F4842077", "#AE408E77", "#209FD977", "#264B9377"];
+        _this.isLightBackground = false;
         return _this;
     }
     return SciChartJSDarkv2Theme;

package/Charting/Themes/SciChartJSLightTheme.d.ts

@@ -26,6 +26,10 @@ import { ThemeProvider } from "./IThemeProvider";
  * ```
  */
 export declare class SciChartJSLightTheme extends ThemeProvider {
+    /** @inheritDoc */
+    strokePalette: string[];
+    /** @inheritDoc */
+    fillPalette: string[];
     /** @inheritDoc */
     type: EThemeProviderType;
     /** @inheritDoc */
@@ -73,6 +77,8 @@ export declare class SciChartJSLightTheme extends ThemeProvider {
     /** @inheritDoc */
     annotationsGripsBackroundBrush: string;
     /** @inheritDoc */
+    annotationSelectionStroke: string;
+    /** @inheritDoc */
     overviewFillBrush: string;
     /** @inheritDoc */
     scrollbarBackgroundBrush: string;
@@ -127,4 +133,6 @@ export declare class SciChartJSLightTheme extends ThemeProvider {
     axisPlaneBackgroundFill: string;
     /** @inheritDoc */
     axis3DBandsFill: string;
+    /** @inheritDoc */
+    isLightBackground: boolean;
 }

package/Charting/Themes/SciChartJSLightTheme.js

@@ -48,6 +48,10 @@ var SciChartJSLightTheme = /** @class */ (function (_super) {
     function SciChartJSLightTheme() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
         /** @inheritDoc */
+        _this.strokePalette = ["#F48420", "#AE408E", "#30BC9A", "#209FD9", "#264B93"];
+        /** @inheritDoc */
+        _this.fillPalette = ["#F4842077", "#AE408E77", "#30BC9A77", "#209FD977", "#264B9377"];
+        /** @inheritDoc */
         _this.type = ThemeProviderType_1.EThemeProviderType.Light;
         /** @inheritDoc */
         _this.sciChartBackground = "#F9F9F9FF";
@@ -94,6 +98,8 @@ var SciChartJSLightTheme = /** @class */ (function (_super) {
         /** @inheritDoc */
         _this.annotationsGripsBackroundBrush = "#FFFFFF33";
         /** @inheritDoc */
+        _this.annotationSelectionStroke = "#f00e0e66";
+        /** @inheritDoc */
         _this.overviewFillBrush = "#33333322";
         /** @inheritDoc */
         _this.scrollbarBackgroundBrush = "#33333322";
@@ -149,6 +155,8 @@ var SciChartJSLightTheme = /** @class */ (function (_super) {
         _this.axisPlaneBackgroundFill = "TRANSPARENT";
         /** @inheritDoc */
         _this.axis3DBandsFill = "#33333333";
+        /** @inheritDoc */
+        _this.isLightBackground = true;
         return _this;
     }
     return SciChartJSLightTheme;

package/Charting/Themes/SciChartJsNavyTheme.d.ts

@@ -0,0 +1,10 @@
+import { EThemeProviderType } from "../../types/ThemeProviderType";
+import { SciChartJSDarkv2Theme } from "./SciChartJSDarkv2Theme";
+export declare class SciChartJsNavyTheme extends SciChartJSDarkv2Theme {
+    type: EThemeProviderType;
+    private background1;
+    private background2;
+    private loadingBackground1;
+    private loadingBackground2;
+    constructor();
+}

package/Charting/Themes/SciChartJsNavyTheme.js

@@ -0,0 +1,49 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SciChartJsNavyTheme = void 0;
+var ThemeProviderType_1 = require("../../types/ThemeProviderType");
+var IThemeProvider_1 = require("./IThemeProvider");
+var SciChartJSDarkv2Theme_1 = require("./SciChartJSDarkv2Theme");
+var SciChartJsNavyTheme = /** @class */ (function (_super) {
+    __extends(SciChartJsNavyTheme, _super);
+    function SciChartJsNavyTheme() {
+        var _this = _super.call(this) || this;
+        _this.type = ThemeProviderType_1.EThemeProviderType.Navy;
+        _this.background1 = "#22365B";
+        _this.background2 = "#17243d";
+        _this.loadingBackground1 = "#21253D";
+        _this.loadingBackground2 = "#09090F";
+        _this.sciChartBackground = "radial-gradient(circle, ".concat(_this.background1, " 0%, ").concat(_this.background2, " 100%)");
+        _this.loadingAnimationBackground = "radial-gradient(circle, ".concat(_this.loadingBackground1, " 0%, ").concat(_this.loadingBackground2, " 100%)");
+        _this.loadingAnimationForeground = "#2A2F4C";
+        _this.axisBandsFill = "#52469503";
+        _this.majorGridLineBrush = "#191C6D77";
+        _this.minorGridLineBrush = "#2B2D7077";
+        _this.tickTextBrush = "#8398ba";
+        _this.strokePalette = ["#274b92", "#47bde6", "#ae418d", "#e97064", "#68bcae", "#634e96"];
+        _this.fillPalette = ["#274b9288", "#47bde688", "#ae418d88", "#e9706488", "#68bcae88", "#634e9688"];
+        _this.lineSeriesColor = IThemeProvider_1.AUTO_COLOR;
+        _this.planeBorderColor = "#191C6D77";
+        _this.axisPlaneBackgroundFill = "TRANSPARENT";
+        _this.axis3DBandsFill = "#52469503";
+        _this.isLightBackground = false;
+        return _this;
+    }
+    return SciChartJsNavyTheme;
+}(SciChartJSDarkv2Theme_1.SciChartJSDarkv2Theme));
+exports.SciChartJsNavyTheme = SciChartJsNavyTheme;

package/Charting/Visuals/Annotations/AdornerLayer.js

@@ -11,14 +11,10 @@ var AdornerLayer = /** @class */ (function () {
         var selectAnnotationHelper = function (annotations) {
             annotations.forEach(function (an) {
                 var anBase = an;
-                if (!selectedAnnotation && anBase.isEditable) {
-                    var isAnnotationSelected = anBase.clickToSelect(args);
-                    if (isAnnotationSelected) {
-                        selectedAnnotation = anBase;
-                    }
-                }
-                else {
-                    anBase.isSelected = false;
+                /** Allow all annotations to be clicked.  Only select if editable */
+                var isAnnotationSelected = anBase.click(args, !selectedAnnotation && anBase.isEditable);
+                if (isAnnotationSelected) {
+                    selectedAnnotation = anBase;
                 }
             });
         };

package/Charting/Visuals/Annotations/AnnotationBase.d.ts

@@ -6,14 +6,19 @@ import { CoordinateCalculatorBase } from "../../Numerics/CoordinateCalculators/C
 import { SciChartSurface } from "../SciChartSurface";
 import { SciChartSurfaceBase } from "../SciChartSurfaceBase";
 import { TDpiChangedEventArgs } from "../TextureManager/DpiHelper";
+import { AnnotationClickEventArgs } from "./AnnotationClickEventArgs";
 import { AnnotationDragDeltaEventArgs } from "./AnnotationDragDeltaEventArgs";
 import { IAdornerProvider } from "./IAdornerProvider";
 import { EAnnotationLayer, EAnnotationType, IAnnotation } from "./IAnnotation";
 export declare enum EDraggingGripPoint {
-    Point1 = "Point1",
-    Point2 = "Point2",
-    Point3 = "Point3",
-    Point4 = "Point4",
+    /** x1,y1 */
+    x1y1 = "x1y1",
+    /** x2,y1 */
+    x2y2 = "x2y2",
+    /** x1,y2 */
+    x2y1 = "x2y1",
+    /** x2,y2 */
+    x1y2 = "x1y2",
     Body = "Body"
 }
 /**
@@ -165,6 +170,24 @@ export interface IAnnotationBaseOptions {
      * Callback function called when drag operation is in progress. Only applicable if {@link isEditable} is true
      */
     onDrag?: ((args: AnnotationDragDeltaEventArgs) => void) | string;
+    /**
+     * Callback function called when the annotation is clicked.  Fires even for non Editable annotations
+     */
+    onClick?: ((args: AnnotationClickEventArgs) => void) | string;
+    /** The stroke color for the adorner drag handle */
+    annotationsGripsStroke?: string;
+    /** The fill color for the adorner drag handle */
+    annotationsGripsFill?: string;
+    /** The radius of the adorner drag handle */
+    annotationsGripsRadius?: number;
+    /** The stroke color for the adorner selection box */
+    selectionBoxStroke?: string;
+    /** How much bigger the selection box is than the bounding box of the annotation, in pixels */
+    selectionBoxDelta?: number;
+    /** The thickness of the selection box line */
+    selectionBoxThickness?: number;
+    /** The dragPoints that should be enabled for this annotation */
+    dragPoints?: EDraggingGripPoint[];
 }
 /**
  * Defines the CoordinateMode for {@link AnnotationBase | Annotations} within SciChart's
@@ -210,6 +233,8 @@ export declare abstract class AnnotationBase implements IAnnotation, IAdornerPro
     /** @inheritDoc */
     invalidateParentCallback: () => void;
     adornerDraggingPoint: EDraggingGripPoint;
+    selectedChanged: EventHandler<boolean>;
+    clicked: EventHandler<AnnotationClickEventArgs>;
     protected svgAdorner: SVGElement;
     protected prevIsSelected: boolean;
     /** the annotation absolute coordinates */
@@ -225,6 +250,13 @@ export declare abstract class AnnotationBase implements IAnnotation, IAdornerPro
     };
     protected typeMap: Map<string, string>;
     protected isHiddenProperty: boolean;
+    protected annotationsGripsStrokeProperty: string;
+    protected annotationsGripsFillProperty: string;
+    protected annotationsGripsRadiusProperty: number;
+    protected selectionBoxStrokeProperty: string;
+    protected selectionBoxDeltaProperty: number;
+    protected selectionBoxThicknessProperty: number;
+    protected dragPointsProperty: EDraggingGripPoint[];
     private opacityProperty;
     private annotationLayerProperty;
     private isEditableProperty;
@@ -300,10 +332,34 @@ export declare abstract class AnnotationBase implements IAnnotation, IAdornerPro
     /** @inheritDoc */
     get isSelected(): boolean;
     /** @inheritDoc */
+    get annotationsGripsStroke(): string;
+    /** @inheritDoc */
+    set annotationsGripsStroke(color: string);
+    /** @inheritDoc */
+    get annotationsGripsFill(): string;
+    /** @inheritDoc */
+    set annotationsGripsFill(color: string);
+    /** @inheritDoc */
+    get annotationsGripsRadius(): number;
+    /** @inheritDoc */
+    set annotationsGripsRadius(radius: number);
+    /** @inheritDoc */
+    get selectionBoxStroke(): string;
+    /** @inheritDoc */
+    set selectionBoxStroke(color: string);
+    /** @inheritDoc */
+    get selectionBoxDelta(): number;
+    /** @inheritDoc */
+    set selectionBoxDelta(delta: number);
+    /** @inheritDoc */
+    get selectionBoxThickness(): number;
+    /** @inheritDoc */
+    set selectionBoxThickness(delta: number);
+    get isDraggingStarted(): boolean;
+    /** @inheritDoc */
     get opacity(): number;
     /** @inheritDoc */
     set opacity(opacity: number);
-    get isDraggingStarted(): boolean;
     protected get svgAdornerRoot(): SVGSVGElement;
     /**
      * Creates an instance of the Annotation
@@ -314,8 +370,15 @@ export declare abstract class AnnotationBase implements IAnnotation, IAdornerPro
     onAttach(scs: SciChartSurfaceBase): void;
     /** @inheritDoc */
     onDetach(): void;
+    /** Get the dragging points that should be enabled for this annotation */
+    getDragPoints(): readonly EDraggingGripPoint[];
+    /** Set the dragging points that should be enabled for this annotation */
+    setDragPoints(dragPoints: EDraggingGripPoint[]): void;
     /** @inheritDoc */
     abstract delete(): void;
+    /** Called internally. Send a click to the annotation if the point is in bounds, raising the clicked event and optionally selecting the annotation. */
+    click(args: ModifierMouseArgs, selectOnClick: boolean): boolean;
+    /** Called internally. Select the annotation if the point is in bounds.  Does not raise the clicked event */
     clickToSelect(args: ModifierMouseArgs): boolean;
     calcDragDistance(xyPoint: Point): void;
     onDragStarted(args: ModifierMouseArgs): boolean;
@@ -338,7 +401,7 @@ export declare abstract class AnnotationBase implements IAnnotation, IAdornerPro
      * Returns annotationBorders
      * @param ordered flag to return x and y values in ascending order, where x1 <= x2 and y1 <= y2
      */
-    getAnnotationBorders(ordered?: boolean): {
+    getAnnotationBorders(ordered?: boolean, applyDelta?: boolean): {
         x1: number;
         x2: number;
         y1: number;
@@ -348,12 +411,22 @@ export declare abstract class AnnotationBase implements IAnnotation, IAdornerPro
      * Returns annotation borders for the {@link AdornerLayer} which has the size of the whole canvas
      * @param ordered flag to return x and y values in ascending order
      */
-    getAdornerAnnotationBorders(ordered?: boolean): {
+    getAdornerAnnotationBorders(ordered?: boolean, applyDelta?: boolean): {
         x1: number;
         x2: number;
         y1: number;
         y2: number;
     };
+    /** Get svg for the adorner grip handles for standard annotations */
+    getAnnotationGripSvg(x: number, y: number): string;
+    /** Override this to disable drag behaviour for certain dragging points */
+    canDragPoint(dragPoint: EDraggingGripPoint): boolean;
+    /**
+     * Gets the svg string for the adorner for standard annotations.  Called by updateAdornerInner.
+     * Coordinates passed in are the top left and bottom right of the bounding box.
+     * To get the bounding coordinates in their original order call this.getAdornerAnnotationBorders(false, true);
+     */
+    protected svgStringAdornerTemplate(x1: number, y1: number, x2: number, y2: number): string;
     /**
      * Updates adorner layer for the annotation
      * @protected