igniteui-angular-charts
Version:
Ignite UI Angular charting components for building rich data visualizations for modern web apps.
1,089 lines (1,088 loc) • 30.1 kB
JavaScript
/*
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 { XYChart } from "./XYChart";
import { typeCast, runOn, delegateCombine, enumGetBox, markType, TypeRegistrar, getInstanceType } from "igniteui-angular-core";
import { CategoryChartType_$type } from "./CategoryChartType";
import { CategorySeriesMarkerCollisionAvoidance_$type } from "./CategorySeriesMarkerCollisionAvoidance";
import { CategoryTransitionInMode_$type } from "./CategoryTransitionInMode";
import { TransitionInSpeedType_$type } from "./TransitionInSpeedType";
import { AutoMarginsAndAngleUpdateMode_$type } from "./AutoMarginsAndAngleUpdateMode";
import { AxisRangeBufferMode_$type } from "./AxisRangeBufferMode";
import { CategoryXAxis } from "./CategoryXAxis";
import { List$1 } from "igniteui-angular-core";
import { DataSeriesType_$type } from "igniteui-angular-core";
import { NumericYAxis } from "./NumericYAxis";
import { IDataSeriesAdapterRule_$type } from "igniteui-angular-core";
import { SimpleCategorySeriesRule } from "igniteui-angular-core";
import { SubCollectionsRule } from "igniteui-angular-core";
import { DVContainer } from "igniteui-angular-core";
import { Brush } from "igniteui-angular-core";
import { AxisDefaults } from "./AxisDefaults";
import { Defaults } from "./Defaults";
import { Series } from "./Series";
import { HorizontalAnchoredCategorySeries } from "./HorizontalAnchoredCategorySeries";
import { ArrayExtension } from "igniteui-angular-core";
import { AxisLabelSettings } from "./AxisLabelSettings";
import { CategoryAxisBase } from "./CategoryAxisBase";
import { DeviceUtils } from "igniteui-angular-core";
import { CategoryChartMockDataGenerator } from "./CategoryChartMockDataGenerator";
import { stringIsNullOrEmpty } from "igniteui-angular-core";
/**
* @hidden
*/
export class CategoryChart extends XYChart {
static { this.$t = markType(CategoryChart, 'CategoryChart', XYChart.$); }
v9() {
super.v9();
if (this.dataChart == null) {
return;
}
let a = this.dataChart.dw.j.e();
this.aji = a.d;
this.ajj = a.e;
if (this.ais == null) {
this.ais = a.k;
}
if (this.aiz == null) {
this.aiz = a.k;
}
this.aef = 0;
this.ai0 = AxisDefaults.axis_MajorBrush;
this.ai3 = null;
this.aiw = AxisDefaults.axis_LineBrush;
this.ait = null;
this.adw = AxisDefaults.categoryAxis_TickLength;
this.aix = AxisDefaults.axis_TickBrush;
this.adx = AxisDefaults.axis_TickStroke;
this.crosshairsAnnotationEnabled = true;
this.g0 = true;
this.crosshairsDisplayMode = 0;
this.j3 = Defaults.crosshairLineThickness;
this.zt = Defaults.crosshairLineBrush;
this.zo = Defaults.crosshairXAxisAnnotationBackground;
this.zp = Defaults.crosshairXAxisAnnotationTextColor;
this.ako = true;
}
wb(a, b) {
super.wb(a, b);
a.kp = this.al8;
a.kq = this.al9;
a.df = this.aj6;
a.dg = this.aj7;
}
w5(a, b, c) {
super.w5(a, b, c);
switch (a) {
case "TransitionInDuration":
this.vy((d) => d.kp = this.al8);
break;
case "TransitionOutDuration":
this.vy((d) => d.kq = this.al9);
break;
case "TransitionInEasingFunction":
this.vy((d) => d.df = this.aj6);
break;
case "TransitionOutEasingFunction":
this.vy((d) => d.dg = this.aj7);
break;
}
}
get al8() {
return this.al5;
}
set al8(a) {
let b = this.al8;
if (a != b) {
this.al5 = a;
this.w1("TransitionInDuration", b, this.al8);
}
}
get al9() {
return this.al6;
}
set al9(a) {
let b = this.al9;
if (a != b) {
this.al6 = a;
this.w1("TransitionOutDuration", b, this.al9);
}
}
get aj6() {
return this.aj4;
}
set aj6(a) {
let b = this.aj6;
if (a != b) {
this.aj4 = a;
this.w1("TransitionInEasingFunction", b, this.aj6);
}
}
get aj7() {
return this.aj5;
}
set aj7(a) {
let b = this.aj7;
if (a != b) {
this.aj5 = a;
this.w1("TransitionOutEasingFunction", b, this.aj7);
}
}
amf() {
let cvd_ = this.mj();
cvd_.scaleByViewport();
return (cvd_.serialize());
}
v4(a, b) {
super.v4(a, b);
a.e8 = this.gr;
a.aap = this.akp;
a.aas = this.akq;
a.abg = this.alg;
a.abh = this.alh;
a.zk = this.ajl;
}
wa(a, b) {
super.wa(a, b);
let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
if (c == null) {
return;
}
c.acb = this.ajr;
c.aax = this.ako;
c.aah = this.ajt;
c.c6 = this.aj3;
c.trendLineBrush = ArrayExtension.getModulus$1(Brush.$, this.af, b);
c.trendLineType = this.ee;
c.trendLineThickness = this.k0;
c.xy = this.c4(a, b);
if (a.fq) {
a.sn(ArrayExtension.getModulus$1(Brush.$, this.aji, b), ArrayExtension.getModulus$1(Brush.$, this.ajj, b));
}
}
aju() {
return new CategoryXAxis();
}
ajy() {
return new NumericYAxis();
}
vi() {
this.xAxis = this.aju();
this.xAxis.name = "xAxis";
let a = this.xAxis;
a.propertyChanged = delegateCombine(a.propertyChanged, runOn(this, this.anl));
this.yAxis = this.ajy();
this.yAxis.name = "yAxis";
let b = this.yAxis;
b.propertyChanged = delegateCombine(b.propertyChanged, runOn(this, this.anm));
if (this.xAxis.a4 == null) {
this.xAxis.a4 = new AxisLabelSettings();
}
if (this.yAxis.a4 == null) {
this.yAxis.a4 = new AxisLabelSettings();
}
}
ahs(a) {
super.ahs(a);
a.ql = this.akt;
a.qp = this.akv;
a.c1 = this.aku;
let b = typeCast(CategoryAxisBase.$, a);
if (b != null) {
b.p3 = this.akw;
}
}
ahq(a) {
super.ahq(a);
a.c1 = this.akr;
let b = typeCast(CategoryAxisBase.$, a);
if (b != null) {
b.p3 = this.aks;
}
a.zoomMaximumCategoryRange = this.alu;
a.zoomToCategoryRange = this.alw;
a.zoomToCategoryStart = this.alx;
a.zoomMaximumItemSpan = this.alv;
a.zoomToItemSpan = this.aly;
}
get_cd() {
return 0;
}
get cd() {
return this.get_cd();
}
get ajp() {
return this.ajo;
}
set ajp(a) {
if (a != this.ajo) {
let b = this.ajp;
this.ajo = a;
this.w1("ChartType", enumGetBox(CategoryChartType_$type, b), enumGetBox(CategoryChartType_$type, this.ajp));
}
}
get ajr() {
return this.ajq;
}
set ajr(a) {
let b = this.ajr;
if (a != b) {
this.ajq = a;
this.w1("MarkerCollisionAvoidance", enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, b), enumGetBox(CategorySeriesMarkerCollisionAvoidance_$type, this.ajr));
}
}
get akn() {
return this.aka;
}
set akn(a) {
let b = this.akn;
if (a != b) {
this.aka = a;
this.w1("IsSplineShapePartOfRange", b, this.akn);
}
}
get ako() {
return this.akb;
}
set ako(a) {
let b = this.ako;
if (a != b) {
this.akb = a;
this.w1("IsTransitionInEnabled", b, this.ako);
}
}
get ajt() {
return this.ajs;
}
set ajt(a) {
let b = this.ajt;
if (a != b) {
this.ajs = a;
this.w1("TransitionInMode", enumGetBox(CategoryTransitionInMode_$type, b), enumGetBox(CategoryTransitionInMode_$type, this.ajt));
}
}
get aj3() {
return this.aj2;
}
set aj3(a) {
let b = this.aj3;
if (a != b) {
this.aj2 = a;
this.w1("TransitionInSpeedType", enumGetBox(TransitionInSpeedType_$type, b), enumGetBox(TransitionInSpeedType_$type, this.aj3));
}
}
get alp() {
return this.ak2;
}
set alp(a) {
let b = this.alp;
if (a != b) {
this.ak2 = a;
this.w1("XAxisInterval", b, this.alp);
}
}
get als() {
return this.ak5;
}
set als(a) {
let b = this.als;
if (a != b) {
this.ak5 = a;
this.w1("XAxisMinorInterval", b, this.als);
}
}
get alo() {
return this.ak1;
}
set alo(a) {
let b = this.alo;
if (a != b) {
this.ak1 = a;
this.w1("XAxisGap", b, this.alo);
}
}
get alr() {
return this.ak4;
}
set alr(a) {
let b = this.alr;
if (a != b) {
this.ak4 = a;
this.w1("XAxisMinimumGapSize", b, this.alr);
}
}
get alq() {
return this.ak3;
}
set alq(a) {
let b = this.alq;
if (a != b) {
this.ak3 = a;
this.w1("XAxisMaximumGap", b, this.alq);
}
}
get alt() {
return this.ak6;
}
set alt(a) {
let b = this.alt;
if (a != b) {
this.ak6 = a;
this.w1("XAxisOverlap", b, this.alt);
}
}
get al1() {
return this.alc;
}
set al1(a) {
let b = this.al1;
if (a != b) {
this.alc = a;
this.w1("YAxisInterval", b, this.al1);
}
}
get ajl() {
return this.ajk;
}
set ajl(a) {
let b = this.ajl;
if (a != b) {
this.ajk = a;
this.w1("AutoMarginAndAngleUpdateMode", enumGetBox(AutoMarginsAndAngleUpdateMode_$type, b), enumGetBox(AutoMarginsAndAngleUpdateMode_$type, this.ajl));
}
}
ann() {
if (this.dataChart != null) {
this.dataChart.ac4();
}
}
get akp() {
return this.akc;
}
set akp(a) {
let b = this.akp;
if (a != b) {
this.akc = a;
this.w1("ShouldAutoExpandMarginForInitialLabels", b, this.akp);
}
}
static { this.amo = "ShouldConsiderAutoRotationForInitialLabels"; }
get akq() {
return this.akd;
}
set akq(a) {
let b = this.akq;
if (a != b) {
this.akd = a;
this.w1(CategoryChart.amo, b, this.akq);
}
}
get alg() {
return this.akz;
}
set alg(a) {
let b = this.alg;
if (a != b) {
this.akz = a;
this.w1("AutoExpandMarginExtraPadding", b, this.alg);
}
}
get alh() {
return this.ak0;
}
set alh(a) {
let b = this.alh;
if (a != b) {
this.ak0 = a;
this.w1("AutoExpandMarginMaximumValue", b, this.alh);
}
}
get akv() {
return this.aki;
}
set akv(a) {
let b = this.akv;
if (a != b) {
this.aki = a;
this.w1("YAxisFavorLabellingScaleEnd", b, this.akv);
}
}
get aks() {
return this.akf;
}
set aks(a) {
let b = this.aks;
if (a != b) {
this.akf = a;
this.w1("XAxisIsLastLabelMandatory", b, this.aks);
}
}
get akw() {
return this.akj;
}
set akw(a) {
let b = this.akw;
if (a != b) {
this.akj = a;
this.w1("YAxisIsLastLabelMandatory", b, this.akw);
}
}
static { this.amv = "XAxisEnhancedIntervalPreferMoreCategoryLabels"; }
get akr() {
return this.ake;
}
set akr(a) {
let b = this.akr;
if (a != b) {
this.ake = a;
this.w1(CategoryChart.amv, b, this.akr);
}
}
static { this.ana = "YAxisEnhancedIntervalPreferMoreCategoryLabels"; }
get aku() {
return this.akh;
}
set aku(a) {
let b = this.aku;
if (a != b) {
this.akh = a;
this.w1(CategoryChart.ana, b, this.aku);
}
}
get ajn() {
return this.ajm;
}
set ajn(a) {
let b = this.ajn;
if (a != b) {
this.ajm = a;
this.w1("YAxisAutoRangeBufferMode", enumGetBox(AxisRangeBufferMode_$type, b), enumGetBox(AxisRangeBufferMode_$type, this.ajn));
}
}
get akx() {
return this.akk;
}
set akx(a) {
let b = this.akx;
if (a != b) {
this.akk = a;
this.w1("YAxisIsLogarithmic", b, this.akx);
}
}
get ama() {
return this.al7;
}
set ama(a) {
let b = this.ama;
if (a != b) {
this.al7 = a;
this.w1("YAxisLogarithmBase", b, this.ama);
}
}
get al3() {
return this.ale;
}
set al3(a) {
let b = this.al3;
if (a != b) {
this.ale = a;
this.w1("YAxisMinimumValue", b, this.al3);
}
}
get al2() {
return this.ald;
}
set al2(a) {
let b = this.al2;
if (a != b) {
this.ald = a;
this.w1("YAxisMaximumValue", b, this.al2);
}
}
get al4() {
return this.alf;
}
set al4(a) {
let b = this.al4;
if (a != b) {
this.alf = a;
this.w1("YAxisMinorInterval", b, this.al4);
}
}
get aln() {
return this.xAxis.sb;
}
get alm() {
return this.xAxis.sa;
}
alj() {
return this.aln;
}
all() {
return this.al0;
}
ali() {
return this.alm;
}
alk() {
return this.alz;
}
get al0() {
return this.yAxis.ra;
}
get alz() {
return this.yAxis.q9;
}
get aji() {
return this.ajg;
}
set aji(a) {
let b = this.aji;
if (a != b) {
this.ajg = a;
this.w1("NegativeBrushes", b, this.aji);
}
}
get ajj() {
return this.ajh;
}
set ajj(a) {
let b = this.ajj;
if (a != b) {
this.ajh = a;
this.w1("NegativeOutlines", b, this.ajj);
}
}
get akt() {
return this.akg;
}
set akt(a) {
let b = this.akt;
if (a != b) {
this.akg = a;
this.w1("YAxisAbbreviateLargeNumbers", b, this.akt);
}
}
get alu() {
return this.ak7;
}
set alu(a) {
let b = this.alu;
if (a != b) {
this.ak7 = a;
this.w1("XAxisZoomMaximumCategoryRange", b, this.alu);
}
}
get alv() {
return this.ak8;
}
set alv(a) {
let b = this.alv;
if (a != b) {
this.ak8 = a;
this.w1("XAxisZoomMaximumItemSpan", b, this.alv);
}
}
get alw() {
return this.ak9;
}
set alw(a) {
let b = this.alw;
if (a != b) {
this.ak9 = a;
this.w1("XAxisZoomToCategoryRange", b, this.alw);
}
}
get alx() {
return this.ala;
}
set alx(a) {
let b = this.alx;
if (a != b) {
this.ala = a;
this.w1("XAxisZoomToCategoryStart", b, this.alx);
}
}
get aly() {
return this.alb;
}
set aly(a) {
let b = this.aly;
if (a != b) {
this.alb = a;
this.w1("XAxisZoomToItemSpan", b, this.aly);
}
}
get akl() {
return this.aj8;
}
set akl(a) {
let b = this.akl;
if (a != b) {
this.aj8 = a;
this.w1("IsCategoryHighlightingEnabled", b, this.akl);
}
}
get akm() {
return this.aj9;
}
set akm(a) {
let b = this.akm;
if (a != b) {
this.aj9 = a;
this.w1("IsItemHighlightingEnabled", b, this.akm);
}
}
constructor() {
super();
this.al5 = 1000;
this.al6 = 1000;
this.aj4 = null;
this.aj5 = null;
this.ajo = 9;
this.ajq = 1;
this.aka = false;
this.akb = true;
this.ajs = 0;
this.aj2 = 0;
this.ak2 = 0;
this.ak5 = 0;
this.ak1 = 0;
this.ak4 = 0;
this.ak3 = 1;
this.ak6 = 0;
this.alc = NaN;
this.ajk = 1;
this.akc = true;
this.akd = true;
this.akz = DeviceUtils.g(2);
this.ak0 = DeviceUtils.g(60);
this.aki = true;
this.akf = false;
this.akj = false;
this.ake = true;
this.akh = false;
this.ajm = 0;
this.akk = false;
this.al7 = 10;
this.ale = NaN;
this.ald = NaN;
this.alf = 0;
this.ajg = null;
this.ajh = null;
this.akg = true;
this.ak7 = 3;
this.ak8 = NaN;
this.ak9 = NaN;
this.ala = NaN;
this.alb = NaN;
this.aj8 = false;
this.aj9 = false;
this.aky = null;
DVContainer.instance.registerIfLoaded("CategoryChartToolbarFactoryManager");
this.vn();
}
get_ie() {
let a = new List$1(DataSeriesType_$type, 0);
if (TypeRegistrar.isRegistered("AreaSeries")) {
a.add(2);
}
if (TypeRegistrar.isRegistered("ColumnSeries")) {
a.add(1);
}
if (TypeRegistrar.isRegistered("LineSeries")) {
a.add(0);
}
if (TypeRegistrar.isRegistered("PointSeries")) {
a.add(10);
}
if (TypeRegistrar.isRegistered("SplineSeries")) {
a.add(6);
}
if (TypeRegistrar.isRegistered("SplineAreaSeries")) {
a.add(7);
}
if (TypeRegistrar.isRegistered("StepAreaSeries")) {
a.add(5);
}
if (TypeRegistrar.isRegistered("StepLineSeries")) {
a.add(4);
}
if (TypeRegistrar.isRegistered("WaterfallSeries")) {
a.add(8);
}
return a;
}
get ie() {
return this.get_ie();
}
il() {
if (this.aky == null) {
this.aky = CategoryChartMockDataGenerator.a();
}
return this.aky;
}
c3(a) {
if (a != null) {
let b = super.c3(a);
if (b == 2) {
if (a.fp && this.hb) {
return 13;
}
}
}
return super.c3(a);
}
c5(a) {
if (a != null) {
let b = super.c3(a);
if (b == 2) {
if (a.fp && this.hb) {
return 13;
}
}
}
return super.c5(a);
}
get_hw() {
return true;
}
anl(a, b) {
switch (b.propertyName) {
case "ActualMinimum":
this.xk("XAxisActualMinimum");
break;
case "ActualMaximum":
this.xk("XAxisActualMaximum");
break;
}
}
anm(a, b) {
switch (b.propertyName) {
case "ActualMinimumValue":
this.xk("YAxisActualMinimum");
break;
case "ActualMaximumValue":
this.xk("YAxisActualMaximum");
break;
}
}
x1() {
super.x1();
this.xAxis.h3 = this.aep == null ? XYChart.ae1(this.xAxis, this.bg.dataSeries) : this.aep;
this.xAxis.itemsSource = this.dataChart != null && this.dataChart.b9.count > 0 ? this.dataChart.b9._inner[0].itemsSource : null;
if (this.akp) {
this.wr((a) => a.ac4());
}
}
get xAxis() {
return this._xAxis;
}
set xAxis(a) {
this._xAxis = a;
}
get yAxis() {
return this._yAxis;
}
set yAxis(a) {
this._yAxis = a;
}
ajx(a, b) {
switch (a) {
case 2: return this.dh(1);
case 3: return this.dh(10);
case 0: return this.dh(0);
case 1: return this.dh(2);
case 6: return this.dh(6);
case 7: return this.dh(7);
case 4: return this.dh(4);
case 5: return this.dh(5);
case 8: return this.dh(8);
case 9: return this.ajw(b);
default: return this.dh(1);
}
}
ajw(a) {
return this.dh(a);
}
bf(a) {
switch (this.ajp) {
case 1: return 2;
case 0: return 0;
case 3: return 10;
case 6: return 6;
case 7: return 7;
case 5: return 5;
case 4: return 4;
case 8: return 8;
case 9: return a.suggestedSeries;
default:
case 2: return 1;
}
}
de(a, b) {
let c = this.ajx(this.ajp, a.suggestedSeries);
c.ac1 = a.findMatchingHint(0).path;
c.xAxis = this.xAxis;
c.yAxis = this.yAxis;
return c;
}
xz(a) {
if (a.suggestedSecondaryAxis == 2) {
this.yAxis.qu = true;
this.yAxis.rx = 10;
}
}
x2() {
this.yAxis.qu = this.akx;
this.yAxis.rx = this.ama;
}
get_id() {
return ((() => {
let $ret = new List$1(IDataSeriesAdapterRule_$type, 0);
$ret.add(new SimpleCategorySeriesRule());
$ret.add(new SubCollectionsRule());
return $ret;
})());
}
get id() {
return this.get_id();
}
vb(a, b) {
let c = typeCast(HorizontalAnchoredCategorySeries.$, a);
if (c != null) {
c.acb = this.ajr;
c.xy = this.c4(a, b);
}
}
anj(a) {
this.ank((b, c) => a(b));
}
ank(a) {
if (this.dataChart == null) {
return;
}
for (let b = 0; b < this.dataChart.b9.count; b++) {
let c = typeCast(HorizontalAnchoredCategorySeries.$, this.dataChart.b9._inner[b]);
if (c == null) {
continue;
}
a(c, b);
}
}
abj() {
return this.xAxis;
}
abk() {
return this.yAxis;
}
aj0() {
return this.dh(30);
}
aj1() {
return this.dh(31);
}
ia(a, b) {
let c = super.ia(a, b);
if (c != null) {
let d = new List$1(Series.$, 0);
if (this.aj8) {
d.add(this.aj0());
}
if (this.aj9) {
d.add(this.aj1());
}
for (let e = 0; e < d.count; e++) {
let f = d._inner[e];
f.name = a + getInstanceType(f).typeName;
c.add(f);
}
}
return c;
}
bb() {
if (this.ba == 0) {
return 1;
}
else {
return this.ba;
}
}
x6(a, b, c) {
super.x6(a, b, c);
if (this.bg.dataSeries.count > 0) {
if (stringIsNullOrEmpty(this.od)) {
this.cg.setXMemberPath(a, c.getMemberPathFor(16));
}
if (stringIsNullOrEmpty(this.of)) {
this.cg.setYMemberPath(a, c.getMemberPathFor(0));
}
if (stringIsNullOrEmpty(this.n0)) {
this.cg.setLabelMemberPath(a, c.getMemberPathFor(0));
}
if (stringIsNullOrEmpty(this.nw)) {
this.cg.setContentMemberPath(a, c.getMemberPathFor(0));
}
}
}
he() {
if (this.crosshairsDisplayMode == 4 || this.crosshairsDisplayMode == 3) {
return true;
}
else if (this.crosshairsDisplayMode == 0) {
if (this.ajp == 2 || this.ajp == 8) {
return false;
}
else if (this.ajp == 9 && this.bg != null && this.bg.dataSeries != null && this.bg.dataSeries.count > 0) {
let a = this.bg.dataSeries._inner[0].suggestedSeries;
if (a == 1 || a == 8) {
return false;
}
}
return true;
}
return false;
}
get_hl() {
return DVContainer.instance.checkLoaded("CategoryChartToolbarFactoryManager");
}
w1(a, b, c) {
super.w1(a, b, c);
switch (a) {
case "ChartType":
this.vv();
break;
case "MarkerCollisionAvoidance":
this.anj((d) => d.acb = this.ajr);
break;
case "IsTransitionInEnabled":
this.anj((d) => d.aax = this.ako);
break;
case "IsSplineShapePartOfRange":
this.anj((d) => {
if (d.f4) {
d.so(this.akn);
}
});
break;
case "TransitionInMode":
this.anj((d) => d.aah = this.ajt);
break;
case "TransitionInSpeedType":
this.anj((d) => d.c6 = this.aj3);
break;
case "XAxisInterval":
this.xAxis.r6 = this.alp;
break;
case "XAxisMinorInterval":
this.xAxis.r7 = this.als;
break;
case "XAxisGap":
this.xAxis.qb = this.alo;
break;
case "XAxisOverlap":
this.xAxis.qk = this.alt;
break;
case "XAxisMinimumGapSize":
this.xAxis.qj = this.alr;
break;
case "XAxisMaximumGap":
this.xAxis.qi = this.alq;
break;
case "XAxisZoomMaximumCategoryRange":
this.xAxis.zoomMaximumCategoryRange = this.alu;
break;
case "XAxisZoomMaximumItemSpan":
this.xAxis.zoomMaximumItemSpan = this.alv;
break;
case "XAxisZoomToCategoryRange":
this.xAxis.zoomToCategoryRange = this.alw;
break;
case "XAxisZoomToCategoryStart":
this.xAxis.zoomToCategoryStart = this.alx;
break;
case "XAxisZoomToItemSpan":
this.xAxis.zoomToItemSpan = this.aly;
break;
case "YAxisInterval":
this.yAxis.rj = this.al1;
break;
case "YAxisFavorLabellingScaleEnd":
this.yAxis.qp = this.akv;
break;
case "YAxisAutoRangeBufferMode":
this.yAxis.p3 = this.ajn;
break;
case "YAxisIsLogarithmic":
this.yAxis.qu = this.akx;
break;
case "YAxisLogarithmBase":
this.yAxis.rx = this.ama;
break;
case "YAxisMinimumValue":
this.yAxis.rn = this.al3;
break;
case "YAxisMaximumValue":
this.yAxis.rm = this.al2;
break;
case "YAxisMinorInterval":
this.yAxis.ro = this.al4;
break;
case "NegativeBrushes":
case "NegativeOutlines":
this.ank((d, e) => {
if (d.fq) {
d.sn(ArrayExtension.getModulus$1(Brush.$, this.aji, e), ArrayExtension.getModulus$1(Brush.$, this.ajj, e));
}
});
break;
case "YAxisAbbreviateLargeNumbers":
this.ah0((d) => d.ql = this.akt);
break;
case "IsCategoryHighlightingEnabled":
case "IsItemHighlightingEnabled":
this.vv();
break;
case "AutoMarginAndAngleUpdateMode":
this.wr((d) => d.zk = this.ajl);
break;
case "ShouldAutoExpandMarginForInitialLabels":
this.wr((d) => d.aap = this.akp);
break;
case CategoryChart.amo:
this.wr((d) => d.aas = this.akq);
break;
case "AutoExpandMarginExtraPadding":
this.wr((d) => d.abg = this.alg);
break;
case "AutoExpandMarginMaximumValue":
this.wr((d) => d.abh = this.alh);
break;
case "XAxisIsLastLabelMandatory":
this.ahu((d) => {
let e = typeCast(CategoryAxisBase.$, d);
if (e != null) {
e.p3 = this.aks;
}
}, a);
break;
case "YAxisIsLastLabelMandatory":
this.ah0((d) => {
let e = typeCast(CategoryAxisBase.$, d);
if (e != null) {
e.p3 = this.akw;
}
});
break;
case CategoryChart.amv:
this.ahu((d) => d.c1 = this.akr, a);
break;
case CategoryChart.ana:
this.ah0((d) => d.c1 = this.aku);
break;
}
}
}