合同：打印模板调整

@@ -1253,13 +1253,41 @@ public class ContractDistributorStandardController extends DefaultBaseController
                         }
                     }
 
+                    int contractSpecFontSize = Integer.MAX_VALUE;
+                    for (SpecImageCell specCell : specImageCells) {
+                        int currentFontSize = LatexFormulaExcelExporterUtil.calculateContractReferenceFontSize(
+                                workbook,
+                                sheet,
+                                specCell.rowIndex,
+                                specCell.colIndex
+                        );
+                        contractSpecFontSize = Math.min(contractSpecFontSize, currentFontSize);
+                    }
+                    if (contractSpecFontSize == Integer.MAX_VALUE) {
+                        contractSpecFontSize = 16;
+                    }
+
+                    double contractSpecScale = 1.0;
+                    for (SpecImageCell specCell : specImageCells) {
+                        double currentScale = LatexFormulaExcelExporterUtil.calculateContractReferenceFitScale(
+                                workbook,
+                                sheet,
+                                specCell.rowIndex,
+                                specCell.colIndex,
+                                contractSpecFontSize
+                        );
+                        contractSpecScale = Math.min(contractSpecScale, currentScale);
+                    }
+
                     for (SpecImageCell specCell : specImageCells) {
                         LatexFormulaExcelExporterUtil.insertContractLatexImageToCellFillTemplate(
                                 workbook,
                                 sheet,
                                 specCell.latex,
                                 specCell.rowIndex,
-                                specCell.colIndex
+                                specCell.colIndex,
+                                contractSpecFontSize,
+                                contractSpecScale
                         );
                     }
 

@@ -24,6 +24,9 @@ import java.util.List;
 @Slf4j
 public class LatexFormulaExcelExporterUtil {
 
+    private static final String CONTRACT_SPEC_REFERENCE_LATEX =
+            "\\mathbf{\\mathrm{22^{+0.2}_{+0.1}\\!\\times\\!22^{+0.2}_{+0.1}\\!\\times\\!22^{+0.2}_{+0.1}}}";
+
     public static String convertToLatex(List<FormulaComponent> componentList) {
         if (CollectionUtils.isEmpty(componentList)) {
             return "";
@@ -97,11 +100,12 @@ public class LatexFormulaExcelExporterUtil {
             return "";
         }
 
+        String referenceComponentLatex = resolveReferenceComponentLatex(componentList);
         int missing = Math.max(0, 3 - nonNullCount);
         if (missing > 0) {
             StringBuilder phantom = new StringBuilder();
             for (int i = 0; i < missing; i++) {
-                phantom.append(" \\times 000^{+00}_{+00}");
+                phantom.append(" \\times ").append(referenceComponentLatex);
             }
             actual = actual + "\\phantom{" + phantom + "}";
         }
@@ -129,11 +133,12 @@ public class LatexFormulaExcelExporterUtil {
             return "";
         }
 
+        String referenceComponentLatex = resolveReferenceComponentLatex(componentList);
         int missing = Math.max(0, 3 - nonNullCount);
         if (missing > 0) {
             StringBuilder phantom = new StringBuilder();
             for (int i = 0; i < missing; i++) {
-                phantom.append("\\!\\times\\!000^{+00}_{+00}");
+                phantom.append("\\!\\times\\!").append(referenceComponentLatex);
             }
             actual = actual + "\\phantom{" + phantom + "}";
         }
@@ -158,21 +163,45 @@ public class LatexFormulaExcelExporterUtil {
                 latex.append(separator);
             }
             first = false;
+            latex.append(buildLatexComponent(comp));
+        }
+        return latex.toString();
+    }
 
-            latex.append(formatScientificNotation(comp.getBase()));
-            if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) >= 0) {
-                latex.append("^{+").append(formatScientificNotation(comp.getSup())).append("}");
+    private static String resolveReferenceComponentLatex(List<FormulaComponent> componentList) {
+        String reference = "000^{+00}_{+00}";
+        int maxLength = reference.length();
+        for (FormulaComponent comp : componentList) {
+            if (comp == null || comp.getBase() == null) {
+                continue;
             }
-            if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) < 0) {
-                latex.append("^{").append(formatScientificNotation(comp.getSup())).append("}");
+            String candidate = buildLatexComponent(comp);
+            if (candidate.length() > maxLength) {
+                reference = candidate;
+                maxLength = candidate.length();
             }
+        }
+        return reference;
+    }
 
-            if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) >= 0) {
-                latex.append("_{+").append(formatScientificNotation(comp.getSub())).append("}");
-            }
-            if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) < 0) {
-                latex.append("_{").append(formatScientificNotation(comp.getSub())).append("}");
-            }
+    private static String buildLatexComponent(FormulaComponent comp) {
+        if (comp == null || comp.getBase() == null) {
+            return "";
+        }
+        StringBuilder latex = new StringBuilder();
+        latex.append(formatScientificNotation(comp.getBase()));
+        if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) >= 0) {
+            latex.append("^{+").append(formatScientificNotation(comp.getSup())).append("}");
+        }
+        if (comp.getSup() != null && comp.getSup().compareTo(BigDecimal.ZERO) < 0) {
+            latex.append("^{").append(formatScientificNotation(comp.getSup())).append("}");
+        }
+
+        if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) >= 0) {
+            latex.append("_{+").append(formatScientificNotation(comp.getSub())).append("}");
+        }
+        if (comp.getSub() != null && comp.getSub().compareTo(BigDecimal.ZERO) < 0) {
+            latex.append("_{").append(formatScientificNotation(comp.getSub())).append("}");
         }
         return latex.toString();
     }
@@ -295,6 +324,17 @@ public class LatexFormulaExcelExporterUtil {
     public static void insertContractLatexImageToCellFillTemplate(Workbook workbook, Sheet sheet, String latex,
                                                                   int rowIndex, int colIndex) throws IOException {
         int baseFontSize = Math.max(16, resolveCellFontSize(workbook, sheet, rowIndex, colIndex));
+        insertContractLatexImageToCellFillTemplate(workbook, sheet, latex, rowIndex, colIndex, baseFontSize);
+    }
+
+    public static void insertContractLatexImageToCellFillTemplate(Workbook workbook, Sheet sheet, String latex,
+                                                                  int rowIndex, int colIndex, int baseFontSize) throws IOException {
+        insertContractLatexImageToCellFillTemplate(workbook, sheet, latex, rowIndex, colIndex, baseFontSize, null);
+    }
+
+    public static void insertContractLatexImageToCellFillTemplate(Workbook workbook, Sheet sheet, String latex,
+                                                                  int rowIndex, int colIndex, int baseFontSize,
+                                                                  Double maxScale) throws IOException {
         CellRangeAddress mergedRegion = findMergedRegion(sheet, rowIndex, colIndex);
         if (mergedRegion != null) {
             insertContractLatexImageToRegionFillTemplate(
@@ -305,11 +345,57 @@ public class LatexFormulaExcelExporterUtil {
                     mergedRegion.getFirstColumn(),
                     mergedRegion.getLastRow() - mergedRegion.getFirstRow() + 1,
                     mergedRegion.getLastColumn() - mergedRegion.getFirstColumn() + 1,
-                    baseFontSize
+                    baseFontSize,
+                    maxScale
             );
             return;
         }
-        insertContractLatexImageToRegionFillTemplate(workbook, sheet, latex, rowIndex, colIndex, 1, 1, baseFontSize);
+        insertContractLatexImageToRegionFillTemplate(workbook, sheet, latex, rowIndex, colIndex, 1, 1, baseFontSize, maxScale);
+    }
+
+    public static int calculateContractBestFontSize(Workbook workbook, Sheet sheet, String latex,
+                                                    int rowIndex, int colIndex) throws IOException {
+        int baseFontSize = Math.max(16, resolveCellFontSize(workbook, sheet, rowIndex, colIndex));
+        CellRangeAddress mergedRegion = findMergedRegion(sheet, rowIndex, colIndex);
+        if (mergedRegion != null) {
+            return calculateContractBestFontSizeForRegion(
+                    sheet,
+                    latex,
+                    mergedRegion.getFirstRow(),
+                    mergedRegion.getFirstColumn(),
+                    mergedRegion.getLastRow() - mergedRegion.getFirstRow() + 1,
+                    mergedRegion.getLastColumn() - mergedRegion.getFirstColumn() + 1,
+                    baseFontSize
+            );
+        }
+        return calculateContractBestFontSizeForRegion(sheet, latex, rowIndex, colIndex, 1, 1, baseFontSize);
+    }
+
+    public static int calculateContractReferenceFontSize(Workbook workbook, Sheet sheet,
+                                                         int rowIndex, int colIndex) throws IOException {
+        return calculateContractBestFontSize(workbook, sheet, CONTRACT_SPEC_REFERENCE_LATEX, rowIndex, colIndex);
+    }
+
+    public static double calculateContractFitScale(Workbook workbook, Sheet sheet, String latex,
+                                                   int rowIndex, int colIndex, int fontSize) throws IOException {
+        CellRangeAddress mergedRegion = findMergedRegion(sheet, rowIndex, colIndex);
+        if (mergedRegion != null) {
+            return calculateContractFitScaleForRegion(
+                    sheet,
+                    latex,
+                    mergedRegion.getFirstRow(),
+                    mergedRegion.getFirstColumn(),
+                    mergedRegion.getLastRow() - mergedRegion.getFirstRow() + 1,
+                    mergedRegion.getLastColumn() - mergedRegion.getFirstColumn() + 1,
+                    fontSize
+            );
+        }
+        return calculateContractFitScaleForRegion(sheet, latex, rowIndex, colIndex, 1, 1, fontSize);
+    }
+
+    public static double calculateContractReferenceFitScale(Workbook workbook, Sheet sheet,
+                                                            int rowIndex, int colIndex, int fontSize) throws IOException {
+        return calculateContractFitScale(workbook, sheet, CONTRACT_SPEC_REFERENCE_LATEX, rowIndex, colIndex, fontSize);
     }
 
     private static final int EMU_PER_PX = 9525;
@@ -478,7 +564,7 @@ public class LatexFormulaExcelExporterUtil {
 
     private static void insertContractLatexImageToRegionFillTemplate(Workbook workbook, Sheet sheet, String latex,
                                                                      int rowIndex, int colIndex, int rowRange, int colRange,
-                                                                     int baseFontSize) throws IOException {
+                                                                     int baseFontSize, Double maxScale) throws IOException {
         int regionWidthPx = 0;
         for (int c = colIndex; c < colIndex + colRange; c++) {
             regionWidthPx += getColumnWidthPx(sheet, c);
@@ -488,26 +574,29 @@ public class LatexFormulaExcelExporterUtil {
             regionHeightPx += getRowHeightPx(sheet, r);
         }
 
-        int paddingXPx = 4;
-        int paddingYPx = 2;
+        int paddingXPx = 6;
+        int paddingYPx = 4;
         int availableWidthPx = Math.max(1, regionWidthPx - paddingXPx * 2);
         int availableHeightPx = Math.max(1, regionHeightPx - paddingYPx * 2);
-        RenderedLatexImage renderedImage = renderBestFitLatexImageByHeight(
-                latex,
-                baseFontSize,
-                availableHeightPx
-        );
+        RenderedLatexImage renderedImage = renderLatexImage(latex, baseFontSize);
         if (renderedImage.image == null) {
             return;
         }
 
         byte[] imageBytes = renderedImage.imageBytes;
         BufferedImage image = renderedImage.image;
-        int scaledHeightPx = availableHeightPx;
-        int widthByHeightPx = Math.max(1, (int) Math.round(
-                (double) image.getWidth() * scaledHeightPx / Math.max(1, image.getHeight())
-        ));
-        int scaledWidthPx = Math.min(availableWidthPx, widthByHeightPx);
+        double scale = Math.min(
+                1.0,
+                Math.min(
+                        (double) availableWidthPx / Math.max(1, image.getWidth()),
+                        (double) availableHeightPx / Math.max(1, image.getHeight())
+                )
+        );
+        if (maxScale != null) {
+            scale = Math.min(scale, maxScale);
+        }
+        int scaledWidthPx = Math.max(1, (int) Math.round(image.getWidth() * scale));
+        int scaledHeightPx = Math.max(1, (int) Math.round(image.getHeight() * scale));
 
         int offsetXPx = Math.max(paddingXPx, (regionWidthPx - scaledWidthPx) / 2);
         int offsetYPx = Math.max(paddingYPx, (regionHeightPx - scaledHeightPx) / 2);
@@ -566,6 +655,55 @@ public class LatexFormulaExcelExporterUtil {
         drawing.createPicture(anchor, pictureIdx);
     }
 
+    private static int calculateContractBestFontSizeForRegion(Sheet sheet, String latex,
+                                                              int rowIndex, int colIndex, int rowRange, int colRange,
+                                                              int preferredFontSize) throws IOException {
+        int regionWidthPx = 0;
+        for (int c = colIndex; c < colIndex + colRange; c++) {
+            regionWidthPx += getColumnWidthPx(sheet, c);
+        }
+        int regionHeightPx = 0;
+        for (int r = rowIndex; r < rowIndex + rowRange; r++) {
+            regionHeightPx += getRowHeightPx(sheet, r);
+        }
+
+        int paddingXPx = 3;
+        int paddingYPx = 1;
+        int availableWidthPx = Math.max(1, regionWidthPx - paddingXPx * 2);
+        int availableHeightPx = Math.max(1, regionHeightPx - paddingYPx * 2);
+        return renderBestFitLatexFontSize(latex, preferredFontSize, availableWidthPx, availableHeightPx);
+    }
+
+    private static double calculateContractFitScaleForRegion(Sheet sheet, String latex,
+                                                             int rowIndex, int colIndex, int rowRange, int colRange,
+                                                             int fontSize) throws IOException {
+        int regionWidthPx = 0;
+        for (int c = colIndex; c < colIndex + colRange; c++) {
+            regionWidthPx += getColumnWidthPx(sheet, c);
+        }
+        int regionHeightPx = 0;
+        for (int r = rowIndex; r < rowIndex + rowRange; r++) {
+            regionHeightPx += getRowHeightPx(sheet, r);
+        }
+
+        int paddingXPx = 6;
+        int paddingYPx = 4;
+        int availableWidthPx = Math.max(1, regionWidthPx - paddingXPx * 2);
+        int availableHeightPx = Math.max(1, regionHeightPx - paddingYPx * 2);
+        RenderedLatexImage renderedImage = renderLatexImage(latex, fontSize);
+        if (renderedImage.image == null) {
+            return 1.0;
+        }
+
+        return Math.min(
+                1.0,
+                Math.min(
+                        (double) availableWidthPx / Math.max(1, renderedImage.image.getWidth()),
+                        (double) availableHeightPx / Math.max(1, renderedImage.image.getHeight())
+                )
+        );
+    }
+
     private static int getColumnWidthPx(Sheet sheet, int colIndex) {
         int widthUnits = sheet.getColumnWidth(colIndex);
         return Math.max(1, (int) Math.round(widthUnits / 256.0 * 7.0 + 5));
@@ -577,26 +715,26 @@ public class LatexFormulaExcelExporterUtil {
         return Math.max(1, (int) Math.round(points * 96.0 / 72.0));
     }
 
-    private static RenderedLatexImage renderBestFitLatexImageByHeight(String latex, int preferredFontSize,
-                                                                      int targetHeightPx) throws IOException {
+    private static int renderBestFitLatexFontSize(String latex, int preferredFontSize,
+                                                  int targetWidthPx, int targetHeightPx) throws IOException {
         int minFontSize = 8;
         int maxFontSize = Math.max(minFontSize, preferredFontSize + 40);
         maxFontSize = Math.min(96, maxFontSize);
         int left = minFontSize;
         int right = maxFontSize;
-        RenderedLatexImage best = renderLatexImage(latex, minFontSize);
+        int bestFontSize = minFontSize;
 
         while (left <= right) {
             int mid = (left + right) >>> 1;
             RenderedLatexImage candidate = renderLatexImage(latex, mid);
-            if (candidate.image != null && candidate.image.getHeight() <= targetHeightPx) {
-                best = candidate;
+            if (fitsWithin(candidate, targetWidthPx, targetHeightPx)) {
+                bestFontSize = mid;
                 left = mid + 1;
             } else {
                 right = mid - 1;
             }
         }
-        return best;
+        return bestFontSize;
     }
 
     private static RenderedLatexImage renderLatexImage(String latex, int fontSize) throws IOException {
@@ -659,6 +797,13 @@ public class LatexFormulaExcelExporterUtil {
         }
     }
 
+    private static boolean fitsWithin(RenderedLatexImage renderedImage, int targetWidthPx, int targetHeightPx) {
+        return renderedImage != null
+                && renderedImage.image != null
+                && renderedImage.image.getWidth() <= targetWidthPx
+                && renderedImage.image.getHeight() <= targetHeightPx;
+    }
+
     private static BufferedImage trimWhitespace(BufferedImage source, int whiteThreshold, int marginPx) {
         if (source == null || source.getWidth() <= 0 || source.getHeight() <= 0) {
             return source;