igniteui-react-charts/esm5/lib/DataPieBaseChart.js

Ignite UI React charting components for building rich data visualizations using TypeScript APIs.

/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { __extends } from "tslib";
import { RadialBaseChart } from "./RadialBaseChart";
import { ProportionalCategoryAngleAxis } from "./ProportionalCategoryAngleAxis";
import { NumericRadiusAxis } from "./NumericRadiusAxis";
import { Base, typeCast, runOn, delegateCombine, enumGetBox, markType } from "igniteui-react-core";
import { PieChartSweepDirection_$type } from "./PieChartSweepDirection";
import { CalloutCollisionMode_$type } from "igniteui-react-core";
import { LegendEmptyValuesMode_$type } from "igniteui-react-core";
import { OthersCategoryType_$type } from "igniteui-react-core";
import { AxisRangeBufferMode_$type } from "./AxisRangeBufferMode";
import { RadialLabelMode_$type } from "igniteui-react-core";
import { CollisionAvoidanceType_$type } from "./CollisionAvoidanceType";
import { RadialBase } from "./RadialBase";
import { List$1 } from "igniteui-react-core";
import { RadialPieSeries } from "./RadialPieSeries";
import { AnchoredRadialSeries } from "./AnchoredRadialSeries";
import { AxisLabelSettings } from "./AxisLabelSettings";
import { OthersCategoryContext } from "./OthersCategoryContext";
import { isNaN_ } from "igniteui-react-core";
/**
 * @hidden
 */
var DataPieBaseChart = /** @class */ /*@__PURE__*/ (function (_super) {
    __extends(DataPieBaseChart, _super);
    function DataPieBaseChart() {
        var _this = _super.call(this) || this;
        _this.ak0 = null;
        _this.aiv = null;
        _this.akw = null;
        _this.ait = null;
        _this.aky = null;
        _this.aiu = null;
        _this.akv = null;
        _this.ais = null;
        _this.aj1 = 0;
        _this.ajd = 0;
        _this.ai2 = 6;
        _this.amr = null;
        _this.amq = null;
        _this.ak1 = null;
        _this.aku = null;
        _this.ai6 = 0;
        _this.ajb = 1;
        _this.aj2 = 3;
        _this.akx = null;
        _this.akt = null;
        _this.ajq = true;
        _this.ai0 = 0;
        _this.ajz = 0;
        _this.aj0 = 0;
        _this.aj8 = 0;
        _this.ajr = false;
        _this.akr = 10;
        _this.aka = NaN;
        _this.aj9 = NaN;
        _this.akb = 0;
        _this.aj3 = NaN;
        _this.aj7 = NaN;
        _this.akz = " - ";
        _this.aji = 0;
        _this.ajh = 0;
        _this.aj4 = 2;
        _this.aj5 = 2;
        _this.aj6 = NaN;
        _this.ajo = false;
        _this.ajm = true;
        _this.ajp = true;
        _this.ai4 = 0;
        _this.ajn = false;
        return _this;
    }
    DataPieBaseChart.prototype.hr = function () {
        return true;
    };
    DataPieBaseChart.prototype.amm = function (a) {
        this.amn(function (b, c) { return a(b); });
    };
    DataPieBaseChart.prototype.amn = function (a) {
        if (this.dataChart == null) {
            return;
        }
        for (var b = 0; b < this.dataChart.b9.count; b++) {
            var c = this.dataChart.b9._inner[b];
            if (c.fw) {
                a(c, b);
            }
        }
    };
    DataPieBaseChart.prototype.amk = function (a) {
        this.aml(function (b, c) { return a(b); });
    };
    DataPieBaseChart.prototype.aml = function (a) {
        if (this.dataChart == null) {
            return;
        }
        for (var b = 0; b < this.dataChart.b9.count; b++) {
            var c = this.dataChart.b9._inner[b];
            if (c.fw) {
                a(c, b);
            }
        }
    };
    DataPieBaseChart.prototype.x1 = function () {
        var a = this.bg.dataSeries != null ? this.bg.dataSeries.count : 0;
        _super.prototype.x1.call(this);
        if (this.ak8 != null) {
            var b = this.ak8;
            this.angleAxis.hx = b;
        }
        else {
            this.angleAxis.hx = this.ad9 == null ? RadialBaseChart.afs(this.angleAxis, this.bg.dataSeries) : this.ad9;
        }
        this.angleAxis.itemsSource = this.dataChart != null && this.dataChart.b9.count > 0 ? this.dataChart.b9._inner[0].itemsSource : null;
        if (this.amh != null) {
            this.angleAxis.tu = this.amh;
        }
        else {
            this.angleAxis.tu = (this.dataChart != null && this.dataChart.b9.count > 0 && typeCast(RadialPieSeries.$, this.dataChart.b9._inner[0]) !== null) ? this.dataChart.b9._inner[0].adh : null;
        }
    };
    DataPieBaseChart.prototype.c4 = function (a, b) {
        if (this.c7 == null || this.c7.count == 0) {
            return 13;
        }
        var c = _super.prototype.c4.call(this, a, b);
        if (c == 1) {
            return 13;
        }
        return c;
    };
    DataPieBaseChart.prototype.xz = function (a) {
    };
    DataPieBaseChart.prototype.hn = function (a) {
        if (!_super.prototype.hn.call(this, a)) {
            return false;
        }
        return true;
    };
    DataPieBaseChart.prototype.x2 = function () {
        this.valueAxis.qg = this.ajy;
        this.valueAxis.rj = this.aks;
    };
    Object.defineProperty(DataPieBaseChart.prototype, "angleAxis", {
        get: function () {
            return this.ajf;
        },
        set: function (a) {
            var b = this.angleAxis;
            if (a != b) {
                this.ajf = a;
                this.w1("AngleAxis", b, this.angleAxis);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "valueAxis", {
        get: function () {
            return this.ai8;
        },
        set: function (a) {
            var b = this.valueAxis;
            if (a != b) {
                this.ai8 = a;
                this.w1("ValueAxis", b, this.valueAxis);
            }
        },
        enumerable: false,
        configurable: true
    });
    DataPieBaseChart.prototype.get_aju = function () {
        return false;
    };
    Object.defineProperty(DataPieBaseChart.prototype, "aju", {
        get: function () {
            return this.get_aju();
        },
        enumerable: false,
        configurable: true
    });
    DataPieBaseChart.prototype.de = function (a, b) {
        var c = null;
        if (b == 35) {
            c = this.ajl(a, b);
        }
        if (a.index > 0) {
            if (!this.aju) {
                if (c != null) {
                    c.pf();
                }
                return null;
            }
        }
        return c;
    };
    DataPieBaseChart.prototype.wa = function (a, b) {
        _super.prototype.wa.call(this, a, b);
        if (this.ha(a) && this.cg.isCalloutLayer(a)) {
            if (this.amt != null) {
                this.cg.setCalloutLightColor(a, this.amt);
            }
            if (this.ams != null) {
                this.cg.setCalloutDarkColor(a, this.ams);
            }
            var c = this.ah;
            if (this.ai3 != 0) {
                c = this.ai3;
            }
            this.cg.setCollisionMode(a, c);
        }
    };
    DataPieBaseChart.prototype.ajl = function (a, b) {
        var c = null;
        if (b == 35) {
            c = this.dh(35);
        }
        else {
            c = this.dh(35);
        }
        if (this.amh != null) {
            c.adh = this.amh;
        }
        else {
            c.adh = a.getMemberPathFor(0);
        }
        if (this.alb != null) {
            c.aem = this.alb;
        }
        c.aea = this.ai7;
        c.zk = this.angleAxis;
        c.zq = this.valueAxis;
        c.hf = true;
        c.ac1 = true;
        c.abm = this.al0;
        c.zc = this.aiz;
        c.abj = this.alq;
        c.zb = this.aiy;
        c.abc = this.alh;
        c.y9 = this.aix;
        c.abg = this.ald;
        c.za = this.aiw;
        c.zx = this.ajk;
        c.zy = this.ajj;
        c.aax = this.aly;
        c.aeh = this.akh;
        c.aei = this.aki;
        c.ju = this.akj;
        c.aeg = this.ajv;
        return c;
    };
    DataPieBaseChart.prototype.abl = function () {
        return this.angleAxis;
    };
    DataPieBaseChart.prototype.abm = function () {
        return this.valueAxis;
    };
    DataPieBaseChart.prototype.vi = function () {
        this.angleAxis = new ProportionalCategoryAngleAxis();
        this.angleAxis.name = "angleAxis";
        var a = this.angleAxis;
        a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.amo));
        this.angleAxis.pw = 0;
        this.valueAxis = new NumericRadiusAxis();
        this.valueAxis.name = "valueAxis";
        var b = this.valueAxis;
        b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.amp));
        if (this.angleAxis.a4 == null) {
            this.angleAxis.a4 = new AxisLabelSettings();
        }
        if (this.valueAxis.a4 == null) {
            this.valueAxis.a4 = new AxisLabelSettings();
        }
    };
    DataPieBaseChart.prototype.amo = function (a, b) {
        switch (b.propertyName) {
            case "ActualMinimumValue":
                this.xk("AngleAxisActualMinimum");
                break;
            case "ActualMaximumValue":
                this.xk("AngleAxisActualMaximum");
                break;
        }
    };
    DataPieBaseChart.prototype.amp = function (a, b) {
        switch (b.propertyName) {
            case "ActualMinimumValue":
                this.xk("ValueAxisActualMinimum");
                break;
            case "ActualMaximumValue":
                this.xk("ValueAxisActualMaximum");
                break;
        }
    };
    DataPieBaseChart.prototype.vb = function (a, b) {
        var c = typeCast(RadialBase.$, a);
        if (c != null) {
            c.xv = this.c4(a, b);
        }
    };
    DataPieBaseChart.prototype.ag4 = function (a) {
        _super.prototype.ag4.call(this, a);
        a.p7 = this.ajw;
        a.qb = this.ajx;
        a.tp = this.ake;
        if (!isNaN_(this.akg)) {
            a.tq = this.akg;
        }
        else {
            a.tq = 0.65;
        }
    };
    DataPieBaseChart.prototype.ag2 = function (a) {
        _super.prototype.ag2.call(this, a);
        if (!a.ds) {
            return;
        }
        a.to = this.alm;
        a.s3 = this.ajc;
        a.th = this.akf;
        if (!isNaN_(this.akk)) {
            a.r9 = this.akk;
        }
        if (this.aje != 0) {
            if (this.aje == 1) {
                a.dn = false;
            }
            else {
                a.dn = true;
            }
        }
    };
    DataPieBaseChart.prototype.v5 = function (a) {
        _super.prototype.v5.call(this, a);
        a.fk = this.ajt;
    };
    DataPieBaseChart.prototype.w1 = function (a, b, c) {
        var _this = this;
        _super.prototype.w1.call(this, a, b, c);
        switch (a) {
            case "SliceLabelPositionMode":
                this.vw(function (d) {
                    if (d.eq) {
                        _this.cg.setCollisionMode(d, _this.ai3);
                    }
                });
                break;
            case "SliceLabelContentSeparator":
                this.amk(function (d) { return d.aax = _this.aly; });
                break;
            case "SliceLabelContentMode":
                this.amk(function (d) { return d.zx = _this.ajk; });
                break;
            case "LegendSliceLabelContentMode":
                this.amk(function (d) { return d.zy = _this.ajj; });
                break;
            case "SliceLabelFormat":
                this.amk(function (d) { return d.abm = _this.al0; });
                break;
            case "SliceLabelFormatSpecifiers":
                this.amk(function (d) { return d.zc = _this.aiz; });
                break;
            case "OthersSliceLabelFormat":
                this.amk(function (d) { return d.abj = _this.alq; });
                break;
            case "OthersSliceLabelFormatSpecifiers":
                this.amk(function (d) { return d.zb = _this.aiy; });
                break;
            case "LegendSliceLabelFormat":
                this.amk(function (d) { return d.abc = _this.al0; });
                break;
            case "LegendSliceLabelFormatSpecifiers":
                this.amk(function (d) { return d.y9 = _this.aiz; });
                break;
            case "LegendOthersSliceLabelFormat":
                this.amk(function (d) { return d.abg = _this.ald; });
                break;
            case "LegendOthersSliceLabelFormatSpecifiers":
                this.amk(function (d) { return d.za = _this.aiw; });
                break;
            case "RadiusX":
                this.amk(function (d) { return d.aeh = _this.akh; });
                break;
            case "RadiusY":
                this.amk(function (d) { return d.aei = _this.aki; });
                break;
            case "SelectionThickness":
                this.amk(function (d) { return d.ju = _this.akj; });
                break;
            case "UseInsetOutlines":
                this.amk(function (d) { return d.aeg = _this.ajv; });
                break;
            case "SweepDirection":
                if (this.angleAxis != null) {
                    if (this.aje != 0) {
                        if (this.aje == 1) {
                            this.angleAxis.dn = false;
                        }
                        else {
                            this.angleAxis.dn = true;
                        }
                    }
                    else {
                        this.angleAxis.dn = this.abx;
                    }
                }
                break;
            case "StartAngle":
                if (this.angleAxis != null) {
                    this.angleAxis.r9 = isNaN_(this.akk) ? 0 : this.akk;
                }
                break;
            case "RadiusExtent":
                if (this.valueAxis != null) {
                    this.valueAxis.tq = isNaN_(this.akg) ? 0.65 : this.akg;
                }
                break;
            case "OthersCategoryText":
                if (this.angleAxis != null) {
                    this.angleAxis.to = this.alm;
                }
                break;
            case "OthersCategoryType":
                if (this.angleAxis != null) {
                    this.angleAxis.s3 = this.ajc;
                }
                break;
            case "OthersCategoryThreshold":
                if (this.angleAxis != null) {
                    this.angleAxis.th = this.akf;
                }
                break;
            case "InnerExtent":
                if (this.valueAxis != null) {
                    this.valueAxis.tp = this.ake;
                }
                break;
            case "LightSliceLabelColor":
                this.vt(function (d) {
                    if (d.eq) {
                        _this.cg.setCalloutLightColor(d, _this.amt);
                    }
                });
                break;
            case "DarkSliceLabelColor":
                this.vt(function (d) {
                    if (d.eq) {
                        _this.cg.setCalloutDarkColor(d, _this.ams);
                    }
                });
                break;
            case "ValueMemberPath":
                if (c != null) {
                    this.vy(function (d) {
                        if (typeCast(AnchoredRadialSeries.$, d) !== null) {
                            var e = d;
                            e.adh = _this.amh;
                        }
                    });
                    this.angleAxis.tu = this.amh;
                }
                else {
                    this.w8();
                }
                break;
            case "LabelMemberPath":
                if (c != null) {
                    var d = this.ak8;
                    this.angleAxis.hx = d;
                }
                else {
                    this.w8();
                }
                break;
            case "LegendLabelMemberPath":
                if (c != null) {
                    this.vy(function (e) {
                        if (typeCast(RadialPieSeries.$, e) !== null) {
                            var f = e;
                            f.aem = _this.alb;
                        }
                    });
                }
                else {
                    this.w8();
                }
                break;
            case "AngleAxisInterval":
                this.angleAxis.r6 = this.akc;
                break;
            case "ValueAxisInterval":
                this.valueAxis.q5 = this.akn;
                break;
            case "ValueAxisFavorLabellingScaleEnd":
                this.valueAxis.qb = this.ajx;
                break;
            case "ValueAxisAutoRangeBufferMode":
                this.valueAxis.pp = this.ai1;
                break;
            case "AngleAxisMinorInterval":
                this.angleAxis.r7 = this.akd;
                break;
            case "ValueAxisMinorInterval":
                this.valueAxis.ra = this.akq;
                break;
            case "ValueAxisIsLogarithmic":
                this.valueAxis.qg = this.ajy;
                break;
            case "ValueAxisLogarithmBase":
                this.valueAxis.rj = this.aks;
                break;
            case "ValueAxisMinimumValue":
                this.valueAxis.q9 = this.akp;
                break;
            case "ValueAxisMaximumValue":
                this.valueAxis.q8 = this.ako;
                break;
            case "MarkerCollision":
                this.vz(function (e, f) { return _this.vb(e, f); });
                break;
            case "ValueAxisAbbreviateLargeNumbers":
                this.ahb(function (e) { return e.p7 = _this.ajw; });
                break;
            case "FireMouseLeaveOnManipulationStart":
                this.wp(function (e) { return e.fk = _this.ajt; });
                break;
        }
    };
    Object.defineProperty(DataPieBaseChart.prototype, "al0", {
        get: function () {
            return this.ak0;
        },
        set: function (a) {
            var b = this.al0;
            if (a != b) {
                this.ak0 = a;
                this.w1("SliceLabelFormat", b, this.al0);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aiz", {
        get: function () {
            return this.aiv;
        },
        set: function (a) {
            var b = this.aiz;
            if (a != b) {
                this.aiv = a;
                this.w1("SliceLabelFormatSpecifiers", b, this.aiz);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "alh", {
        get: function () {
            return this.akw;
        },
        set: function (a) {
            var b = this.alh;
            if (a != b) {
                this.akw = a;
                this.w1("LegendSliceLabelFormat", b, this.alh);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aix", {
        get: function () {
            return this.ait;
        },
        set: function (a) {
            var b = this.aix;
            if (a != b) {
                this.ait = a;
                this.w1("LegendSliceLabelFormatSpecifiers", b, this.aix);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "alq", {
        get: function () {
            return this.aky;
        },
        set: function (a) {
            var b = this.alq;
            if (a != b) {
                this.aky = a;
                this.w1("OthersSliceLabelFormat", b, this.alq);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aiy", {
        get: function () {
            return this.aiu;
        },
        set: function (a) {
            var b = this.aiy;
            if (a != b) {
                this.aiu = a;
                this.w1("OthersSliceLabelFormatSpecifiers", b, this.aiy);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ald", {
        get: function () {
            return this.akv;
        },
        set: function (a) {
            var b = this.ald;
            if (a != b) {
                this.akv = a;
                this.w1("LegendOthersSliceLabelFormat", b, this.ald);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aiw", {
        get: function () {
            return this.ais;
        },
        set: function (a) {
            var b = this.aiw;
            if (a != b) {
                this.ais = a;
                this.w1("LegendOthersSliceLabelFormatSpecifiers", b, this.aiw);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ake", {
        get: function () {
            return this.aj1;
        },
        set: function (a) {
            var b = this.ake;
            if (a != b) {
                this.aj1 = a;
                this.w1("InnerExtent", b, this.ake);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aje", {
        get: function () {
            return this.ajd;
        },
        set: function (a) {
            var b = this.aje;
            if (a != b) {
                this.ajd = a;
                this.w1("SweepDirection", enumGetBox(PieChartSweepDirection_$type, b), enumGetBox(PieChartSweepDirection_$type, this.aje));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ai3", {
        get: function () {
            return this.ai2;
        },
        set: function (a) {
            var b = this.ai3;
            if (a != b) {
                this.ai2 = a;
                this.w1("SliceLabelPositionMode", enumGetBox(CalloutCollisionMode_$type, b), enumGetBox(CalloutCollisionMode_$type, this.ai3));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "amt", {
        get: function () {
            return this.amr;
        },
        set: function (a) {
            var b = this.amt;
            if (a != b) {
                this.amr = a;
                this.w1("LightSliceLabelColor", b, this.amt);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ams", {
        get: function () {
            return this.amq;
        },
        set: function (a) {
            var b = this.ams;
            if (a != b) {
                this.amq = a;
                this.w1("DarkSliceLabelColor", b, this.ams);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "amh", {
        get: function () {
            return this.ak1;
        },
        set: function (a) {
            var b = this.amh;
            if (a != b) {
                this.ak1 = a;
                this.w1("ValueMemberPath", b, this.amh);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "alb", {
        get: function () {
            return this.aku;
        },
        set: function (a) {
            var b = this.aku;
            if (a != b) {
                this.aku = a;
                this.w1("LegendLabelMemberPath", b, this.aku);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ai7", {
        get: function () {
            return this.ai6;
        },
        set: function (a) {
            var b = this.ai6;
            if (a != b) {
                this.ai6 = a;
                this.w1("LegendEmptyValuesMode", enumGetBox(LegendEmptyValuesMode_$type, b), this.aku);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajc", {
        get: function () {
            return this.ajb;
        },
        set: function (a) {
            var b = this.ajc;
            if (a != b) {
                this.ajb = a;
                this.w1("OthersCategoryType", enumGetBox(OthersCategoryType_$type, b), enumGetBox(OthersCategoryType_$type, this.ajc));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akf", {
        get: function () {
            return this.aj2;
        },
        set: function (a) {
            var b = this.akf;
            if (a != b) {
                this.aj2 = a;
                this.w1("OthersCategoryThreshold", b, this.akf);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "alm", {
        get: function () {
            return this.akx;
        },
        set: function (a) {
            var b = this.alm;
            if (a != b) {
                this.akx = a;
                this.w1("OthersCategoryText", b, this.alm);
            }
        },
        enumerable: false,
        configurable: true
    });
    DataPieBaseChart.prototype.aja = function () {
        var a = new OthersCategoryContext();
        if (this.angleAxis != null && this.angleAxis.pm != null) {
            var b = new List$1(Base.$, 0);
            for (var c = 0; c < this.angleAxis.pm.count; c++) {
                if (this.angleAxis.isOthersValue(c)) {
                    b.add1(this.angleAxis.pm.item(c));
                }
            }
            a.items = b.toArray();
        }
        return a;
    };
    Object.defineProperty(DataPieBaseChart.prototype, "ak8", {
        get: function () {
            return this.akt;
        },
        set: function (a) {
            var b = this.ak8;
            if (a != b) {
                this.akt = a;
                this.w1("LabelMemberPath", b, this.ak8);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajx", {
        get: function () {
            return this.ajq;
        },
        set: function (a) {
            var b = this.ajx;
            if (a != b) {
                this.ajq = a;
                this.w1("ValueAxisFavorLabellingScaleEnd", b, this.ajx);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ai1", {
        get: function () {
            return this.ai0;
        },
        set: function (a) {
            var b = this.ai1;
            if (a != b) {
                this.ai0 = a;
                this.w1("ValueAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ai1));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akc", {
        get: function () {
            return this.ajz;
        },
        set: function (a) {
            var b = this.akc;
            if (a != b) {
                this.ajz = a;
                this.w1("AngleAxisInterval", b, this.akc);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akd", {
        get: function () {
            return this.aj0;
        },
        set: function (a) {
            var b = this.akd;
            if (a != b) {
                this.aj0 = a;
                this.w1("AngleAxisMinorInterval", b, this.akd);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akn", {
        get: function () {
            return this.aj8;
        },
        set: function (a) {
            var b = this.akn;
            if (a != b) {
                this.aj8 = a;
                this.w1("ValueAxisInterval", b, this.akn);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajy", {
        get: function () {
            return this.ajr;
        },
        set: function (a) {
            var b = this.ajy;
            if (a != b) {
                this.ajr = a;
                this.w1("ValueAxisIsLogarithmic", b, this.ajy);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aks", {
        get: function () {
            return this.akr;
        },
        set: function (a) {
            var b = this.aks;
            if (a != b) {
                this.akr = a;
                this.w1("ValueAxisLogarithmBase", b, this.aks);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akp", {
        get: function () {
            return this.aka;
        },
        set: function (a) {
            var b = this.akp;
            if (a != b) {
                this.aka = a;
                this.w1("ValueAxisMinimumValue", b, this.akp);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ako", {
        get: function () {
            return this.aj9;
        },
        set: function (a) {
            var b = this.ako;
            if (a != b) {
                this.aj9 = a;
                this.w1("ValueAxisMaximumValue", b, this.ako);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akq", {
        get: function () {
            return this.akb;
        },
        set: function (a) {
            var b = this.akq;
            if (a != b) {
                this.akb = a;
                this.w1("ValueAxisMinorInterval", b, this.akq);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akm", {
        get: function () {
            return this.valueAxis.qw;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akl", {
        get: function () {
            return this.valueAxis.qv;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akg", {
        get: function () {
            return this.aj3;
        },
        set: function (a) {
            var b = this.akg;
            if (a != b) {
                this.aj3 = a;
                this.w1("RadiusExtent", b, this.akg);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akk", {
        get: function () {
            return this.aj7;
        },
        set: function (a) {
            var b = this.akk;
            if (a != b) {
                this.aj7 = a;
                this.w1("StartAngle", b, this.akk);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aly", {
        get: function () {
            return this.akz;
        },
        set: function (a) {
            var b = this.aly;
            if (a != b) {
                this.akz = a;
                this.w1("SliceLabelContentSeparator", b, this.aly);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajk", {
        get: function () {
            return this.aji;
        },
        set: function (a) {
            var b = this.ajk;
            if (a != b) {
                this.aji = a;
                this.w1("SliceLabelContentMode", enumGetBox(RadialLabelMode_$type, b), enumGetBox(RadialLabelMode_$type, this.ajk));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajj", {
        get: function () {
            return this.ajh;
        },
        set: function (a) {
            var b = this.ajj;
            if (a != b) {
                this.ajh = a;
                this.w1("LegendSliceLabelContentMode", enumGetBox(RadialLabelMode_$type, b), enumGetBox(RadialLabelMode_$type, this.ajj));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akh", {
        get: function () {
            return this.aj4;
        },
        set: function (a) {
            var b = this.aj4;
            if (a != b) {
                this.aj4 = a;
                this.w1("RadiusX", b, this.aj4);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "aki", {
        get: function () {
            return this.aj5;
        },
        set: function (a) {
            var b = this.aj5;
            if (a != b) {
                this.aj5 = a;
                this.w1("RadiusY", b, this.aj5);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "akj", {
        get: function () {
            return this.aj6;
        },
        set: function (a) {
            var b = this.aj6;
            if (a != b) {
                this.aj6 = a;
                this.w1("SelectionThickness", b, this.aj6);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajv", {
        get: function () {
            return this.ajo;
        },
        set: function (a) {
            var b = this.ajo;
            if (a != b) {
                this.ajo = a;
                this.w1("UseInsetOutlines", b, this.ajo);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajs", {
        get: function () {
            return this.ajm;
        },
        set: function (a) {
            var b = this.ajs;
            if (a != b) {
                this.ajm = a;
                this.w1("AngleAxisFavorLabellingScaleEnd", b, this.ajs);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajw", {
        get: function () {
            return this.ajp;
        },
        set: function (a) {
            var b = this.ajw;
            if (a != b) {
                this.ajp = a;
                this.w1("ValueAxisAbbreviateLargeNumbers", b, this.ajw);
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ai5", {
        get: function () {
            return this.ai4;
        },
        set: function (a) {
            var b = this.ai4;
            if (a != b) {
                this.ai4 = a;
                this.w1("MarkerCollision", enumGetBox(CollisionAvoidanceType_$type, b), enumGetBox(CollisionAvoidanceType_$type, this.ai4));
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(DataPieBaseChart.prototype, "ajt", {
        get: function () {
            return this.ajn;
        },
        set: function (a) {
            var b = this.ajn;
            if (a != b) {
                this.ajn = a;
                this.w1("FireMouseLeaveOnManipulationStart", b, this.ajn);
            }
        },
        enumerable: false,
        configurable: true
    });
    DataPieBaseChart.$t = markType(DataPieBaseChart, 'DataPieBaseChart', RadialBaseChart.$);
    return DataPieBaseChart;
}(RadialBaseChart));
export { DataPieBaseChart };