File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
import { MultiDisposer } from "../../core/util/Disposer";
import { SpriteResizer } from "../../core/render/SpriteResizer";
import { PanelControls } from "./PanelControls";
import { StockChartDefaultTheme } from "./StockChartDefaultTheme";
import { XYChartDefaultTheme } from "../xy/XYChartDefaultTheme";
import { Container } from "../../core/render/Container";
import { ListAutoDispose } from "../../core/util/List";
import { Rectangle } from "../../core/render/Rectangle";
import { p100, percent } from "../../core/util/Percent";
import { SettingsModal } from "./SettingsModal";
import { Color } from "../../core/util/Color";
import { registry } from "../../core/Registry";
import { registerCustomClass } from "../../plugins/json/Json";
import * as $array from "../../core/util/Array";
import * as $utils from "../../core/util/Utils";
import * as $object from "../../core/util/Object";
/**
* A main class for the Stock Chart.
*
* @see {@link https://www.amcharts.com/docs/v5/charts/stock/} for more info
* @important
*/
export class StockChart extends Container {
constructor() {
super(...arguments);
Object.defineProperty(this, "_xAxes", {
enumerable: true,
configurable: true,
writable: true,
value: []
});
Object.defineProperty(this, "_downY", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_upperPanel", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_dhp", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_uhp", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_downResizer", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_syncExtremesDp", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "_drawingsChanged", {
enumerable: true,
configurable: true,
writable: true,
value: false
});
Object.defineProperty(this, "_indicatorsChanged", {
enumerable: true,
configurable: true,
writable: true,
value: false
});
Object.defineProperty(this, "_baseDP", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
/**
* A list of stock panels.
*
* @see {@link https://www.amcharts.com/docs/v5/charts/stock/#Panels} for more info
*/
Object.defineProperty(this, "panels", {
enumerable: true,
configurable: true,
writable: true,
value: new ListAutoDispose()
});
/**
* A list of indicators on chart.
*
* @see {@link https://www.amcharts.com/docs/v5/charts/stock/indicators/} for more info
*/
Object.defineProperty(this, "indicators", {
enumerable: true,
configurable: true,
writable: true,
value: new ListAutoDispose()
});
/**
* A [[Container]], resiting on top of the charts, suitable for additional
* tools, like [[Scrollbar]].
*
* @default Container.new()
*/
Object.defineProperty(this, "toolsContainer", {
enumerable: true,
configurable: true,
writable: true,
value: this.children.push(Container.new(this._root, { width: p100, themeTags: [] }))
});
/**
* A [[Container]] where all the stock panels are placed into.
*
* @default Container.new()
*/
Object.defineProperty(this, "panelsContainer", {
enumerable: true,
configurable: true,
writable: true,
value: this.children.push(Container.new(this._root, { width: p100, height: p100, layout: this._root.verticalLayout, themeTags: ["chartscontainer"] }))
});
/**
* An array of all Stock Controls that are created for this chart.
*
* @since 5.7.0
*/
Object.defineProperty(this, "controls", {
enumerable: true,
configurable: true,
writable: true,
value: []
});
/**
* An instance of [[SpriteResizer]] used for various drawing tools.
*
* @since 5.7.0
*/
Object.defineProperty(this, "spriteResizer", {
enumerable: true,
configurable: true,
writable: true,
value: this.children.push(SpriteResizer.new(this._root, {}))
});
}
_afterNew() {
this._settings.themeTags = $utils.mergeTags(this._settings.themeTags, ["stock"]);
this._defaultThemes.push(StockChartDefaultTheme.new(this._root));
this._defaultThemes.push(XYChartDefaultTheme.new(this._root));
const tooltipContainer = this._root.tooltipContainer;
tooltipContainer.set("themeTags", $utils.mergeTags(tooltipContainer.get("themeTags", []), ["stock"]));
super._afterNew();
const children = this.panelsContainer.children;
this._disposers.push(this.panels.events.onAll((change) => {
if (change.type === "clear") {
$array.each(change.oldValues, (chart) => {
this._removePanel(chart);
});
}
else if (change.type === "push") {
children.moveValue(change.newValue);
this._processPanel(change.newValue);
}
else if (change.type === "setIndex") {
children.setIndex(change.index, change.newValue);
this._processPanel(change.newValue);
}
else if (change.type === "insertIndex") {
children.insertIndex(change.index, change.newValue);
this._processPanel(change.newValue);
}
else if (change.type === "removeIndex") {
this._removePanel(change.oldValue);
}
else {
throw new Error("Unknown IListEvent type");
}
}));
this._disposers.push(this.indicators.events.onAll((change) => {
if (change.type === "clear") {
$array.each(change.oldValues, (indicator) => {
this._removeIndicator(indicator);
});
}
else if (change.type === "push") {
this._processIndicator(change.newValue);
}
else if (change.type === "setIndex") {
this._processIndicator(change.newValue);
}
else if (change.type === "insertIndex") {
this._processIndicator(change.newValue);
}
else if (change.type === "removeIndex") {
this._removeIndicator(change.oldValue);
}
else {
throw new Error("Unknown IListEvent type");
}
}));
this.setPrivateRaw("settingsModal", SettingsModal.new(this.root, {
stockChart: this
}));
let license = false;
for (let i = 0; i < registry.licenses.length; i++) {
if (registry.licenses[i].match(/^AM5S.{5,}/i)) {
license = true;
}
}
if (!license) {
this._root._showBranding();
}
else {
this._root._licenseApplied();
}
}
dispose() {
super.dispose();
const settingsModal = this.getPrivate("settingsModal");
if (settingsModal) {
settingsModal.dispose();
}
}
/**
* Forces redrawing of all annotations (drfawings).
*/
markDirtyDrawings() {
this._drawingsChanged = true;
this.markDirty();
}
/**
* Forces redrawing of Indicators.
*/
markDirtyIndicators() {
this._indicatorsChanged = true;
this.markDirty();
}
/**
* Enables or disables interactivity of annotations (drawings).
*
* @param value Drawings interactive?
* @since 5.4.9
*/
drawingsInteractive(value) {
this.panels.each((panel) => {
panel.series.each((series) => {
if (series.isType("DrawingSeries")) {
series.setInteractive(value);
}
});
});
}
_prepareChildren() {
if (this.isDirty("volumeNegativeColor") || this.isDirty("volumePositiveColor")) {
const volumeSeries = this.get("volumeSeries");
if (volumeSeries && volumeSeries.isType("BaseColumnSeries")) {
volumeSeries.columns.each((column) => {
column._markDirtyKey("fill");
});
}
}
const stockSeries = this.get("stockSeries");
if (this.isDirty("stockSeries")) {
if (stockSeries) {
const previous = this._prevSettings.stockSeries;
this.indicators.each((indicator) => {
if (previous == indicator.get("stockSeries")) {
indicator.set("stockSeries", stockSeries);
}
else {
indicator._setSoft("stockSeries", stockSeries);
}
});
const mainChart = stockSeries.chart;
if (mainChart) {
mainChart.series.each((series) => {
if (series.isType("DrawingSeries")) {
let s = series.get("series");
if (s == previous) {
series.set("series", stockSeries);
}
else {
series._setSoft("series", stockSeries);
}
}
});
const xAxis = mainChart.xAxes.getIndex(0);
if (xAxis) {
if (this._syncExtremesDp) {
this._syncExtremesDp.dispose();
}
this.setPrivateRaw("mainAxis", xAxis);
if (this._baseDP) {
this._baseDP.dispose();
}
this._baseDP = xAxis.on("baseInterval", (baseInterval) => {
this.indicators.each((indicator) => {
if (indicator.isType("ChartIndicator")) {
indicator.xAxis.set("baseInterval", baseInterval);
}
});
});
this._syncExtremesDp = new MultiDisposer([
xAxis.onPrivate("max", () => {
this._syncExtremes();
}),
xAxis.onPrivate("min", () => {
this._syncExtremes();
})
]);
}
}
if (this.getPrivate("comparing")) {
this.setPercentScale(true);
}
}
}
super._prepareChildren();
}
_afterChanged() {
super._afterChanged();
if (this._drawingsChanged) {
this._drawingsChanged = false;
const type = "drawingsupdated";
if (this.events.isEnabled(type)) {
this.events.dispatch(type, { type: type, target: this });
}
}
if (this._indicatorsChanged) {
this._indicatorsChanged = false;
const type = "indicatorsupdated";
if (this.events.isEnabled(type)) {
this.events.dispatch(type, { type: type, target: this });
}
}
}
_updateChildren() {
super._updateChildren();
const stockSeries = this.get("stockSeries");
if (this.isDirty("volumeSeries")) {
const volumeSeries = this.get("volumeSeries");
if (volumeSeries) {
const volumePanel = volumeSeries.chart;
if (volumePanel) {
volumePanel.series.events.on("removeIndex", (event) => {
if (event.oldValue == volumeSeries) {
this.set("volumeSeries", undefined);
}
});
}
}
}
if (this.isDirty("stockNegativeColor") || this.isDirty("stockPositiveColor") || this.isDirty("stockSeries")) {
if (stockSeries && stockSeries.isType("BaseColumnSeries")) {
const ic = this._root.interfaceColors;
const stockNegativeColor = this.get("stockNegativeColor", ic.get("negative"));
const stockPositiveColor = this.get("stockPositiveColor", ic.get("positive"));
let previous = stockSeries.dataItems[0];
if (stockPositiveColor && stockPositiveColor) {
$array.each(stockSeries.dataItems, (dataItem) => {
const column = dataItem.get("graphics");
if (column) {
const dropFromOpen = column.states.lookup("dropFromOpen");
if (dropFromOpen) {
dropFromOpen.setAll({ fill: stockNegativeColor, stroke: stockNegativeColor });
}
const riseFromOpen = column.states.lookup("riseFromOpen");
if (riseFromOpen) {
riseFromOpen.setAll({ fill: stockPositiveColor, stroke: stockPositiveColor });
}
const dropFromPrevious = column.states.lookup("dropFromPrevious");
if (dropFromPrevious) {
dropFromPrevious.setAll({ fill: stockNegativeColor, stroke: stockNegativeColor });
}
const riseFromPrevious = column.states.lookup("riseFromPrevious");
if (riseFromPrevious) {
riseFromPrevious.setAll({ fill: stockPositiveColor, stroke: stockPositiveColor });
}
stockSeries._applyGraphicsStates(dataItem, previous);
previous = dataItem;
}
});
const states = stockSeries.columns.template.states;
const riseFromOpen = states.lookup("riseFromOpen");
const themeTags = stockSeries.columns.template.get("themeTags");
if (stockPositiveColor) {
if (riseFromOpen) {
riseFromOpen.setAll({ fill: stockPositiveColor, stroke: stockPositiveColor });
}
else {
states.create("riseFromOpen", { fill: stockPositiveColor, stroke: stockPositiveColor });
}
const riseFromPrevious = states.lookup("riseFromPrevious");
if (riseFromPrevious) {
riseFromPrevious.setAll({ fill: stockPositiveColor, stroke: stockPositiveColor });
}
else {
if (themeTags && themeTags.indexOf("pro") != -1) {
states.create("riseFromPrevious", { fill: stockPositiveColor, stroke: stockPositiveColor });
}
}
}
if (stockNegativeColor) {
const dropFromOpen = states.lookup("dropFromOpen");
if (dropFromOpen) {
dropFromOpen.setAll({ fill: stockNegativeColor, stroke: stockNegativeColor });
}
else {
states.create("dropFromOpen", { fill: stockNegativeColor, stroke: stockNegativeColor });
}
const dropFromPrevious = states.lookup("dropFromPrevious");
if (dropFromPrevious) {
dropFromPrevious.setAll({ fill: stockNegativeColor, stroke: stockNegativeColor });
}
else {
if (themeTags && themeTags.indexOf("pro") != -1) {
states.create("dropFromPrevious", { fill: stockNegativeColor, stroke: stockNegativeColor });
}
}
}
}
stockSeries.markDirtyValues();
}
}
}
/**
* Enables or disables percent scale mode.
*
* If `percentScale` is not set, it will try to determine the status on its own.
*
* In percent scale mode `percentScaleSeriesSettings` and `percentScaleValueAxisSettings` will
* be applied to the regular series on the main panel and its Y axis.
*
* @param percentScale Comparison mode active
*/
setPercentScale(percentScale) {
const stockSeries = this.get("stockSeries");
const seriesSettings = this.get("percentScaleSeriesSettings");
const axisSettings = this.get("percentScaleValueAxisSettings");
if (stockSeries) {
const mainChart = stockSeries.chart;
const yAxis = stockSeries.get("yAxis");
yAxis.set("logarithmic", false);
this._maybePrepAxisDefaults();
if (mainChart) {
const seriesList = [];
mainChart.series.each((series) => {
if (series.get("yAxis") == yAxis) {
seriesList.push(series);
this._maybePrepSeriesDefaults(series);
}
});
if (percentScale == undefined) {
percentScale = this.getPrivate("comparedSeries", []).length > 0;
}
this.setPrivate("comparing", percentScale);
if (seriesSettings) {
$array.each(seriesList, (series) => {
if (percentScale) {
series.setAll(seriesSettings);
series.states.lookup("default").setAll(seriesSettings);
}
else {
series.states.apply("comparingDefaults");
const seriesDefaults = series.states.lookup("comparingDefaults");
if (seriesDefaults) {
series.states.lookup("default").setAll(seriesDefaults._settings);
}
}
});
}
if (axisSettings) {
if (percentScale) {
yAxis.setAll(axisSettings);
}
else {
yAxis.states.apply("comparingDefaults");
}
}
}
}
this.indicators.each((indicator) => {
indicator.markDataDirty();
});
}
/**
* Adds a "compared" series to chart. Returns the same series.
*
* @param series Compared series
* @return Compared series
*/
addComparingSeries(series) {
const stockSeries = this.get("stockSeries");
if (stockSeries) {
const chart = stockSeries.chart;
if (chart) {
chart.series.push(series);
}
// Apply comparingSeriesSettings
const comparingSeriesSettings = this.get("comparingSeriesSettings");
if (comparingSeriesSettings) {
series.setAll(comparingSeriesSettings);
}
const comparedSeries = this.getPrivate("comparedSeries");
if (comparedSeries) {
comparedSeries.push(series);
}
else {
this.setPrivate("comparedSeries", [series]);
}
const legendDataItem = stockSeries.get("legendDataItem");
if (legendDataItem) {
const legend = legendDataItem.component;
if (legend.isType("StockLegend")) {
legend.data.push(series);
const ldi = series.get("legendDataItem");
if (ldi) {
const closeButton = ldi.get("closeButton");
closeButton.set("forceHidden", false);
closeButton.events.on("click", () => {
this.removeComparingSeries(series);
});
}
}
}
if (this.get("autoSetPercentScale")) {
this.setPercentScale(true);
}
}
return series;
}
/**
* Removes compared series.
*
* @param series Compared series
*/
removeComparingSeries(series) {
const stockSeries = this.get("stockSeries");
if (stockSeries) {
const chart = stockSeries.chart;
if (chart) {
chart.series.removeValue(series);
}
const comparedSeries = this.getPrivate("comparedSeries");
if (comparedSeries) {
$array.remove(comparedSeries, series);
if (comparedSeries.length == 0 && this.get("autoSetPercentScale")) {
this.setPercentScale(false);
}
}
}
const ldi = series.get("legendDataItem");
if (ldi) {
const legend = ldi.component;
legend.data.removeValue(series);
}
}
_maybePrepSeriesDefaults(series) {
if (!series.states.lookup("comparingDefaults")) {
const seriesSettings = this.get("percentScaleSeriesSettings");
const defaults = {};
$object.each(seriesSettings, (key, _val) => {
defaults[key] = series.get(key);
});
series.states.create("comparingDefaults", defaults);
}
}
getSeriesDefault(series, setting) {
const defaults = series.states.lookup("comparingDefaults");
return defaults ? defaults.get(setting) : series.get(setting);
}
_maybePrepAxisDefaults() {
const stockSeries = this.get("stockSeries");
const axis = stockSeries.get("yAxis");
if (!axis.states.lookup("comparingDefaults")) {
const axisSettings = this.get("percentScaleValueAxisSettings");
const defaults = {};
$object.each(axisSettings, (key, _val) => {
defaults[key] = axis.get(key);
});
axis.states.create("comparingDefaults", defaults);
}
}
_processIndicator(indicator) {
this.children.push(indicator);
const stockSeries = this.get("stockSeries");
if (stockSeries) {
indicator._setSoft("stockSeries", stockSeries);
}
const volumeSeries = this.get("volumeSeries");
if (volumeSeries) {
indicator._setSoft("volumeSeries", volumeSeries);
}
if (this.getPrivate("comparing")) {
this.setPercentScale(true);
}
$array.each(indicator._editableSettings, (setting) => {
indicator.on(setting.key, () => {
this.markDirtyIndicators();
});
});
this.markDirtyIndicators();
//indicator.markDataDirty(); // not good, shows zoomed out value axis
indicator.prepareData();
this._syncExtremes();
}
_removeIndicator(indicator) {
this.children.removeValue(indicator);
this.markDirtyIndicators();
}
_removePanel(chart) {
this.panelsContainer.children.removeValue(chart);
}
_updateControls() {
const stockSeries = this.get("stockSeries");
this.panels.each((panel) => {
const panelControls = panel.panelControls;
const index = this.panelsContainer.children.indexOf(panel);
const len = this.panels.length;
const visible = "visible";
panelControls.upButton.setPrivate(visible, false);
panelControls.downButton.setPrivate(visible, false);
panelControls.expandButton.setPrivate(visible, false);
panelControls.closeButton.setPrivate(visible, false);
if (len > 1) {
panelControls.expandButton.setPrivate(visible, true);
if (index != 0) {
panelControls.upButton.setPrivate(visible, true);
}
if (index != len - 1) {
panelControls.downButton.setPrivate(visible, true);
}
if (!stockSeries || stockSeries.chart != panel) {
panelControls.closeButton.setPrivate(visible, true);
}
}
if (stockSeries) {
this.indicators.each((indicator) => {
indicator.set("stockSeries", stockSeries);
});
}
});
}
_processPanel(panel) {
panel.setPrivate("otherCharts", this.panels.values);
panel.setPrivate("stockChart", this);
panel.panelControls = panel.topPlotContainer.children.push(PanelControls.new(this._root, { stockPanel: panel, stockChart: this }));
this._updateControls();
if (this.panels.length > 1) {
const resizer = panel.children.push(Rectangle.new(this._root, { themeTags: ["panelresizer"] }));
panel.panelResizer = resizer;
resizer.events.on("pointerdown", (e) => {
const chartsContainer = this.panelsContainer;
this._downResizer = e.target;
this.panels.each((chart) => {
chart.set("height", percent(chart.height() / chartsContainer.height() * 100));
});
this._downY = chartsContainer.toLocal(e.point).y;
const upperChart = this.panels.getIndex(this.panels.indexOf(panel) - 1);
this._upperPanel = upperChart;
if (upperChart) {
this._uhp = upperChart.get("height");
}
this._dhp = panel.get("height");
});
resizer.events.on("pointerup", () => {
this._downResizer = undefined;
});
resizer.events.on("globalpointermove", (e) => {
if (e.target == this._downResizer) {
const chartsContainer = this.panelsContainer;
const height = chartsContainer.height();
const upperChart = this._upperPanel;
if (upperChart) {
const index = this.panels.indexOf(upperChart) + 2;
let max = height - panel.get("minHeight", 0);
const lowerChart = this.panels.getIndex(index);
if (lowerChart) {
max = lowerChart.y() - panel.get("minHeight", 0);
}
//console.log(upperChart.get("minHeight", 0))
const y = Math.max(upperChart.y() + upperChart.get("minHeight", 0) + upperChart.get("paddingTop", 0), Math.min(chartsContainer.toLocal(e.point).y, max));
const downY = this._downY;
const dhp = this._dhp;
const uhp = this._uhp;
if (downY != null && dhp != null && uhp != null) {
const diff = (downY - y) / height;
panel.set("height", percent((dhp.value + diff) * 100));
upperChart.set("height", percent((uhp.value - diff) * 100));
}
}
}
});
}
panel.xAxes.events.onAll((change) => {
if (change.type === "clear") {
$array.each(change.oldValues, (axis) => {
this._removeXAxis(axis);
});
}
else if (change.type === "push") {
this._processXAxis(change.newValue);
}
else if (change.type === "setIndex") {
this._processXAxis(change.newValue);
}
else if (change.type === "insertIndex") {
this._processXAxis(change.newValue);
}
else if (change.type === "removeIndex") {
this._removeXAxis(change.oldValue);
}
else {
throw new Error("Unknown IListEvent type");
}
});
panel.leftAxesContainer.events.on("boundschanged", () => {
this._syncYAxesSize();
});
panel.rightAxesContainer.events.on("boundschanged", () => {
this._syncYAxesSize();
});
}
_syncYAxesSize() {
let maxLeft = 0;
let maxRight = 0;
this.panels.each((chart) => {
let lw = chart.leftAxesContainer.width();
let rw = chart.rightAxesContainer.width();
if (lw > maxLeft) {
maxLeft = lw;
}
if (rw > maxRight) {
maxRight = rw;
}
});
this.panels.each((chart) => {
chart.leftAxesContainer.set("minWidth", maxLeft);
chart.rightAxesContainer.set("minWidth", maxRight);
});
this.toolsContainer.set("paddingLeft", maxLeft);
this.toolsContainer.set("paddingRight", maxRight);
}
_removeXAxis(_axis) {
}
_processXAxis(axis) {
$array.move(this._xAxes, axis);
axis.on("start", () => {
if (axis._skipSync != true) {
this._syncXAxes(axis);
}
});
axis.on("end", () => {
if (axis._skipSync != true) {
this._syncXAxes(axis);
}
});
}
_syncExtremes() {
const mainAxis = this.getPrivate("mainAxis");
if (mainAxis) {
const min = mainAxis.getPrivate("min");
const max = mainAxis.getPrivate("max");
this.panels.each((panel) => {
panel.xAxes.each((xAxis) => {
if (xAxis != mainAxis && xAxis.isType("DateAxis")) {
let axisMin = xAxis.getPrivate("min");
let axisMax = xAxis.getPrivate("max");
if (axisMin != min) {
xAxis.set("min", min);
}
if (axisMax != max) {
xAxis.set("max", max);
}
const type = "GaplessDateAxis";
if (xAxis.isType(type) && mainAxis.isType(type)) {
xAxis._customDates = mainAxis._dates;
}
}
});
});
}
}
_syncXAxes(axis) {
$array.each(this._xAxes, (xAxis) => {
if (xAxis != axis && xAxis.isType("DateAxis")) {
xAxis._skipSync = true;
xAxis.set("start", axis.get("start"));
xAxis.set("end", axis.get("end"));
xAxis._skipSync = false;
}
});
}
/**
* Returns a color for volume, based on current and previous close.
*
* * `positiveColor` - close is greater or euqal than close of the previous period.
* * `negativeColor` - close is lower than close of the previous period.
*
* @param dataItem Target data item
* @param negativeColor "Negative color" (red)
* @param positiveColor "Positive color" (green)
* @return Color
*/
getVolumeColor(dataItem, negativeColor, positiveColor) {
if (dataItem) {
const stockSeries = this.get("stockSeries");
const volumeSeries = dataItem.component;
if (!negativeColor) {
negativeColor = this.get("volumeNegativeColor", this.root.interfaceColors.get("negative", Color.fromHex(0xff0000)));
}
if (!positiveColor) {
positiveColor = this.get("volumePositiveColor", this.root.interfaceColors.get("positive", Color.fromHex(0x00FF00)));
}
if (negativeColor && positiveColor) {
if (stockSeries && volumeSeries) {
const index = volumeSeries.dataItems.indexOf(dataItem);
if (index > 0) {
let stockDataItem = stockSeries.dataItems[index];
if (stockDataItem) {
let close = stockDataItem.get("valueY");
if (close != null) {
for (let i = index - 1; i >= 0; i--) {
let di = stockSeries.dataItems[i];
let previousClose = di.get("valueY");
if (previousClose != null) {
if (close < previousClose) {
return negativeColor;
}
else {
return positiveColor;
}
}
}
}
}
}
}
}
}
return positiveColor;
}
/**
* Returns a first [[StockControl]] of specific type.
*
* @since 5.7.0
* @param type Control name
* @return Control
*/
getControl(type) {
let found;
$array.eachContinue(this.controls, (control) => {
if (control.className == type) {
found = control;
return false;
}
return true;
});
return found;
}
}
Object.defineProperty(StockChart, "className", {
enumerable: true,
configurable: true,
writable: true,
value: "StockChart"
});
Object.defineProperty(StockChart, "classNames", {
enumerable: true,
configurable: true,
writable: true,
value: Container.classNames.concat([StockChart.className])
});
/**
* Registers a custom class so that objects (e.g. indicators) using it can be
* serialized and restored later.
*
* @param name Class name
* @param ref Class reference
* @since 5.7.2
*/
export function registerClass(name, ref) {
ref.className = name;
registerCustomClass(name, ref);
}
//# sourceMappingURL=StockChart.js.map