/**
 * DevExtreme (ui/gantt/ui.gantt.js)
 * Version: 20.2.0 (build 20182-0310)
 * Build date: Tue Jun 30 2020
 *
 * Copyright (c) 2012 - 2020 Developer Express Inc. ALL RIGHTS RESERVED
 * Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
 */
"use strict";
var _renderer = require("../../core/renderer");
var _renderer2 = _interopRequireDefault(_renderer);
var _type = require("../../core/utils/type");
var _type2 = _interopRequireDefault(_type);
var _ui = require("../widget/ui.widget");
var _ui2 = _interopRequireDefault(_ui);
var _component_registrator = require("../../core/component_registrator");
var _component_registrator2 = _interopRequireDefault(_component_registrator);
var _data = require("../../core/utils/data");
var _data2 = _interopRequireDefault(_data);
var _uiGantt = require("./ui.gantt.view");
var _uiGantt2 = require("./ui.gantt.bars");
var _tree_list = require("../tree_list");
var _tree_list2 = _interopRequireDefault(_tree_list);
var _extend = require("../../core/utils/extend");
var _position = require("../../core/utils/position");
var _window = require("../../core/utils/window");
var _uiGanttData = require("./ui.gantt.data.option");
var _uiGanttData2 = _interopRequireDefault(_uiGanttData);
var _splitter = require("../splitter");
var _splitter2 = _interopRequireDefault(_splitter);
var _uiGantt3 = require("./ui.gantt.dialogs");
var _load_panel = require("../load_panel");
var _load_panel2 = _interopRequireDefault(_load_panel);

function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        "default": obj
    }
}

function _typeof(obj) {
    "@babel/helpers - typeof";
    if ("function" === typeof Symbol && "symbol" === typeof Symbol.iterator) {
        _typeof = function(obj) {
            return typeof obj
        }
    } else {
        _typeof = function(obj) {
            return obj && "function" === typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj
        }
    }
    return _typeof(obj)
}

function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function")
    }
}

function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) {
            descriptor.writable = true
        }
        Object.defineProperty(target, descriptor.key, descriptor)
    }
}

function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) {
        _defineProperties(Constructor.prototype, protoProps)
    }
    if (staticProps) {
        _defineProperties(Constructor, staticProps)
    }
    return Constructor
}

function _get(target, property, receiver) {
    if ("undefined" !== typeof Reflect && Reflect.get) {
        _get = Reflect.get
    } else {
        _get = function(target, property, receiver) {
            var base = _superPropBase(target, property);
            if (!base) {
                return
            }
            var desc = Object.getOwnPropertyDescriptor(base, property);
            if (desc.get) {
                return desc.get.call(receiver)
            }
            return desc.value
        }
    }
    return _get(target, property, receiver || target)
}

function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
        object = _getPrototypeOf(object);
        if (null === object) {
            break
        }
    }
    return object
}

function _inherits(subClass, superClass) {
    if ("function" !== typeof superClass && null !== superClass) {
        throw new TypeError("Super expression must either be null or a function")
    }
    subClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            writable: true,
            configurable: true
        }
    });
    if (superClass) {
        _setPrototypeOf(subClass, superClass)
    }
}

function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function(o, p) {
        o.__proto__ = p;
        return o
    };
    return _setPrototypeOf(o, p)
}

function _createSuper(Derived) {
    var hasNativeReflectConstruct = _isNativeReflectConstruct();
    return function() {
        var result, Super = _getPrototypeOf(Derived);
        if (hasNativeReflectConstruct) {
            var NewTarget = _getPrototypeOf(this).constructor;
            result = Reflect.construct(Super, arguments, NewTarget)
        } else {
            result = Super.apply(this, arguments)
        }
        return _possibleConstructorReturn(this, result)
    }
}

function _possibleConstructorReturn(self, call) {
    if (call && ("object" === _typeof(call) || "function" === typeof call)) {
        return call
    }
    return _assertThisInitialized(self)
}

function _assertThisInitialized(self) {
    if (void 0 === self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called")
    }
    return self
}

function _isNativeReflectConstruct() {
    if ("undefined" === typeof Reflect || !Reflect.construct) {
        return false
    }
    if (Reflect.construct.sham) {
        return false
    }
    if ("function" === typeof Proxy) {
        return true
    }
    try {
        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
        return true
    } catch (e) {
        return false
    }
}

function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function(o) {
        return o.__proto__ || Object.getPrototypeOf(o)
    };
    return _getPrototypeOf(o)
}
var GANTT_CLASS = "dx-gantt";
var GANTT_VIEW_CLASS = "dx-gantt-view";
var GANTT_COLLAPSABLE_ROW = "dx-gantt-collapsable-row";
var GANTT_TREE_LIST_WRAPPER = "dx-gantt-treelist-wrapper";
var GANTT_TOOLBAR_WRAPPER = "dx-gantt-toolbar-wrapper";
var GANTT_MAIN_WRAPPER = "dx-gantt-main-wrapper";
var GANTT_TASKS = "tasks";
var GANTT_DEPENDENCIES = "dependencies";
var GANTT_RESOURCES = "resources";
var GANTT_RESOURCE_ASSIGNMENTS = "resourceAssignments";
var GANTT_DEFAULT_ROW_HEIGHT = 34;
var Gantt = function(_Widget) {
    _inherits(Gantt, _Widget);
    var _super = _createSuper(Gantt);

    function Gantt() {
        _classCallCheck(this, Gantt);
        return _super.apply(this, arguments)
    }
    _createClass(Gantt, [{
        key: "_initMarkup",
        value: function() {
            _get(_getPrototypeOf(Gantt.prototype), "_initMarkup", this).call(this);
            this.$element().addClass(GANTT_CLASS);
            this._$toolbarWrapper = (0, _renderer2.default)("<div>").addClass(GANTT_TOOLBAR_WRAPPER).appendTo(this.$element());
            this._$toolbar = (0, _renderer2.default)("<div>").appendTo(this._$toolbarWrapper);
            this._$mainWrapper = (0, _renderer2.default)("<div>").addClass(GANTT_MAIN_WRAPPER).appendTo(this.$element());
            this._$treeListWrapper = (0, _renderer2.default)("<div>").addClass(GANTT_TREE_LIST_WRAPPER).appendTo(this._$mainWrapper);
            this._$treeList = (0, _renderer2.default)("<div>").appendTo(this._$treeListWrapper);
            this._$splitter = (0, _renderer2.default)("<div>").appendTo(this._$mainWrapper);
            this._$ganttView = (0, _renderer2.default)("<div>").addClass(GANTT_VIEW_CLASS).appendTo(this._$mainWrapper);
            this._$dialog = (0, _renderer2.default)("<div>").appendTo(this.$element());
            this._$loadPanel = (0, _renderer2.default)("<div>").appendTo(this.$element());
            this._$contextMenu = (0, _renderer2.default)("<div>").appendTo(this.$element());
            this._refreshDataSource(GANTT_TASKS);
            this._refreshDataSource(GANTT_DEPENDENCIES);
            this._refreshDataSource(GANTT_RESOURCES);
            this._refreshDataSource(GANTT_RESOURCE_ASSIGNMENTS)
        }
    }, {
        key: "_renderContent",
        value: function() {
            this._renderBars();
            this._renderTreeList();
            this._renderSplitter()
        }
    }, {
        key: "_renderTreeList",
        value: function() {
            var _this = this;
            var _this$option = this.option(GANTT_TASKS),
                keyExpr = _this$option.keyExpr,
                parentIdExpr = _this$option.parentIdExpr;
            this._treeList = this._createComponent(this._$treeList, _tree_list2.default, {
                dataSource: this._tasksRaw,
                keyExpr: keyExpr,
                parentIdExpr: parentIdExpr,
                columns: this.option("columns"),
                columnResizingMode: "nextColumn",
                height: this._$treeList.height() ? this._$treeList.height() : "100%",
                width: this.option("taskListWidth"),
                selection: {
                    mode: this._getSelectionMode(this.option("allowSelection"))
                },
                selectedRowKeys: this._getArrayFromOneElement(this.option("selectedRowKey")),
                sorting: {
                    mode: "none"
                },
                scrolling: {
                    showScrollbar: "onHover",
                    mode: "virtual"
                },
                allowColumnResizing: true,
                autoExpandAll: true,
                showRowLines: this.option("showRowLines"),
                onContentReady: function(e) {
                    _this._onTreeListContentReady(e)
                },
                onSelectionChanged: function(e) {
                    _this._onTreeListSelectionChanged(e)
                },
                onRowCollapsed: function(e) {
                    return _this._ganttView.changeTaskExpanded(e.key, false)
                },
                onRowExpanded: function(e) {
                    return _this._ganttView.changeTaskExpanded(e.key, true)
                },
                onRowPrepared: function(e) {
                    _this._onTreeListRowPrepared(e)
                },
                onContextMenuPreparing: function(e) {
                    _this._onTreeListContextMenuPreparing(e)
                },
                onRowDblClick: function() {
                    _this._onTreeListRowDblClick()
                }
            })
        }
    }, {
        key: "_renderSplitter",
        value: function() {
            this._splitter = this._createComponent(this._$splitter, _splitter2.default, {
                container: this.$element(),
                leftElement: this._$treeListWrapper,
                rightElement: this._$ganttView,
                onApplyPanelSize: this._onApplyPanelSize.bind(this)
            });
            this._splitter.option("initialLeftPanelWidth", this.option("taskListWidth"))
        }
    }, {
        key: "_renderBars",
        value: function() {
            this._bars = [];
            this._toolbar = new _uiGantt2.GanttToolbar(this._$toolbar, this);
            this._updateToolbarContent();
            this._bars.push(this._toolbar);
            this._contextMenuBar = new _uiGantt2.GanttContextMenuBar(this._$contextMenu, this);
            this._bars.push(this._contextMenuBar)
        }
    }, {
        key: "_initGanttView",
        value: function() {
            if (this._ganttView) {
                return
            }
            this._ganttView = this._createComponent(this._$ganttView, _uiGantt.GanttView, {
                width: "100%",
                height: this._treeList._$element.get(0).offsetHeight,
                rowHeight: this._getTreeListRowHeight(),
                headerHeight: this._getTreeListHeaderHeight(),
                tasks: this._tasks,
                dependencies: this._dependencies,
                resources: this._resources,
                resourceAssignments: this._resourceAssignments,
                allowSelection: this.option("allowSelection"),
                selectedRowKey: this.option("selectedRowKey"),
                showResources: this.option("showResources"),
                taskTitlePosition: this.option("taskTitlePosition"),
                firstDayOfWeek: this.option("firstDayOfWeek"),
                showRowLines: this.option("showRowLines"),
                scaleType: this.option("scaleType"),
                editing: this.option("editing"),
                validation: this.option("validation"),
                stripLines: this.option("stripLines"),
                bars: this._bars,
                mainElement: this.$element(),
                onSelectionChanged: this._onGanttViewSelectionChanged.bind(this),
                onScroll: this._onGanttViewScroll.bind(this),
                onDialogShowing: this._showDialog.bind(this),
                onPopupMenuShowing: this._showPopupMenu.bind(this),
                onExpandAll: this._expandAll.bind(this),
                onCollapseAll: this._collapseAll.bind(this),
                modelChangesListener: this._createModelChangesListener()
            });
            this._fireContentReadyAction()
        }
    }, {
        key: "_onApplyPanelSize",
        value: function(e) {
            this._setInnerElementsWidth(e)
        }
    }, {
        key: "_onTreeListContentReady",
        value: function(e) {
            if (e.component.getDataSource()) {
                this._initGanttView();
                this._initScrollSync(e.component)
            }
        }
    }, {
        key: "_onTreeListRowPrepared",
        value: function(e) {
            if ("data" === e.rowType && e.node.children.length > 0) {
                (0, _renderer2.default)(e.rowElement).addClass(GANTT_COLLAPSABLE_ROW)
            }
        }
    }, {
        key: "_onTreeListContextMenuPreparing",
        value: function(e) {
            if (e.row && "data" === e.row.rowType) {
                this._setTreeListOption("selectedRowKeys", [e.row.data[this.option("tasks.keyExpr")]]);
                e.items = [];
                this._showPopupMenu({
                    position: {
                        x: e.event.pageX,
                        y: e.event.pageY
                    }
                })
            }
        }
    }, {
        key: "_onTreeListRowDblClick",
        value: function() {
            this._ganttView._ganttViewCore.commandManager.showTaskEditDialog.execute()
        }
    }, {
        key: "_onTreeListSelectionChanged",
        value: function(e) {
            var selectedRowKey = e.currentSelectedRowKeys[0];
            this._setGanttViewOption("selectedRowKey", selectedRowKey);
            this.option("selectedRowKey", selectedRowKey);
            this._raiseSelectionChangedAction(selectedRowKey)
        }
    }, {
        key: "_onGanttViewSelectionChanged",
        value: function(e) {
            this._setTreeListOption("selectedRowKeys", this._getArrayFromOneElement(e.id))
        }
    }, {
        key: "_onGanttViewScroll",
        value: function(e) {
            var treeListScrollable = this._treeList.getScrollable();
            if (treeListScrollable) {
                var diff = e.scrollTop - treeListScrollable.scrollTop();
                if (0 !== diff) {
                    treeListScrollable.scrollBy({
                        left: 0,
                        top: diff
                    })
                }
            }
        }
    }, {
        key: "_onTreeListScroll",
        value: function(treeListScrollView) {
            var ganttViewTaskAreaContainer = this._ganttView.getTaskAreaContainer();
            if (ganttViewTaskAreaContainer.scrollTop !== treeListScrollView.component.scrollTop()) {
                ganttViewTaskAreaContainer.scrollTop = treeListScrollView.component.scrollTop()
            }
        }
    }, {
        key: "_expandAll",
        value: function() {
            var _this2 = this;
            this._treeList.forEachNode(function(node) {
                if (node.children && node.children.length) {
                    _this2._treeList.expandRow(node.key);
                    _this2._ganttView.changeTaskExpanded(node.key, true)
                }
            })
        }
    }, {
        key: "_collapseAll",
        value: function() {
            var _this3 = this;
            this._treeList.forEachNode(function(node) {
                if (node.children && node.children.length) {
                    _this3._treeList.collapseRow(node.key);
                    _this3._ganttView.changeTaskExpanded(node.key, false)
                }
            })
        }
    }, {
        key: "_initScrollSync",
        value: function(treeList) {
            var _this4 = this;
            var treeListScrollable = treeList.getScrollable();
            if (treeListScrollable) {
                treeListScrollable.off("scroll");
                treeListScrollable.on("scroll", function(e) {
                    _this4._onTreeListScroll(e)
                })
            }
        }
    }, {
        key: "_getTreeListRowHeight",
        value: function() {
            var $row = this._treeList._$element.find(".dx-data-row");
            var height = $row.length ? (0, _position.getBoundingRect)($row.last().get(0)).height : GANTT_DEFAULT_ROW_HEIGHT;
            return height ? height : GANTT_DEFAULT_ROW_HEIGHT
        }
    }, {
        key: "_getTreeListHeaderHeight",
        value: function() {
            return (0, _position.getBoundingRect)(this._treeList._$element.find(".dx-treelist-headers").get(0)).height
        }
    }, {
        key: "_setInnerElementsWidth",
        value: function(widths) {
            if (!(0, _window.hasWindow)()) {
                return
            }
            if (!widths) {
                widths = this._getPanelsWidthByOption()
            }
            var leftPanelWidth = widths.leftPanelWidth;
            var rightPanelWidth = widths.rightPanelWidth;
            this._$treeListWrapper.width(leftPanelWidth);
            var isPercentage = _type2.default.isString(leftPanelWidth) && "%" === leftPanelWidth.slice(-1);
            this._$treeList.width(isPercentage ? "100%" : leftPanelWidth);
            this._$ganttView.width(rightPanelWidth);
            this._setGanttViewOption("width", this._$ganttView.width())
        }
    }, {
        key: "_getPanelsWidthByOption",
        value: function() {
            return {
                leftPanelWidth: this.option("taskListWidth"),
                rightPanelWidth: this._$element.width() - this.option("taskListWidth")
            }
        }
    }, {
        key: "_setGanttViewOption",
        value: function(optionName, value) {
            this._ganttView && this._ganttView.option(optionName, value)
        }
    }, {
        key: "_setTreeListOption",
        value: function(optionName, value) {
            this._treeList && this._treeList.option(optionName, value)
        }
    }, {
        key: "_refreshDataSource",
        value: function(name) {
            var _this5 = this;
            var dataOption = this["_".concat(name, "Option")];
            if (dataOption) {
                dataOption._disposeDataSource();
                delete this["_".concat(name, "Option")];
                delete this["_".concat(name)]
            }
            if (this.option("".concat(name, ".dataSource"))) {
                dataOption = new _uiGanttData2.default(name, this._getLoadPanel(), function(name, data) {
                    _this5._dataSourceChanged(name, data)
                });
                dataOption.option("dataSource", this._getSpecificDataSourceOption(name));
                dataOption._refreshDataSource();
                this["_".concat(name, "Option")] = dataOption
            }
        }
    }, {
        key: "_getSpecificDataSourceOption",
        value: function(name) {
            var dataSource = this.option("".concat(name, ".dataSource"));
            if (Array.isArray(dataSource)) {
                return {
                    store: {
                        type: "array",
                        data: dataSource,
                        key: this.option("".concat(name, ".keyExpr"))
                    }
                }
            }
            return dataSource
        }
    }, {
        key: "_compileGettersByOption",
        value: function(optionName) {
            var getters = {};
            var optionValue = this.option(optionName);
            for (var field in optionValue) {
                var exprMatches = field.match(/(\w*)Expr/);
                if (exprMatches) {
                    getters[exprMatches[1]] = _data2.default.compileGetter(optionValue[exprMatches[0]])
                }
            }
            return getters
        }
    }, {
        key: "_compileSettersByOption",
        value: function(optionName) {
            var setters = {};
            var optionValue = this.option(optionName);
            for (var field in optionValue) {
                var exprMatches = field.match(/(\w*)Expr/);
                if (exprMatches) {
                    setters[exprMatches[1]] = _data2.default.compileSetter(optionValue[exprMatches[0]])
                }
            }
            return setters
        }
    }, {
        key: "_getStoreObject",
        value: function(optionName, modelObject) {
            var setters = this._compileSettersByOption(optionName);
            return Object.keys(setters).reduce(function(previous, key) {
                if ("key" !== key) {
                    setters[key](previous, modelObject[key])
                }
                return previous
            }, {})
        }
    }, {
        key: "_prepareSetterMapHandler",
        value: function(setters) {
            return function(data) {
                return Object.keys(setters).reduce(function(previous, key) {
                    var resultKey = "key" === key ? "id" : key;
                    setters[key](previous, data[resultKey]);
                    return previous
                }, {})
            }
        }
    }, {
        key: "_prepareMapHandler",
        value: function(getters) {
            return function(data) {
                return Object.keys(getters).reduce(function(previous, key) {
                    var resultKey = "key" === key ? "id" : key;
                    previous[resultKey] = getters[key](data);
                    return previous
                }, {})
            }
        }
    }, {
        key: "_dataSourceChanged",
        value: function(dataSourceName, data) {
            var getters = this._compileGettersByOption(dataSourceName);
            var mappedData = data.map(this._prepareMapHandler(getters));
            this["_".concat(dataSourceName)] = mappedData;
            this._setGanttViewOption(dataSourceName, mappedData);
            if (dataSourceName === GANTT_TASKS) {
                this._tasksRaw = data;
                var expandedRowKeys = data.map(function(t) {
                    return t.parentId
                }).filter(function(value, index, self) {
                    return value && self.indexOf(value) === index
                });
                this._setTreeListOption("expandedRowKeys", expandedRowKeys);
                this._setTreeListOption("dataSource", data)
            }
        }
    }, {
        key: "_createModelChangesListener",
        value: function() {
            var _this6 = this;
            return {
                NotifyTaskCreated: function(task, callback, errorCallback) {
                    _this6._onRecordInserted(GANTT_TASKS, task, callback)
                },
                NotifyTaskRemoved: function(taskId, errorCallback) {
                    _this6._onRecordRemoved(GANTT_TASKS, taskId)
                },
                NotifyTaskTitleChanged: function(taskId, newValue, errorCallback) {
                    _this6._onRecordUpdated(GANTT_TASKS, taskId, "title", newValue)
                },
                NotifyTaskDescriptionChanged: function(taskId, newValue, errorCallback) {
                    _this6._onRecordUpdated(GANTT_TASKS, taskId, "description", newValue)
                },
                NotifyTaskStartChanged: function(taskId, newValue, errorCallback) {
                    _this6._onRecordUpdated(GANTT_TASKS, taskId, "start", newValue)
                },
                NotifyTaskEndChanged: function(taskId, newValue, errorCallback) {
                    _this6._onRecordUpdated(GANTT_TASKS, taskId, "end", newValue)
                },
                NotifyTaskProgressChanged: function(taskId, newValue, errorCallback) {
                    _this6._onRecordUpdated(GANTT_TASKS, taskId, "progress", newValue)
                },
                NotifyDependencyInserted: function(dependency, callback, errorCallback) {
                    _this6._onRecordInserted(GANTT_DEPENDENCIES, dependency, callback)
                },
                NotifyDependencyRemoved: function(dependencyId, errorCallback) {
                    _this6._onRecordRemoved(GANTT_DEPENDENCIES, dependencyId)
                },
                NotifyResourceCreated: function(resource, callback, errorCallback) {
                    _this6._onRecordInserted(GANTT_RESOURCES, resource, callback)
                },
                NotifyResourceRemoved: function(resource, errorCallback) {
                    _this6._onRecordRemoved(GANTT_RESOURCES, resource)
                },
                NotifyResourceAssigned: function(assignment, callback, errorCallback) {
                    _this6._onRecordInserted(GANTT_RESOURCE_ASSIGNMENTS, assignment, callback)
                },
                NotifyResourceUnassigned: function(assignmentId, errorCallback) {
                    _this6._onRecordRemoved(GANTT_RESOURCE_ASSIGNMENTS, assignmentId)
                },
                NotifyParentDataRecalculated: function(data) {
                    _this6._onParentTasksRecalculated(data)
                }
            }
        }
    }, {
        key: "_onRecordInserted",
        value: function(optionName, record, callback) {
            var _this7 = this;
            var dataOption = this["_".concat(optionName, "Option")];
            if (dataOption) {
                var data = this._getStoreObject(optionName, record);
                dataOption.insert(data, function(response) {
                    var keyGetter = _data2.default.compileGetter(_this7.option("".concat(optionName, ".keyExpr")));
                    var insertedId = keyGetter(response);
                    callback(insertedId);
                    if (optionName === GANTT_TASKS) {
                        _this7._updateTreeListDataSource();
                        var parentId = record.parentId;
                        if (void 0 !== parentId) {
                            var expandedRowKeys = _this7._treeList.option("expandedRowKeys");
                            if (expandedRowKeys.indexOf(parentId) === -1) {
                                expandedRowKeys.push(parentId);
                                _this7._treeList.option("expandedRowKeys", expandedRowKeys)
                            }
                        }
                        _this7._setTreeListOption("selectedRowKeys", _this7._getArrayFromOneElement(insertedId));
                        _this7._setTreeListOption("focusedRowKey", insertedId)
                    }
                })
            }
        }
    }, {
        key: "_onRecordRemoved",
        value: function(optionName, key) {
            var _this8 = this;
            var dataOption = this["_".concat(optionName, "Option")];
            if (dataOption) {
                dataOption.remove(key, function() {
                    if (optionName === GANTT_TASKS) {
                        _this8._updateTreeListDataSource()
                    }
                })
            }
        }
    }, {
        key: "_onRecordUpdated",
        value: function(optionName, key, fieldName, value) {
            var _this9 = this;
            var dataOption = this["_".concat(optionName, "Option")];
            if (dataOption) {
                var setter = _data2.default.compileSetter(this.option("".concat(optionName, ".").concat(fieldName, "Expr")));
                var data = {};
                setter(data, value);
                dataOption.update(key, data, function() {
                    if (optionName === GANTT_TASKS) {
                        _this9._updateTreeListDataSource()
                    }
                })
            }
        }
    }, {
        key: "_onParentTasksRecalculated",
        value: function(data) {
            var setters = this._compileSettersByOption(GANTT_TASKS);
            var treeDataSource = this._appendCustomFields(data.map(this._prepareSetterMapHandler(setters)));
            this._setTreeListOption("dataSource", treeDataSource)
        }
    }, {
        key: "_appendCustomFields",
        value: function(data) {
            var modelData = this._tasksOption && this._tasksOption._getItems();
            var keyGetter = _data2.default.compileGetter(this.option("".concat(GANTT_TASKS, ".keyExpr")));
            return data.reduce(function(previous, item) {
                var modelItem = modelData && modelData.filter(function(obj) {
                    return keyGetter(obj) === keyGetter(item)
                })[0];
                if (!modelItem) {
                    previous.push(item)
                } else {
                    var updatedItem = {};
                    for (var field in modelItem) {
                        updatedItem[field] = Object.prototype.hasOwnProperty.call(item, field) ? item[field] : modelItem[field]
                    }
                    previous.push(updatedItem)
                }
                return previous
            }, [])
        }
    }, {
        key: "_updateTreeListDataSource",
        value: function() {
            if (!this._skipUpdateTreeListDataSource()) {
                var dataSource = this.option("tasks.dataSource");
                var storeArray = this._tasksOption._getStore()._array || dataSource.items && dataSource.items();
                this._setTreeListOption("dataSource", storeArray ? storeArray : dataSource)
            }
        }
    }, {
        key: "_skipUpdateTreeListDataSource",
        value: function() {
            return this.option("validation.autoUpdateParentTasks")
        }
    }, {
        key: "_getLoadPanel",
        value: function() {
            if (!this._loadPanel) {
                this._loadPanel = this._createComponent(this._$loadPanel, _load_panel2.default, {
                    position: {
                        of: this.$element()
                    }
                })
            }
            return this._loadPanel
        }
    }, {
        key: "_createSelectionChangedAction",
        value: function() {
            this._selectionChangedAction = this._createActionByOption("onSelectionChanged")
        }
    }, {
        key: "_raiseSelectionChangedAction",
        value: function(selectedRowKey) {
            if (!this._selectionChangedAction) {
                this._createSelectionChangedAction()
            }
            this._selectionChangedAction({
                selectedRowKey: selectedRowKey
            })
        }
    }, {
        key: "_getSelectionMode",
        value: function(allowSelection) {
            return allowSelection ? "single" : "none"
        }
    }, {
        key: "_getArrayFromOneElement",
        value: function(element) {
            return void 0 === element || null === element ? [] : [element]
        }
    }, {
        key: "_getToolbarItems",
        value: function() {
            var items = this.option("toolbar.items");
            return items ? items : []
        }
    }, {
        key: "_updateToolbarContent",
        value: function() {
            var items = this._getToolbarItems();
            if (items.length) {
                this._$toolbarWrapper.show()
            } else {
                this._$toolbarWrapper.hide()
            }
            this._toolbar && this._toolbar.createItems(items);
            this._updateBarItemsState()
        }
    }, {
        key: "_updateBarItemsState",
        value: function() {
            this._ganttView && this._ganttView.updateBarItemsState()
        }
    }, {
        key: "_showDialog",
        value: function(e) {
            if (!this._dialogInstance) {
                this._dialogInstance = new _uiGantt3.GanttDialog(this, this._$dialog)
            }
            this._dialogInstance.show(e.name, e.parameters, e.callback, e.afterClosing, this.option("editing"))
        }
    }, {
        key: "_showPopupMenu",
        value: function(e) {
            this._ganttView.getBarManager().updateContextMenu();
            this._contextMenuBar.show(e.position)
        }
    }, {
        key: "_executeCoreCommand",
        value: function(id) {
            this._ganttView.executeCoreCommand(id)
        }
    }, {
        key: "_clean",
        value: function() {
            delete this._ganttView;
            delete this._dialogInstance;
            _get(_getPrototypeOf(Gantt.prototype), "_clean", this).call(this)
        }
    }, {
        key: "_getDefaultOptions",
        value: function() {
            return (0, _extend.extend)(_get(_getPrototypeOf(Gantt.prototype), "_getDefaultOptions", this).call(this), {
                tasks: {
                    dataSource: null,
                    keyExpr: "id",
                    parentIdExpr: "parentId",
                    startExpr: "start",
                    endExpr: "end",
                    progressExpr: "progress",
                    titleExpr: "title",
                    colorExpr: "color"
                },
                dependencies: {
                    dataSource: null,
                    keyExpr: "id",
                    predecessorIdExpr: "predecessorId",
                    successorIdExpr: "successorId",
                    typeExpr: "type"
                },
                resources: {
                    dataSource: null,
                    keyExpr: "id",
                    textExpr: "text",
                    colorExpr: "color"
                },
                resourceAssignments: {
                    dataSource: null,
                    keyExpr: "id",
                    taskIdExpr: "taskId",
                    resourceIdExpr: "resourceId"
                },
                columns: void 0,
                taskListWidth: 300,
                showResources: true,
                taskTitlePosition: "inside",
                firstDayOfWeek: void 0,
                selectedRowKey: void 0,
                onSelectionChanged: null,
                allowSelection: true,
                showRowLines: true,
                stripLines: void 0,
                scaleType: "auto",
                editing: {
                    enabled: false,
                    allowTaskAdding: true,
                    allowTaskDeleting: true,
                    allowTaskUpdating: true,
                    allowDependencyAdding: true,
                    allowDependencyDeleting: true,
                    allowResourceAdding: true,
                    allowResourceDeleting: true,
                    allowResourceUpdating: true
                },
                validation: {
                    validateDependencies: false,
                    autoUpdateParentTasks: false
                },
                toolbar: null
            })
        }
    }, {
        key: "_optionChanged",
        value: function(args) {
            switch (args.name) {
                case "tasks":
                    this._refreshDataSource(GANTT_TASKS);
                    break;
                case "dependencies":
                    this._refreshDataSource(GANTT_DEPENDENCIES);
                    break;
                case "resources":
                    this._refreshDataSource(GANTT_RESOURCES);
                    break;
                case "resourceAssignments":
                    this._refreshDataSource(GANTT_RESOURCE_ASSIGNMENTS);
                    break;
                case "columns":
                    this._setTreeListOption("columns", this.option(args.name));
                    break;
                case "taskListWidth":
                    this._setInnerElementsWidth();
                    break;
                case "showResources":
                    this._setGanttViewOption("showResources", args.value);
                    break;
                case "taskTitlePosition":
                    this._setGanttViewOption("taskTitlePosition", args.value);
                    break;
                case "firstDayOfWeek":
                    this._setGanttViewOption("firstDayOfWeek", args.value);
                    break;
                case "selectedRowKey":
                    this._setTreeListOption("selectedRowKeys", this._getArrayFromOneElement(args.value));
                    break;
                case "onSelectionChanged":
                    this._createSelectionChangedAction();
                    break;
                case "allowSelection":
                    this._setTreeListOption("selection.mode", this._getSelectionMode(args.value));
                    this._setGanttViewOption("allowSelection", args.value);
                    break;
                case "showRowLines":
                    this._setTreeListOption("showRowLines", args.value);
                    this._setGanttViewOption("showRowLines", args.value);
                    break;
                case "stripLines":
                    this._setGanttViewOption("stripLines", args.value);
                    break;
                case "scaleType":
                    this._setGanttViewOption("scaleType", args.value);
                    break;
                case "editing":
                    this._setGanttViewOption("editing", this.option(args.name));
                    break;
                case "validation":
                    this._setGanttViewOption("validation", this.option(args.name));
                    break;
                case "toolbar":
                    this._updateToolbarContent();
                    break;
                default:
                    _get(_getPrototypeOf(Gantt.prototype), "_optionChanged", this).call(this, args)
            }
        }
    }]);
    return Gantt
}(_ui2.default);
(0, _component_registrator2.default)("dxGantt", Gantt);
module.exports = Gantt;
