import type { IFreeze, Workbook } from '@univerjs/core';
|
|
import { Disposable, Inject, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';
|
import { IRenderManagerService, SpreadsheetSkeleton } from '@univerjs/engine-render';
|
import { SheetsSelectionsService } from '@univerjs/sheets';
|
import { SheetPrintInterceptorService, SheetSkeletonManagerService } from '@univerjs/sheets-ui';
|
|
import { isEmptyObject, isNullOrUndefined } from '../utils';
|
import {
|
DefaultPrintConfig,
|
JnpfPaperPaddingForType,
|
JnpfPrintAreaEnum,
|
JnpfPrintCustomFooterEnum,
|
JnpfPrintCustomHeaderEnum,
|
JnpfPrintDirectionEnum,
|
JnpfPrintFreezeEnum,
|
JnpfPrintOtherParamsEnum,
|
JnpfPrintPaperSizeForType,
|
JnpfPrintScaleEnum,
|
} from '../utils/define';
|
import { buildUUID } from '../utils/uuid';
|
|
export class JnpfSheetsPrintService extends Disposable {
|
private _configParams: Record<string, any> = {};
|
private _layoutHeaderFooterParams: any[] = [];
|
|
constructor(
|
@IUniverInstanceService protected readonly _univerInstanceService: IUniverInstanceService,
|
@IRenderManagerService private readonly _renderManagerService: IRenderManagerService,
|
@Inject(SheetsSelectionsService) private readonly _selectionManagerService: SheetsSelectionsService,
|
@Inject(SheetPrintInterceptorService) private readonly _sheetPrintInterceptorService: SheetPrintInterceptorService,
|
) {
|
super();
|
}
|
|
/**
|
* 根据配置获取打印布局。
|
* @param {any} printConfig - 打印配置对象，默认为 `DefaultPrintConfig`。
|
*/
|
getLayouts(printConfig: any = DefaultPrintConfig) {
|
// 分析布局的页眉和页脚配置，并将结果存储在 `_layoutHeaderFooterParams` 中
|
this._layoutHeaderFooterParams = this._analyseLayoutHeaderFooterConfig(printConfig);
|
|
// 获取参数出来判断是不是存在冻结
|
const subUnitId = this._getWorkbook()!.getActiveSheet()?.getSheetId();
|
if (!subUnitId) {
|
return;
|
}
|
|
const snapshot = this._getWorkbook()!.save();
|
|
let freeze = [];
|
|
switch (printConfig.printArea) {
|
case JnpfPrintAreaEnum.currentSheet: {
|
const { xSplit = 0, ySplit = 0 } = snapshot?.sheets?.[subUnitId]?.freeze ?? {};
|
|
// 正确的冻结状态判断
|
const colHasFreeze = xSplit > 0; // 列冻结（xSplit 对应列冻结）
|
const rowHasFreeze = ySplit > 0; // 行冻结（ySplit 对应行冻结）
|
|
// 判断冻结状态【判断是单体还是全部，全部的话判断有开就有，没开就没有】
|
freeze = [
|
rowHasFreeze && printConfig?.yFreeze && JnpfPrintFreezeEnum.row, // 行冻结
|
colHasFreeze && printConfig?.xFreeze && JnpfPrintFreezeEnum.column, // 列冻结
|
].filter(Boolean); // 过滤掉 false/null/undefined
|
|
break;
|
}
|
case JnpfPrintAreaEnum.partSheets: {
|
const { sheets } = snapshot;
|
const { partSheets = [] } = printConfig;
|
|
const colHasFreeze =
|
Object.values(sheets).some((sheet: any) => {
|
return partSheets.includes(sheet.id) ? sheet?.freeze?.xSplit > 0 : false;
|
}) && printConfig?.xFreeze;
|
const rowHasFreeze =
|
Object.values(sheets).some((sheet: any) => {
|
return partSheets.includes(sheet.id) ? sheet?.freeze?.ySplit > 0 : false;
|
}) && printConfig?.yFreeze;
|
|
if (colHasFreeze) {
|
freeze.push('column');
|
}
|
if (rowHasFreeze) {
|
freeze.push('row');
|
}
|
|
break;
|
}
|
case JnpfPrintAreaEnum.workbook: {
|
const { sheets } = snapshot;
|
const colHasFreeze = Object.values(sheets).some((sheet: any) => sheet?.freeze?.xSplit > 0) && printConfig?.xFreeze;
|
const rowHasFreeze = Object.values(sheets).some((sheet: any) => sheet?.freeze?.ySplit > 0) && printConfig?.yFreeze;
|
|
if (colHasFreeze) {
|
freeze.push('column');
|
}
|
if (rowHasFreeze) {
|
freeze.push('row');
|
}
|
|
break;
|
}
|
// No default
|
}
|
|
// 提取剩余配置
|
const { xFreeze, yFreeze, ...restPrintConfig } = printConfig ?? {};
|
|
// 将配置参数存储在 `_configParams` 中
|
this._configParams = {
|
...restPrintConfig,
|
freeze,
|
};
|
|
// 获取所有需要打印的范围
|
const printRanges = this._computePrintRanges();
|
// 初始化空数组，用于存储计算出的布局
|
const layouts: any[] = [];
|
|
// 遍历每个打印范围，计算对应的页面布局
|
printRanges?.forEach(range => {
|
// 如果当前范围存在，继续处理
|
if (range) {
|
// 计算页面布局
|
const pageLayout = this._computePageLayout(range);
|
|
// 如果页面布局存在，将其添加到 layouts 数组中
|
if (pageLayout) {
|
layouts.push(pageLayout);
|
}
|
}
|
});
|
|
// 获取纸张大小
|
const paperSize = this._getPaperSize();
|
// 获取纸张边距
|
const paperPadding = this._getPaperPadding();
|
|
// 整个需要打印的页码数量
|
const bookTotalPage = layouts.reduce((total, layout) => total + layout.pages.length, 0);
|
|
let bookPageNumber = 1;
|
const pagesLayout = layouts.flatMap(({ pages: pageRanges, ...info }) =>
|
pageRanges.map((range: any, rangeIndex: any) => ({
|
...info,
|
bookPageNumber: bookPageNumber++,
|
bookTotalPage,
|
browserPreviewScale: 1,
|
layoutId: `layout_${buildUUID()}`,
|
paperPadding,
|
paperSize,
|
range,
|
sheetPageNumber: rangeIndex + 1, // layout 内部页码从 1 开始
|
sheetTotalPage: pageRanges?.length,
|
})),
|
);
|
|
return {
|
pagesLayout,
|
paperSize,
|
printConfig: {
|
...this._configParams,
|
currentDateTime: new Date(Date.now() + 8 * 3600 * 1000).toJSON().slice(0, 19).replace('T', ' '),
|
headerFooterParams: this._layoutHeaderFooterParams,
|
},
|
};
|
}
|
|
/**
|
* 解析页面布局中的页眉和页脚配置。
|
* @param {any} printConfig - 页眉页脚的配置对象，包含多个布尔值属性来决定是否显示某些信息。
|
* @returns 返回需要在页眉或页脚中包含的参数数组。
|
*/
|
private _analyseLayoutHeaderFooterConfig(printConfig: any) {
|
// 定义一个数组，用于存储需要包含的页眉和页脚参数
|
const layoutHeaderFooterParams = [];
|
|
if (printConfig.headerFooterType === 'default') {
|
if (printConfig?.workbookTitle) {
|
layoutHeaderFooterParams.push(JnpfPrintOtherParamsEnum.workbookTitle);
|
}
|
if (printConfig?.worksheetTitle) {
|
layoutHeaderFooterParams.push(JnpfPrintOtherParamsEnum.worksheetTitle);
|
}
|
if (printConfig?.printDate) {
|
layoutHeaderFooterParams.push(JnpfPrintOtherParamsEnum.printDate);
|
}
|
if (printConfig?.printTime) {
|
layoutHeaderFooterParams.push(JnpfPrintOtherParamsEnum.printTime);
|
}
|
if (printConfig?.pageNumber) {
|
layoutHeaderFooterParams.push(JnpfPrintOtherParamsEnum.pageNumber);
|
}
|
} else {
|
if (printConfig.customHeaderFooterValue?.leftTop) {
|
layoutHeaderFooterParams.push(JnpfPrintCustomHeaderEnum.leftTop);
|
}
|
if (printConfig.customHeaderFooterValue?.centerTop) {
|
layoutHeaderFooterParams.push(JnpfPrintCustomHeaderEnum.centerTop);
|
}
|
if (printConfig.customHeaderFooterValue?.rightTop) {
|
layoutHeaderFooterParams.push(JnpfPrintCustomHeaderEnum.rightTop);
|
}
|
if (printConfig.customHeaderFooterValue?.leftBottom) {
|
layoutHeaderFooterParams.push(JnpfPrintCustomFooterEnum.leftBottom);
|
}
|
if (printConfig.customHeaderFooterValue?.centerBottom) {
|
layoutHeaderFooterParams.push(JnpfPrintCustomFooterEnum.centerBottom);
|
}
|
if (printConfig.customHeaderFooterValue?.rightBottom) {
|
layoutHeaderFooterParams.push(JnpfPrintCustomFooterEnum.rightBottom);
|
}
|
}
|
|
// 返回最终解析出来的页眉页脚参数数组
|
return layoutHeaderFooterParams;
|
}
|
|
/**
|
* 计算页面布局，根据给定的打印范围和工作表的骨架信息，计算每一页的布局。
|
* @param printRange {any} 打印范围，包含工作簿信息、工作表信息、打印范围、冻结信息、缩放比例及内容尺寸
|
* @returns 返回计算出的页面布局信息
|
*/
|
private _computePageLayout(printRange: any) {
|
// 解构打印范围信息
|
const { contentSize, freeze, printScale, range, subUnitId, unitId } = printRange ?? {};
|
|
// 获取工作表的骨架信息
|
const skeleton = this._getUnitSkeleton(unitId, subUnitId);
|
if (!skeleton) {
|
return;
|
}
|
|
// 解构工作表的行高和列宽累计值
|
const { columnWidthAccumulation, rowHeightAccumulation } = skeleton;
|
|
// 解构打印范围的行列信息
|
const { endColumn, endRow, startColumn, startRow } = range;
|
|
const calcRow = (start: any) => {
|
let end = start;
|
const offset = start === 0 ? 0 : rowHeightAccumulation[start - 1];
|
for (; end < endRow; end++) {
|
const current = (rowHeightAccumulation[end] - offset) * printScale;
|
const next = (rowHeightAccumulation[end + 1] - offset) * printScale;
|
if (current > contentSize.h || (current < contentSize.h && next > contentSize.h)) return { endRow: end - 1, startRow: start };
|
}
|
return { endRow: end, startRow: start };
|
};
|
|
const calcColumn = (start: any) => {
|
let end = start;
|
const offset = start === 0 ? 0 : columnWidthAccumulation[start - 1];
|
for (; end < endColumn; end++) {
|
const current = (columnWidthAccumulation[end] - offset) * printScale;
|
const next = (columnWidthAccumulation[end + 1] - offset) * printScale;
|
|
if (current >= contentSize.w || (current < contentSize.w && next > contentSize.w)) {
|
return { endColumn: end, startColumn: start };
|
}
|
}
|
return { endColumn: end, startColumn: start };
|
};
|
|
// 计算所有行的分页范围
|
const rows = [];
|
for (let start = startRow; start <= endRow; ) {
|
const row = calcRow(start);
|
rows.push(row);
|
start = row.endRow + 1; // 移动到下一个分页起始行
|
}
|
|
// 计算所有列的分页范围
|
const columns: any[] = [];
|
for (let start = startColumn; start <= endColumn; ) {
|
const column = calcColumn(start);
|
columns.push(column);
|
start = column.endColumn + 1; // 移动到下一个分页起始列
|
}
|
|
// 将行列的分页信息组合成每一页的布局
|
const pages: any[] = [];
|
rows.forEach(row => {
|
columns.forEach(column => {
|
pages.push({ ...row, ...column });
|
});
|
});
|
|
// 返回计算的页面布局信息，包括单位ID、子单位ID、页面信息、冻结信息和缩放比例
|
return { freeze, pages, printScale, subUnitId, unitId };
|
}
|
|
/**
|
* 计算并返回打印页面的范围，包括内容区域、冻结行列以及打印比例。
|
* @param {string} subUnitId - 工作表的唯一标识符。
|
* @param {any} sheetRange - 需要打印的工作表范围，包含起始和结束的行列。
|
* @returns 返回打印页面的范围、冻结信息、内容区域和打印比例。
|
*/
|
private _computePrintPageRange(subUnitId: string, sheetRange: any) {
|
// 获取工作簿实例
|
const workbook = this._getWorkbook();
|
|
// 如果没有获取到工作簿，返回 undefined
|
if (!workbook) {
|
return;
|
}
|
|
// 获取工作簿的唯一标识符
|
const unitId = workbook!.getUnitId();
|
|
// 获取纸张大小
|
const paperSize = this._getPaperSize();
|
if (!paperSize) {
|
return;
|
}
|
|
// 获取纸张的边距
|
const paperPadding = this._getPaperPadding();
|
if (!paperPadding) {
|
return;
|
}
|
|
// 计算内容区域的大小，减去左右、上下的边距
|
const contentSize = {
|
h: paperSize.h - (paperPadding.top + paperPadding.bottom),
|
w: paperSize.w - (paperPadding.left + paperPadding.right),
|
};
|
|
// 如果起始行列小于等于 -1，返回默认的打印范围，表示无效的打印范围
|
if (sheetRange?.startRow <= -1 || sheetRange?.startColumn <= -1) {
|
return {
|
contentSize,
|
freeze: { startColumn: -1, startRow: -1, xSplit: 0, ySplit: 0 },
|
printScale: 1,
|
range: { endColumn: 0, endRow: 0, startColumn: 0, startRow: 0 },
|
subUnitId,
|
unitId,
|
};
|
}
|
|
// 获取工作表实例
|
const worksheet = workbook!.getSheetBySheetId(subUnitId);
|
if (!worksheet) {
|
return;
|
}
|
|
// 获取工作表的冻结信息
|
const freeze = worksheet?.getFreeze();
|
if (!freeze) {
|
return;
|
}
|
|
// 获取工作表的骨架信息（如列宽、行高等）
|
const skeleton = this._getUnitSkeleton(unitId, subUnitId);
|
if (!skeleton) {
|
return;
|
}
|
|
// 计算打印比例
|
const printScale = this._computePrintScale(skeleton, sheetRange, freeze);
|
|
// 初始化打印范围和冻结信息的默认值
|
let startColumn = -1;
|
let startRow = -1;
|
let xSplit = 0;
|
let ySplit = 0;
|
|
// 获取骨架中的列宽和行高累积数据
|
const { columnWidthAccumulation, rowHeightAccumulation } = skeleton ?? {};
|
let { endColumn: sheetRangeEndColumn, endRow: sheetRangeEndRow, startColumn: sheetRangeStartColumn, startRow: sheetRangeStartRow } = sheetRange ?? {};
|
const { startColumn: freezeStartColumn, startRow: freezeStartRow, xSplit: freezeXSplit, ySplit: freezeYSplit } = freeze ?? {};
|
|
// 处理冻结行（如果配置了冻结行）
|
if (freezeYSplit && this._configParams?.freeze.includes(JnpfPrintFreezeEnum?.row)) {
|
// 如果打印范围的结束行大于等于冻结行，则计算冻结区域的高度并调整打印区域的高度
|
if (sheetRangeEndRow >= freezeStartRow) {
|
const offsetHeight = rowHeightAccumulation[freezeStartRow] - rowHeightAccumulation[freezeStartRow - freezeYSplit];
|
|
if (offsetHeight < contentSize?.h) {
|
startRow = freezeStartRow;
|
ySplit = freezeYSplit;
|
contentSize.h -= offsetHeight;
|
}
|
} else {
|
// 如果打印范围的结束行小于冻结行，则计算冻结区域的高度并调整打印区域的高度
|
startRow = sheetRangeEndRow + 1;
|
ySplit = sheetRangeEndRow + 1 - (freezeStartRow - freezeYSplit);
|
contentSize.h = contentSize?.h - rowHeightAccumulation[freezeStartRow] - rowHeightAccumulation[freezeStartRow - freezeYSplit];
|
}
|
}
|
|
// 更新起始行，确保不小于冻结区域的起始行
|
sheetRangeStartRow = Math.max(startRow, sheetRangeStartRow);
|
|
// 处理冻结列（如果配置了冻结列）
|
if (freezeXSplit && this._configParams?.freeze.includes(JnpfPrintFreezeEnum?.column)) {
|
// 如果打印范围的结束列大于等于冻结列，则计算冻结区域的宽度并调整打印区域的宽度
|
if (sheetRangeEndColumn >= freezeStartColumn) {
|
const offsetWidth =
|
printScale * (columnWidthAccumulation[freezeStartColumn - 1] - (columnWidthAccumulation[freezeStartColumn - freezeXSplit - 1] || 0));
|
|
if (offsetWidth < contentSize?.w) {
|
startColumn = freezeStartColumn;
|
xSplit = freezeXSplit;
|
contentSize.w -= offsetWidth;
|
}
|
} else {
|
// 如果打印范围的结束列小于冻结列，则计算冻结区域的宽度并调整打印区域的宽度
|
const offsetWidth =
|
printScale * (columnWidthAccumulation[freezeStartColumn - 1] - (columnWidthAccumulation[freezeStartColumn - freezeXSplit] - 1 || 0));
|
|
if (offsetWidth < contentSize?.w) {
|
const startColumnCache = sheetRangeEndColumn + 1;
|
const xSplitCache = sheetRangeEndColumn + 1 - (freezeStartColumn - freezeXSplit);
|
|
startColumn = startColumnCache;
|
xSplit = xSplitCache;
|
contentSize.w -= offsetWidth;
|
}
|
}
|
}
|
|
// 更新起始列，确保不小于冻结区域的起始列
|
sheetRangeStartColumn = Math.max(startColumn, sheetRangeStartColumn);
|
|
// 返回计算出的打印页面范围，包含打印区域、冻结信息、内容大小和打印比例
|
return {
|
contentSize,
|
freeze: { startColumn, startRow, xSplit, ySplit },
|
printScale,
|
range: { endColumn: sheetRangeEndColumn, endRow: sheetRangeEndRow, startColumn: sheetRangeStartColumn, startRow: sheetRangeStartRow },
|
subUnitId,
|
unitId,
|
};
|
}
|
|
/**
|
* 计算打印范围，根据配置的区域选择合适的打印范围。
|
* @returns 返回包含一个或多个打印范围的数组。
|
*/
|
private _computePrintRanges() {
|
// 初始化空数组 result，用于存储计算的打印范围
|
let result: any[] = [];
|
|
// 根据配置的打印区域 执行不同的处理
|
switch (this._configParams.printArea) {
|
// 如果区域是当前选择的区域
|
case JnpfPrintAreaEnum.currentSelection: {
|
// 计算当前选择区域的打印范围，并返回该范围的数组
|
result = [this._computePrintSelectionRange()];
|
break;
|
}
|
|
// 如果区域是当前工作表
|
case JnpfPrintAreaEnum.currentSheet: {
|
// 获取当前活动工作表的 ID
|
const subUnitId = this._getWorkbook()!.getActiveSheet()?.getSheetId();
|
|
// 如果工作表 ID 不存在，则跳出
|
if (!subUnitId) {
|
break;
|
}
|
|
// 计算当前工作表的打印范围
|
const range = this._computePrintSheetRange(subUnitId);
|
// 如果计算结果有效，返回一个包含该范围的数组
|
result = range ? [range] : [];
|
break;
|
}
|
|
// 如果区域是部分工作簿
|
case JnpfPrintAreaEnum.partSheets: {
|
const partSheets = new Set(this._configParams.partSheets ?? []);
|
// 获取工作簿中的所有工作表
|
const sheets = this._getWorkbook()!.getSheets();
|
|
const targetSheets = sheets.filter(sheet => partSheets.has(sheet?.getSheetId()));
|
|
// 对每个工作表计算打印范围，并过滤掉无效的范围
|
result = targetSheets
|
?.map(sheet => {
|
const subUnitId = sheet?.getSheetId();
|
// 对每个工作表计算并返回其打印范围
|
return this._computePrintSheetRange(subUnitId);
|
})
|
.filter(Boolean); // 过滤掉无效值（如 null 或 undefined）
|
break;
|
}
|
|
// 如果区域是整个工作簿
|
case JnpfPrintAreaEnum.workbook: {
|
// 获取工作簿中的所有工作表
|
const sheets = this._getWorkbook()!.getSheets();
|
|
// 对每个工作表计算打印范围，并过滤掉无效的范围
|
result = sheets
|
?.map(sheet => {
|
const subUnitId = sheet?.getSheetId();
|
// 对每个工作表计算并返回其打印范围
|
return this._computePrintSheetRange(subUnitId);
|
})
|
.filter(Boolean); // 过滤掉无效值（如 null 或 undefined）
|
break;
|
}
|
|
// 如果区域类型不匹配，返回空数组
|
default: {
|
break;
|
}
|
}
|
|
// 返回计算出的打印范围数组
|
return result;
|
}
|
|
/**
|
* 计算打印比例。
|
* @param {SpreadsheetSkeleton} skeleton - 工作表的骨架信息，包括行高、列宽累积数据。
|
* @param {any} sheetRange - 打印的单元格范围，包括起始行、起始列、结束行、结束列。
|
* @param {IFreeze} freeze - 冻结范围信息，包括冻结的起始行列和冻结的分割范围。
|
* @returns 返回适合的打印缩放比例，范围在 [0, 1] 之间。
|
*/
|
private _computePrintScale(skeleton: SpreadsheetSkeleton, sheetRange: any, freeze: IFreeze) {
|
// 解构骨架中的列宽和行高累积信息
|
const { columnWidthAccumulation, rowHeightAccumulation } = skeleton ?? {};
|
|
// 骨架信息为空时，返回默认比例 1
|
if (isNullOrUndefined(columnWidthAccumulation) || isNullOrUndefined(rowHeightAccumulation)) {
|
return 1;
|
}
|
|
// 解构打印范围的起始和结束行列
|
const { endColumn: sheetRangeEndColumn, endRow: sheetRangeEndRow, startColumn: sheetRangeStartColumn, startRow: sheetRangeStartRow } = sheetRange ?? {};
|
|
// 打印范围信息为空时，返回默认比例 1
|
if (
|
isNullOrUndefined(sheetRangeStartRow) ||
|
isNullOrUndefined(sheetRangeStartColumn) ||
|
isNullOrUndefined(sheetRangeEndRow) ||
|
isNullOrUndefined(sheetRangeEndColumn)
|
) {
|
return 1;
|
}
|
|
// 解构冻结范围的起始行列和分割范围
|
const { startColumn: freezeStartColumn, startRow: freezeStartRow, xSplit: freezeXSplit, ySplit: freezeYSplit } = freeze ?? {};
|
|
// 冻结范围信息为空时，返回默认比例 1
|
if (isNullOrUndefined(freezeXSplit) || isNullOrUndefined(freezeYSplit) || isNullOrUndefined(freezeStartRow) || isNullOrUndefined(freezeStartColumn)) {
|
return 1;
|
}
|
|
// 确定打印范围的起始行：对冻结范围与打印范围取交集
|
const startRow = sheetRangeEndRow < freezeStartRow ? sheetRangeStartRow : Math.max(freezeStartRow, sheetRangeStartRow);
|
|
// 确定打印范围的起始列：对冻结范围与打印范围取交集
|
const startColumn = sheetRangeEndColumn < freezeStartColumn ? sheetRangeStartColumn : Math.max(freezeStartColumn, sheetRangeStartColumn);
|
|
// 获取纸张尺寸
|
const paperSize = this._getPaperSize();
|
if (!paperSize) {
|
return 1;
|
}
|
|
// 获取纸张边距
|
const paperPadding = this._getPaperPadding();
|
if (!paperPadding) {
|
return 1;
|
}
|
|
// 计算冻结区域的宽度（列）和高度（行）
|
const xSplit = freezeXSplit > 0 ? columnWidthAccumulation[freezeStartColumn - 1] - (columnWidthAccumulation[freezeStartColumn - freezeXSplit - 1] || 0) : 0;
|
const ySplit = freezeYSplit > 0 ? rowHeightAccumulation[freezeStartRow - 1] - (rowHeightAccumulation[freezeStartRow - freezeYSplit - 1] || 0) : 0;
|
|
// 计算打印范围的高度和宽度
|
const rowHeight = rowHeightAccumulation[sheetRangeEndRow] - (rowHeightAccumulation[startRow - 1] || 0);
|
const columnWidth = columnWidthAccumulation[sheetRangeEndColumn] - (columnWidthAccumulation[startColumn - 1] || 0);
|
|
// 加上冻结区域的尺寸，得到总的打印高度和宽度
|
const xScale = columnWidth + xSplit;
|
const yScale = rowHeight + ySplit;
|
|
let result = 1;
|
|
// 根据配置参数计算打印比例
|
switch (this._configParams.printScale) {
|
case JnpfPrintScaleEnum.fitHeight: {
|
// 高度适应比例
|
result = Math.min(1, (paperSize.h - paperPadding.top - paperPadding.bottom) / yScale);
|
break;
|
}
|
case JnpfPrintScaleEnum.fitPage: {
|
// 页面完全适应比例（宽度和高度都适应）
|
result = Math.min(1, (paperSize.w - paperPadding.left - paperPadding.right) / xScale, (paperSize.h - paperPadding.top - paperPadding.bottom) / yScale);
|
break;
|
}
|
case JnpfPrintScaleEnum.fitWidth: {
|
// 宽度适应比例
|
result = Math.min(1, (paperSize.w - paperPadding.left - paperPadding.right) / xScale);
|
break;
|
}
|
default: {
|
break;
|
}
|
}
|
|
// 返回比例值，保留两位小数
|
return Math.floor(result * 100) / 100;
|
}
|
|
/**
|
* 计算并返回打印选择范围的详细信息。
|
* @returns 返回选区的打印范围信息。
|
*/
|
private _computePrintSelectionRange() {
|
// 获取当前工作簿实例
|
const workbook = this._getWorkbook();
|
|
// 如果没有获取到工作簿，返回 undefined
|
if (!workbook) {
|
return;
|
}
|
|
// 获取工作簿的唯一标识符
|
const unitId = workbook!.getUnitId();
|
|
// 获取当前活动工作表
|
const worksheet = workbook!.getActiveSheet();
|
|
// 如果没有获取到工作表，返回 undefined
|
if (!worksheet) {
|
return;
|
}
|
|
// 获取当前工作表的唯一标识符（subUnitId）
|
const subUnitId = worksheet?.getSheetId();
|
|
// 获取当前工作簿的最后选择区域
|
const lastSelection = this._selectionManagerService?.getWorkbookSelections(unitId)?.getCurrentLastSelection();
|
|
// 如果没有获取到选择区域，返回 undefined
|
if (!lastSelection) {
|
return;
|
}
|
|
// 根据最后选择的范围计算打印的页面范围
|
return this._computePrintPageRange(subUnitId, lastSelection?.range);
|
}
|
|
/**
|
* 计算工作表的打印范围。
|
* @param {string} subUnitId - 工作表的唯一标识符。
|
* @returns 返回计算出的打印范围，包含页面范围、冻结信息等。
|
*/
|
private _computePrintSheetRange(subUnitId: string) {
|
// 获取工作簿实例
|
const workbook = this._getWorkbook();
|
|
// 如果没有获取到工作簿，返回 undefined
|
if (!workbook) {
|
return;
|
}
|
|
// 获取工作簿的唯一标识符
|
const unitId = workbook!.getUnitId();
|
|
// 获取当前工作表
|
const worksheet = workbook!.getSheetBySheetId(subUnitId);
|
|
// 如果工作表不存在，返回 undefined
|
if (!worksheet) {
|
return;
|
}
|
|
// 获取工作表的骨架信息，包含如行列宽度、冻结状态等数据
|
const skeleton = this._getUnitSkeleton(unitId, subUnitId);
|
|
// 如果工作表的骨架信息不存在，返回 undefined
|
if (!skeleton) {
|
return;
|
}
|
|
// 获取工作表的冻结信息，包括冻结行列位置
|
const freeze = worksheet?.getFreeze();
|
|
// 如果冻结信息不存在，返回 undefined
|
if (!freeze) {
|
return;
|
}
|
|
// 获取当前工作表的单元格矩阵打印范围
|
const cellMatrixPrintRange = worksheet?.getCellMatrixPrintRange();
|
|
// 如果没有获取到单元格矩阵打印范围，返回 undefined
|
if (!cellMatrixPrintRange) {
|
return;
|
}
|
|
// 获取当前工作表骨架中的溢出缓存数据
|
const { overflowCache } = skeleton;
|
if (overflowCache) {
|
// 如果有溢出缓存，遍历其值并调整打印范围
|
overflowCache.forValue((_row: any, _col: any, value: any) => {
|
const { endColumn } = value;
|
|
// 如果溢出的单元格列超过当前打印范围的结束列，则调整打印范围
|
if (endColumn > cellMatrixPrintRange?.endColumn) {
|
cellMatrixPrintRange.endColumn = endColumn;
|
}
|
});
|
}
|
|
// 使用拦截器调整打印范围
|
const realCellMatrixPrintRange = this._sheetPrintInterceptorService.interceptor?.fetchThroughInterceptors(
|
this._sheetPrintInterceptorService.interceptor?.getInterceptPoints()?.PRINTING_RANGE,
|
)(cellMatrixPrintRange, { subUnitId, unitId });
|
|
// 返回最终计算出的打印页面范围，包括冻结行列的调整
|
return this._computePrintPageRange(subUnitId, {
|
// 调整起始行列位置，确保不小于零
|
...realCellMatrixPrintRange,
|
startColumn: Math.max(freeze.startColumn - freeze.xSplit, 0),
|
startRow: Math.max(freeze.startRow - freeze.ySplit, 0),
|
});
|
}
|
|
/**
|
* 获取当前配置的纸张边距信息。
|
* @returns 返回包含边距信息的对象，或者返回 `null`。
|
*/
|
private _getPaperPadding() {
|
// 从配置参数中解构获取边距类型（padding）
|
const { padding } = this._configParams ?? {};
|
|
// 根据边距类型从预定义的边距配置映射中查找对应的边距值
|
const paperPadding = JnpfPaperPaddingForType[padding as keyof typeof JnpfPaperPaddingForType] ?? {};
|
|
// 如果找到有效的边距配置，返回边距配置；否则返回 null
|
return isEmptyObject(paperPadding) ? null : paperPadding;
|
}
|
|
/**
|
* 获取当前配置的纸张大小。
|
* @returns 返回包含宽度和高度的纸张尺寸对象，或者返回 `null`。
|
*/
|
private _getPaperSize() {
|
// 从配置参数中解构获取纸张类型（paperType）和方向（direction）
|
const { direction, paperType } = this._configParams ?? {};
|
|
// 根据纸张类型获取对应的尺寸数据
|
const paperSize = JnpfPrintPaperSizeForType[paperType as keyof typeof JnpfPrintPaperSizeForType] ?? {};
|
// 如果纸张尺寸为空，返回 null
|
if (isEmptyObject(paperSize)) {
|
return null;
|
}
|
|
// 根据打印方向返回调整后的纸张尺寸
|
return direction === JnpfPrintDirectionEnum?.portrait
|
? { ...paperSize } // 如果是纵向模式，直接返回原始纸张尺寸
|
: {
|
h: paperSize?.w,
|
w: paperSize?.h, // 如果是横向模式，交换宽度和高度
|
};
|
}
|
|
/**
|
* 获取指定单元的骨架信息。
|
* @param {string} unitId - 单元的唯一标识符。
|
* @param {string} subUnitId - 子单元的唯一标识符。
|
* @returns 返回单元骨架信息对象，如果未找到则返回空对象。
|
*/
|
private _getUnitSkeleton(unitId: string, subUnitId: string) {
|
// 从 `RenderManagerService` 中获取指定单元 ID 的渲染服务
|
return (this._renderManagerService
|
?.getRenderById(unitId) // 根据单元 ID 获取对应的渲染服务
|
?.with(SheetSkeletonManagerService) // 使用骨架管理服务进行扩展
|
?.getUnitSkeleton(unitId, subUnitId)?.skeleton ?? {}) as any; // 获取单元对应的骨架信息 // 如果骨架信息不存在，则返回空对象 // 强制将返回值类型设置为 `any`
|
}
|
|
/**
|
* 获取当前活动的工作簿实例。
|
* @returns 返回当前活动的工作簿实例，如果不存在则返回 `undefined`。
|
*/
|
private _getWorkbook() {
|
// 使用 `UniverInstanceService` 获取当前类型为 `UNIVER_SHEET` 的活动单元实例
|
return this._univerInstanceService.getCurrentUnitForType<Workbook>(UniverInstanceType.UNIVER_SHEET);
|
}
|
}
|
