@syncfusion/ej2-treegrid 31.1.17 → 31.1.20

package/dist/ts/treegrid/actions/sort.ts

@@ -1,149 +0,0 @@
-import { isNullOrUndefined } from '@syncfusion/ej2-base';
-import { DataManager, Query, QueryOptions } from '@syncfusion/ej2-data';
-import { ITreeData } from '../base/interface';
-import { TreeGrid } from '../base/treegrid';
-import { Sort as GridSort, Grid, SortDirection, getActualProperties } from '@syncfusion/ej2-grids';
-import { getParentData } from '../utils';
-
-/**
- * Internal dataoperations for TreeGrid
- *
- * @hidden
- */
-export class Sort {
-    // Internal variables
-    private flatSortedData: Object[];
-    private taskIds: Object[];
-    private storedIndex: number;
-    private parent: TreeGrid;
-    private isSelfReference: boolean;
-
-    constructor(grid: TreeGrid) {
-        Grid.Inject(GridSort);
-        this.parent = grid;
-        this.taskIds = [];
-        this.flatSortedData = [];
-        this.storedIndex = -1;
-        this.isSelfReference = !isNullOrUndefined(this.parent.parentIdMapping);
-        this.addEventListener();
-    }
-
-    /**
-     * For internal use only - Get the module name.
-     *
-     * @private
-     * @returns {string} Returns Sort module name
-     */
-    private getModuleName(): string {
-        return 'sort';
-    }
-    /**
-     * @hidden
-     */
-
-    public addEventListener(): void {
-        this.parent.on('updateModel', this.updateModel, this);
-        this.parent.on('createSort', this.createdSortedRecords, this);
-    }
-
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    public removeEventListener(): void {
-        if (this.parent.isDestroyed) { return; }
-        this.parent.off('updateModel', this.updateModel);
-        this.parent.off('createSort', this.createdSortedRecords);
-    }
-
-    private createdSortedRecords(sortParams: { modifiedData: ITreeData[], filteredData: ITreeData[], srtQry: Query }) : void {
-        const data: ITreeData[] = sortParams.modifiedData;
-        const srtQry: Query = sortParams.srtQry;
-        this.iterateSort(data, srtQry);
-        this.storedIndex = -1;
-        sortParams.modifiedData = this.flatSortedData;
-        this.flatSortedData = [];
-    }
-    private iterateSort(data: ITreeData[], srtQry: Query): void {
-        const gridQuery: Query = this.parent.query;
-        let filterQuery: QueryOptions[] = [];
-        if (!isNullOrUndefined(gridQuery)) {
-            filterQuery = gridQuery.queries.filter((q: QueryOptions) => q.fn === 'onWhere');
-        }
-        for (let d: number = 0; d < data.length; d++) {
-            if (filterQuery.length > 0 || this.parent.grid.filterSettings.columns.length > 0 || this.parent.grid.searchSettings.key !== '') {
-                if (!isNullOrUndefined(getParentData(this.parent, data[parseInt(d.toString(), 10)].uniqueID, true))) {
-                    this.storedIndex++;
-                    this.flatSortedData[this.storedIndex] = data[parseInt(d.toString(), 10)];
-                }
-            } else {
-                this.storedIndex++;
-                this.flatSortedData[this.storedIndex] = data[parseInt(d.toString(), 10)];
-            }
-            if (data[parseInt(d.toString(), 10)].hasChildRecords) {
-                const childSort: ITreeData[] = <ITreeData[]>(new DataManager(data[parseInt(d.toString(), 10)].childRecords)
-                    .executeLocal(srtQry));
-                if (this.parent.allowRowDragAndDrop && data[parseInt(d.toString(), 10)].childRecords.indexOf(this.parent.rowDragAndDropModule['draggedRecord']) !== -1 && this.parent.rowDragAndDropModule['dropPosition'] !== 'middleSegment') {
-                    const dragdIndex: number = childSort.indexOf(this.parent.rowDragAndDropModule['draggedRecord']);
-                    childSort.splice(dragdIndex, 1);
-                    const dropdIndex: number = childSort.indexOf(this.parent.rowDragAndDropModule['droppedRecord']);
-                    if (this.parent.rowDragAndDropModule['dropPosition'] === 'topSegment') {
-                        childSort.splice(dropdIndex, 0, this.parent.rowDragAndDropModule['draggedRecord']);
-                    }
-                    else if (this.parent.rowDragAndDropModule['dropPosition'] === 'bottomSegment') {
-                        childSort.splice(dropdIndex + 1, 0, this.parent.rowDragAndDropModule['draggedRecord']);
-                    }
-                }
-                this.iterateSort(childSort, srtQry);
-            }
-        }
-    }
-    /**
-     * Sorts a column with the given options.
-     *
-     * @param {string} columnName - Defines the column name to be sorted.
-     * @param {SortDirection} direction - Defines the direction of sorting field.
-     * @param {boolean} isMultiSort - Specifies whether the previous sorted columns are to be maintained.
-     * @returns {void}
-     */
-
-    public sortColumn(columnName: string, direction: SortDirection, isMultiSort?: boolean): void {
-        this.parent.grid.sortColumn(columnName, direction, isMultiSort);
-    }
-
-    public removeSortColumn(field: string): void {
-        this.parent.grid.removeSortColumn(field);
-    }
-
-    /**
-     * The function used to update sortSettings of TreeGrid.
-     *
-     * @returns {void}
-     * @hidden
-     */
-    private updateModel(): void {
-        this.parent.setProperties({sortSettings: getActualProperties(this.parent.grid.sortSettings)}, true);
-    }
-
-    /**
-     * Clears all the sorted columns of the TreeGrid.
-     *
-     * @returns {void}
-     */
-
-
-    public clearSorting(): void {
-        this.parent.grid.clearSorting();
-        this.updateModel();
-    }
-
-    /**
-     * Destroys the Sorting of TreeGrid.
-     *
-     * @function destroy
-     * @returns {void}
-     */
-    public destroy(): void {
-        this.removeEventListener();
-    }
-}

package/dist/ts/treegrid/actions/summary.d.ts

@@ -1,47 +0,0 @@
-import { TreeGrid } from '../base/treegrid';
-import { QueryOptions } from '@syncfusion/ej2-data';
-/**
- * TreeGrid Aggregate module
- *
- * @hidden
- */
-export declare class Aggregate {
-    private parent;
-    private flatChildRecords;
-    private summaryQuery;
-    /**
-     * Constructor for Aggregate module
-     *
-     * @param {TreeGrid} parent - Tree Grid instance
-     */
-    constructor(parent?: TreeGrid);
-    /**
-     * For internal use only - Get the module name.
-     *
-     * @private
-     * @returns {string} Returns Summary module name
-     */
-    private getModuleName;
-    removeEventListener(): void;
-    /**
-     * Function to calculate summary values
-     *
-     * @param {QueryOptions[]} summaryQuery - DataManager query for aggregate operations
-     * @param {Object[]} filteredData - Filtered data collection
-     * @param {boolean} isSort - Specified whether sorting operation performed
-     * @hidden
-     * @returns {Object[]} -  return flat records with summary values
-     */
-    calculateSummaryValue(summaryQuery: QueryOptions[], filteredData: Object[], isSort: boolean): Object[];
-    private getChildRecordsLength;
-    private createSummaryItem;
-    private getSummaryValues;
-    private getFormatFromType;
-    /**
-     * To destroy the Aggregate module
-     *
-     * @returns {void}
-     * @hidden
-     */
-    destroy(): void;
-}

package/dist/ts/treegrid/actions/summary.ts

@@ -1,231 +0,0 @@
-import { TreeGrid } from '../base/treegrid';
-import { QueryOptions, Query, DataManager } from '@syncfusion/ej2-data';
-import { getObject, AggregateType, calculateAggregate, Aggregate as GridAggregate, Grid, appendChildren } from '@syncfusion/ej2-grids';
-import { ITreeData } from '../base';
-import { findParentRecords } from '../utils';
-import { isNullOrUndefined, setValue, NumberFormatOptions, DateFormatOptions, createElement, extend } from '@syncfusion/ej2-base';
-import { AggregateColumn } from '../models/summary';
-import { AggregateRowModel } from '../models/summary-model';
-import { Column } from '../models';
-
-
-/**
- * TreeGrid Aggregate module
- *
- * @hidden
- */
-export class Aggregate {
-    private parent: TreeGrid;
-    private flatChildRecords: Object[];
-    private summaryQuery: QueryOptions[];
-    /**
-     * Constructor for Aggregate module
-     *
-     * @param {TreeGrid} parent - Tree Grid instance
-     */
-    constructor(parent?: TreeGrid) {
-        Grid.Inject(GridAggregate);
-        this.parent = parent;
-        this.flatChildRecords = [];
-        this.summaryQuery = [];
-    }
-
-    /**
-     * For internal use only - Get the module name.
-     *
-     * @private
-     * @returns {string} Returns Summary module name
-     */
-    private getModuleName(): string {
-        return 'summary';
-    }
-
-    public removeEventListener(): void {
-        if (this.parent.isDestroyed) { return; }
-    }
-
-    /**
-     * Function to calculate summary values
-     *
-     * @param {QueryOptions[]} summaryQuery - DataManager query for aggregate operations
-     * @param {Object[]} filteredData - Filtered data collection
-     * @param {boolean} isSort - Specified whether sorting operation performed
-     * @hidden
-     * @returns {Object[]} -  return flat records with summary values
-     */
-    public calculateSummaryValue(summaryQuery: QueryOptions[], filteredData: Object[], isSort: boolean): Object[] {
-        this.summaryQuery = summaryQuery;
-        let parentRecord: ITreeData;
-        const parentData: Object[] = filteredData.filter((data: Object) => !getObject('isSummaryRow', data));
-        const parentRecords: Object = findParentRecords(parentData);
-        const flatRecords: Object[] = (<Object[]>parentData).slice();
-        const summaryLength: number = Object.keys(this.parent.aggregates).length;
-        const dataLength: number = Object.keys(parentRecords).length; let childRecordsLength: number;
-        const columns: Column[] = this.parent.getColumns();
-        if (this.parent.aggregates.filter((x: AggregateRowModel) => x.showChildSummary).length) {
-            for (let i: number = 0, len: number = dataLength; i < len; i++) {
-                parentRecord = parentRecords[parseInt(i.toString(), 10)];
-                childRecordsLength = this.getChildRecordsLength(parentRecord, flatRecords);
-                if (childRecordsLength) {
-                    for (let summaryRowIndex: number = 1, len: number = summaryLength; summaryRowIndex <= len; summaryRowIndex++) {
-                        let item: Object; item = {};
-                        for (let i: number = 0; i < columns.length; i++) {
-                            const  field: string = (isNullOrUndefined(getObject('field', columns[parseInt(i.toString(), 10)]))) ?
-                                columns[parseInt(i.toString(), 10)] : getObject('field', (columns[parseInt(i.toString(), 10)]));
-                            item[`${field}`] = null;
-                        }
-                        item = this.createSummaryItem(item,  this.parent.aggregates[summaryRowIndex - 1]);
-                        if (this.parent.aggregates[summaryRowIndex - 1].showChildSummary) {
-                            let idx: number;
-                            flatRecords.map((e: ITreeData, i: number) => {
-                                if (e.uniqueID === parentRecord.uniqueID) { idx = i; return; } });
-                            const currentIndex: number = idx + childRecordsLength + summaryRowIndex;
-                            const summaryParent: ITreeData = extend({}, parentRecord);
-                            delete summaryParent.childRecords;
-                            delete summaryParent[this.parent.childMapping];
-                            setValue('parentItem', summaryParent, item);
-                            const level: number = getObject('level', summaryParent);
-                            setValue('level', level + 1, item);
-                            setValue('isSummaryRow', true, item);
-                            setValue('parentUniqueID', summaryParent.uniqueID, item);
-                            if (isSort) {
-                                const childRecords: Object[] = getObject('childRecords', parentRecord);
-                                if (childRecords.length) {
-                                    childRecords.push(item);
-                                }
-                            }
-                            flatRecords.splice(currentIndex, 0, item);
-                        } else {
-                            continue;
-                        }
-                    }
-                    this.flatChildRecords = [];
-                }
-            }
-        } else {
-            const items: Object = {};
-            for (let columnIndex: number = 0, length: number = columns.length; columnIndex < length; columnIndex++) {
-                const fields: string = isNullOrUndefined(getObject('field', columns[parseInt(columnIndex.toString(), 10)])) ?
-                    columns[parseInt(columnIndex.toString(), 10)] : getObject('field', columns[parseInt(columnIndex.toString(), 10)]);
-                items[`${fields}`] = null;
-            }
-            for (let summaryRowIndex: number = 1, length: number = summaryLength; summaryRowIndex <= length; summaryRowIndex++) {
-                this.createSummaryItem(items,  this.parent.aggregates[summaryRowIndex - 1]);
-            }
-        }
-        return flatRecords;
-    }
-
-    private getChildRecordsLength(parentData: ITreeData, flatData: Object[]): number {
-        const recordLength: number = Object.keys(flatData).length; let record: ITreeData;
-        for (let i: number = 0, len: number = recordLength; i < len; i++) {
-            record = flatData[parseInt(i.toString(), 10)];
-            const parent: Object = isNullOrUndefined(record.parentItem) ? null :
-                flatData.filter((e: ITreeData) => {return e.uniqueID === record.parentItem.uniqueID; })[0];
-            if (parentData === parent) {
-                this.flatChildRecords.push(record);
-                const hasChild: boolean = getObject('hasChildRecords', record);
-                if (hasChild) {
-                    this.getChildRecordsLength(record, flatData);
-                } else {
-                    continue;
-                }
-            }
-        }
-        return this.flatChildRecords.length;
-    }
-
-    private createSummaryItem(itemData: Object, summary: AggregateRowModel): Object {
-        const summaryColumnLength: number = Object.keys(summary.columns).length;
-        for (let i: number = 0, len: number = summaryColumnLength; i < len; i++) {
-            const displayColumn: string = isNullOrUndefined(summary.columns[parseInt(i.toString(), 10)].columnName) ?
-                summary.columns[parseInt(i.toString(), 10)].field : summary.columns[parseInt(i.toString(), 10)].columnName;
-            const keys: string[] = Object.keys(itemData);
-            for (const key of keys) {
-                if (key === displayColumn) {
-                    if (this.flatChildRecords.length) {
-                        itemData[`${key}`] = this.getSummaryValues(summary.columns[parseInt(i.toString(), 10)] as AggregateColumn, this.flatChildRecords);
-                    } else if (this.parent.isLocalData) {
-                        const data: Object[] = this.parent.dataSource instanceof DataManager ? this.parent.dataSource.dataSource.json
-                            : this.parent.flatData;
-                        itemData[`${key}`] = this.getSummaryValues(summary.columns[parseInt(i.toString(), 10)] as AggregateColumn, data);
-                    }
-                } else {
-                    continue;
-                }
-            }
-        }
-        return itemData;
-    }
-
-    private getSummaryValues(summaryColumn: AggregateColumn, summaryData: Object[]): string {
-        const qry: Query =  new Query(); const single: Object = {};
-        const helper: Object & { format?: Function } = {};
-        const type: string = !isNullOrUndefined(summaryColumn.field) ?
-            this.parent.getColumnByField(summaryColumn.field).type : undefined;
-        summaryColumn.setPropertiesSilent({format: this.getFormatFromType(summaryColumn.format, type)});
-        summaryColumn.setFormatter(this.parent.grid.locale);
-        const formatFn: Function = summaryColumn.getFormatter() || ((): Function => (a: Object) => a)();
-        summaryColumn.setTemplate(helper);
-        const tempObj: { fn: Function, property: string } = summaryColumn.getTemplate(2);
-        qry.queries = this.summaryQuery;
-        qry.requiresCount();
-        const sumData: Object[] = new DataManager(summaryData).executeLocal(qry);
-        let types: AggregateType[] = <AggregateType[]>summaryColumn.type; let summaryKey: string;
-        types = <AggregateType[]>[summaryColumn.type];
-        for (let i: number = 0; i < types.length; i++) {
-            summaryKey = types[parseInt(i.toString(), 10)];
-            const key: string = summaryColumn.field + ' - ' + types[parseInt(i.toString(), 10)].toLowerCase();
-            const val: Object = types[parseInt(i.toString(), 10)] !== 'Custom' ? getObject('aggregates', sumData) :
-            /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-                calculateAggregate(types[parseInt(i.toString(), 10)], sumData, summaryColumn as any, this.parent);
-            const disp: string = summaryColumn.columnName;
-            const value: Object = types[parseInt(i.toString(), 10)] !== 'Custom' ? val[`${key}`] : val;
-            single[`${disp}`] = single[`${disp}`] || {}; single[`${disp}`][`${key}`] = value;
-            single[`${disp}`][types[parseInt(i.toString(), 10)]] = !isNullOrUndefined(val) ? formatFn(value) : ' ';
-        }
-        helper.format = summaryColumn.getFormatter();
-        const cellElement: Element = createElement('td', {
-            className: 'e-summary'
-        });
-        if ((<{ isReact?: boolean }>this.parent).isReact && typeof (summaryColumn.footerTemplate) !== 'string') {
-            const renderReactTemplates: string = 'renderReactTemplates';
-            tempObj.fn(single[summaryColumn.columnName], this.parent, tempObj.property, '', null, null, cellElement);
-            this.parent[`${renderReactTemplates}`]();
-        } else {
-            appendChildren(cellElement, tempObj.fn(single[summaryColumn.columnName], this.parent, tempObj.property));
-        }
-        const value: string = single[`${summaryColumn.columnName}`][`${summaryKey}`];
-        return cellElement.innerHTML.indexOf(value) === -1 ? cellElement.innerHTML + value : cellElement.innerHTML;
-    }
-
-    private getFormatFromType(summaryformat: string| NumberFormatOptions, type: string):
-    string | NumberFormatOptions | DateFormatOptions {
-        if (isNullOrUndefined(type) || typeof summaryformat !== 'string') {
-            return summaryformat;
-        }
-        let obj: string | NumberFormatOptions | DateFormatOptions;
-        switch (type) {
-        case 'number':
-            obj = { format: summaryformat };
-            break;
-        case 'datetime':
-            obj = { type: 'dateTime', skeleton: summaryformat };
-            break;
-        case 'date':
-            obj = { type: type, skeleton: summaryformat };
-            break;
-        }
-        return obj;
-    }
-
-    /**
-     * To destroy the Aggregate module
-     *
-     * @returns {void}
-     * @hidden
-     */
-    public destroy(): void {
-        this.removeEventListener();
-    }
-}

package/dist/ts/treegrid/actions/toolbar.d.ts

@@ -1,52 +0,0 @@
-import { TreeGrid } from '../base';
-/**
- * Toolbar Module for TreeGrid
- *
- * @hidden
- */
-export declare class Toolbar {
-    private parent;
-    constructor(parent: TreeGrid);
-    /**
-     * For internal use only - Get the module name.
-     *
-     * @private
-     * @returns {string} - Returns Toolbar module name
-     */
-    private getModuleName;
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    addEventListener(): void;
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    removeEventListener(): void;
-    private refreshToolbar;
-    private toolbarClickHandler;
-    /**
-     * Gets the toolbar of the TreeGrid.
-     *
-     * @returns {Element} - Returns Toolbar element
-     * @hidden
-     */
-    getToolbar(): Element;
-    /**
-     * Enables or disables ToolBar items.
-     *
-     * @param {string[]} items - Defines the collection of itemID of ToolBar items.
-     * @param {boolean} isEnable - Defines the items to be enabled or disabled.
-     * @returns {void}
-     * @hidden
-     */
-    enableItems(items: string[], isEnable: boolean): void;
-    /**
-     * Destroys the ToolBar.
-     *
-     * @method destroy
-     * @returns {void}
-     */
-    destroy(): void;
-}

package/dist/ts/treegrid/actions/toolbar.ts

@@ -1,154 +0,0 @@
-import { Grid, Toolbar as tool, RowSelectEventArgs } from '@syncfusion/ej2-grids';
-import { TreeGrid, ITreeData } from '../base';
-import * as events from '../base/constant';
-import { ClickEventArgs } from '@syncfusion/ej2-navigations/src/toolbar';
-import { isNullOrUndefined } from '@syncfusion/ej2-base';
-/**
- * Toolbar Module for TreeGrid
- *
- * @hidden
- */
-export class Toolbar {
-    private parent: TreeGrid;
-    constructor(parent: TreeGrid) {
-        Grid.Inject(tool);
-        this.parent = parent;
-        this.addEventListener();
-    }
-    /**
-     * For internal use only - Get the module name.
-     *
-     * @private
-     * @returns {string} - Returns Toolbar module name
-     */
-    private getModuleName(): string {
-        return 'toolbar';
-    }
-
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    public addEventListener(): void {
-        this.parent.on(events.rowSelected, this.refreshToolbar, this);
-        this.parent.on(events.rowDeselected, this.refreshToolbar, this);
-        this.parent.on(events.toolbarClick, this.toolbarClickHandler, this);
-    }
-
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    public removeEventListener(): void {
-        if (this.parent.isDestroyed) { return; }
-        this.parent.off(events.rowSelected, this.refreshToolbar);
-        this.parent.off(events.rowDeselected, this.refreshToolbar);
-        this.parent.off(events.toolbarClick, this.toolbarClickHandler);
-    }
-
-    private refreshToolbar(args: RowSelectEventArgs): void {
-        const toolbarElement: Element = this.parent.grid.toolbarModule.getToolbar();
-        if (!isNullOrUndefined(toolbarElement)) {
-            const tObj: TreeGrid = this.parent; let indentElement: HTMLElement; let outdentElement: HTMLElement;
-            const indentID: string = tObj.element.id + '_gridcontrol_indent';
-            const outdentID: string = tObj.element.id + '_gridcontrol_outdent';
-            const indentEle: HTMLElement = toolbarElement.querySelector('#' + indentID);
-            const outdentEle: HTMLElement = toolbarElement.querySelector('#' + outdentID);
-            let row: HTMLTableRowElement = args.row as HTMLTableRowElement;
-            const selectedrow: HTMLTableRowElement = tObj.getSelectedRows()[0] as HTMLTableRowElement;
-            if (!isNullOrUndefined(row[0])) {
-                row = row[0];
-            }
-            row = (!isNullOrUndefined(selectedrow) && selectedrow.rowIndex !== row.rowIndex) ? selectedrow : row;
-            if (indentEle !== null && outdentEle !== null) {
-                indentElement = indentEle.parentElement;
-                outdentElement = outdentEle.parentElement;
-                if (row.rowIndex === 0 || tObj.getSelectedRowIndexes().length > 1) {
-                    indentElement.classList.add('e-hidden');
-                    outdentElement.classList.add('e-hidden');
-                }
-                else if (args['name'] !== 'rowDeselected' || (!isNullOrUndefined(selectedrow) && tObj.grid.isCheckBoxSelection)) {
-                    const selectedItem: ITreeData = tObj.getCurrentViewRecords()[row.rowIndex];
-                    if (!isNullOrUndefined(selectedItem)) {
-                        if ((selectedItem.level > (tObj.getCurrentViewRecords()[row.rowIndex - 1] as ITreeData).level)) {
-                            indentElement.classList.add('e-hidden');
-                        } else {
-                            indentElement.classList.remove('e-hidden');
-                        }
-                        if (selectedItem.level === (tObj.getCurrentViewRecords()[row.rowIndex - 1] as ITreeData).level) {
-                            indentElement.classList.remove('e-hidden');
-                        }
-                        if (selectedItem.level === 0) {
-                            outdentElement.classList.add('e-hidden');
-                        }
-                        if (selectedItem.level !== 0) {
-                            outdentElement.classList.remove('e-hidden');
-                        }
-                    }
-                }
-                if (args['name'] === 'rowDeselected' && isNullOrUndefined(selectedrow) && !tObj.grid.isCheckBoxSelection) {
-                    if (this.parent.toolbar['includes']('Indent')) {
-                        indentElement.classList.add('e-hidden');
-                    }
-                    if (this.parent.toolbar['includes']('Outdent')) {
-                        outdentElement.classList.add('e-hidden');
-                    }
-                }
-            }
-        }
-    }
-    private toolbarClickHandler(args: ClickEventArgs): void {
-        const tObj: TreeGrid = this.parent; const indentOutdentAction: string = 'indentOutdentAction';
-        if (this.parent.editSettings.mode === 'Cell' && this.parent.grid.editSettings.mode === 'Batch' &&
-            args.item.id === this.parent.grid.element.id + '_update') {
-            args.cancel = true;
-            this.parent.grid.editModule.saveCell();
-        }
-        if (args.item.id === this.parent.grid.element.id + '_expandall') {
-            this.parent.expandAll();
-        }
-        if (args.item.id === this.parent.grid.element.id + '_collapseall') {
-            this.parent.collapseAll();
-        }
-        if (args.item.id === tObj.grid.element.id + '_indent' && tObj.getSelectedRecords().length
-         && !isNullOrUndefined(tObj.rowDragAndDropModule)) {
-            this.parent.rowDragAndDropModule[`${indentOutdentAction}`](null, 'indent');
-        }
-        if (args.item.id === tObj.grid.element.id + '_outdent' && tObj.getSelectedRecords().length
-         && !isNullOrUndefined(tObj.rowDragAndDropModule)) {
-            this.parent.rowDragAndDropModule[`${indentOutdentAction}`](null, 'outdent');
-        }
-    }
-
-    /**
-     * Gets the toolbar of the TreeGrid.
-     *
-     * @returns {Element} - Returns Toolbar element
-     * @hidden
-     */
-    public getToolbar(): Element {
-        return this.parent.grid.toolbarModule.getToolbar();
-    }
-
-    /**
-     * Enables or disables ToolBar items.
-     *
-     * @param {string[]} items - Defines the collection of itemID of ToolBar items.
-     * @param {boolean} isEnable - Defines the items to be enabled or disabled.
-     * @returns {void}
-     * @hidden
-     */
-    public enableItems(items: string[], isEnable: boolean): void {
-        this.parent.grid.toolbarModule.enableItems(items, isEnable);
-    }
-
-    /**
-     * Destroys the ToolBar.
-     *
-     * @method destroy
-     * @returns {void}
-     */
-    public destroy(): void {
-        this.removeEventListener();
-    }
-}