@syncfusion/ej2-treegrid 30.1.38 → 31.1.17

package/dist/ts/treegrid/actions/logger.ts

@@ -0,0 +1,136 @@
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { TreeGrid } from '../base/treegrid';
+import { Column } from '../models/column';
+import { Logger as GridLogger, Grid, IGrid, ItemDetails, detailLists, CheckOptions } from '@syncfusion/ej2-grids';
+
+/**
+ * Logger module for TreeGrid
+ *
+ * @hidden
+ */
+
+const DOC_URL: string = 'https://ej2.syncfusion.com/documentation/treegrid';
+const BASE_DOC_URL: string = 'https://ej2.syncfusion.com/documentation';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const WARNING: string = '[EJ2TreeGrid.Warning]';
+const ERROR: string = '[EJ2TreeGrid.Error]';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const INFO: string = '[EJ2TreeGrid.Info]';
+let IsRowDDEnabled: boolean = false;
+
+export interface TreeItemDetails {
+    type: string;
+    logType: string;
+    message?: string;
+    check: (args: Object, parent: TreeGrid) => CheckOptions;
+    generateMessage: (args: Object, parent: TreeGrid, checkOptions?: Object) => string;
+}
+
+
+export class Logger extends GridLogger {
+
+    private treeGridObj: TreeGrid;
+
+    constructor(parent: IGrid) {
+        Grid.Inject(GridLogger);
+        super(parent);
+    }
+
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} - Returns Logger module name
+     */
+    public getModuleName(): string {
+        return 'logger';
+    }
+
+    public log(types: string | string[], args: Object): void {
+        if (!(types instanceof Array)) { types = [types]; }
+        const type: string[] = (<string[]>types);
+        for (let i: number = 0; i < type.length; i++) {
+            const item: ItemDetails = detailLists[type[parseInt(i.toString(), 10)]];
+            const cOp: CheckOptions = item.check(args, this.parent);
+            if (cOp.success) {
+                let message: string = item.generateMessage(args, this.parent, cOp.options);
+                message =  message.replace('EJ2Grid', 'EJ2TreeGrid').replace('* Hierarchy Grid', '').replace('* Grouping', '');
+                if (IsRowDDEnabled && type[parseInt(i.toString(), 10)] === 'primary_column_missing') {
+                    message = message.replace('Editing', 'Row DragAndDrop');
+                    IsRowDDEnabled = false;
+                }
+                const index: number = message.indexOf('https');
+                const gridurl: string = message.substring(index);
+                if (type[parseInt(i.toString(), 10)] === 'module_missing') {
+                    message = message.replace(gridurl, DOC_URL + '/modules');
+                } else if (type[parseInt(i.toString(), 10)] === 'primary_column_missing' || type[parseInt(i.toString(), 10)] === 'selection_key_missing') {
+                    message = message.replace(gridurl, BASE_DOC_URL + '/api/treegrid/column/#isprimarykey');
+                } else if (type[parseInt(i.toString(), 10)] === 'grid_remote_edit') {
+                    message = message.replace(gridurl, DOC_URL + '/edit');
+                } else if (type[parseInt(i.toString(), 10)] === 'virtual_height') {
+                    message = message.replace(gridurl, DOC_URL + '/virtual');
+                } else if (type[parseInt(i.toString(), 10)] === 'check_datasource_columns') {
+                    message = message.replace(gridurl, DOC_URL + '/columns');
+                } else if (type[parseInt(i.toString(), 10)] === 'locale_missing') {
+                    message = message.replace(gridurl, DOC_URL + '/global-local/#localization');
+                }
+                if (type[parseInt(i.toString(), 10)] === 'datasource_syntax_mismatch') {
+                    if (!isNullOrUndefined(this.treeGridObj) && !isNullOrUndefined(this.treeGridObj.dataStateChange)) {
+                        // eslint-disable-next-line no-console
+                        console[item.logType](message);
+                    }
+                } else {
+                    // eslint-disable-next-line no-console
+                    console[item.logType](message);
+                }
+            }
+        }
+    }
+
+    public treeLog(types: string | string[], args: Object, treeGrid: TreeGrid): void {
+        this.treeGridObj = treeGrid;
+        if (!(types instanceof Array)) { types = [types]; }
+        const type: string[] = (<string[]>types);
+        if (treeGrid.allowRowDragAndDrop && !(<Column[]>treeGrid.columns).filter((column: Column) => column.isPrimaryKey).length) {
+            IsRowDDEnabled = true;
+            this.log('primary_column_missing', args);
+        }
+        for (let i: number = 0; i < type.length; i++) {
+            const item: TreeItemDetails = treeGridDetails[type[parseInt(i.toString(), 10)]];
+            const cOp: CheckOptions = item.check(args, treeGrid);
+            if (cOp.success) {
+                const message: string = item.generateMessage(args, treeGrid, cOp.options);
+                // eslint-disable-next-line no-console
+                console[item.logType](message);
+            }
+        }
+    }
+
+}
+
+export const treeGridDetails: {[key: string]: TreeItemDetails} = {
+    // eslint-disable-next-line camelcase
+    mapping_fields_missing: {
+        type: 'mapping_fields_missing',
+        logType: 'error',
+        check(args: Object, parent: TreeGrid): CheckOptions {
+            let opt: CheckOptions = { success: false };
+            if ((isNullOrUndefined(parent.idMapping) && isNullOrUndefined(parent.childMapping)
+           && isNullOrUndefined(parent.parentIdMapping)) ||
+           (!isNullOrUndefined(parent.idMapping) && isNullOrUndefined(parent.parentIdMapping)) ||
+           (isNullOrUndefined(parent.idMapping) && !isNullOrUndefined(parent.parentIdMapping))) {
+                opt = { success: true };
+            }
+            return opt;
+        },
+        generateMessage(): string {
+            return ERROR + ':' + ' MAPPING FIELDS MISSING \n' + 'One of the following fields is missing. It is ' +
+               'required for the hierarchical relationship of records in TreeGrid:\n' +
+               '* childMapping\n' + '* idMapping\n' + '* parentIdMapping\n' +
+               'Refer to the following documentation links for more details.\n' +
+                `${BASE_DOC_URL}/api/treegrid#childmapping` + '\n' +
+                `${BASE_DOC_URL}/api/treegrid#idmapping` + '\n' +
+                `${BASE_DOC_URL}/api/treegrid#$parentidmapping`;
+        }
+    }
+};

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

@@ -0,0 +1,67 @@
+import { TreeGrid } from '../base';
+/**
+ * The `Page` module is used to render pager and handle paging action.
+ *
+ * @hidden
+ */
+export declare class Page {
+    private parent;
+    constructor(parent: TreeGrid);
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    addEventListener(): void;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    removeEventListener(): void;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Pager module name
+     */
+    protected getModuleName(): string;
+    /**
+     * Refreshes the page count, pager information, and external message.
+     *
+     * @returns {void}
+     */
+    refresh(): void;
+    /**
+     * To destroy the pager
+     *
+     * @returns {void}
+     * @hidden
+     */
+    destroy(): void;
+    /**
+     * Navigates to the target page according to the given number.
+     *
+     * @param  {number} pageNo - Defines the page number to navigate.
+     * @returns {void}
+     */
+    goToPage(pageNo: number): void;
+    /**
+     * Defines the text of the external message.
+     *
+     * @param  {string} message - Defines the message to update.
+     * @returns {void}
+     */
+    updateExternalMessage(message: string): void;
+    /**
+     * @param {{action: string, row: HTMLTableRowElement, record: ITreeData, args: RowCollapsedEventArgs}} rowDetails - Expand Collapse details arguments
+     * @param {string} rowDetails.action - Expand Collapse action type
+     * @param {HTMLTableRowElement} rowDetails.row - Row element
+     * @param {ITreeData} rowDetails.record - Row object data
+     * @param {RowCollapsedEventArgs} rowDetails.args - Expand Collapse event arguments
+     * @hidden
+     * @returns {void}
+     */
+    private collapseExpandPagedchilds;
+    private pageRoot;
+    private updatePageSize;
+    private pageAction;
+}

package/dist/ts/treegrid/actions/page.ts

@@ -0,0 +1,212 @@
+import { Grid, ActionEventArgs } from '@syncfusion/ej2-grids';
+import { Page as GridPage } from '@syncfusion/ej2-grids';
+import { TreeGrid, ITreeData, RowCollapsedEventArgs } from '../base';
+import * as events from '../base/constant';
+import { DataManager, Query, Predicate } from '@syncfusion/ej2-data';
+import { getValue, isNullOrUndefined, addClass, removeClass } from '@syncfusion/ej2-base';
+import { getExpandStatus, isFilterChildHierarchy } from '../utils';
+
+/**
+ * The `Page` module is used to render pager and handle paging action.
+ *
+ * @hidden
+ */
+export class Page {
+    private parent: TreeGrid;
+    constructor(parent: TreeGrid) {
+        Grid.Inject(GridPage);
+        this.parent = parent;
+        this.addEventListener();
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public addEventListener(): void {
+        this.parent.on(events.localPagedExpandCollapse, this.collapseExpandPagedchilds, this);
+        this.parent.on(events.pagingActions, this.pageAction, this);
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public removeEventListener(): void {
+        if (this.parent.isDestroyed) { return; }
+        this.parent.off(events.localPagedExpandCollapse, this.collapseExpandPagedchilds);
+        this.parent.off(events.pagingActions, this.pageAction);
+    }
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Pager module name
+     */
+    protected getModuleName(): string {
+        return 'pager';
+    }
+
+    /**
+     * Refreshes the page count, pager information, and external message.
+     *
+     * @returns {void}
+     */
+    public refresh(): void {
+        this.parent.grid.pagerModule.refresh();
+    }
+
+    /**
+     * To destroy the pager
+     *
+     * @returns {void}
+     * @hidden
+     */
+    public destroy(): void {
+        this.removeEventListener();
+    }
+
+    /**
+     * Navigates to the target page according to the given number.
+     *
+     * @param  {number} pageNo - Defines the page number to navigate.
+     * @returns {void}
+     */
+    public goToPage(pageNo: number): void {
+        this.parent.grid.pagerModule.goToPage(pageNo);
+    }
+
+    /**
+     * Defines the text of the external message.
+     *
+     * @param  {string} message - Defines the message to update.
+     * @returns {void}
+     */
+    public updateExternalMessage(message: string): void {
+        if (isNullOrUndefined(message)) {
+            const error: string = 'The provided value for the message is undefined. Please ensure the message contains string.';
+            this.parent.trigger(events.actionFailure, { error: error });
+        }
+        this.parent.grid.pagerModule.updateExternalMessage(message);
+    }
+    /**
+     * @param {{action: string, row: HTMLTableRowElement, record: ITreeData, args: RowCollapsedEventArgs}} rowDetails - Expand Collapse details arguments
+     * @param {string} rowDetails.action - Expand Collapse action type
+     * @param {HTMLTableRowElement} rowDetails.row - Row element
+     * @param {ITreeData} rowDetails.record - Row object data
+     * @param {RowCollapsedEventArgs} rowDetails.args - Expand Collapse event arguments
+     * @hidden
+     * @returns {void}
+     */
+    private collapseExpandPagedchilds(rowDetails: { action: string, row: HTMLTableRowElement,
+        record: ITreeData, args: RowCollapsedEventArgs }): void {
+        rowDetails.record.expanded = rowDetails.action === 'collapse' ? false : true;
+        this.parent.flatData.map((e: ITreeData) => e.expanded = e.uniqueID === rowDetails.record.uniqueID &&
+           e.expanded !== rowDetails.record.expanded  ? rowDetails.record.expanded : e.expanded);
+        if (this.parent.enableImmutableMode) {
+            const primaryKeyField: string = this.parent.getPrimaryKeyFieldNames()[0];
+            const record: ITreeData[] = this.parent.flatData.filter((e: ITreeData) => {
+                return e[`${primaryKeyField}`] === rowDetails.record[`${primaryKeyField}`];
+            });
+            if (record.length) {
+                record[0].expanded = rowDetails.record.expanded;
+            }
+        }
+        const ret: Object = {
+            result: this.parent.flatData,
+            row: rowDetails.row,
+            action: rowDetails.action,
+            record: rowDetails.record,
+            count: this.parent.flatData.length
+        };
+        getValue('grid.renderModule', this.parent).dataManagerSuccess(ret);
+        if (this.parent.enableImmutableMode) {
+            const row: string = 'row'; const action: string = 'action'; let targetEle: Element;
+            if (ret[`${action}`] === 'collapse') {
+                targetEle = ret[`${row}`].getElementsByClassName('e-treegridexpand')[0];
+                if (!isNullOrUndefined(targetEle)) {
+                    removeClass([targetEle], 'e-treegridexpand');
+                    addClass([targetEle], 'e-treegridcollapse');
+                }
+            } else if (ret[`${action}`] === 'expand') {
+                targetEle = ret[`${row}`].getElementsByClassName('e-treegridcollapse')[0];
+                if (!isNullOrUndefined(targetEle)) {
+                    removeClass([targetEle], 'e-treegridcollapse');
+                    addClass([targetEle], 'e-treegridexpand');
+                }
+            }
+        }
+    }
+    private pageRoot(pagedResults: ITreeData[], temp: ITreeData[], result?: ITreeData[]) : ITreeData[] {
+        let newResults: ITreeData[] = isNullOrUndefined(result) ? [] : result;
+        for (let t: number = 0; t < temp.length; t++) {
+            newResults.push(temp[parseInt(t.toString(), 10)]);
+            let res: ITreeData[] = [];
+            if (temp[parseInt(t.toString(), 10)].hasChildRecords) {
+                res = pagedResults.filter((e: ITreeData) => {
+                    return temp[parseInt(t.toString(), 10)].uniqueID === e.parentUniqueID;
+                });
+                newResults = this.pageRoot(pagedResults, res, newResults);
+            }
+        }
+        return newResults;
+    }
+
+    private updatePageSize(pageingDetails: {result: ITreeData[], count: number}) : void {
+        const updateSize: number = pageingDetails.count;
+        const gridPagerModule: GridPage = this.parent.grid.pagerModule;
+        if (this.parent.pageSettings.pageSizes === true) {
+            if (gridPagerModule.pagerObj.pagerdropdownModule['dropDownListObject'].value === gridPagerModule.pagerObj.getLocalizedLabel('All')) {
+                gridPagerModule['pagerObj'].totalRecordsCount = updateSize;
+                this.parent.grid.pageSettings.pageSize = updateSize;
+            }
+        }
+    }
+
+    private pageAction(pageingDetails: {result: ITreeData[], count: number, actionArgs: ActionEventArgs}): void {
+        const dm: DataManager = new DataManager(pageingDetails.result);
+        if (this.parent.pageSettings.pageSizeMode === 'Root') {
+            let temp: ITreeData[] = [];
+            const propname: string =
+          (this.parent.grid.filterSettings.columns.length > 0) &&
+              (this.parent.filterSettings.hierarchyMode === 'Child' || this.parent.filterSettings.hierarchyMode === 'None') ?
+              'filterLevel' : 'level';
+            let query: Query = new Query().where(propname, 'equal', 0);
+            temp = dm.executeLocal(query);
+            pageingDetails.count = temp.length;
+            const size: number = this.parent.grid.pageSettings.pageSize;
+            const current: number = this.parent.grid.pageSettings.currentPage;
+            const skip: number = size * (current - 1);
+            query = query.skip(skip).take(size);
+            temp = dm.executeLocal(query);
+            const newResults: ITreeData[] = this.pageRoot(pageingDetails.result, temp);
+            pageingDetails.result = newResults;
+        } else {
+            const dm: DataManager = new DataManager(pageingDetails.result);
+            const expanded: Predicate = new Predicate('expanded', 'notequal', null).or('expanded', 'notequal', undefined);
+            const parents: ITreeData[] = dm.executeLocal(new Query().where(expanded));
+            let visualData: ITreeData[];
+            if (isFilterChildHierarchy(this.parent) && (pageingDetails.actionArgs.action !== 'collapse' &&
+                pageingDetails.actionArgs.action !== 'expand')){
+                visualData = parents;
+            } else {
+                visualData = parents.filter((e: ITreeData) => {
+                    return getExpandStatus(this.parent, e, parents);
+                });
+            }
+            pageingDetails.count = visualData.length;
+            let query: Query = new Query();
+            const size: number = this.parent.grid.pageSettings.pageSize;
+            this.updatePageSize(pageingDetails);
+            let current: number = this.parent.grid.pageSettings.currentPage;
+            if (visualData.length < (current * size)) {
+                current = (Math.floor(visualData.length / size)) + ((visualData.length % size) ? 1 : 0);
+                current = current ? current : 1;
+                this.parent.grid.setProperties({pageSettings: {currentPage: current}}, true);
+            }
+            const skip: number = size * (current - 1);
+            query = query.skip(skip).take(size);
+            dm.dataSource.json = visualData;
+            pageingDetails.result = dm.executeLocal(query);
+        }
+        this.parent.notify('updateAction', pageingDetails);
+    }
+}

package/dist/ts/treegrid/actions/pdf-export.d.ts

@@ -0,0 +1,63 @@
+import { TreeGrid } from '../base/treegrid';
+import { PdfExportProperties } from '@syncfusion/ej2-grids';
+import { Fetch } from '@syncfusion/ej2-base';
+import { Query } from '@syncfusion/ej2-data';
+/**
+ * TreeGrid PDF Export module
+ *
+ * @hidden
+ */
+export declare class PdfExport {
+    private parent;
+    private dataResults;
+    /**
+     * Constructor for PDF export module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid);
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} PdfExport module name
+     */
+    protected getModuleName(): string;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    addEventListener(): void;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    removeEventListener(): void;
+    /**
+     * To destroy the PDF Export
+     *
+     * @returns {void}
+     * @hidden
+     */
+    destroy(): void;
+    private updatePdfResultModel;
+    Map(pdfExportProperties?: PdfExportProperties, isMultipleExport?: boolean, pdfDoc?: Object, isBlob?: boolean): Promise<Object>;
+    protected generateQuery(query: Query, prop?: PdfExportProperties): Query;
+    protected manipulatePdfProperties(prop?: PdfExportProperties, dtSrc?: Object, queryResult?: Fetch): Object;
+    /**
+     * TreeGrid PDF Export cell modifier
+     *
+     * @param {PdfQueryCellInfoEventArgs} args - Current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private pdfQueryCellInfo;
+    /**
+     * TreeGrid PDF Export Aggregate cell modifier
+     *
+     * @param {AggregateQueryCellInfoEventArgs} args - current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private pdfAggregateCellInfo;
+}

package/dist/ts/treegrid/actions/pdf-export.ts

@@ -0,0 +1,182 @@
+import { TreeGrid } from '../base/treegrid';
+import { ITreeData, TreeGridPdfExportProperties } from '../base/interface';
+import { getObject, PdfExport as GridPdf, Grid, BeforeDataBoundArgs, PdfExportProperties, AggregateQueryCellInfoEventArgs} from '@syncfusion/ej2-grids';
+import { PdfQueryCellInfoEventArgs, PdfStyle } from '@syncfusion/ej2-grids';
+import { isRemoteData, isOffline } from '../utils';
+import { isNullOrUndefined, setValue, Fetch, extend, getValue } from '@syncfusion/ej2-base';
+import { DataManager, Query, ReturnOption } from '@syncfusion/ej2-data';
+import * as event from '../base/constant';
+import { PdfDocument } from '@syncfusion/ej2-pdf-export';
+/**
+ * TreeGrid PDF Export module
+ *
+ * @hidden
+ */
+export class PdfExport {
+    private parent: TreeGrid;
+    private dataResults: ReturnOption;
+    /**
+     * Constructor for PDF export module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid) {
+        Grid.Inject(GridPdf);
+        this.parent = parent;
+        this.dataResults = <ReturnOption>{};
+        this.addEventListener();
+    }
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} PdfExport module name
+     */
+    protected getModuleName(): string {
+        return 'PdfExport';
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public addEventListener(): void {
+        this.parent.on('pdfCellInfo', this.pdfQueryCellInfo, this);
+        this.parent.on('updateResults', this.updatePdfResultModel, this);
+        this.parent.on('pdfAggregateCellInfo', this.pdfAggregateCellInfo, this);
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public removeEventListener(): void {
+        if (this.parent.isDestroyed) { return; }
+        this.parent.off('pdfCellInfo', this.pdfQueryCellInfo);
+        this.parent.off('updateResults', this.updatePdfResultModel);
+        this.parent.off('pdfAggregateCellInfo', this.pdfAggregateCellInfo);
+    }
+    /**
+     * To destroy the PDF Export
+     *
+     * @returns {void}
+     * @hidden
+     */
+    public destroy(): void {
+        this.removeEventListener();
+    }
+    private updatePdfResultModel(returnResult: { result: ITreeData[], count: number }): void {
+        this.dataResults = <ReturnOption>returnResult;
+    }
+    public Map(
+        pdfExportProperties?: PdfExportProperties,
+        isMultipleExport?: boolean, pdfDoc?: Object, isBlob?: boolean) : Promise<Object> {
+        const dtSrc: Object = this.parent.dataSource;
+        const prop: Object = Object();
+        const isLocal: boolean = !isRemoteData(this.parent) && isOffline(this.parent);
+        setValue('cancel', false, prop);
+        return new Promise((resolve: Function) => {
+            const dm: DataManager = isLocal && !(dtSrc instanceof DataManager) ? new DataManager(dtSrc)
+                : <DataManager>this.parent.dataSource;
+            let query: Query = new Query();
+            if (!isLocal) {
+                query = this.generateQuery(query);
+                setValue('query', query, prop);
+            }
+            this.parent.trigger(event.beforePdfExport, extend(prop, pdfExportProperties));
+            if (getObject('cancel', prop)) {
+                return null;
+            }
+            dm.executeQuery(query).then((e: Object) => {
+                let customsData: Object = null;
+                if (!isNullOrUndefined(pdfExportProperties) && !isNullOrUndefined(pdfExportProperties.dataSource)) {
+                    customsData = pdfExportProperties.dataSource;
+                }
+                pdfExportProperties = this.manipulatePdfProperties(pdfExportProperties, dtSrc, <Fetch>e);
+                return this.parent.grid.pdfExportModule.Map(
+                    this.parent.grid, pdfExportProperties, isMultipleExport, pdfDoc, isBlob).then((document: PdfDocument) => {
+                    if (customsData != null) {
+                        pdfExportProperties.dataSource = customsData;
+                    } else {
+                        delete pdfExportProperties.dataSource;
+                    }
+                    resolve(document);
+                });
+            });
+        });
+    }
+    protected generateQuery(query: Query, prop?: PdfExportProperties) : Query {
+        if (!isNullOrUndefined(prop) && prop.exportType === 'CurrentPage'
+        && this.parent.allowPaging) {
+            prop.exportType = 'AllPages';
+            query.addParams('ExportType', 'CurrentPage');
+            query.where(this.parent.parentIdMapping, 'equal', null);
+            query = getObject('grid.renderModule.data.pageQuery', this.parent)(query);
+        }
+        return query;
+    }
+    protected manipulatePdfProperties(prop?: PdfExportProperties, dtSrc?: Object, queryResult?: Fetch) : Object {
+        let args: Object = {};
+        //count not required for this query
+        const isLocal: boolean = !isRemoteData(this.parent) && isOffline(this.parent);
+        setValue('query', this.parent.grid.getDataModule().generateQuery(true), args);
+        setValue('isExport',  true, args);
+        setValue('isPdfExport', true, args);
+        if (!isNullOrUndefined(prop) && !isNullOrUndefined((prop as TreeGridPdfExportProperties).isCollapsedStatePersist)) {
+            setValue('isCollapsedStatePersist',  (prop as TreeGridPdfExportProperties).isCollapsedStatePersist, args);
+        }
+        if (!isNullOrUndefined(prop) && !isNullOrUndefined(prop.exportType)) {
+            setValue('exportType',  prop.exportType, args);
+        }
+        if (!isLocal) {
+            this.parent.parentData = [];
+            this.parent.dataModule.convertToFlatData(getValue('result', queryResult));
+            setValue('expresults',  this.parent.flatData, args);
+        }
+        this.parent.notify('dataProcessor', args);
+        //args = this.parent.dataModule.dataProcessor(args);
+        args = <BeforeDataBoundArgs>this.dataResults;
+        dtSrc = isNullOrUndefined((<BeforeDataBoundArgs>args).result) ? this.parent.flatData.slice(0) : (<BeforeDataBoundArgs>args).result;
+        if (!isLocal) {
+            this.parent.flatData = [];
+        }
+        if (prop && prop.dataSource && isLocal) {
+            const flatDatas: Object[] = this.parent.flatData;
+            const dataSrc: Object = prop.dataSource instanceof DataManager ? prop.dataSource.dataSource.json : prop.dataSource;
+            this.parent.dataModule.convertToFlatData(dataSrc);
+            dtSrc = this.parent.flatData;
+            this.parent.flatData = flatDatas;
+        }
+        prop = isNullOrUndefined(prop) ? {} : prop;
+        prop.dataSource = new DataManager({json: <Object[]>dtSrc});
+        prop.query = args['query'];
+        return prop;
+    }
+    /**
+     * TreeGrid PDF Export cell modifier
+     *
+     * @param {PdfQueryCellInfoEventArgs} args - Current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private pdfQueryCellInfo(args?: PdfQueryCellInfoEventArgs) : void {
+        if (this.parent.grid.getColumnIndexByUid(args.column.uid) === this.parent.treeColumnIndex) {
+            const style: PdfStyle = {};
+            const data: ITreeData = <ITreeData>getObject('data', args);
+            const ispadfilter: boolean = isNullOrUndefined(data.filterLevel);
+            const pad: number = ispadfilter ? data.level : data.filterLevel;
+            style.paragraphIndent = pad * 3;
+            args.style = style;
+        }
+        this.parent.notify('updateResults', args);
+        this.parent.trigger('pdfQueryCellInfo', args);
+    }
+    /**
+     * TreeGrid PDF Export Aggregate cell modifier
+     *
+     * @param {AggregateQueryCellInfoEventArgs} args - current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private pdfAggregateCellInfo(args?: AggregateQueryCellInfoEventArgs) : void {
+        this.parent.trigger('pdfAggregateQueryCellInfo', args);
+    }
+}