@syncfusion/ej2-gantt 19.4.55 → 20.1.47-1460716

package/dist/ts/gantt/actions/excel-export.ts

@@ -0,0 +1,61 @@
+import { TreeGrid, ExcelExport as TreeGridExcel } from '@syncfusion/ej2-treegrid';
+import { Gantt } from '../base/gantt';
+import { ExcelExportCompleteArgs, ExcelHeaderQueryCellInfoEventArgs, ExcelQueryCellInfoEventArgs } from '@syncfusion/ej2-grids';
+
+/**
+ * Gantt Excel Export module
+ *
+ * @hidden
+ */
+export class ExcelExport {
+    private parent: Gantt;
+    /**
+     * Constructor for Excel Export module
+     *
+     * @param {Gantt} gantt .
+     */
+    constructor(gantt: Gantt) {
+        this.parent = gantt;
+        TreeGrid.Inject(TreeGridExcel);
+        this.parent.treeGrid.allowExcelExport = this.parent.allowExcelExport;
+        this.bindEvents();
+    }
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @returns {string} .
+     * @private
+     */
+    protected getModuleName(): string {
+        return 'excelExport';
+    }
+    /**
+     * To destroy excel export module.
+     *
+     * @returns {void} .
+     * @private
+     */
+    public destroy(): void {
+        // Destroy Method
+    }
+    /**
+     * To bind excel exporting events.
+     *
+     * @returns {void} .
+     * @private
+     */
+    private bindEvents(): void {
+        this.parent.treeGrid.beforeExcelExport = (args: Object) => {
+            this.parent.trigger('beforeExcelExport', args);
+        };
+        this.parent.treeGrid.excelQueryCellInfo = (args: ExcelQueryCellInfoEventArgs) => {
+            this.parent.trigger('excelQueryCellInfo', args);
+        };
+        this.parent.treeGrid.excelHeaderQueryCellInfo = (args: ExcelHeaderQueryCellInfoEventArgs) => {
+            this.parent.trigger('excelHeaderQueryCellInfo', args);
+        };
+        this.parent.treeGrid.excelExportComplete = (args: ExcelExportCompleteArgs) => {
+            this.parent.trigger('excelExportComplete', args);
+        };
+    }
+}

package/dist/ts/gantt/actions/filter.ts

@@ -0,0 +1,302 @@
+import { TreeGrid, Filter as TreeGridFilter, FilterSettingsModel as TreeFilterSettingsModel } from '@syncfusion/ej2-treegrid';
+import { FilterEventArgs, filterAfterOpen, GroupEventArgs, getFilterMenuPostion, ColumnMenuOpenEventArgs } from '@syncfusion/ej2-grids';
+import { getActualProperties, IFilterMUI, Filter as GridFilter, getCustomDateFormat } from '@syncfusion/ej2-grids';
+import { Gantt } from '../base/gantt';
+import { FilterSettingsModel, ColumnModel, TaskFieldsModel } from '../models/models';
+import { getValue, isNullOrUndefined, remove, createElement, addClass, closest } from '@syncfusion/ej2-base';
+import { DropDownList } from '@syncfusion/ej2-dropdowns';
+import { NumericTextBox, TextBox } from '@syncfusion/ej2-inputs';
+import { DatePicker, DateTimePicker } from '@syncfusion/ej2-calendars';
+
+/**
+ * The Filter module is used to handle filter action.
+ */
+
+export class Filter {
+    public parent: Gantt;
+    private filterMenuElement: HTMLElement;
+    constructor(gantt: Gantt) {
+        this.parent = gantt;
+        TreeGrid.Inject(TreeGridFilter);
+        this.parent.treeGrid.allowFiltering = this.parent.allowFiltering;
+        this.updateCustomFilters();
+        this.parent.treeGrid.filterSettings = getActualProperties(this.parent.filterSettings) as TreeFilterSettingsModel;
+        this.addEventListener();
+    }
+
+    private getModuleName(): string {
+        return 'filter';
+    }
+    /**
+     * Update custom filter for default Gantt columns
+     *
+     * @returns {void} .
+     */
+    private updateCustomFilters(): void {
+        const settings: TaskFieldsModel = this.parent.taskFields;
+        for (let i: number = 0; i < this.parent.ganttColumns.length; i++) {
+            const column: ColumnModel = this.parent.ganttColumns[i];
+            if (((column.editType === 'datepickeredit' || column.editType === 'datetimepickeredit') &&
+                (column.field === settings.startDate || column.field === settings.endDate
+                    || column.field === settings.baselineStartDate || column.field === settings.baselineEndDate)) ||
+                (column.field === settings.duration && column.editType === 'stringedit')) {
+                this.initiateFiltering(this.parent.ganttColumns[i]);
+            }
+        }
+    }
+
+    private updateModel(): void {
+        this.parent.filterSettings = this.parent.treeGrid.filterSettings as FilterSettingsModel;
+    }
+    private addEventListener(): void {
+        this.parent.on('updateModel', this.updateModel, this);
+        this.parent.on('actionBegin', this.actionBegin, this);
+        this.parent.on('actionComplete', this.actionComplete, this);
+        this.parent.on('columnMenuOpen', this.columnMenuOpen, this);
+    }
+
+    private initiateFiltering(column: ColumnModel): void {
+        const treeColumn: ColumnModel = this.parent.getColumnByField(column.field, this.parent.treeGridModule.treeGridColumns);
+        column.allowFiltering = column.allowFiltering === false ? false : true;
+        if (column.allowFiltering && this.parent.filterSettings.type === 'Menu' && !column.filter) {
+            column.filter = { ui: this.getCustomFilterUi(column) };
+        }
+        if (treeColumn) {
+            treeColumn.allowFiltering = column.allowFiltering;
+            treeColumn.filter = column.allowFiltering ? column.filter : {};
+        }
+    }
+
+    /**
+     * To get filter menu UI
+     *
+     * @param {ColumnModel} column .
+     * @returns {IFilterMUI} .
+     */
+    private getCustomFilterUi(column: ColumnModel): IFilterMUI {
+        const settings: TaskFieldsModel = this.parent.taskFields;
+        let filterUI: IFilterMUI = {};
+        if (column.editType === 'datepickeredit' && (column.field === settings.startDate || column.field === settings.endDate
+            || column.field === settings.baselineStartDate || column.field === settings.baselineEndDate)) {
+            filterUI = this.getDatePickerFilter(column.field);
+        } else if (column.editType === 'datetimepickeredit' && (column.field === settings.startDate || column.field === settings.endDate
+            || column.field === settings.baselineStartDate || column.field === settings.baselineEndDate)) {
+            filterUI = this.getDateTimePickerFilter();
+        } else if (column.field === settings.duration && column.editType === 'stringedit') {
+            filterUI = this.getDurationFilter();
+        }
+        return filterUI;
+    }
+
+    private getDatePickerFilter(columnName: string): IFilterMUI {
+        const parent: Gantt = this.parent;
+        const timeValue: number = (columnName === parent.taskFields.startDate) || (columnName === parent.taskFields.baselineStartDate)
+            ? parent.defaultStartTime : parent.defaultEndTime;
+        let dropDateInstance: DatePicker;
+        const filterDateUI: IFilterMUI = {
+            create: (args: { target: Element, column: ColumnModel }) => {
+                const format: string = getCustomDateFormat(args.column.format, args.column.type);
+                const flValInput: HTMLElement = createElement('input', { className: 'flm-input' });
+                args.target.appendChild(flValInput);
+                dropDateInstance = new DatePicker({ placeholder: this.parent.localeObj.getConstant('enterValue'), format: format });
+                dropDateInstance.appendTo(flValInput);
+            },
+            write: (args: {
+                filteredValue: Date
+            }) => {
+                dropDateInstance.value = args.filteredValue;
+            },
+            read: (args: { target: Element, column: ColumnModel, operator: string, fltrObj: GridFilter }) => {
+                if (dropDateInstance.value) {
+                    dropDateInstance.value.setSeconds(timeValue);
+                }
+                args.fltrObj.filterByColumn(args.column.field, args.operator, dropDateInstance.value);
+            }
+        };
+        return filterDateUI;
+    }
+
+    private getDateTimePickerFilter(): IFilterMUI {
+        let dropInstance: DateTimePicker;
+        const filterDateTimeUI: IFilterMUI = {
+            create: (args: { target: Element, column: ColumnModel }) => {
+                const format: string = getCustomDateFormat(args.column.format, args.column.type);
+                const flValInput: HTMLElement = createElement('input', { className: 'flm-input' });
+                args.target.appendChild(flValInput);
+                dropInstance = new DateTimePicker({ placeholder: this.parent.localeObj.getConstant('enterValue'), format: format });
+                dropInstance.appendTo(flValInput);
+            },
+            write: (args: {
+                filteredValue: Date
+            }) => {
+                dropInstance.value = args.filteredValue;
+            },
+            read: (args: { target: Element, column: ColumnModel, operator: string, fltrObj: GridFilter }) => {
+                args.fltrObj.filterByColumn(args.column.field, args.operator, dropInstance.value);
+            }
+        };
+        return filterDateTimeUI;
+    }
+
+    private getDurationFilter(): IFilterMUI {
+        const parent: Gantt = this.parent;
+        let textBoxInstance: TextBox;
+        let textValue: string = '';
+        const filterDurationUI: IFilterMUI = {
+            create: (args: { target: Element, column: Object }) => {
+                const flValInput: HTMLElement = createElement('input', { className: 'e-input' });
+                flValInput.setAttribute('placeholder', this.parent.localeObj.getConstant('enterValue'));
+                args.target.appendChild(flValInput);
+                textBoxInstance = new TextBox();
+                textBoxInstance.appendTo(flValInput);
+            },
+            write: (args: {
+                filteredValue: string
+            }) => {
+                textBoxInstance.value = args.filteredValue ? textValue : '';
+            },
+            read: (args: { element: HTMLInputElement, column: ColumnModel, operator: string, fltrObj: GridFilter }) => {
+                const durationObj: object = this.parent.dataOperation.getDurationValue(textBoxInstance.value);
+                const intVal: number = getValue('duration', durationObj);
+                let unit: string = getValue('durationUnit', durationObj);
+                if (intVal >= 0) {
+                    let dayVal: number;
+                    if (unit === 'minute') {
+                        dayVal = (intVal * 60) / parent.secondsPerDay;
+                    } else if (unit === 'hour') {
+                        dayVal = (intVal * 60 * 60) / parent.secondsPerDay;
+                    } else {
+                        //Consider it as day unit
+                        dayVal = intVal;
+                        unit = 'day';
+                    }
+                    args.fltrObj.filterByColumn(args.column.field, args.operator, dayVal);
+                    textValue = this.parent.dataOperation.getDurationString(intVal, unit);
+                } else {
+                    args.fltrObj.filterByColumn(args.column.field, args.operator, null);
+                    textValue = null;
+                }
+            }
+        };
+        return filterDurationUI;
+    }
+
+    /**
+     * Remove filter menu while opening column chooser menu
+     *
+     * @param {ColumnMenuOpenEventArgs} args .
+     * @returns {void} .
+     */
+    private columnMenuOpen(args: ColumnMenuOpenEventArgs): void {// eslint-disable-line
+        if (this.filterMenuElement && document.body.contains(this.filterMenuElement)) {
+            remove(this.filterMenuElement);
+        }
+        this.filterMenuElement = null;
+    }
+    // eslint-disable-next-line
+    private actionBegin(args: FilterEventArgs): void {
+        // ...
+    }
+    public closeFilterOnContextClick(element: Element): void {
+        if (this.filterMenuElement && document.body.contains(this.filterMenuElement)) {
+            const ganttElement: Element = closest(element, '#' + this.parent.element.id)
+                || element.querySelector('#' + this.parent.element.id);
+            if ((!(this.filterMenuElement.contains(element)) && !isNullOrUndefined(ganttElement)) || element.nodeName === 'HTML'
+                || ((element.nodeName === 'DIV') && (!element.classList.contains('e-day')))) {
+                remove(this.filterMenuElement);
+                this.parent.treeGrid.grid.notify('filter-menu-close', { isOpen: false });
+                this.filterMenuElement = null;
+            }
+        }
+    }
+    private actionComplete(args: GroupEventArgs): void {
+        if (args.requestType === filterAfterOpen) {
+            if (this.parent.treeGrid.filterSettings.type === 'Menu') {
+                this.filterMenuElement = getValue('filterModel.dlgObj.element', args);
+            }
+            else {
+                this.filterMenuElement = getValue('filterModel.dialogObj.element', args);
+            }
+            this.updateFilterMenuPosition(this.filterMenuElement, args);
+            // To set default values as 'contains' in filter dialog
+            const taskID: string = this.parent.taskFields.id;
+            const predecessor: string = this.parent.taskFields.dependency;
+            const resource: string = this.parent.taskFields.resourceInfo;
+            const filterObj: object = this.parent.treeGrid.grid.filterModule;
+            const filterValues: object = getValue('values', filterObj);
+            if ((args.columnName === predecessor && isNullOrUndefined(getValue(predecessor, filterValues)))
+                || (args.columnName === resource && isNullOrUndefined(getValue(resource, filterValues)))) {
+                const element: HTMLElement = this.filterMenuElement.querySelector('.e-dropdownlist');
+                const instanceObj: DropDownList = getValue('ej2_instances[0]', element);
+                instanceObj.index = 2;
+                instanceObj.dataBind();
+            } else if (args.columnName === taskID && isNullOrUndefined(getValue(taskID, filterValues)) && this.parent.treeGrid.filterSettings.type === 'Menu') {
+                const element: HTMLElement = this.filterMenuElement.querySelector('.e-numerictextbox');
+                const instanceObj: NumericTextBox = getValue('ej2_instances[0]', element);
+                if (!isNullOrUndefined(instanceObj) && isNullOrUndefined(this.parent.columnByField[args.columnName].format)) {
+                    instanceObj.format = 'n';
+                }
+            }
+        }
+    }
+    private setPosition(li: Element, ul: HTMLElement): void {
+        const gridPos: ClientRect = this.parent.element.getBoundingClientRect();
+        const liPos: ClientRect = li.getBoundingClientRect();
+        let left: number = liPos.right + window.scrollX;
+        const top: number = liPos.top + window.scrollY;
+
+        if (gridPos.right < (left + ul.offsetWidth)) {
+            if ((liPos.left - ul.offsetWidth) > gridPos.left) {
+                left = (liPos.left - ul.offsetWidth);
+            } else {
+                left -= (left + ul.offsetWidth) - gridPos.right;
+            }
+        }
+        ul.style.top = top + 'px';
+        ul.style.left = left + 'px';
+    }
+
+    private updateFilterMenuPosition(element: HTMLElement, args: GroupEventArgs): void {
+        addClass([element], 'e-gantt');
+        document.body.appendChild(element);
+        let targetElement: HTMLElement;
+        if (this.parent.showColumnMenu) {
+            targetElement = document.querySelector('#treeGrid' + this.parent.controlId + '_gridcontrol_colmenu_Filter');
+            element.style.zIndex = targetElement.parentElement.style.zIndex;
+            if (this.parent.treeGrid.filterSettings.type === 'Menu') {
+                this.setPosition(targetElement, getValue('filterModel.dlgObj.element', args));
+            }
+            else {
+                this.setPosition(targetElement, getValue('filterModel.dialogObj.element', args));
+            }
+        } else {
+            targetElement = this.parent.treeGrid.grid.getColumnHeaderByField(args.columnName).querySelector('.e-filtermenudiv');
+            if (this.parent.treeGrid.filterSettings.type === 'Menu') {
+                getFilterMenuPostion(targetElement, getValue('filterModel.dlgObj', args));
+            }
+            else {
+                getFilterMenuPostion(targetElement, getValue('filterModel.dialogObj', args));
+            }
+        }
+        if (this.parent.treeGrid.filterSettings.type === 'Menu') {
+            (element.querySelector('.e-valid-input') as HTMLElement).focus();
+        }
+    }
+    private removeEventListener(): void {
+        if (this.parent.isDestroyed) {
+            return;
+        }
+        this.parent.off('updateModel', this.updateModel);
+        this.parent.off('actionBegin', this.actionBegin);
+        this.parent.off('actionComplete', this.actionComplete);
+        this.parent.off('columnMenuOpen', this.columnMenuOpen);
+    }
+    /**
+     * To destroy module
+     *
+     * @returns {void} .
+     */
+    public destroy(): void {
+        this.removeEventListener();
+    }
+}

package/dist/ts/gantt/actions/keyboard.ts

@@ -0,0 +1,306 @@
+import { Gantt } from '../base/gantt';
+import { KeyboardEventArgs, isNullOrUndefined, getValue } from '@syncfusion/ej2-base';
+import { IKeyPressedEventArgs, IGanttData, ColumnModel, ITaskData } from '..';
+import { TextBox } from '@syncfusion/ej2-inputs';
+import { ISelectedCell, IIndex } from '@syncfusion/ej2-grids';
+import { ContextMenu } from '@syncfusion/ej2-navigations/src/context-menu';
+interface EJ2Instance extends HTMLElement {
+    // eslint-disable-next-line
+    ej2_instances: Object[];
+}
+/**
+ * Focus module is used to handle certain action on focus elements in keyboard navigations.
+ */
+
+export class FocusModule {
+    private parent: Gantt;
+    private activeElement: HTMLElement;
+    private previousActiveElement: HTMLElement;
+    constructor(parent: Gantt) {
+        this.parent = parent;
+        this.activeElement = null;
+        this.previousActiveElement = null;
+    }
+
+    public getActiveElement(isPreviousActiveElement?: boolean): HTMLElement {
+        return isPreviousActiveElement ? this.previousActiveElement : this.activeElement;
+    }
+
+    public setActiveElement(element: HTMLElement): void {
+        this.previousActiveElement = this.activeElement;
+        this.activeElement = element;
+    }
+
+    /**
+     * To perform key interaction in Gantt
+     *
+     * @param {KeyboardEventArgs} e .
+     * @returns {void} .
+     * @private
+     */
+    public onKeyPress(e: KeyboardEventArgs): void | boolean {
+        const ganttObj: Gantt = this.parent;
+        const expandedRecords: IGanttData[] = ganttObj.getExpandedRecords(ganttObj.currentViewData);
+        if (isNullOrUndefined(this.parent.focusModule.getActiveElement()) && (e.action === 'expandAll' || e.action === 'collapseAll')) {
+            const focussedElement: HTMLElement = this.parent.element.querySelector('.e-treegrid');
+            focussedElement.focus();
+        }
+        const targetElement: Element = this.parent.focusModule.getActiveElement();
+        if (e.action === 'home' || e.action === 'end' || e.action === 'downArrow' || e.action === 'upArrow' || e.action === 'delete' ||
+            e.action === 'rightArrow' || e.action === 'leftArrow' || e.action === 'focusTask' || e.action === 'focusSearch' ||
+            e.action === 'expandAll' || e.action === 'collapseAll') {
+            if (!isNullOrUndefined(ganttObj.editModule) && !isNullOrUndefined(ganttObj.editModule.cellEditModule) &&
+                ganttObj.editModule.cellEditModule.isCellEdit === true) {
+                return;
+            }
+        }
+        if (ganttObj.isAdaptive) {
+            if (e.action === 'addRowDialog' || e.action === 'editRowDialog' || e.action === 'delete'
+                || e.action === 'addRow') {
+                if (ganttObj.selectionModule && ganttObj.selectionSettings.type === 'Multiple') {
+                    ganttObj.selectionModule.hidePopUp();
+                    (<HTMLElement>document.getElementsByClassName('e-gridpopup')[0]).style.display = 'none';
+                }
+            }
+        }
+        switch (e.action) {
+        case 'home':
+            if (ganttObj.selectionModule && ganttObj.selectionSettings.mode !== 'Cell') {
+                if (ganttObj.selectedRowIndex === 0) {
+                    return;
+                }
+                ganttObj.selectionModule.selectRow(0, false, true);
+            }
+            break;
+        case 'end':
+            if (ganttObj.selectionModule && ganttObj.selectionSettings.mode !== 'Cell') {
+                const currentSelectingRecord: IGanttData = expandedRecords[expandedRecords.length - 1];
+                if (ganttObj.selectedRowIndex === ganttObj.flatData.indexOf(currentSelectingRecord)) {
+                    return;
+                }
+                ganttObj.selectionModule.selectRow(ganttObj.flatData.indexOf(currentSelectingRecord), false, true);
+            }
+            break;
+        case 'downArrow':
+        case 'upArrow':
+        {
+            const searchElement: HTMLInputElement = ganttObj.element.querySelector('#' + ganttObj.element.id + '_searchbar');
+            if (searchElement && searchElement.parentElement.classList.contains('e-input-focus')) {
+                ganttObj.selectionModule.clearSelection();
+            }
+            if (!ganttObj.element.classList.contains('e-scroll-disabled')) {
+                this.upDownKeyNavigate(e);
+                if (!isNullOrUndefined(targetElement) && !isNullOrUndefined(targetElement.closest('.e-chart-row'))) {
+                    ganttObj.ganttChartModule.manageFocus(this.getActiveElement(), 'remove', true);
+                }
+            }
+            break;
+        }
+        case 'expandAll':
+            ganttObj.ganttChartModule.expandCollapseAll('expand');
+            break;
+        case 'collapseAll':
+            ganttObj.ganttChartModule.expandCollapseAll('collapse');
+            break;
+        case 'expandRow':
+        case 'collapseRow':
+            this.expandCollapseKey(e);
+            break;
+        case 'saveRequest':
+            if (!isNullOrUndefined(ganttObj.editModule) && !isNullOrUndefined(ganttObj.editModule.cellEditModule) &&
+                ganttObj.editModule.cellEditModule.isCellEdit) {
+                const col: ColumnModel = ganttObj.editModule.cellEditModule.editedColumn;
+                if (col.field === ganttObj.columnMapping.duration && !isNullOrUndefined(col.edit) &&
+                        !isNullOrUndefined(col.edit.read)) {
+                    const textBox: TextBox = <TextBox>(<EJ2Instance>e.target).ej2_instances[0];
+                    const textValue: string = (e.target as HTMLInputElement).value;
+                    const ganttProp: ITaskData = ganttObj.currentViewData[ganttObj.selectedRowIndex].ganttProperties;
+                    let tempValue: string | Date | number;
+                    if (col.field === ganttObj.columnMapping.duration) {
+                        tempValue = !isNullOrUndefined(col.edit) && !isNullOrUndefined(col.edit.read) ? (col.edit.read as Function)() :
+                            // eslint-disable-next-line
+                            !isNullOrUndefined(col.valueAccessor) ? (col.valueAccessor as Function)(ganttObj.columnMapping.duration, ganttObj.editedRecords, col) :
+                                ganttObj.dataOperation.getDurationString(ganttProp.duration, ganttProp.durationUnit);
+                        if (textValue !== tempValue.toString()) {
+                            textBox.value = textValue;
+                            textBox.dataBind();
+                        }
+                    }
+                }
+                if (ganttObj.editModule.dialogModule.dialogObj && getValue('dialogOpen', ganttObj.editModule.dialogModule.dialogObj)) {
+                    return;
+                }
+                ganttObj.editModule.cellEditModule.isCellEdit = false;
+                ganttObj.treeGrid.grid.saveCell();
+                const focussedElement: HTMLElement = <HTMLElement>ganttObj.element.querySelector('.e-treegrid');
+                focussedElement.focus();
+            }
+            if (!isNullOrUndefined(this.parent.onTaskbarClick) && !isNullOrUndefined(targetElement)
+                && !isNullOrUndefined(targetElement.closest('.e-chart-row'))) {
+                const target: EventTarget = e.target;
+                const taskbarElement: Element = targetElement.querySelector('.e-gantt-parent-taskbar,' +
+                        '.e-gantt-child-taskbar,.e-gantt-milestone');
+                if (taskbarElement) {
+                    this.parent.ganttChartModule.onTaskbarClick(e, target, taskbarElement);
+                }
+            }
+            break;
+        case 'cancelRequest':
+            if (!isNullOrUndefined(ganttObj.editModule) && !isNullOrUndefined(ganttObj.editModule.cellEditModule)) {
+                ganttObj.editModule.cellEditModule.isCellEdit = false;
+                if (!isNullOrUndefined(ganttObj.toolbarModule)) {
+                    ganttObj.toolbarModule.refreshToolbarItems();
+                }
+            }
+            break;
+        case 'addRow':
+        {
+            if (isNullOrUndefined(document.getElementById(this.parent.element.id + '_dialog'))) {
+                e.preventDefault();
+                ganttObj.addRecord(undefined, this.parent.editSettings.newRowPosition);
+                const focussedElement: HTMLElement = <HTMLElement>ganttObj.element;
+                focussedElement.focus();
+            }
+            break;
+        }
+        case 'addRowDialog':
+            e.preventDefault();
+            if (ganttObj.editModule && ganttObj.editModule.dialogModule && ganttObj.editSettings.allowAdding) {
+                if (ganttObj.editModule.dialogModule.dialogObj && getValue('dialogOpen', ganttObj.editModule.dialogModule.dialogObj)) {
+                    return;
+                }
+                ganttObj.editModule.dialogModule.openAddDialog();
+            }
+            break;
+        case 'editRowDialog':
+        {
+            e.preventDefault();
+            const focussedTreeElement: HTMLElement = <HTMLElement>ganttObj.element.querySelector('.e-treegrid');
+            focussedTreeElement.focus();
+            if (ganttObj.editModule && ganttObj.editModule.dialogModule && ganttObj.editSettings.allowEditing) {
+                if (ganttObj.editModule.dialogModule.dialogObj && getValue('dialogOpen', ganttObj.editModule.dialogModule.dialogObj)) {
+                    return;
+                }
+                ganttObj.editModule.dialogModule.openToolbarEditDialog();
+            }
+            break;
+        }
+        case 'delete':
+            if (ganttObj.selectionModule && ganttObj.editModule && (!ganttObj.editModule.dialogModule.dialogObj ||
+                     (ganttObj.editModule.dialogModule.dialogObj &&
+                    !ganttObj.editModule.dialogModule.dialogObj.visible)) && (!ganttObj.editSettings.allowTaskbarEditing
+                    || (ganttObj.editSettings.allowTaskbarEditing && !ganttObj.editModule.taskbarEditModule.touchEdit))) {
+                if ((ganttObj.selectionSettings.mode !== 'Cell' && ganttObj.selectionModule.selectedRowIndexes.length)
+                        || (ganttObj.selectionSettings.mode === 'Cell' && ganttObj.selectionModule.getSelectedRowCellIndexes().length)) {
+                    ganttObj.editModule.startDeleteAction();
+                }
+            }
+            break;
+        case 'focusTask':
+        {
+            e.preventDefault();
+            let selectedId: string;
+            if (ganttObj.selectionModule) {
+                const currentViewData: IGanttData[] = ganttObj.currentViewData;
+                if (ganttObj.selectionSettings.mode !== 'Cell' &&
+                    !isNullOrUndefined(currentViewData[ganttObj.selectedRowIndex])) {
+                    selectedId = ganttObj.currentViewData[ganttObj.selectedRowIndex].ganttProperties.rowUniqueID;
+                } else if (ganttObj.selectionSettings.mode === 'Cell' &&
+                        ganttObj.selectionModule.getSelectedRowCellIndexes().length > 0) {
+                    const selectCellIndex: ISelectedCell[] = ganttObj.selectionModule.getSelectedRowCellIndexes();
+                    selectedId = currentViewData[selectCellIndex[selectCellIndex.length - 1].rowIndex].ganttProperties.rowUniqueID;
+                }
+            }
+            if (selectedId) {
+                ganttObj.scrollToTask(selectedId.toString());
+            }
+            break;
+        }
+        case 'focusSearch':
+        {
+            if (<HTMLInputElement>ganttObj.element.querySelector('#' + ganttObj.element.id + '_searchbar')) {
+                const searchElement: HTMLInputElement =
+                        <HTMLInputElement>ganttObj.element.querySelector('#' + ganttObj.element.id + '_searchbar');
+                searchElement.setAttribute('tabIndex', '-1');
+                searchElement.focus();
+            }
+            break;
+        }
+        case 'tab':
+        case 'shiftTab':
+            if (!ganttObj.element.classList.contains('e-scroll-disabled')) {
+                ganttObj.ganttChartModule.onTabAction(e);
+            }
+            break;
+        case 'contextMenu':
+        {
+            const contextMenu: ContextMenu = <ContextMenu>(<EJ2Instance>document.getElementById(this.parent.element.id +
+                    '_contextmenu')).ej2_instances[0];
+            const containerPosition: { top: number, left: number, width?: number, height?: number } =
+                    this.parent.getOffsetRect(e.target as HTMLElement);
+            const top: number = containerPosition.top + (containerPosition.height / 2);
+            const left: number = containerPosition.left + (containerPosition.width / 2);
+            this.setActiveElement(e.target as HTMLElement);
+            contextMenu.open(top, left);
+            e.preventDefault();
+            break;
+        }
+        default:
+        {
+            const eventArgs: IKeyPressedEventArgs = {
+                requestType: 'keyPressed',
+                action: e.action,
+                keyEvent: e
+            };
+            ganttObj.trigger('actionComplete', eventArgs);
+            break;
+        }
+        }
+    }
+    private upDownKeyNavigate(e: KeyboardEventArgs): void {
+        e.preventDefault();
+        const ganttObj: Gantt = this.parent;
+        const expandedRecords: IGanttData[] = ganttObj.getExpandedRecords(ganttObj.currentViewData);
+        if (ganttObj.selectionModule) {
+            if (ganttObj.selectionSettings.mode !== 'Cell' && ganttObj.selectedRowIndex !== -1) {
+                const selectedItem: IGanttData = ganttObj.currentViewData[ganttObj.selectedRowIndex];
+                const focusedRowIndex: number = this.parent.ganttChartModule.focusedRowIndex;
+                const selectingRowIndex: number = focusedRowIndex > -1 ? focusedRowIndex : expandedRecords.indexOf(selectedItem);
+                const currentSelectingRecord: IGanttData = e.action === 'downArrow' ? expandedRecords[selectingRowIndex + 1] :
+                    expandedRecords[selectingRowIndex - 1];
+                ganttObj.selectionModule.selectRow(ganttObj.currentViewData.indexOf(currentSelectingRecord), false, true);
+            } else if (ganttObj.selectionSettings.mode === 'Cell' && ganttObj.selectionModule.getSelectedRowCellIndexes().length > 0) {
+                const selectCellIndex: ISelectedCell[] = ganttObj.selectionModule.getSelectedRowCellIndexes();
+                const selectedCellItem: ISelectedCell = selectCellIndex[selectCellIndex.length - 1];
+                const currentCellIndex: number = selectedCellItem.cellIndexes[selectedCellItem.cellIndexes.length - 1];
+                const selectedItem: IGanttData = ganttObj.currentViewData[selectedCellItem.rowIndex];
+                const selectingRowIndex: number = expandedRecords.indexOf(selectedItem);
+                const currentSelectingRecord: IGanttData = e.action === 'downArrow' ? expandedRecords[selectingRowIndex + 1] :
+                    expandedRecords[selectingRowIndex - 1];
+                const cellInfo: IIndex = {
+                    rowIndex: ganttObj.currentViewData.indexOf(currentSelectingRecord),
+                    cellIndex: currentCellIndex
+                };
+                ganttObj.selectionModule.selectCell(cellInfo);
+            }
+            this.parent.ganttChartModule.focusedRowIndex = this.parent.selectedRowIndex;
+        }
+    }
+    private expandCollapseKey(e: KeyboardEventArgs): void {
+        const ganttObj: Gantt = this.parent;
+        if (ganttObj.selectionModule && ganttObj.selectedRowIndex !== -1) {
+            let selectedRowIndex: number;
+            if (ganttObj.selectionSettings.mode !== 'Cell') {
+                selectedRowIndex = ganttObj.selectedRowIndex;
+            } else if (ganttObj.selectionSettings.mode === 'Cell' && ganttObj.selectionModule.getSelectedRowCellIndexes().length > 0) {
+                const selectCellIndex: ISelectedCell[] = ganttObj.selectionModule.getSelectedRowCellIndexes();
+                selectedRowIndex = selectCellIndex[selectCellIndex.length - 1].rowIndex;
+            }
+            if (e.action === 'expandRow') {
+                ganttObj.expandByIndex(selectedRowIndex);
+            } else {
+                ganttObj.collapseByIndex(selectedRowIndex);
+            }
+        }
+    }
+}