@syncfusion/ej2-treegrid 30.1.38 → 31.1.17

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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,231 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,154 @@
+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();
+    }
+}