@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/pdf/render/layout-engine.js

@@ -92,8 +92,77 @@ export async function layoutSheet(sheet, options, fontManager) {
     if (layoutPages.length > 0 && sheet.images) {
         assignImagesToPages(sheet.images, layoutPages, ctx.scaleFactor);
     }
+    if (layoutPages.length > 0 && sheet.charts) {
+        assignChartsToPages(sheet.charts, layoutPages, ctx.scaleFactor);
+    }
     return layoutPages;
 }
+/**
+ * Produce the layout for a chartsheet — a single PDF page whose entire
+ * content area is covered by one chart.
+ *
+ * Chartsheets have no row/column grid, so we bypass the cell-layout
+ * pipeline entirely. Page dimensions come from `options.pageSize`, with
+ * orientation overridden by the chartsheet's own `orientation` field
+ * (Excel's chartsheet convention defaults to landscape; see the
+ * `CHARTSHEET_EMU_CX/CY` constants that define the drawing canvas in
+ * `xlsx.browser.ts`).
+ *
+ * The returned LayoutPage has:
+ *  - `cells = []` (no grid to render)
+ *  - `charts` containing one full-content-area chart
+ *  - all other cell-grid arrays empty
+ *
+ * The existing `renderSinglePage` in `pdf-exporter.ts` already handles
+ * pages with zero cells and a non-empty `charts` array via the shared
+ * chart-rendering path, so no exporter changes are needed here.
+ */
+export function layoutChartsheet(sheet, documentOptions) {
+    // Chartsheet orientation override — independent of the document
+    // default. We clone the options so neighbouring worksheets aren't
+    // affected when a single chartsheet flips to portrait.
+    const orientation = sheet.orientation ?? documentOptions.orientation;
+    const options = { ...documentOptions, orientation };
+    let pageWidth = options.pageSize.width;
+    let pageHeight = options.pageSize.height;
+    if (options.orientation === "landscape") {
+        [pageWidth, pageHeight] = [pageHeight, pageWidth];
+    }
+    const margins = options.margins;
+    const headerHeight = options.showSheetNames ? 20 : 0;
+    const contentX = margins.left;
+    const contentY = margins.bottom;
+    const contentWidth = pageWidth - margins.left - margins.right;
+    const contentHeight = pageHeight - margins.top - margins.bottom - headerHeight;
+    const chart = {
+        rect: {
+            x: contentX,
+            y: contentY,
+            width: Math.max(0, contentWidth),
+            height: Math.max(0, contentHeight)
+        },
+        drawVector: sheet.chart.drawVector,
+        raster: sheet.chart.raster
+    };
+    const page = {
+        pageNumber: 1,
+        options,
+        cells: [],
+        width: pageWidth,
+        height: pageHeight,
+        sheetName: sheet.name,
+        sheetCols: [],
+        columnOffsets: [],
+        columnWidths: [],
+        sheetRows: [],
+        rowYPositions: [],
+        rowHeights: [],
+        images: [],
+        charts: [chart],
+        scaleFactor: 1
+    };
+    return [page];
+}
 /**
  * Steps 1–5: compute columns, scale, rows, merges, pagination.
  * Returns null if the sheet has no visible columns (→ caller should emit an empty page).
@@ -259,6 +328,7 @@ function buildPageLayout(ctx, rowPage, colGroup, currentPageCount, sheet, option
         rowYPositions,
         rowHeights: pageRowHeights,
         images: [],
+        charts: [],
         scaleFactor
     };
 }
@@ -282,6 +352,7 @@ function createEmptyPage(sheet, options) {
         rowYPositions: [],
         rowHeights: [],
         images: [],
+        charts: [],
         scaleFactor: 1
     };
 }
@@ -474,6 +545,17 @@ function countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options
         : 0;
     const padding = CELL_PADDING_H + borderLeft + (CELL_PADDING_H + borderRight) + indent * INDENT_WIDTH;
     const effectiveWidth = Math.max(scaledColPts - padding, 1);
+    // For rich text cells, use per-run font size measurement to match rendering
+    if (cell.type === PdfCellType.RichText) {
+        const value = cell.value;
+        if (value && typeof value === "object" && "richText" in value) {
+            const runs = value.richText;
+            if (runs.length > 0) {
+                const wrappedCount = countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options);
+                return Math.max(lineCount, wrappedCount);
+            }
+        }
+    }
     const scaledFontSize = fontSize * scaleFactor;
     const fontProps = extractFontProperties(cell.style.font, options.defaultFontFamily, options.defaultFontSize);
     const pdfFontName = resolvePdfFontName(fontProps.fontFamily, fontProps.bold, fontProps.italic);
@@ -484,6 +566,119 @@ function countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options
     const wrappedLines = wrapTextLines(text, measure, effectiveWidth);
     return Math.max(lineCount, wrappedLines.length);
 }
+/**
+ * Count wrap lines for a rich text cell using per-run font sizes.
+ * This mirrors the logic in wrapRichTextLines (page-renderer) so that
+ * the row height calculation matches the actual rendering.
+ */
+function countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options) {
+    // Build character-to-run mapping
+    const runForChar = [];
+    for (let ri = 0; ri < runs.length; ri++) {
+        for (let ci = 0; ci < runs[ri].text.length; ci++) {
+            runForChar.push(ri);
+        }
+    }
+    // Resolve font resources for each run
+    const runResources = runs.map(run => {
+        const fontProps = extractFontProperties(run.font, options.defaultFontFamily, options.defaultFontSize);
+        const pdfFontName = resolvePdfFontName(fontProps.fontFamily, fontProps.bold, fontProps.italic);
+        return fontManager.hasEmbeddedFont()
+            ? fontManager.getEmbeddedResourceName()
+            : fontManager.ensureFont(pdfFontName);
+    });
+    // Resolve scaled font sizes for each run
+    const runFontSizes = runs.map(run => {
+        const fontProps = extractFontProperties(run.font, options.defaultFontFamily, options.defaultFontSize);
+        return fontProps.fontSize * scaleFactor;
+    });
+    // Measure a range of fullText using per-character run font sizes
+    const measureRange = (start, end) => {
+        let width = 0;
+        let segStart = start;
+        let currentRi = runForChar[start] ?? 0;
+        for (let i = start + 1; i <= end; i++) {
+            const ri = i < end ? (runForChar[i] ?? currentRi) : -1;
+            if (ri !== currentRi) {
+                const seg = text.slice(segStart, i);
+                width += fontManager.measureText(seg, runResources[currentRi], runFontSizes[currentRi]);
+                segStart = i;
+                currentRi = ri;
+            }
+        }
+        return width;
+    };
+    // Word-wrap using per-run measurements — mirrors wrapRichTextLines in
+    // page-renderer exactly (paragraph split on \n, word boundaries by
+    // scanning space/tab characters) to ensure line count matches rendering.
+    let totalLines = 0;
+    let globalOffset = 0;
+    const len = text.length;
+    while (globalOffset <= len) {
+        // Find end of current paragraph (handles both \n and \r\n)
+        let paraEnd = text.indexOf("\n", globalOffset);
+        if (paraEnd === -1) {
+            paraEnd = len;
+        }
+        // Skip \r before \n
+        const paraContentEnd = paraEnd > globalOffset && text[paraEnd - 1] === "\r" ? paraEnd - 1 : paraEnd;
+        if (paraContentEnd === globalOffset) {
+            // Empty paragraph
+            totalLines++;
+            globalOffset = paraEnd + 1;
+            if (paraEnd === len) {
+                break;
+            }
+            continue;
+        }
+        // Find word boundaries within this paragraph (space/tab are separators)
+        const paraText = text.slice(globalOffset, paraContentEnd);
+        const wordStarts = [];
+        const wordEnds = [];
+        let inWord = false;
+        for (let i = 0; i < paraText.length; i++) {
+            const isSpace = paraText[i] === " " || paraText[i] === "\t";
+            if (!isSpace && !inWord) {
+                wordStarts.push(i);
+                inWord = true;
+            }
+            else if (isSpace && inWord) {
+                wordEnds.push(i);
+                inWord = false;
+            }
+        }
+        if (inWord) {
+            wordEnds.push(paraText.length);
+        }
+        let lineStart = globalOffset;
+        let lineEnd = globalOffset;
+        let linesInParagraph = 0;
+        for (let wi = 0; wi < wordStarts.length; wi++) {
+            const wordEnd = globalOffset + wordEnds[wi];
+            if (lineEnd === lineStart) {
+                lineEnd = wordEnd;
+                continue;
+            }
+            if (measureRange(lineStart, wordEnd) <= effectiveWidth) {
+                lineEnd = wordEnd;
+            }
+            else {
+                linesInParagraph++;
+                lineStart = globalOffset + wordStarts[wi];
+                lineEnd = wordEnd;
+            }
+        }
+        if (lineEnd > lineStart || wordStarts.length === 0) {
+            linesInParagraph++;
+        }
+        totalLines += linesInParagraph;
+        globalOffset = paraEnd + 1;
+        if (paraEnd === len) {
+            break;
+        }
+    }
+    return Math.max(1, totalLines);
+}
 // =============================================================================
 // Row Breaks
 // =============================================================================
@@ -778,70 +973,242 @@ export function resolveSharedBorders(cellGrid, rowCount, colCount) {
     }
 }
 // =============================================================================
-// Image Placement
+// Image & Chart Placement
 // =============================================================================
+/**
+ * Resolve an anchor's page-space rectangle by combining the `tl` / `br` /
+ * `ext` fields of a {@link PdfSheetImage.range} or {@link PdfSheetChart.range}.
+ *
+ * The convention is identical for both object types:
+ *  - `tl` locates the upper-left corner in sheet coordinates (`nativeCol`,
+ *    `nativeRow`, + sub-cell offsets in EMU).
+ *  - `br` — when present — locates the opposite corner, so the rect size is
+ *    the difference.
+ *  - `ext` — when present — overrides the size directly. Images use pixels
+ *    (px × 0.75 = pt); charts use EMU (EMU / 9525 = pt). The `extUnit`
+ *    field disambiguates. Historical callers that omit `extUnit` keep
+ *    the legacy px behaviour.
+ *
+ * Returns `null` if the anchor does not land on any of the supplied
+ * pages (e.g. the object is anchored below the printed area).
+ */
+function resolveAnchorRect(range, layoutPages, scaleFactor) {
+    const tl = range.tl;
+    const tlCol = (tl.nativeCol ?? tl.col ?? 0) + 1; // 0-indexed → 1-indexed
+    const tlRow = (tl.nativeRow ?? tl.row ?? 0) + 1;
+    const targetPage = layoutPages.find(page => page.sheetCols.includes(tlCol) && page.sheetRows.includes(tlRow));
+    if (!targetPage) {
+        return null;
+    }
+    const pageColIndex = targetPage.sheetCols.indexOf(tlCol);
+    const pageRowIndex = targetPage.sheetRows.indexOf(tlRow);
+    const baseX = targetPage.columnOffsets[pageColIndex] ?? targetPage.options.margins.left;
+    const baseY = targetPage.rowYPositions[pageRowIndex] ??
+        targetPage.height -
+            targetPage.options.margins.top -
+            (targetPage.options.showSheetNames ? 20 : 0);
+    // Apply sub-cell offsets (EMU: 1pt = 12700 EMU), scaled to match page layout
+    const tlColOff = ((tl.nativeColOff ?? 0) / 12700 || 0) * scaleFactor;
+    const tlRowOff = ((tl.nativeRowOff ?? 0) / 12700 || 0) * scaleFactor;
+    const x = baseX + tlColOff;
+    const yTop = baseY - tlRowOff;
+    // Determine width / height
+    let width = 100;
+    let height = 100;
+    const extUnit = range.extUnit ?? "px";
+    if (range.ext) {
+        if (extUnit === "emu") {
+            // EMU → pt (1 pt = 9525 EMU, same as the Excel drawing ext.cx/cy).
+            width = (range.ext.width / 9525) * scaleFactor;
+            height = (range.ext.height / 9525) * scaleFactor;
+        }
+        else {
+            // Legacy pixel → pt (0.75 factor = 72/96 dpi)
+            width = range.ext.width * 0.75 * scaleFactor;
+            height = range.ext.height * 0.75 * scaleFactor;
+        }
+    }
+    else if (range.br) {
+        const br = range.br;
+        const brCol = (br.nativeCol ?? br.col ?? 0) + 1;
+        const brRow = (br.nativeRow ?? br.row ?? 0) + 1;
+        const brPageColIndex = targetPage.sheetCols.indexOf(brCol);
+        const brPageRowIndex = targetPage.sheetRows.indexOf(brRow);
+        let brBaseX;
+        let brBaseY;
+        if (brPageColIndex >= 0) {
+            brBaseX = targetPage.columnOffsets[brPageColIndex];
+        }
+        else {
+            // br column is beyond this page — sum column widths from tl
+            // through the last page column, then extrapolate remaining cols
+            // at the average page column width so the chart stretches to its
+            // intended width even when the page doesn't extend far enough.
+            const lastCI = targetPage.sheetCols.length - 1;
+            const lastPageCol = targetPage.sheetCols[lastCI] ?? tlCol;
+            // End of the last column on this page:
+            const lastColEnd = lastCI >= 0
+                ? targetPage.columnOffsets[lastCI] + (targetPage.columnWidths[lastCI] ?? 0)
+                : baseX;
+            if (brCol <= lastPageCol) {
+                // brCol should be on this page but indexOf missed — use end of
+                // the closest column as a fallback.
+                brBaseX = lastColEnd;
+            }
+            else {
+                const avgColWidth = targetPage.columnWidths.length > 0
+                    ? targetPage.columnWidths.reduce((s, w) => s + w, 0) / targetPage.columnWidths.length
+                    : 48;
+                const extraCols = brCol - lastPageCol;
+                brBaseX = lastColEnd + extraCols * avgColWidth;
+            }
+        }
+        if (brPageRowIndex >= 0) {
+            brBaseY = targetPage.rowYPositions[brPageRowIndex];
+        }
+        else {
+            // br row is beyond this page — accumulate row heights from tl
+            // downward to compute the real chart height. In PDF coords,
+            // rows stack downward (decreasing y). `baseY` (= yTop before
+            // offsets) is the PDF y of the top of `tlRow`. Each subsequent
+            // row's top y = previous row's top y - that row's height.
+            const lastRI = targetPage.sheetRows.length - 1;
+            const lastPageRow = targetPage.sheetRows[lastRI] ?? tlRow;
+            if (brRow <= lastPageRow) {
+                // brRow is on this page — sum heights from tl up to br.
+                let accH = 0;
+                for (let ri = pageRowIndex; ri <= lastRI; ri++) {
+                    if (targetPage.sheetRows[ri] >= brRow) {
+                        break;
+                    }
+                    accH += targetPage.rowHeights[ri] ?? 0;
+                }
+                brBaseY = baseY - accH;
+            }
+            else {
+                // brRow exceeds the page — sum all rows from tl to end of page,
+                // then extrapolate remaining rows at default height.
+                let accH = 0;
+                for (let ri = pageRowIndex; ri <= lastRI; ri++) {
+                    accH += targetPage.rowHeights[ri] ?? 0;
+                }
+                const remainingRows = brRow - lastPageRow - 1;
+                accH += remainingRows * (15 * scaleFactor);
+                brBaseY = baseY - accH;
+            }
+        }
+        const brColOff = ((br.nativeColOff ?? 0) / 12700 || 0) * scaleFactor;
+        const brRowOff = ((br.nativeRowOff ?? 0) / 12700 || 0) * scaleFactor;
+        const brX = brBaseX + brColOff;
+        const brYTop = brBaseY - brRowOff;
+        width = brX - x;
+        height = yTop - brYTop;
+    }
+    // Normalise to bottom-left y (PDF origin is bottom-left).
+    // Clamp width to the page's content area; for height, if the chart's
+    // anchor extends well below the page boundary (less than 50% of the
+    // chart fits on this page), skip it entirely — drawing a severely
+    // clipped chart is worse than omitting it. Otherwise keep the full
+    // computed height so the chart renders at the correct aspect ratio
+    // even if it slightly overflows the page bottom.
+    const contentRight = targetPage.width - targetPage.options.margins.right;
+    const contentBottom = targetPage.options.margins.bottom;
+    const absWidth = Math.min(Math.abs(width), Math.max(0, contentRight - x));
+    const absHeight = Math.abs(height);
+    const availableHeight = Math.max(0, yTop - contentBottom);
+    if (absHeight > 0 && availableHeight < absHeight * 0.5) {
+        // Less than half the chart fits on this page — skip it.
+        return null;
+    }
+    return {
+        page: targetPage,
+        x,
+        y: yTop - absHeight,
+        width: absWidth,
+        height: absHeight
+    };
+}
 /**
  * Assign pre-collected images to the pages that contain their top-left anchor.
  */
 function assignImagesToPages(images, layoutPages, scaleFactor) {
     for (const img of images) {
-        const tl = img.range.tl;
-        const tlCol = (tl.nativeCol ?? tl.col ?? 0) + 1; // convert 0-indexed to 1-indexed
-        const tlRow = (tl.nativeRow ?? tl.row ?? 0) + 1;
-        const targetPage = layoutPages.find(page => page.sheetCols.includes(tlCol) && page.sheetRows.includes(tlRow));
-        if (!targetPage) {
+        const placement = resolveAnchorRect(img.range, layoutPages, scaleFactor);
+        if (!placement) {
             continue;
         }
-        const pageColIndex = targetPage.sheetCols.indexOf(tlCol);
-        const pageRowIndex = targetPage.sheetRows.indexOf(tlRow);
-        const baseX = targetPage.columnOffsets[pageColIndex] ?? targetPage.options.margins.left;
-        const baseY = targetPage.rowYPositions[pageRowIndex] ??
-            targetPage.height -
-                targetPage.options.margins.top -
-                (targetPage.options.showSheetNames ? 20 : 0);
-        // Apply sub-cell offsets (EMU: 1pt = 12700 EMU), scaled to match page layout
-        const tlColOff = ((tl.nativeColOff ?? 0) / 12700 || 0) * scaleFactor;
-        const tlRowOff = ((tl.nativeRowOff ?? 0) / 12700 || 0) * scaleFactor;
-        const imgX = baseX + tlColOff;
-        const imgY = baseY - tlRowOff;
-        // Determine image size
-        let imgWidth = 100;
-        let imgHeight = 100;
-        if (img.range.ext) {
-            imgWidth = (img.range.ext.width ?? 100) * 0.75 * scaleFactor;
-            imgHeight = (img.range.ext.height ?? 100) * 0.75 * scaleFactor;
-        }
-        else if (img.range.br) {
-            const br = img.range.br;
-            const brCol = (br.nativeCol ?? br.col ?? 0) + 1;
-            const brRow = (br.nativeRow ?? br.row ?? 0) + 1;
-            const brPageColIndex = targetPage.sheetCols.indexOf(brCol);
-            const brPageRowIndex = targetPage.sheetRows.indexOf(brRow);
-            const brBaseX = brPageColIndex >= 0
-                ? targetPage.columnOffsets[brPageColIndex]
-                : imgX + (targetPage.columnWidths[pageColIndex] ?? 100);
-            const brBaseY = brPageRowIndex >= 0
-                ? targetPage.rowYPositions[brPageRowIndex]
-                : imgY - (targetPage.rowHeights[pageRowIndex] ?? 100);
-            const brColOff = ((br.nativeColOff ?? 0) / 12700 || 0) * scaleFactor;
-            const brRowOff = ((br.nativeRowOff ?? 0) / 12700 || 0) * scaleFactor;
-            const brX = brBaseX + brColOff;
-            const brY = brBaseY - brRowOff;
-            imgWidth = brX - imgX;
-            imgHeight = imgY - brY;
-        }
-        targetPage.images.push({
+        placement.page.images.push({
             data: img.data,
             format: img.format,
             rect: {
-                x: imgX,
-                y: imgY - imgHeight,
-                width: Math.abs(imgWidth),
-                height: Math.abs(imgHeight)
+                x: placement.x,
+                y: placement.y,
+                width: placement.width,
+                height: placement.height
             }
         });
     }
 }
+/**
+ * Assign pre-collected charts to the pages that contain their top-left
+ * anchor. When a chart's anchor doesn't fit on any page (e.g. it spans
+ * most of its height below the page boundary), place it full-page on
+ * the next available page so it's not lost entirely.
+ */
+function assignChartsToPages(charts, layoutPages, scaleFactor) {
+    for (const chart of charts) {
+        const placement = resolveAnchorRect(chart.range, layoutPages, scaleFactor);
+        if (placement) {
+            placement.page.charts.push({
+                rect: {
+                    x: placement.x,
+                    y: placement.y,
+                    width: placement.width,
+                    height: placement.height
+                },
+                drawVector: chart.drawVector,
+                raster: chart.raster
+            });
+            continue;
+        }
+        // Chart didn't fit — find the page whose rows are closest to the
+        // chart's tl row and place it full-content-area on that page (or
+        // the next one if it exists). This handles charts whose tl anchor
+        // is near a page break: rather than clipping them to a sliver, we
+        // push them onto the following page at full size.
+        const tl = chart.range.tl;
+        const tlRow = (tl.nativeRow ?? tl.row ?? 0) + 1;
+        let targetPage;
+        for (let pi = 0; pi < layoutPages.length; pi++) {
+            const page = layoutPages[pi];
+            const lastPageRow = page.sheetRows[page.sheetRows.length - 1] ?? 0;
+            if (lastPageRow >= tlRow - 1 && pi + 1 < layoutPages.length) {
+                targetPage = layoutPages[pi + 1];
+                break;
+            }
+            if (lastPageRow >= tlRow) {
+                targetPage = page;
+                break;
+            }
+        }
+        if (!targetPage) {
+            targetPage = layoutPages[layoutPages.length - 1];
+        }
+        if (targetPage) {
+            const margins = targetPage.options.margins;
+            const headerH = targetPage.options.showSheetNames ? 20 : 0;
+            const contentX = margins.left;
+            const contentY = margins.bottom;
+            const contentW = targetPage.width - margins.left - margins.right;
+            const contentH = targetPage.height - margins.top - margins.bottom - headerH;
+            targetPage.charts.push({
+                rect: { x: contentX, y: contentY, width: contentW, height: contentH },
+                drawVector: chart.drawVector,
+                raster: chart.raster
+            });
+        }
+    }
+}
 // =============================================================================
 // Merge Border Propagation
 // =============================================================================
@@ -889,16 +1256,29 @@ function computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleC
             if (!cell ||
                 cell.wrapText ||
                 cell.colSpan > 1 ||
-                !cell.text ||
-                cell.richText ||
+                (!cell.text && !cell.richText) ||
                 (typeof cell.textRotation === "number" && cell.textRotation !== 0) ||
                 cell.textRotation === "vertical") {
                 continue;
             }
-            const resourceName = fontManager.hasEmbeddedFont()
-                ? fontManager.getEmbeddedResourceName()
-                : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
-            const textWidth = fontManager.measureText(cell.text, resourceName, cell.fontSize);
+            // Measure the total text width (plain text or rich text runs)
+            let textWidth;
+            if (cell.richText) {
+                textWidth = 0;
+                const isEmbedded = fontManager.hasEmbeddedFont();
+                for (const run of cell.richText) {
+                    const resourceName = isEmbedded
+                        ? fontManager.getEmbeddedResourceName()
+                        : fontManager.ensureFont(resolvePdfFontName(run.fontFamily, run.bold, run.italic));
+                    textWidth += fontManager.measureText(run.text, resourceName, run.fontSize);
+                }
+            }
+            else {
+                const resourceName = fontManager.hasEmbeddedFont()
+                    ? fontManager.getEmbeddedResourceName()
+                    : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
+                textWidth = fontManager.measureText(cell.text, resourceName, cell.fontSize);
+            }
             const cellContentWidth = cell.rect.width -
                 (CELL_PADDING_H + cell.borderInsets.left) -
                 (CELL_PADDING_H + cell.borderInsets.right);
@@ -915,7 +1295,7 @@ function computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleC
                     break;
                 }
                 const neighborCell = cellGrid.get(`${ri}:${j}`);
-                if (neighborCell?.text) {
+                if (neighborCell?.text || neighborCell?.richText) {
                     break;
                 }
                 overflowAvailable += groupColWidths[j];