@syncfusion/ej2-pdf-export 29.1.40 → 29.1.41

package/dist/es6/ej2-pdf-export.es2015.js

@@ -3636,10 +3636,16 @@ class PdfColor {
             this.greenColor = g;
             this.blueColor = b;
             if (typeof a === 'undefined') {
-                this.alpha = PdfColor.maxColourChannelValue;
+                this.a = PdfColor.maxColourChannelValue;
             }
             else {
-                this.alpha = a;
+                this.a = a;
+                const isFractional = (a >= 0 && a <= 1);
+                const scaleFactor = isFractional ? a : a / 255;
+                const inverseScale = 1 - scaleFactor;
+                this.redColor = Math.max(0, Math.min(255, Math.round(r * scaleFactor + PdfColor.maxColourChannelValue * inverseScale)));
+                this.greenColor = Math.max(0, Math.min(255, Math.round(g * scaleFactor + PdfColor.maxColourChannelValue * inverseScale)));
+                this.blueColor = Math.max(0, Math.min(255, Math.round(b * scaleFactor + PdfColor.maxColourChannelValue * inverseScale)));
             }
             this.filled = true;
             this.assignCMYK(r, g, b);
@@ -29109,7 +29115,7 @@ class PdfGrid extends PdfLayoutElement {
         this.setSpan();
         this.checkSpan();
         this.layoutFormat = param.format;
-        this.gridLocation = param.bounds;
+        this._gridLocation = param.bounds;
         let layouter = new PdfGridLayouter(this);
         let result = (layouter.Layouter(param));
         return result;
@@ -29357,8 +29363,8 @@ class PdfGrid extends PdfLayoutElement {
                 widths[n] = 0;
             }
             let cellWidth = 0;
-            if ((typeof this.isChildGrid === 'undefined' && typeof this.gridLocation !== 'undefined') || (this.isChildGrid === null && typeof this.gridLocation !== 'undefined')) {
-                this.initialWidth = this.gridLocation.width;
+            if ((typeof this.isChildGrid === 'undefined' && typeof this._gridLocation !== 'undefined') || (this.isChildGrid === null && typeof this._gridLocation !== 'undefined')) {
+                this.initialWidth = this._gridLocation.width;
             }
             if (this.headers.count > 0) {
                 let colCount = this.headers.getHeader(0).cells.count;
@@ -30497,6 +30503,7 @@ class PdfGridLayouter extends ElementLayouter {
             let result = new RowLayoutResult();
             let rowHeightWithSpan = 0;
             let isHeader = false;
+            let allowRowBreak = true;
             if (row.rowSpanExists) {
                 let maxSpan = 0;
                 let currRowIndex = this.Grid.rows.rowCollection.indexOf(row);
@@ -30527,7 +30534,90 @@ class PdfGridLayouter extends ElementLayouter {
                 // }
                 // if ((rowMaxHeight > rowHeightWithSpan) && flag) {
                 //     row.height += (rowMaxHeight - rowHeightWithSpan);
-                // }                
+                // }
+                if ((rowHeightWithSpan > this.currentBounds.height ||
+                    rowHeightWithSpan + this.currentBounds.y > this.currentBounds.height)) {
+                    if (row.rowSpanExists &&
+                        (this.Grid.LayoutFormat.break === PdfLayoutBreakType.FitElement || !this.Grid.allowRowBreakAcrossPages)) {
+                        allowRowBreak = false;
+                    }
+                }
+                if ((rowHeightWithSpan > this.currentBounds.height || rowHeightWithSpan + this.currentBounds.y > this.currentBounds.height)
+                    && allowRowBreak) {
+                    rowHeightWithSpan = 0;
+                    row.isPageBreakRowSpanApplied = true;
+                    for (let i = 0; i < row.cells.count; i++) {
+                        let cell = row.cells.getCell(i);
+                        maxSpan = cell.rowSpan;
+                        for (let i = currRowIndex; i < currRowIndex + maxSpan; i++) {
+                            rowHeightWithSpan += isHeader ? this.Grid.headers.getHeader(i).height : this.Grid.rows.getRow(i).height;
+                            const layoutFormat = this.Grid.LayoutFormat;
+                            let currentBoundsHeight = this.currentPageBounds.height;
+                            if (layoutFormat.usePaginateBounds && layoutFormat.paginateBounds && layoutFormat.paginateBounds.height > 0) {
+                                let bottom = layoutFormat.paginateBounds.y + layoutFormat.paginateBounds.height;
+                                if (!this.Grid.isChildGrid && this.Grid.listOfNavigatePages.length === 1) {
+                                    bottom += this.Grid._gridLocation.y;
+                                }
+                                if (bottom < currentBoundsHeight) {
+                                    currentBoundsHeight = bottom;
+                                    this.currentPageBounds.height = currentBoundsHeight;
+                                    this.currentBounds.height = currentBoundsHeight;
+                                }
+                            }
+                            if ((this.currentBounds.y + rowHeightWithSpan) > currentBoundsHeight) {
+                                rowHeightWithSpan -= isHeader ? this.Grid.headers.getHeader(i).height : this.Grid.rows.getRow(i).height;
+                                for (let j = 0; j < this.Grid.rows.getRow(currRowIndex).cells.count; j++) {
+                                    const newSpan = i - currRowIndex;
+                                    if (!isHeader &&
+                                        this.Grid.rows.getRow(currRowIndex).cells.getCell(j).rowSpan === maxSpan &&
+                                        newSpan !== 0) {
+                                        const currCell = this.Grid.rows.getRow(currRowIndex).cells.getCell(j);
+                                        const nextCell = this.Grid.rows.getRow(i).cells.getCell(j);
+                                        currCell.rowSpan = newSpan === 0 ? 1 : newSpan;
+                                        this.Grid.rows.getRow(currRowIndex).maximumRowSpan = newSpan === 0 ? 1 : newSpan;
+                                        nextCell.rowSpan = maxSpan - newSpan;
+                                        if (this.Grid.rows.getRow(i).maximumRowSpan < (maxSpan - newSpan)) {
+                                            this.Grid.rows.getRow(i).maximumRowSpan = maxSpan - newSpan;
+                                        }
+                                        const pdfGrid = currCell.value;
+                                        nextCell.stringFormat = currCell.stringFormat;
+                                        nextCell.style = currCell.style;
+                                        nextCell.style.backgroundImage = null;
+                                        nextCell.columnSpan = currCell.columnSpan;
+                                        if (pdfGrid instanceof PdfGrid &&
+                                            this.currentBounds.y + pdfGrid.size.height + this.Grid.rows.getRow(i).height +
+                                                pdfGrid.style.cellPadding.top + pdfGrid.style.cellPadding.bottom >= this.currentBounds.height) {
+                                            nextCell.value = currCell.value;
+                                        }
+                                        else if (!(pdfGrid instanceof PdfGrid)) {
+                                            nextCell.value = currCell.value;
+                                        }
+                                        if (i > 0)
+                                            this.Grid.rows.getRow(i - 1).rowSpanExists = true;
+                                        nextCell.isRowMergeContinue = false;
+                                        nextCell.isRowMergeStart = true;
+                                    }
+                                    else if (isHeader &&
+                                        this.Grid.headers.getHeader(currRowIndex).cells.getCell(j).rowSpan === maxSpan) {
+                                        const headerCell = this.Grid.headers.getHeader(currRowIndex).cells.getCell(j);
+                                        const nextHeaderCell = this.Grid.headers.getHeader(i).cells.getCell(j);
+                                        headerCell.rowSpan = newSpan === 0 ? 1 : newSpan;
+                                        nextHeaderCell.rowSpan = maxSpan - newSpan;
+                                        nextHeaderCell.stringFormat = headerCell.stringFormat;
+                                        nextHeaderCell.style = headerCell.style;
+                                        nextHeaderCell.columnSpan = headerCell.columnSpan;
+                                        nextHeaderCell.value = headerCell.value;
+                                        this.Grid.headers.getHeader(i - 1).rowSpanExists = false;
+                                        nextHeaderCell.isRowMergeContinue = false;
+                                        nextHeaderCell.isRowMergeStart = true;
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                        rowHeightWithSpan = 0;
+                    }
+                }
             }
             let calculatedHeight = row.rowBreakHeight > 0.0 ? row.rowBreakHeight : row.height;
             if (typeof this.Grid.isChildGrid !== 'undefined' && this.Grid.isChildGrid && typeof this.Grid.ParentCell !== 'undefined' && this.Grid.ParentCell != null) {