package org.apache.poi.xssf.usermodel.helpers;
import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.xssf.util.CTColComparator;
public CTCols addCleanColIntoCols(CTCols cols, CTCol col) {
boolean colOverlaps = false;
+ // a Map to remember overlapping columns
+ Map<Long, Boolean> overlappingCols = new LinkedHashMap<Long, Boolean>();
int sizeOfColArray = cols.sizeOfColArray();
for (int i = 0; i < sizeOfColArray; i++) {
CTCol ithCol = cols.getColArray(i);
// different behavior required for each of the 4 different
// overlapping types
if (overlappingType == NumericRanges.OVERLAPS_1_MINOR) {
+ // move the max border of the ithCol
+ // and insert a new column within the overlappingRange with merged column attributes
ithCol.setMax(overlappingRange[0] - 1);
- CTCol rangeCol = insertCol(cols, overlappingRange[0],
+ insertCol(cols, overlappingRange[0],
overlappingRange[1], new CTCol[] { ithCol, col });
i++;
- CTCol newCol = insertCol(cols, (overlappingRange[1] + 1), col
- .getMax(), new CTCol[] { col });
- i++;
} else if (overlappingType == NumericRanges.OVERLAPS_2_MINOR) {
+ // move the min border of the ithCol
+ // and insert a new column within the overlappingRange with merged column attributes
ithCol.setMin(overlappingRange[1] + 1);
- CTCol rangeCol = insertCol(cols, overlappingRange[0],
+ insertCol(cols, overlappingRange[0],
overlappingRange[1], new CTCol[] { ithCol, col });
i++;
- CTCol newCol = insertCol(cols, col.getMin(),
- (overlappingRange[0] - 1), new CTCol[] { col });
- i++;
} else if (overlappingType == NumericRanges.OVERLAPS_2_WRAPS) {
+ // merge column attributes, no new column is needed
setColumnAttributes(col, ithCol);
- if (col.getMin() != ithCol.getMin()) {
- CTCol newColBefore = insertCol(cols, col.getMin(), (ithCol
- .getMin() - 1), new CTCol[] { col });
- i++;
- }
- if (col.getMax() != ithCol.getMax()) {
- CTCol newColAfter = insertCol(cols, (ithCol.getMax() + 1),
- col.getMax(), new CTCol[] { col });
- i++;
- }
} else if (overlappingType == NumericRanges.OVERLAPS_1_WRAPS) {
+ // split the ithCol in three columns: before the overlappingRange, overlappingRange, and after the overlappingRange
+ // before overlappingRange
if (col.getMin() != ithCol.getMin()) {
- CTCol newColBefore = insertCol(cols, ithCol.getMin(), (col
+ insertCol(cols, ithCol.getMin(), (col
.getMin() - 1), new CTCol[] { ithCol });
i++;
}
+ // after the overlappingRange
if (col.getMax() != ithCol.getMax()) {
- CTCol newColAfter = insertCol(cols, (col.getMax() + 1),
+ insertCol(cols, (col.getMax() + 1),
ithCol.getMax(), new CTCol[] { ithCol });
i++;
}
+ // within the overlappingRange
ithCol.setMin(overlappingRange[0]);
ithCol.setMax(overlappingRange[1]);
setColumnAttributes(col, ithCol);
}
if (overlappingType != NumericRanges.NO_OVERLAPS) {
colOverlaps = true;
+ // remember overlapped columns
+ for (long j = overlappingRange[0]; j <= overlappingRange[1]; j++) {
+ overlappingCols.put(Long.valueOf(j), Boolean.TRUE);
+ }
}
}
if (!colOverlaps) {
- CTCol newCol = cloneCol(cols, col);
+ cloneCol(cols, col);
+ } else {
+ // insert new columns for ranges without overlaps
+ long colMin = -1;
+ for (long j = col.getMin(); j <= col.getMax(); j++) {
+ if (!Boolean.TRUE.equals(overlappingCols.get(Long.valueOf(j)))) {
+ if (colMin < 0) {
+ colMin = j;
+ }
+ if ((j + 1) > col.getMax() || Boolean.TRUE.equals(overlappingCols.get(Long.valueOf(j + 1)))) {
+ insertCol(cols, colMin, j, new CTCol[] { col });
+ colMin = -1;
+ }
+ }
+ }
}
sortColumns(cols);
return cols;
--- /dev/null
+/* ====================================================================
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+==================================================================== */
+
+package org.apache.poi.xssf.usermodel;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.util.POILogFactory;
+import org.apache.poi.util.POILogger;
+import org.apache.poi.xssf.XSSFTestDataSamples;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCol;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCols;
+
+/**
+ * Test asserts the POI produces <cols> element that could be read and properly interpreted by the MS Excel.
+ * For specification of the "cols" element see the chapter 3.3.1.16 of the "Office Open XML Part 4 - Markup Language Reference.pdf".
+ * The specification can be downloaded at http://www.ecma-international.org/publications/files/ECMA-ST/Office%20Open%20XML%201st%20edition%20Part%204%20(PDF).zip.
+ *
+ * <p><em>
+ * The test saves xlsx file on a disk if the system property is set:
+ * -Dpoi.test.xssf.output.dir=${workspace_loc}/poi/build/xssf-output
+ * </em>
+ *
+ */
+public class TestXSSFColGrouping extends TestCase {
+
+ private static final POILogger logger = POILogFactory.getLogger(TestXSSFColGrouping.class);
+
+
+ /**
+ * Tests that POI doesn't produce "col" elements without "width" attribute.
+ * POI-52186
+ */
+ public void testNoColsWithoutWidthWhenGrouping() {
+ XSSFWorkbook wb = new XSSFWorkbook();
+ XSSFSheet sheet = wb.createSheet("test");
+
+ sheet.setColumnWidth(4, 5000);
+ sheet.setColumnWidth(5, 5000);
+
+ sheet.groupColumn((short) 4, (short) 7);
+ sheet.groupColumn((short) 9, (short) 12);
+
+ wb = XSSFTestDataSamples.writeOutAndReadBack(wb, "testNoColsWithoutWidthWhenGrouping");
+ sheet = wb.getSheet("test");
+
+ CTCols cols = sheet.getCTWorksheet().getColsArray(0);
+ logger.log(POILogger.DEBUG, "test52186/cols:" + cols);
+ for (CTCol col : cols.getColList()) {
+ assertTrue("Col width attribute is unset: " + col.toString(), col.isSetWidth());
+ }
+ }
+
+ /**
+ * Tests that POI doesn't produce "col" elements without "width" attribute.
+ * POI-52186
+ */
+ public void testNoColsWithoutWidthWhenGroupingAndCollapsing() {
+ XSSFWorkbook wb = new XSSFWorkbook();
+ XSSFSheet sheet = wb.createSheet("test");
+
+ sheet.setColumnWidth(4, 5000);
+ sheet.setColumnWidth(5, 5000);
+
+ sheet.groupColumn((short) 4, (short) 5);
+
+ sheet.setColumnGroupCollapsed(4, true);
+
+ CTCols cols = sheet.getCTWorksheet().getColsArray(0);
+ logger.log(POILogger.DEBUG, "test52186_2/cols:" + cols);
+
+ wb = XSSFTestDataSamples.writeOutAndReadBack(wb, "testNoColsWithoutWidthWhenGroupingAndCollapsing");
+ sheet = wb.getSheet("test");
+
+ for (int i = 4; i <= 5; i++) {
+ assertEquals("Unexpected width of column "+ i, 5000, sheet.getColumnWidth(i));
+ }
+ cols = sheet.getCTWorksheet().getColsArray(0);
+ for (CTCol col : cols.getColList()) {
+ assertTrue("Col width attribute is unset: " + col.toString(), col.isSetWidth());
+ }
+ }
+
+ /**
+ * Test the cols element is correct in case of NumericRanges.OVERLAPS_2_WRAPS
+ */
+ public void testMergingOverlappingCols_OVERLAPS_2_WRAPS() {
+ XSSFWorkbook wb = new XSSFWorkbook();
+ XSSFSheet sheet = wb.createSheet("test");
+
+ CTCols cols = sheet.getCTWorksheet().getColsArray(0);
+ CTCol col = cols.addNewCol();
+ col.setMin(1 + 1);
+ col.setMax(4 + 1);
+ col.setWidth(20);
+ col.setCustomWidth(true);
+
+ sheet.groupColumn((short) 2, (short) 3);
+
+ sheet.getCTWorksheet().getColsArray(0);
+ logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_2_WRAPS/cols:" + cols);
+
+ assertEquals(0, cols.getColArray(0).getOutlineLevel());
+ assertEquals(2, cols.getColArray(0).getMin()); // 1 based
+ assertEquals(2, cols.getColArray(0).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(0).getCustomWidth());
+
+ assertEquals(1, cols.getColArray(1).getOutlineLevel());
+ assertEquals(3, cols.getColArray(1).getMin()); // 1 based
+ assertEquals(4, cols.getColArray(1).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(1).getCustomWidth());
+
+ assertEquals(0, cols.getColArray(2).getOutlineLevel());
+ assertEquals(5, cols.getColArray(2).getMin()); // 1 based
+ assertEquals(5, cols.getColArray(2).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(2).getCustomWidth());
+
+ assertEquals(3, cols.sizeOfColArray());
+
+ wb = XSSFTestDataSamples.writeOutAndReadBack(wb, "testMergingOverlappingCols_OVERLAPS_2_WRAPS");
+ sheet = wb.getSheet("test");
+
+ for (int i = 1; i <= 4; i++) {
+ assertEquals("Unexpected width of column "+ i, 20 * 256, sheet.getColumnWidth(i));
+ }
+ }
+
+ /**
+ * Test the cols element is correct in case of NumericRanges.OVERLAPS_1_WRAPS
+ */
+ public void testMergingOverlappingCols_OVERLAPS_1_WRAPS() {
+ XSSFWorkbook wb = new XSSFWorkbook();
+ XSSFSheet sheet = wb.createSheet("test");
+
+ CTCols cols = sheet.getCTWorksheet().getColsArray(0);
+ CTCol col = cols.addNewCol();
+ col.setMin(2 + 1);
+ col.setMax(4 + 1);
+ col.setWidth(20);
+ col.setCustomWidth(true);
+
+ sheet.groupColumn((short) 1, (short) 5);
+
+ cols = sheet.getCTWorksheet().getColsArray(0);
+ logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_1_WRAPS/cols:" + cols);
+
+ assertEquals(1, cols.getColArray(0).getOutlineLevel());
+ assertEquals(2, cols.getColArray(0).getMin()); // 1 based
+ assertEquals(2, cols.getColArray(0).getMax()); // 1 based
+ assertEquals(false, cols.getColArray(0).getCustomWidth());
+
+ assertEquals(1, cols.getColArray(1).getOutlineLevel());
+ assertEquals(3, cols.getColArray(1).getMin()); // 1 based
+ assertEquals(5, cols.getColArray(1).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(1).getCustomWidth());
+
+ assertEquals(1, cols.getColArray(2).getOutlineLevel());
+ assertEquals(6, cols.getColArray(2).getMin()); // 1 based
+ assertEquals(6, cols.getColArray(2).getMax()); // 1 based
+ assertEquals(false, cols.getColArray(2).getCustomWidth());
+
+ assertEquals(3, cols.sizeOfColArray());
+
+ wb = XSSFTestDataSamples.writeOutAndReadBack(wb, "testMergingOverlappingCols_OVERLAPS_1_WRAPS");
+ sheet = wb.getSheet("test");
+
+ for (int i = 2; i <= 4; i++) {
+ assertEquals("Unexpected width of column "+ i, 20 * 256, sheet.getColumnWidth(i));
+ }
+ }
+
+ /**
+ * Test the cols element is correct in case of NumericRanges.OVERLAPS_1_MINOR
+ */
+ public void testMergingOverlappingCols_OVERLAPS_1_MINOR() {
+ XSSFWorkbook wb = new XSSFWorkbook();
+ XSSFSheet sheet = wb.createSheet("test");
+
+ CTCols cols = sheet.getCTWorksheet().getColsArray(0);
+ CTCol col = cols.addNewCol();
+ col.setMin(2 + 1);
+ col.setMax(4 + 1);
+ col.setWidth(20);
+ col.setCustomWidth(true);
+
+ sheet.groupColumn((short) 3, (short) 5);
+
+ cols = sheet.getCTWorksheet().getColsArray(0);
+ logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_1_MINOR/cols:" + cols);
+
+ assertEquals(0, cols.getColArray(0).getOutlineLevel());
+ assertEquals(3, cols.getColArray(0).getMin()); // 1 based
+ assertEquals(3, cols.getColArray(0).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(0).getCustomWidth());
+
+ assertEquals(1, cols.getColArray(1).getOutlineLevel());
+ assertEquals(4, cols.getColArray(1).getMin()); // 1 based
+ assertEquals(5, cols.getColArray(1).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(1).getCustomWidth());
+
+ assertEquals(1, cols.getColArray(2).getOutlineLevel());
+ assertEquals(6, cols.getColArray(2).getMin()); // 1 based
+ assertEquals(6, cols.getColArray(2).getMax()); // 1 based
+ assertEquals(false, cols.getColArray(2).getCustomWidth());
+
+ assertEquals(3, cols.sizeOfColArray());
+
+ wb = XSSFTestDataSamples.writeOutAndReadBack(wb, "testMergingOverlappingCols_OVERLAPS_1_MINOR");
+ sheet = wb.getSheet("test");
+
+ for (int i = 2; i <= 4; i++) {
+ assertEquals("Unexpected width of column "+ i, 20 * 256, sheet.getColumnWidth(i));
+ }
+ assertEquals("Unexpected width of column "+ 5, sheet.getDefaultColumnWidth() * 256, sheet.getColumnWidth(5));
+ }
+
+ /**
+ * Test the cols element is correct in case of NumericRanges.OVERLAPS_2_MINOR
+ */
+ public void testMergingOverlappingCols_OVERLAPS_2_MINOR() {
+ XSSFWorkbook wb = new XSSFWorkbook();
+ XSSFSheet sheet = wb.createSheet("test");
+
+ CTCols cols = sheet.getCTWorksheet().getColsArray(0);
+ CTCol col = cols.addNewCol();
+ col.setMin(2 + 1);
+ col.setMax(4 + 1);
+ col.setWidth(20);
+ col.setCustomWidth(true);
+
+ sheet.groupColumn((short) 1, (short) 3);
+
+ cols = sheet.getCTWorksheet().getColsArray(0);
+ logger.log(POILogger.DEBUG, "testMergingOverlappingCols_OVERLAPS_2_MINOR/cols:" + cols);
+
+ assertEquals(1, cols.getColArray(0).getOutlineLevel());
+ assertEquals(2, cols.getColArray(0).getMin()); // 1 based
+ assertEquals(2, cols.getColArray(0).getMax()); // 1 based
+ assertEquals(false, cols.getColArray(0).getCustomWidth());
+
+ assertEquals(1, cols.getColArray(1).getOutlineLevel());
+ assertEquals(3, cols.getColArray(1).getMin()); // 1 based
+ assertEquals(4, cols.getColArray(1).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(1).getCustomWidth());
+
+ assertEquals(0, cols.getColArray(2).getOutlineLevel());
+ assertEquals(5, cols.getColArray(2).getMin()); // 1 based
+ assertEquals(5, cols.getColArray(2).getMax()); // 1 based
+ assertEquals(true, cols.getColArray(2).getCustomWidth());
+
+ assertEquals(3, cols.sizeOfColArray());
+
+ wb = XSSFTestDataSamples.writeOutAndReadBack(wb, "testMergingOverlappingCols_OVERLAPS_2_MINOR");
+ sheet = wb.getSheet("test");
+
+ for (int i = 2; i <= 4; i++) {
+ assertEquals("Unexpected width of column "+ i, 20 * 256, sheet.getColumnWidth(i));
+ }
+ assertEquals("Unexpected width of column "+ 1, sheet.getDefaultColumnWidth() * 256, sheet.getColumnWidth(1));
+ }
+
+}
projects / poi.git / commitdiff