@syncfusion/ej2-gantt 19.4.55 → 20.1.47-1460716

package/dist/ts/gantt/export/pdf-timeline.ts

@@ -0,0 +1,202 @@
+import { PdfGantt } from './pdf-gantt';
+import { PdfGanttCellStyle} from './../base/interface';
+import {
+    PointF, PdfPage, PdfGraphics, PdfColor, PdfPen, PdfBrush, PdfSolidBrush,
+    PdfTrueTypeFont, PdfStandardFont, PdfStringFormat, PdfVerticalAlignment,
+    PdfTextAlignment, PdfWordWrapType
+} from '@syncfusion/ej2-pdf-export';
+import { TimelineDetails, TimelineFormat, IGanttStyle, PdfQueryTimelineCellInfoEventArgs } from '../base/interface';
+import { extend, isNullOrUndefined } from '@syncfusion/ej2-base';
+import { pixelToPoint } from '../base/utils';
+import { Gantt } from '../base/gantt';
+import { PdfPaddings } from './pdf-base';
+
+/**
+ */
+export class PdfTimeline {
+    public parent: Gantt;
+    private gantt: PdfGantt;
+    public topTier: TimelineFormat[];
+    public bottomTier: TimelineFormat[];
+    public width: number;
+    public height: number;
+    public topTierCellWidth: number;
+    public bottomTierCellWidth: number;
+    public topTierHeight: number;
+    public bottomTierHeight: number;
+    private topTierPoint: PointF;
+    private bottomTierPoint: PointF;
+    private topTierIndex: number;
+    private bottomTierIndex: number;
+    private prevTopTierIndex: number;
+    private prevBottomTierIndex: number;
+
+    constructor(gantt?: PdfGantt) {
+        this.width = 0;
+        this.gantt = gantt;
+        this.parent = gantt.parent;
+        this.topTierPoint = new PointF();
+        this.bottomTierPoint = new PointF();
+        this.topTierIndex = 0;
+        this.bottomTierIndex = 0;
+        this.prevTopTierIndex = 0;
+        this.prevBottomTierIndex = 0;
+    }
+    /**
+     * @private
+     * @param {PdfPage} page .
+     * @param {PointF} startPoint .
+     * @param {TimelineDetails} detail .
+     * @returns {void}
+     */
+    public drawTimeline(page: PdfPage, startPoint: PointF, detail: TimelineDetails): void {
+        let remainWidth: number = Math.floor(detail.totalWidth);
+        let renderWidth: number = 0;
+        this.topTierPoint.x = startPoint.x;
+        this.topTierPoint.y = startPoint.y;
+        this.prevTopTierIndex = this.topTierIndex;
+        this.prevBottomTierIndex = this.bottomTierIndex;
+        while (remainWidth > 0) {
+            const pHeader: TimelineFormat = this.topTier[this.topTierIndex];
+            if (this.topTier.length > this.topTierIndex) {
+                let isCompleted: boolean = false;
+                if (!this.topTier[this.topTierIndex].isFinished) {
+                    if (remainWidth >= pHeader.width) {
+                        renderWidth = pHeader.width;
+                        pHeader.isFinished = true;
+                        pHeader.completedWidth = renderWidth;
+                        isCompleted = true;
+                    } else {
+                        renderWidth = remainWidth;
+                        isCompleted = false;
+                        pHeader.isFinished = false;
+                        pHeader.width = pHeader.width - remainWidth;
+                        pHeader.completedWidth = renderWidth;
+                    }
+                }
+                //Primary header Event Arguments
+                /* eslint-disable-next-line */
+                this.triggerQueryTimelinecell(page, this.topTierPoint.x, this.topTierPoint.y, this.topTierHeight, renderWidth, pHeader.value, true);
+                this.topTierPoint.x += pixelToPoint(renderWidth);
+                remainWidth -= renderWidth;
+                if (isCompleted) {
+                    this.topTierIndex++;
+                }
+            } else {
+                remainWidth = 0;
+            }
+        }
+        remainWidth = Math.floor(detail.totalWidth);
+        const height: number = this.parent.timelineModule.isSingleTier ? 0 : this.topTierHeight;
+        this.bottomTierPoint = new PointF(startPoint.x, pixelToPoint(startPoint.y + height));
+        while (remainWidth > 0) {
+            const secondHeader: TimelineFormat = this.bottomTier[this.bottomTierIndex];
+            if (this.bottomTier.length > this.bottomTierIndex) {
+                let isCompleted: boolean = true;
+                let width: number = secondHeader.width;
+                if (remainWidth < width) {
+                    width = remainWidth;
+                    isCompleted = false;
+                    secondHeader.completedWidth = width;
+                }
+                //Secondary header Event Arguments
+                /* eslint-disable-next-line */
+                this.triggerQueryTimelinecell(page, this.bottomTierPoint.x, this.bottomTierPoint.y, this.bottomTierHeight, width, secondHeader.value, false);
+                this.bottomTierPoint.x = this.bottomTierPoint.x + pixelToPoint(width);
+                remainWidth -= width;
+                secondHeader.completedWidth = width;
+                if (isCompleted) {
+                    this.bottomTierIndex++;
+                }
+            } else {
+                remainWidth = 0;
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {PdfPage} page .
+     * @param {PointF} startPoint .
+     * @param {TimelineDetails}  detail .
+     * @returns {void} .
+     * Draw the specific gantt chart side header when the taskbar exceeds the page
+     * @private
+     */
+    /* eslint-disable-next-line */
+    public drawPageTimeline(page: PdfPage, startPoint: PointF, detail: TimelineDetails): void {
+        this.topTierPoint = extend({}, {}, startPoint, true) as PointF;
+        for (let index: number = this.prevTopTierIndex; index <= this.topTierIndex; index++) {
+            if (this.topTier.length > index) {
+                const pHeader: TimelineFormat = this.topTier[index];
+                if (pHeader.completedWidth > 0) {
+                    //Primary header Event Arguments
+                    /* eslint-disable-next-line */
+                    this.triggerQueryTimelinecell(page, this.topTierPoint.x, this.topTierPoint.y, this.topTierHeight, pHeader.completedWidth, pHeader.value, true);
+                    this.topTierPoint.x += pixelToPoint(pHeader.completedWidth);
+                }
+            }
+        }
+        this.bottomTierPoint.x = startPoint.x;
+        this.bottomTierPoint.y = pixelToPoint(startPoint.y + this.topTierHeight);
+        for (let index: number = this.prevBottomTierIndex; index <= this.bottomTierIndex; index++) {
+            if (this.bottomTier.length > index) {
+                const secondHeader: TimelineFormat = this.bottomTier[index];
+                if (secondHeader.completedWidth > 0) {
+                    //Secondary header Event Arguments
+                    /* eslint-disable-next-line */
+                    this.triggerQueryTimelinecell(page, this.bottomTierPoint.x, this.bottomTierPoint.y, this.bottomTierHeight, secondHeader.width, secondHeader.value, false);
+                    this.bottomTierPoint.x = this.bottomTierPoint.x + pixelToPoint(secondHeader.width);
+                }
+            }
+        }
+    }
+    /**
+     * Method to trigger pdf query timelinecell event
+     */
+    /* eslint-disable-next-line */
+    private triggerQueryTimelinecell(page: PdfPage, x: number, y: number, height: number, width: number, value: string, isTopTier: boolean): void {
+        const graphics: PdfGraphics = page.graphics;
+        const timelineStyle: PdfGanttCellStyle = {};
+        const ganttStyle: IGanttStyle = this.gantt.ganttStyle;
+        timelineStyle.borderColor = new PdfColor(ganttStyle.timeline.borderColor);
+        timelineStyle.fontColor = new PdfColor(ganttStyle.timeline.fontColor);
+        timelineStyle.fontSize = ganttStyle.timeline.fontSize;
+        timelineStyle.fontStyle = ganttStyle.timeline.fontStyle;
+        timelineStyle.backgroundColor = new PdfColor(ganttStyle.timeline.backgroundColor);
+        if (ganttStyle.timeline.padding) {
+            timelineStyle.padding = ganttStyle.timeline.padding;
+        }
+        let format: PdfStringFormat = new PdfStringFormat();
+        if (isNullOrUndefined(ganttStyle.timeline.format)) {
+            if (isTopTier) {
+                format.lineAlignment = PdfVerticalAlignment.Middle;
+                format.alignment = PdfTextAlignment.Left;
+            } else {
+                format.lineAlignment = PdfVerticalAlignment.Middle;
+                format.alignment = PdfTextAlignment.Center;
+                format.wordWrap = PdfWordWrapType.Character;
+            }
+        } else {
+            format = ganttStyle.timeline.format;
+        }
+        timelineStyle.format = format;
+        const eventArgs: PdfQueryTimelineCellInfoEventArgs = {
+            timelineCell: timelineStyle,
+            value: value
+        };
+        if (this.parent.pdfQueryTimelineCellInfo) {
+            this.parent.trigger('pdfQueryTimelineCellInfo', eventArgs);
+        }
+        const e: PdfGanttCellStyle = eventArgs.timelineCell;
+        const rectPen: PdfPen = new PdfPen(eventArgs.timelineCell.borderColor);
+        const rectBrush: PdfBrush = new PdfSolidBrush(eventArgs.timelineCell.backgroundColor);
+        graphics.drawRectangle(rectPen, rectBrush, x, y, pixelToPoint(width), pixelToPoint(height));
+        const font: PdfTrueTypeFont | PdfStandardFont = new PdfStandardFont(ganttStyle.fontFamily, e.fontSize, e.fontStyle);
+        const textBrush: PdfBrush = new PdfSolidBrush(eventArgs.timelineCell.fontColor);
+        const pLeft: PdfPaddings | number = ganttStyle.timeline.padding ? eventArgs.timelineCell.padding.left : 0;
+        const pTop: PdfPaddings | number = ganttStyle.timeline.padding ? eventArgs.timelineCell.padding.top : 0;
+        /* eslint-disable-next-line */
+        graphics.drawString(eventArgs.value, font, null, textBrush, x + pLeft, y + pTop, pixelToPoint(width), pixelToPoint(height), e.format);
+    }
+}

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

@@ -0,0 +1,406 @@
+import { PdfGanttCellStyle, IGanttStyle } from './../base/interface';
+import {
+    PdfTreeGridColumnCollection, PdfTreeGridCell, PdfTreeGridRow, PdfTreeGridHeaderCollection, PdfTreeGridRowCollection
+} from './pdf-base/index';
+import { PdfTreeGridStyle, PdfBorders, PdfTreeGridLayouter, PdfTreeGridLayoutResult, PdfTreeGridLayoutFormat
+} from './pdf-base/index';
+import {
+    PdfLayoutElement, PdfLayoutParams, RectangleF, PdfLayoutFormat, PdfPage, PointF, PdfLayoutResult,
+    SizeF, PdfGridBeginCellDrawEventArgs, PdfGridEndCellDrawEventArgs
+} from '@syncfusion/ej2-pdf-export';
+
+/**
+ * PdfTreeGrid Class for EJ2-PDF
+ */
+export class PdfTreeGrid extends PdfLayoutElement {
+    public columns: PdfTreeGridColumnCollection;
+    public rows: PdfTreeGridRowCollection;
+    public style: PdfTreeGridStyle;
+    private initialWidth: number;
+    private treeGridSize: SizeF = new SizeF(0, 0);
+    public layouter: PdfTreeGridLayouter;
+    public headers: PdfTreeGridHeaderCollection;
+    private layoutFormat: PdfLayoutFormat;
+    public beginCellDraw: Function;
+    public endCellDraw: Function;
+    private treegridLocation: RectangleF;
+    public treeColumnIndex: number = 0;
+    public rowHeight: number;
+    public allowRowBreakAcrossPages: boolean = true;
+    public enableHeader: boolean = true;
+    public isFitToWidth: boolean = false;
+    public ganttStyle: IGanttStyle;
+
+    constructor() {
+        super();
+        this.columns = new PdfTreeGridColumnCollection(this);
+        this.rows = new PdfTreeGridRowCollection(this);
+        this.headers = new PdfTreeGridHeaderCollection(this);
+        this.style = new PdfTreeGridStyle();
+        this.rowHeight = 0;
+    }
+
+    //Properties
+    /**
+     * Gets a value indicating whether the `start cell layout event` should be raised.
+     *
+     * @returns {boolean} .
+     * @private
+     */
+    public get raiseBeginCellDraw(): boolean {
+        // eslint-disable-next-line
+        return (typeof this.beginCellDraw !== 'undefined' && typeof this.beginCellDraw !== null);
+    }
+    /**
+     * Gets a value indicating whether the `end cell layout event` should be raised.
+     *
+     * @returns {boolean} .
+     * @private
+     */
+    public get raiseEndCellDraw(): boolean {
+        // eslint-disable-next-line
+        return (typeof this.endCellDraw !== 'undefined' && typeof this.endCellDraw !== null);
+    }
+    public get size(): SizeF {
+        if ((this.treeGridSize.width === 0 && this.treeGridSize.height === 0)) {
+            this.treeGridSize = this.calculateTreeGridSize();
+        }
+        return this.treeGridSize;
+    }
+    public set size(value: SizeF) {
+        this.treeGridSize = value;
+    }
+
+    //Implementation
+    /**
+     * `Draws` the element on the page with the specified page and 'PointF' class
+     *
+     * @param {PdfPage} page .
+     * @param {PointF} location .
+     * @returns {PdfLayoutResult} .
+     * @private
+     */
+    public draw(page: PdfPage, location: PointF): PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page and pair of coordinates
+     *
+     * @param {PdfPage} page .
+     * @param {number} x .
+     * @param {number} y .
+     * @returns {PdfLayoutResult} .
+     * @private
+     */
+    public draw(page: PdfPage, x: number, y: number): PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page and 'RectangleF' class
+     *
+     * @param {PdfPage} page .
+     * @param {RectangleF} layoutRectangle .
+     * @returns {PdfLayoutResult} .
+     * @private
+     */
+    public draw(page: PdfPage, layoutRectangle: RectangleF): PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page, 'PointF' class and layout format
+     *
+     * @param {PdfPage} page .
+     * @param {PointF} location .
+     * @param {PdfTreeGridLayoutFormat} format .
+     * @returns {PdfLayoutResult} .
+     * @private
+     */
+    public draw(page: PdfPage, location: PointF, format: PdfLayoutFormat): PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page, pair of coordinates and layout format
+     *
+     * @param {PdfPage} page .
+     * @param {number} x .
+     * @param {number} y .
+     * @param {PdfLayoutFormat} format .
+     * @returns {PdfLayoutResult}
+     * @private
+     */
+    public draw(page: PdfPage, x: number, y: number, format: PdfLayoutFormat): PdfLayoutResult
+    /**
+     * `Draws` the element on the page.
+     *
+     * @private
+     */
+    public draw(page: PdfPage, layoutRectangle: RectangleF, embedFonts: boolean): PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page, 'RectangleF' class and layout format
+     *
+     * @private
+     */
+    /* eslint-disable-next-line */
+    public draw(arg1: PdfPage, arg2: RectangleF | PointF | number, arg3?: PdfLayoutFormat | number | boolean, arg4?: PdfLayoutFormat): PdfLayoutResult {
+        if (arg2 instanceof PointF && typeof (arg2 as RectangleF).width === 'undefined' && typeof arg3 === 'undefined') {
+            return this.drawHelper(arg1, arg2.x, arg2.y);
+        } else if (typeof arg2 === 'number' && typeof arg3 === 'number' && typeof arg4 === 'undefined') {
+            return this.drawHelper(arg1, arg2, arg3, null);
+        } else if (arg2 instanceof RectangleF && typeof arg2.width !== 'undefined' && typeof arg3 === 'undefined') {
+            return this.drawHelper(arg1, arg2, null);
+        } else if (arg2 instanceof PointF && typeof (arg2 as RectangleF).width === 'undefined' && arg3 instanceof PdfLayoutFormat) {
+            return this.drawHelper(arg1, arg2.x, arg2.y, arg3);
+        } else if (typeof arg2 === 'number' && typeof arg3 === 'number' && (arg4 instanceof PdfLayoutFormat || arg4 == null)) {
+            const width: number = (arg1.graphics.clientSize.width - arg2);
+            const layoutRectangle: RectangleF = new RectangleF(arg2, arg3, width, 0);
+            return this.drawHelper(arg1, layoutRectangle, arg4);
+        } else if (arg2 instanceof RectangleF && typeof arg2.width !== 'undefined' && typeof arg3 === 'boolean') {
+            return this.drawHelper(arg1, arg2, null);
+        } else {
+            return this.drawHelper(arg1, (arg2 as RectangleF), arg3 as PdfLayoutFormat);
+        }
+    }
+
+    public measureColumnsWidth(bounds?: RectangleF): void {
+        if (typeof bounds !== 'undefined') {
+            const widths: number[] = this.columns.getDefaultWidths(bounds.width - bounds.x);
+            for (let i: number = 0; i < this.columns.count; i++) {
+                if (this.columns.getColumn(i).width < 0) {
+                    this.columns.getColumn(i).width = widths[i];
+                }
+            }
+        } else {
+            const widths: number[] = [];
+            let cellWidth: number = 0;
+            let totalWidth: number = 0;
+            let rowLevel: number = 0;
+            // if(this.headers.count > 0){
+            //     let colCount: number = this.headers.getHeader(0).cells.count;
+            //     for(let i: number = 0; i < colCount; i++){
+            //         let rowCount: number = this.headers.count;
+            //         for(let j: number = 0; j < rowCount; j++){
+            //             let tempWidth: number = this.headers.getHeader(j).cells.getCell(i).width;
+            //             let rowWidth: number = this.initialWidth > 0 ? Math.min(this.initialWidth, tempWidth) :
+            //                 tempWidth;
+            //             cellWidth = Math.max(cellWidth, rowWidth);
+            //         }
+            //         widths.push(cellWidth);
+            //     }
+            // }
+            const colCount: number = this.columns.count;
+            for (let i: number = 0; i < colCount; i++) {
+                const rowCount: number = this.rows.count;
+                for (let j: number = 0; j < rowCount; j++) {
+                    const tempWidth: number = this.rows.getRow(j).cells.getCell(i).width;
+                    const rowWidth: number = this.initialWidth > 0 ? Math.min(this.initialWidth, tempWidth) : tempWidth;
+                    cellWidth = Math.max(cellWidth, rowWidth);
+                    cellWidth = Math.max(this.columns.getColumn(i).width, cellWidth);
+                    if (this.columns.getColumn(i).isTreeColumn) {
+                        rowLevel = Math.max(rowLevel, this.rows.getRow(j).level);
+                    }
+                }
+                if (this.columns.getColumn(i).isTreeColumn) {
+                    widths.push(cellWidth + (rowLevel * 10));
+                } else {
+                    widths.push(cellWidth);
+                }
+                // eslint-disable-next-line
+                totalWidth += cellWidth;
+                cellWidth = 0;
+            }
+            for (let i: number = 0; i < this.columns.count; i++) {
+                if (this.columns.getColumn(i).width < 0) {
+                    this.columns.getColumn(i).width = widths[i];
+                }
+            }
+        }
+    }
+
+    private calculateTreeGridSize(): SizeF {
+        let height: number = 0;
+        const width: number = this.columns.width;
+        for (let i: number = 0; i < this.headers.count; i++) {
+            const row: PdfTreeGridRow = this.headers.getHeader(i);
+            height += row.height;
+        }
+        for (let i: number = 0; i < this.rows.count; i++) {
+            const row: PdfTreeGridRow = this.rows.getRow(i);
+            height += row.height;
+        }
+        return new SizeF(width, height);
+    }
+    public drawGrid(page: PdfPage, x: number, y: number, format: PdfTreeGridLayoutFormat): PdfTreeGridLayoutResult {
+        this.initialWidth = page.graphics.clientSize.width;
+        const layout: RectangleF = new RectangleF(0, 0, page.getClientSize().height, 0);
+        return this.draw(page, layout, format);
+    }
+
+    protected layout(param: PdfLayoutParams): PdfLayoutResult {
+        if (this.rows.count !== 0) {
+            const style: PdfGanttCellStyle = this.rows.getRow(0).cells.getCell(0).style;
+            if (style.borders.left.width !== 1) {
+                const x: number = style.borders.left.width / 2;
+                const y: number = style.borders.top.width / 2;
+                if (param.bounds.x === PdfBorders.default.right.width / 2 &&
+                    param.bounds.y === PdfBorders.default.right.width / 2) {
+                    const newBound: RectangleF = new RectangleF(new PointF(x, y), new SizeF(this.size.width, this.size.height));
+                    param.bounds = newBound;
+                }
+            }
+        }
+        this.setSpan();
+        this.layouter = new PdfTreeGridLayouter(this);
+        const result: PdfTreeGridLayoutResult = this.layouter.layoutInternal(param);
+        return result;
+    }
+
+    public onBeginCellDraw(args: PdfGridBeginCellDrawEventArgs): void {
+        if (this.raiseBeginCellDraw) {
+            this.beginCellDraw(this, args);
+        }
+    }
+    public onEndCellDraw(args: PdfGridEndCellDrawEventArgs): void {
+        if (this.raiseEndCellDraw) {
+            this.endCellDraw(this, args);
+        }
+    }
+    public setSpan(): void {
+        let colSpan: number = 1;
+        let rowSpan: number = 1;
+        let currentCellIndex: number = 0;
+        let currentRowIndex: number = 0;
+        let maxSpan: number = 0;
+        let rowCount: number = this.headers.count;
+        for (let i: number = 0; i < rowCount; i++) {
+            const row: PdfTreeGridRow = this.headers.getHeader(i);
+            maxSpan = 0;
+            const colCount: number = row.cells.count;
+            for (let j: number = 0; j < colCount; j++) {
+                const cell: PdfTreeGridCell = row.cells.getCell(j);
+                maxSpan = Math.max(maxSpan, cell.rowSpan);
+                //Skip setting span map for already coverted rows/columns.
+                if (!cell.isCellMergeContinue && !cell.isRowMergeContinue && (cell.columnSpan > 1 || cell.rowSpan > 1)) {
+                    if (cell.columnSpan + j > row.cells.count) {
+                        throw new Error('Invalid span specified at row ' + j.toString() + ' column ' + i.toString());
+                    }
+                    if (cell.rowSpan + i > this.headers.count) {
+                        throw new Error('Invalid span specified at Header ' + j.toString() + ' column ' + i.toString());
+                    }
+
+                    if (cell.columnSpan > 1 && cell.rowSpan > 1) {
+                        colSpan = cell.columnSpan;
+                        rowSpan = cell.rowSpan;
+                        currentCellIndex = j;
+                        currentRowIndex = i;
+                        cell.isCellMergeStart = true;
+                        cell.isRowMergeStart = true;
+                        //Set Column merges for first row
+                        while (colSpan > 1) {
+                            currentCellIndex++;
+                            row.cells.getCell(currentCellIndex).isCellMergeContinue = true;
+                            row.cells.getCell(currentCellIndex).isRowMergeContinue = true;
+                            row.cells.getCell(currentCellIndex).rowSpan = rowSpan;
+                            colSpan--;
+                        }
+                        currentCellIndex = j;
+                        colSpan = cell.columnSpan;
+                        //Set Row Merges and column merges foreach subsequent rows.
+                        while (rowSpan > 1) {
+                            currentRowIndex++;
+                            this.headers.getHeader(currentRowIndex).cells.getCell(j).isRowMergeContinue = true;
+                            this.headers.getHeader(currentRowIndex).cells.getCell(currentCellIndex).isRowMergeContinue = true;
+                            rowSpan--;
+                            while (colSpan > 1) {
+                                currentCellIndex++;
+                                this.headers.getHeader(currentRowIndex).cells.getCell(currentCellIndex).isCellMergeContinue = true;
+                                this.headers.getHeader(currentRowIndex).cells.getCell(currentCellIndex).isRowMergeContinue = true;
+                                colSpan--;
+                            }
+                            colSpan = cell.columnSpan;
+                            currentCellIndex = j;
+                        }
+                    } else if (cell.columnSpan > 1 && cell.rowSpan === 1) {
+                        colSpan = cell.columnSpan;
+                        currentCellIndex = j;
+                        cell.isCellMergeStart = true;
+                        //Set Column merges.
+                        while (colSpan > 1) {
+                            currentCellIndex++;
+                            row.cells.getCell(currentCellIndex).isCellMergeContinue = true;
+                            colSpan--;
+                        }
+                    } else if (cell.columnSpan === 1 && cell.rowSpan > 1) {
+                        rowSpan = cell.rowSpan;
+                        currentRowIndex = i;
+                        //Set row Merges.
+                        while (rowSpan > 1) {
+                            currentRowIndex++;
+                            this.headers.getHeader(currentRowIndex).cells.getCell(j).isRowMergeContinue = true;
+                            rowSpan--;
+                        }
+                    }
+                }
+            }
+            row.maximumRowSpan = maxSpan;
+        }
+        colSpan = rowSpan = 1;
+        currentCellIndex = currentRowIndex = 0;
+        rowCount = this.rows.count;
+        for (let i: number = 0; i < rowCount; i++) {
+            const row: PdfTreeGridRow = this.rows.getRow(i);
+            const colcount: number = row.cells.count;
+            for (let j: number = 0; j < colcount; j++) {
+                const cell: PdfTreeGridCell = row.cells.getCell(j);
+                //Skip setting span map for already coverted rows/columns.
+                if (!cell.isCellMergeContinue && !cell.isRowMergeContinue && (cell.columnSpan > 1 || cell.rowSpan > 1)) {
+                    if (cell.columnSpan + j > row.cells.count) {
+                        throw new Error('Invalid span specified at row {0} column {1} ' + j.toString());
+                    }
+                    if (cell.rowSpan + i > this.rows.count) {
+                        throw new Error('Invalid span specified at row {0} column {1} ' + j.toString());
+                    }
+                    if (cell.columnSpan > 1 && cell.rowSpan > 1) {
+                        colSpan = cell.columnSpan;
+                        rowSpan = cell.rowSpan;
+                        currentCellIndex = j;
+                        currentRowIndex = i;
+                        cell.isCellMergeStart = true;
+                        cell.isRowMergeStart = true;
+                        //set Column merges for first row.
+                        while (colSpan > 1) {
+                            currentCellIndex++;
+                            row.cells.getCell(currentCellIndex).isCellMergeContinue = true;
+                            colSpan--;
+                        }
+                        currentCellIndex = j;
+                        colSpan = cell.columnSpan;
+                        // Set row merges and column merges for each subsequentt rows.
+                        while (rowSpan > 1) {
+                            currentRowIndex++;
+                            this.rows.getRow(currentRowIndex).cells.getCell(j).isRowMergeContinue = true;
+                            rowSpan--;
+                            while (colSpan > 1) {
+                                currentCellIndex++;
+                                this.rows.getRow(currentRowIndex).cells.getCell(currentCellIndex).isCellMergeContinue = true;
+                                colSpan--;
+                            }
+                            colSpan = cell.columnSpan;
+                            currentCellIndex = j;
+                        }
+                    } else if (cell.columnSpan > 1 && cell.rowSpan === 1) {
+                        colSpan = cell.columnSpan;
+                        currentCellIndex = j;
+                        cell.isCellMergeStart = true;
+                        //set Column merges.
+                        while (colSpan > 1) {
+                            currentCellIndex++;
+                            row.cells.getCell(currentCellIndex).isCellMergeContinue = true;
+                            colSpan--;
+                        }
+                    } else if (cell.columnSpan === 1 && cell.rowSpan > 1) {
+                        rowSpan = cell.rowSpan;
+                        currentRowIndex = i;
+                        //set row merges.
+                        while (rowSpan > 1) {
+                            currentRowIndex++;
+                            this.rows.getRow(currentRowIndex).cells.getCell(j).isRowMergeContinue = true;
+                            rowSpan--;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/ts/gantt/models/add-dialog-field-settings.ts

@@ -0,0 +1,33 @@
+import { Property, ChildProperty } from '@syncfusion/ej2-base';
+import { DialogFieldType } from '../base/enum';
+/**
+ * Defines dialog fields of add dialog.
+ */
+export class AddDialogFieldSettings extends ChildProperty<AddDialogFieldSettings> {
+    /**
+     * Defines types of tab which contains editor for columns.
+     * * `General` - Defines tab container type as general.
+     * * `Dependency` - Defines tab as dependency editor.
+     * * `Resources` - Defines tab as resources editor.
+     * * `Notes` - Defines tab as notes editor.
+     * * `Custom` - Defines tab as custom column editor.
+     *
+     * @default null
+     */
+    @Property(null)
+    public type: DialogFieldType;
+    /**
+     * Defines header text of tab item.
+     *
+     * @default null
+     */
+    @Property(null)
+    public headerText: string;
+    /**
+     * Defines edited column fields placed inside the tab.
+     *
+     * @default null
+     */
+    @Property([])
+    public fields: string[];
+}