XWPFTable.java
/* ====================================================================
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.xwpf.usermodel;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import org.apache.poi.ooxml.POIXMLDocumentPart;
import org.apache.poi.ooxml.util.POIXMLUnits;
import org.apache.poi.util.Internal;
import org.apache.poi.util.MathUtil;
import org.apache.poi.util.Units;
import org.apache.xmlbeans.XmlCursor;
import org.apache.xmlbeans.XmlObject;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCustomXmlRow;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJcTable;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRow;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtContentRow;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSdtRow;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTbl;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblBorders;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblCellMar;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblWidth;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STBorder;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STJcTable;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STTblWidth;
/**
* <p>Sketch of XWPFTable class. Only table's text is being hold.</p>
* <p>Specifies the contents of a table present in the document. A table is a set
* of paragraphs (and other block-level content) arranged in rows and columns.</p>
*/
@SuppressWarnings("WeakerAccess")
public class XWPFTable implements IBodyElement, ISDTContents {
public static final String REGEX_PERCENTAGE = "[0-9]+(\\.[0-9]+)?%";
public static final String DEFAULT_PERCENTAGE_WIDTH = "100%";
public static final String REGEX_WIDTH_VALUE = "auto|[0-9]+|" + REGEX_PERCENTAGE;
// Create a map from this XWPF-level enum to the STBorder.Enum values
public enum XWPFBorderType {
NIL, NONE, SINGLE, THICK, DOUBLE, DOTTED, DASHED, DOT_DASH, DOT_DOT_DASH, TRIPLE,
THIN_THICK_SMALL_GAP, THICK_THIN_SMALL_GAP, THIN_THICK_THIN_SMALL_GAP,
THIN_THICK_MEDIUM_GAP, THICK_THIN_MEDIUM_GAP, THIN_THICK_THIN_MEDIUM_GAP,
THIN_THICK_LARGE_GAP, THICK_THIN_LARGE_GAP, THIN_THICK_THIN_LARGE_GAP,
WAVE, DOUBLE_WAVE, DASH_SMALL_GAP, DASH_DOT_STROKED, THREE_D_EMBOSS, THREE_D_ENGRAVE,
OUTSET, INSET
}
private enum Border { INSIDE_V, INSIDE_H, LEFT, TOP, BOTTOM, RIGHT }
private static final EnumMap<XWPFBorderType, STBorder.Enum> xwpfBorderTypeMap;
// Create a map from the STBorder.Enum values to the XWPF-level enums
private static final HashMap<Integer, XWPFBorderType> stBorderTypeMap;
static {
// populate enum maps
xwpfBorderTypeMap = new EnumMap<>(XWPFBorderType.class);
xwpfBorderTypeMap.put(XWPFBorderType.NIL, STBorder.NIL);
xwpfBorderTypeMap.put(XWPFBorderType.NONE, STBorder.NONE);
xwpfBorderTypeMap.put(XWPFBorderType.SINGLE, STBorder.SINGLE);
xwpfBorderTypeMap.put(XWPFBorderType.THICK, STBorder.THICK);
xwpfBorderTypeMap.put(XWPFBorderType.DOUBLE, STBorder.DOUBLE);
xwpfBorderTypeMap.put(XWPFBorderType.DOTTED, STBorder.DOTTED);
xwpfBorderTypeMap.put(XWPFBorderType.DASHED, STBorder.DASHED);
xwpfBorderTypeMap.put(XWPFBorderType.DOT_DASH, STBorder.DOT_DASH);
xwpfBorderTypeMap.put(XWPFBorderType.DOT_DOT_DASH, STBorder.DOT_DOT_DASH);
xwpfBorderTypeMap.put(XWPFBorderType.TRIPLE, STBorder.TRIPLE);
xwpfBorderTypeMap.put(XWPFBorderType.THIN_THICK_SMALL_GAP, STBorder.THIN_THICK_SMALL_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THICK_THIN_SMALL_GAP, STBorder.THICK_THIN_SMALL_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THIN_THICK_THIN_SMALL_GAP, STBorder.THIN_THICK_THIN_SMALL_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THIN_THICK_MEDIUM_GAP, STBorder.THIN_THICK_MEDIUM_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THICK_THIN_MEDIUM_GAP, STBorder.THICK_THIN_MEDIUM_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THIN_THICK_THIN_MEDIUM_GAP, STBorder.THIN_THICK_THIN_MEDIUM_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THIN_THICK_LARGE_GAP, STBorder.THIN_THICK_LARGE_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THICK_THIN_LARGE_GAP, STBorder.THICK_THIN_LARGE_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.THIN_THICK_THIN_LARGE_GAP, STBorder.THIN_THICK_THIN_LARGE_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.WAVE, STBorder.WAVE);
xwpfBorderTypeMap.put(XWPFBorderType.DOUBLE_WAVE, STBorder.DOUBLE_WAVE);
xwpfBorderTypeMap.put(XWPFBorderType.DASH_SMALL_GAP, STBorder.DASH_SMALL_GAP);
xwpfBorderTypeMap.put(XWPFBorderType.DASH_DOT_STROKED, STBorder.DASH_DOT_STROKED);
xwpfBorderTypeMap.put(XWPFBorderType.THREE_D_EMBOSS, STBorder.THREE_D_EMBOSS);
xwpfBorderTypeMap.put(XWPFBorderType.THREE_D_ENGRAVE, STBorder.THREE_D_ENGRAVE);
xwpfBorderTypeMap.put(XWPFBorderType.OUTSET, STBorder.OUTSET);
xwpfBorderTypeMap.put(XWPFBorderType.INSET, STBorder.INSET);
stBorderTypeMap = new HashMap<>();
stBorderTypeMap.put(STBorder.INT_NIL, XWPFBorderType.NIL);
stBorderTypeMap.put(STBorder.INT_NONE, XWPFBorderType.NONE);
stBorderTypeMap.put(STBorder.INT_SINGLE, XWPFBorderType.SINGLE);
stBorderTypeMap.put(STBorder.INT_THICK, XWPFBorderType.THICK);
stBorderTypeMap.put(STBorder.INT_DOUBLE, XWPFBorderType.DOUBLE);
stBorderTypeMap.put(STBorder.INT_DOTTED, XWPFBorderType.DOTTED);
stBorderTypeMap.put(STBorder.INT_DASHED, XWPFBorderType.DASHED);
stBorderTypeMap.put(STBorder.INT_DOT_DASH, XWPFBorderType.DOT_DASH);
stBorderTypeMap.put(STBorder.INT_DOT_DOT_DASH, XWPFBorderType.DOT_DOT_DASH);
stBorderTypeMap.put(STBorder.INT_TRIPLE, XWPFBorderType.TRIPLE);
stBorderTypeMap.put(STBorder.INT_THIN_THICK_SMALL_GAP, XWPFBorderType.THIN_THICK_SMALL_GAP);
stBorderTypeMap.put(STBorder.INT_THICK_THIN_SMALL_GAP, XWPFBorderType.THICK_THIN_SMALL_GAP);
stBorderTypeMap.put(STBorder.INT_THIN_THICK_THIN_SMALL_GAP, XWPFBorderType.THIN_THICK_THIN_SMALL_GAP);
stBorderTypeMap.put(STBorder.INT_THIN_THICK_MEDIUM_GAP, XWPFBorderType.THIN_THICK_MEDIUM_GAP);
stBorderTypeMap.put(STBorder.INT_THICK_THIN_MEDIUM_GAP, XWPFBorderType.THICK_THIN_MEDIUM_GAP);
stBorderTypeMap.put(STBorder.INT_THIN_THICK_THIN_MEDIUM_GAP, XWPFBorderType.THIN_THICK_THIN_MEDIUM_GAP);
stBorderTypeMap.put(STBorder.INT_THIN_THICK_LARGE_GAP, XWPFBorderType.THIN_THICK_LARGE_GAP);
stBorderTypeMap.put(STBorder.INT_THICK_THIN_LARGE_GAP, XWPFBorderType.THICK_THIN_LARGE_GAP);
stBorderTypeMap.put(STBorder.INT_THIN_THICK_THIN_LARGE_GAP, XWPFBorderType.THIN_THICK_THIN_LARGE_GAP);
stBorderTypeMap.put(STBorder.INT_WAVE, XWPFBorderType.WAVE);
stBorderTypeMap.put(STBorder.INT_DOUBLE_WAVE, XWPFBorderType.DOUBLE_WAVE);
stBorderTypeMap.put(STBorder.INT_DASH_SMALL_GAP, XWPFBorderType.DASH_SMALL_GAP);
stBorderTypeMap.put(STBorder.INT_DASH_DOT_STROKED, XWPFBorderType.DASH_DOT_STROKED);
stBorderTypeMap.put(STBorder.INT_THREE_D_EMBOSS, XWPFBorderType.THREE_D_EMBOSS);
stBorderTypeMap.put(STBorder.INT_THREE_D_ENGRAVE, XWPFBorderType.THREE_D_ENGRAVE);
stBorderTypeMap.put(STBorder.INT_OUTSET, XWPFBorderType.OUTSET);
stBorderTypeMap.put(STBorder.INT_INSET, XWPFBorderType.INSET);
}
protected StringBuilder text = new StringBuilder(64);
protected final List<XWPFTableRow> tableRows = new ArrayList<>();
// Unused: UUF_UNUSED_PUBLIC_OR_PROTECTED_FIELD
//protected List<String> styleIDs;
protected IBody part;
private final CTTbl ctTbl;
public XWPFTable(CTTbl table, IBody part, int row, int col) {
this(table, part);
for (int i = 0; i < row; i++) {
XWPFTableRow tabRow = (getRow(i) == null) ? createRow() : getRow(i);
for (int k = 0; k < col; k++) {
if (tabRow.getCell(k) == null) {
tabRow.createCell();
}
}
}
}
public XWPFTable(CTTbl table, IBody part) {
this(table, part, true);
}
public XWPFTable(CTTbl table, IBody part, boolean initRow) {
this.part = part;
this.ctTbl = table;
// is an empty table: I add one row and one column as default
// Check if table has any row-like content (TR, or rows wrapped in SDT or custom XML)
if (initRow && table.sizeOfTrArray() == 0 && table.sizeOfSdtArray() == 0
&& table.sizeOfCustomXmlArray() == 0) {
createEmptyTable(table);
}
List<CTRow> rows = new ArrayList<>();
collectRows(table, rows);
for (CTRow row : rows) {
processCTRow(row);
}
}
private void processCTRow(CTRow row) {
StringBuilder rowText = new StringBuilder();
XWPFTableRow tableRow = new XWPFTableRow(row, this);
tableRows.add(tableRow);
// Reuse the paragraphs that XWPFTableRow has just built for the cells of this row,
// rather than parsing every cell a second time into throw-away XWPFParagraph/XWPFRun
// objects. The cells are the same CTTc elements in the same order (XWPFTableRow uses
// ctRow.getTcArray()) and each cell's paragraphs are its direct w:p children in
// document order, so the resulting text is identical.
for (XWPFTableCell cell : tableRow.getTableCells()) {
for (XWPFParagraph p : cell.getParagraphs()) {
if (!rowText.isEmpty()) {
rowText.append('\t');
}
rowText.append(p.getText());
}
}
if (!rowText.isEmpty()) {
this.text.append(rowText);
this.text.append('\n');
}
}
/**
* Collect the rows in container in document order, including rows wrapped
* in SDT rows (w:sdt) or custom XML rows (w:customXml), however deeply nested.
*/
private static void collectRows(XmlObject container, List<CTRow> rows) {
try (XmlCursor cursor = container.newCursor()) {
if (!cursor.toFirstChild()) {
return;
}
do {
XmlObject child = cursor.getObject();
if (child instanceof CTRow ctRow) {
rows.add(ctRow);
} else if (child instanceof CTSdtRow sdtRow) {
CTSdtContentRow sdtContent = sdtRow.getSdtContent();
if (sdtContent != null) {
collectRows(sdtContent, rows);
}
} else if (child instanceof CTCustomXmlRow customXmlRow) {
collectRows(customXmlRow, rows);
}
} while (cursor.toNextSibling());
}
}
private void createEmptyTable(CTTbl table) {
// MINIMUM ELEMENTS FOR A TABLE
table.addNewTr().addNewTc().addNewP();
CTTblPr tblpro = table.addNewTblPr();
tblpro.addNewTblW().setW(BigInteger.valueOf(0));
tblpro.getTblW().setType(STTblWidth.AUTO);
// layout
// tblpro.addNewTblLayout().setType(STTblLayoutType.AUTOFIT);
// borders
CTTblBorders borders = tblpro.addNewTblBorders();
borders.addNewBottom().setVal(STBorder.SINGLE);
borders.addNewInsideH().setVal(STBorder.SINGLE);
borders.addNewInsideV().setVal(STBorder.SINGLE);
borders.addNewLeft().setVal(STBorder.SINGLE);
borders.addNewRight().setVal(STBorder.SINGLE);
borders.addNewTop().setVal(STBorder.SINGLE);
/*
* CTTblGrid tblgrid=table.addNewTblGrid();
* tblgrid.addNewGridCol().setW(new BigInteger("2000"));
*/
//getRows();
}
/**
* @return ctTbl object
*/
@Internal
public CTTbl getCTTbl() {
return ctTbl;
}
/**
* Convenience method to extract text in cells. This
* does not extract text recursively in cells, and it does not
* currently include text in SDT (form) components.
* <p>
* To get all text within a table, see XWPFWordExtractor's appendTableText
* as an example.
*
* @return text
*/
public String getText() {
return text.toString();
}
/**
* Add a new cell at the end of each row in this table, creating a new column.
* If rows have different numbers of columns, will still append a cell to each row.
* Currently, does not match the width of existing columns.
*/
public void addNewCol() {
if (tableRows.isEmpty()) {
createRow();
}
for (XWPFTableRow tableRow : tableRows) {
tableRow.createCell();
}
}
/**
* create a new XWPFTableRow object with as many cells as the number of columns defined in that moment
*
* @return tableRow
*/
public XWPFTableRow createRow() {
int sizeCol = tableRows.isEmpty() ? 0 : tableRows.get(0).getCtRow().sizeOfTcArray();
XWPFTableRow tabRow = new XWPFTableRow(ctTbl.addNewTr(), this);
addColumn(tabRow, sizeCol);
tableRows.add(tabRow);
return tabRow;
}
/**
* Returns the row at the specified position, including SDT-wrapped rows.
* Note: the returned row may be a direct child of the table or nested
* inside an SDT (structured document tag) row element.
*
* @param pos - index of the row
* @return the row at the position specified or null if no rows is defined or if the position is greater than the max size of rows array
*/
public XWPFTableRow getRow(int pos) {
if (pos >= 0 && pos < tableRows.size()) {
return tableRows.get(pos);
}
return null;
}
/**
* Get the width value as an integer.
* <p>If the width type is AUTO, DXA, or NIL, the value is 20ths of a point. If
* the width type is PCT, the value is the percentage times 50 (e.g., 2500 for 50%).</p>
* @return width value as an integer
*/
public int getWidth() {
CTTblPr tblPr = getTblPr(false);
return tblPr != null && tblPr.isSetTblW() ?
MathUtil.safeDoubleToInt(
Units.toDXA(POIXMLUnits.parseLength(tblPr.getTblW().xgetW()))) : -1;
}
/**
* Set the width in 20ths of a point (twips).
* @param width Width value (20ths of a point)
*/
public void setWidth(int width) {
CTTblPr tblPr = getTblPr();
CTTblWidth tblWidth = tblPr.isSetTblW() ? tblPr.getTblW() : tblPr.addNewTblW();
tblWidth.setW(BigInteger.valueOf(width));
tblWidth.setType(STTblWidth.DXA);
}
/**
* @return number of rows in table (including SDT-wrapped rows)
*/
public int getNumberOfRows() {
return tableRows.size();
}
/**
* Get the indentation value in 20ths of a point (twips).
*
* <p>This element specifies the indentation which shall be added before the leading edge of
* the current table in the document (the left edge in a left-to-right table, and the right
* edge in a right-to-left table).</p>
* <p>If the table alignment is not left/start, this property shall be ignored.</p>
*
* @see #hasIndent()
* @return indentation value as an integer (20ths of a point)
*/
public int getIndent() {
CTTblPr tblPr = getTblPr(false);
if (tblPr.isSetTblInd()) {
STTblWidth.Enum typeValue = tblPr.getTblInd().getType();
if (typeValue == null) {
// "��17.4.87: If [type] is omitted, then its value shall be assumed to be dxa"
typeValue = STTblWidth.DXA;
}
switch (typeValue.intValue()) {
case STTblWidth.INT_DXA:
return MathUtil.safeDoubleToInt(
Units.toDXA(POIXMLUnits.parseLength(tblPr.getTblInd().xgetW())));
case STTblWidth.INT_NIL:
// "��17.18.90: [nil] Specifies that the current width is zero, regardless of
// any width value specified on the parent element"
return 0;
case STTblWidth.INT_PCT:
case STTblWidth.INT_AUTO:
// "��17.4.50: Any width value of type pct or auto for this element shall be ignored"
return 0;
}
}
return 0;
}
/**
* Set the indentation in 20ths of a point (twips).
* @see #getIndent()
* @param indent Indentation value (20ths of a point)
*/
public void setIndent(int indent) {
CTTblPr tblPr = getTblPr();
CTTblWidth tblInd = tblPr.isSetTblInd() ? tblPr.getTblInd() : tblPr.addNewTblInd();
tblInd.setW(BigInteger.valueOf(indent));
tblInd.setType(STTblWidth.DXA);
}
/**
* Check if some indentation value is set for the table.
*
* <p>If this attribute is omitted, then the table shall inherit the table indentation from
* the associated table style. If table indentation is never specified in the style hierarchy,
* no indentation shall be added to the parent table.</p>
*
* @return true if the indent value is set and is valid, false if it is not set or shall be
* ignored (e.g. due to invalid type).
*/
public boolean hasIndent() {
CTTblPr tblPr = getTblPr(false);
// According to ��17.4.50, values with type pct or auto shall be ignored.
return tblPr.isSetTblInd() && tblPr.getTblInd().getType() != STTblWidth.PCT
&& tblPr.getTblInd().getType() != STTblWidth.AUTO;
}
/**
* Removes the table indentation attribute from a table
*/
public void removeIndent() {
CTTblPr tPr = getTblPr(false);
if (tPr != null && tPr.isSetTblInd()) {
tPr.unsetTblInd();
}
}
/**
* Returns CTTblPr object for table. Creates it if it does not exist.
*/
private CTTblPr getTblPr() {
return getTblPr(true);
}
/**
* Returns CTTblPr object for table. If force parameter is true, will
* create the element if necessary. If force parameter is false, returns
* null when CTTblPr element is missing.
*
* @param force - force creation of CTTblPr element if necessary
*/
private CTTblPr getTblPr(boolean force) {
return (ctTbl.getTblPr() != null) ? ctTbl.getTblPr()
: (force ? ctTbl.addNewTblPr() : null);
}
/**
* Return CTTblBorders object for table. If force parameter is true, will
* create the element if necessary. If force parameter is false, returns
* null when CTTblBorders element is missing.
*
* @param force - force creation of CTTblBorders element if necessary
*/
private CTTblBorders getTblBorders(boolean force) {
CTTblPr tblPr = getTblPr(force);
return tblPr == null ? null
: tblPr.isSetTblBorders() ? tblPr.getTblBorders()
: force ? tblPr.addNewTblBorders()
: null;
}
/**
* Return CTBorder object for given border. If force parameter is true,
* will create the element if necessary. If force parameter is false, returns
* null when the border element is missing.
*
* @param force - force creation of border if necessary.
*/
private CTBorder getTblBorder(boolean force, Border border) {
final Function<CTTblBorders,Boolean> isSet;
final Function<CTTblBorders,CTBorder> get;
final Function<CTTblBorders,CTBorder> addNew;
switch (border) {
case INSIDE_V:
isSet = CTTblBorders::isSetInsideV;
get = CTTblBorders::getInsideV;
addNew = CTTblBorders::addNewInsideV;
break;
case INSIDE_H:
isSet = CTTblBorders::isSetInsideH;
get = CTTblBorders::getInsideH;
addNew = CTTblBorders::addNewInsideH;
break;
case LEFT:
isSet = CTTblBorders::isSetLeft;
get = CTTblBorders::getLeft;
addNew = CTTblBorders::addNewLeft;
break;
case TOP:
isSet = CTTblBorders::isSetTop;
get = CTTblBorders::getTop;
addNew = CTTblBorders::addNewTop;
break;
case RIGHT:
isSet = CTTblBorders::isSetRight;
get = CTTblBorders::getRight;
addNew = CTTblBorders::addNewRight;
break;
case BOTTOM:
isSet = CTTblBorders::isSetBottom;
get = CTTblBorders::getBottom;
addNew = CTTblBorders::addNewBottom;
break;
default:
return null;
}
CTTblBorders ctb = getTblBorders(force);
return ctb == null ? null
: isSet.apply(ctb) ? get.apply(ctb)
: force ? addNew.apply(ctb)
: null;
}
/**
* Returns the current table alignment or NULL
*
* @return Table Alignment as a {@link TableRowAlign} enum
*/
public TableRowAlign getTableAlignment() {
CTTblPr tPr = getTblPr(false);
return tPr == null ? null
: tPr.isSetJc() ? TableRowAlign.valueOf(tPr.getJc().getVal().intValue())
: null;
}
/**
* Set table alignment to specified {@link TableRowAlign}
*
* @param tra {@link TableRowAlign} to set
*/
public void setTableAlignment(TableRowAlign tra) {
CTTblPr tPr = getTblPr(true);
CTJcTable jc = tPr.isSetJc() ? tPr.getJc() : tPr.addNewJc();
jc.setVal(STJcTable.Enum.forInt(tra.getValue()));
}
/**
* Removes the table alignment attribute from a table
*/
public void removeTableAlignment() {
CTTblPr tPr = getTblPr(false);
if (tPr != null && tPr.isSetJc()) {
tPr.unsetJc();
}
}
private void addColumn(XWPFTableRow tabRow, int sizeCol) {
if (sizeCol > 0) {
for (int i = 0; i < sizeCol; i++) {
tabRow.createCell();
}
}
}
/**
* get the StyleID of the table
*
* @return style-ID of the table
*/
public String getStyleID() {
String styleId = null;
CTTblPr tblPr = getTblPr(false);
if (tblPr != null) {
CTString styleStr = tblPr.getTblStyle();
if (styleStr != null) {
styleId = styleStr.getVal();
}
}
return styleId;
}
/**
* Set the table style. If the style is not defined in the document, MS Word
* will set the table style to "Normal".
*
* @param styleName - the style name to apply to this table
*/
public void setStyleID(String styleName) {
CTTblPr tblPr = getTblPr();
CTString styleStr = tblPr.getTblStyle();
if (styleStr == null) {
styleStr = tblPr.addNewTblStyle();
}
styleStr.setVal(styleName);
}
/**
* Get inside horizontal border type
*
* @return {@link XWPFBorderType} of the inside horizontal borders or null if missing
*/
public XWPFBorderType getInsideHBorderType() {
return getBorderType(Border.INSIDE_H);
}
/**
* Get inside horizontal border size
*
* @return The width of the Inside Horizontal borders in 1/8th points,
* -1 if missing.
*/
public int getInsideHBorderSize() {
return getBorderSize(Border.INSIDE_H);
}
/**
* Get inside horizontal border spacing
*
* @return The offset to the Inside Horizontal borders in points,
* -1 if missing.
*/
public int getInsideHBorderSpace() {
return getBorderSpace(Border.INSIDE_H);
}
/**
* Get inside horizontal border color
*
* @return The color of the Inside Horizontal borders, null if missing.
*/
public String getInsideHBorderColor() {
return getBorderColor(Border.INSIDE_H);
}
/**
* Get inside vertical border type
*
* @return {@link XWPFBorderType} of the inside vertical borders or null if missing
*/
public XWPFBorderType getInsideVBorderType() {
return getBorderType(Border.INSIDE_V);
}
/**
* Get inside vertical border size
*
* @return The width of the Inside vertical borders in 1/8th points,
* -1 if missing.
*/
public int getInsideVBorderSize() {
return getBorderSize(Border.INSIDE_V);
}
/**
* Get inside vertical border spacing
*
* @return The offset to the Inside vertical borders in points,
* -1 if missing.
*/
public int getInsideVBorderSpace() {
return getBorderSpace(Border.INSIDE_V);
}
/**
* Get inside vertical border color
*
* @return The color of the Inside vertical borders, null if missing.
*/
public String getInsideVBorderColor() {
return getBorderColor(Border.INSIDE_V);
}
/**
* Get top border type
*
* @return {@link XWPFBorderType} of the top borders or null if missing
*/
public XWPFBorderType getTopBorderType() {
return getBorderType(Border.TOP);
}
/**
* Get top border size
*
* @return The width of the top borders in 1/8th points,
* -1 if missing.
*/
public int getTopBorderSize() {
return getBorderSize(Border.TOP);
}
/**
* Get top border spacing
*
* @return The offset to the top borders in points,
* -1 if missing.
*/
public int getTopBorderSpace() {
return getBorderSpace(Border.TOP);
}
/**
* Get top border color
*
* @return The color of the top borders, null if missing.
*/
public String getTopBorderColor() {
return getBorderColor(Border.TOP);
}
/**
* Get bottom border type
*
* @return {@link XWPFBorderType} of the bottom borders or null if missing
*/
public XWPFBorderType getBottomBorderType() {
return getBorderType(Border.BOTTOM);
}
/**
* Get bottom border size
*
* @return The width of the bottom borders in 1/8th points,
* -1 if missing.
*/
public int getBottomBorderSize() {
return getBorderSize(Border.BOTTOM);
}
/**
* Get bottom border spacing
*
* @return The offset to the bottom borders in points,
* -1 if missing.
*/
public int getBottomBorderSpace() {
return getBorderSpace(Border.BOTTOM);
}
/**
* Get bottom border color
*
* @return The color of the bottom borders, null if missing.
*/
public String getBottomBorderColor() {
return getBorderColor(Border.BOTTOM);
}
/**
* Get Left border type
*
* @return {@link XWPFBorderType} of the Left borders or null if missing
*/
public XWPFBorderType getLeftBorderType() {
return getBorderType(Border.LEFT);
}
/**
* Get Left border size
*
* @return The width of the Left borders in 1/8th points,
* -1 if missing.
*/
public int getLeftBorderSize() {
return getBorderSize(Border.LEFT);
}
/**
* Get Left border spacing
*
* @return The offset to the Left borders in points,
* -1 if missing.
*/
public int getLeftBorderSpace() {
return getBorderSpace(Border.LEFT);
}
/**
* Get Left border color
*
* @return The color of the Left borders, null if missing.
*/
public String getLeftBorderColor() {
return getBorderColor(Border.LEFT);
}
/**
* Get Right border type
*
* @return {@link XWPFBorderType} of the Right borders or null if missing
*/
public XWPFBorderType getRightBorderType() {
return getBorderType(Border.RIGHT);
}
/**
* Get Right border size
*
* @return The width of the Right borders in 1/8th points,
* -1 if missing.
*/
public int getRightBorderSize() {
return getBorderSize(Border.RIGHT);
}
/**
* Get Right border spacing
*
* @return The offset to the Right borders in points,
* -1 if missing.
*/
public int getRightBorderSpace() {
return getBorderSpace(Border.RIGHT);
}
/**
* Get Right border color
*
* @return The color of the Right borders, null if missing.
*/
public String getRightBorderColor() {
return getBorderColor(Border.RIGHT);
}
private XWPFBorderType getBorderType(Border border) {
final CTBorder b = getTblBorder(false, border);
return (b != null) ? stBorderTypeMap.get(b.getVal().intValue()) : null;
}
private int getBorderSize(Border border) {
final CTBorder b = getTblBorder(false, border);
return (b != null)
? (b.isSetSz() ? b.getSz().intValue() : -1)
: -1;
}
private int getBorderSpace(Border border) {
final CTBorder b = getTblBorder(false, border);
return (b != null)
? (b.isSetSpace() ? b.getSpace().intValue() : -1)
: -1;
}
private String getBorderColor(Border border) {
final CTBorder b = getTblBorder(false, border);
return (b != null)
? (b.isSetColor() ? b.xgetColor().getStringValue() : null)
: null;
}
public int getRowBandSize() {
int size = 0;
CTTblPr tblPr = getTblPr(false);
if (tblPr != null && tblPr.isSetTblStyleRowBandSize()) {
CTDecimalNumber rowSize = tblPr.getTblStyleRowBandSize();
size = rowSize.getVal().intValue();
}
return size;
}
public void setRowBandSize(int size) {
CTTblPr tblPr = getTblPr();
CTDecimalNumber rowSize = tblPr.isSetTblStyleRowBandSize() ? tblPr.getTblStyleRowBandSize() : tblPr.addNewTblStyleRowBandSize();
rowSize.setVal(BigInteger.valueOf(size));
}
public int getColBandSize() {
int size = 0;
CTTblPr tblPr = getTblPr(false);
if (tblPr != null && tblPr.isSetTblStyleColBandSize()) {
CTDecimalNumber colSize = tblPr.getTblStyleColBandSize();
size = colSize.getVal().intValue();
}
return size;
}
public void setColBandSize(int size) {
CTTblPr tblPr = getTblPr();
CTDecimalNumber colSize = tblPr.isSetTblStyleColBandSize() ? tblPr.getTblStyleColBandSize() : tblPr.addNewTblStyleColBandSize();
colSize.setVal(BigInteger.valueOf(size));
}
/**
* Set Inside horizontal borders for a table
*
* @param type - {@link XWPFBorderType} e.g. single, double, thick
* @param size - Specifies the width of the current border. The width of this border is
* specified in measurements of eighths of a point, with a minimum value of two (onefourth
* of a point) and a maximum value of 96 (twelve points). Any values outside this
* range may be reassigned to a more appropriate value.
* @param space - Specifies the spacing offset that shall be used to place this border on the table
* @param rgbColor - This color may either be presented as a hex value (in RRGGBB format),
* or auto to allow a consumer to automatically determine the border color as appropriate.
*/
public void setInsideHBorder(XWPFBorderType type, int size, int space, String rgbColor) {
setBorder(Border.INSIDE_H, type, size, space, rgbColor);
}
/**
* Set Inside Vertical borders for table
*
* @param type - {@link XWPFBorderType} e.g. single, double, thick
* @param size - Specifies the width of the current border. The width of this border is
* specified in measurements of eighths of a point, with a minimum value of two (onefourth
* of a point) and a maximum value of 96 (twelve points). Any values outside this
* range may be reassigned to a more appropriate value.
* @param space - Specifies the spacing offset that shall be used to place this border on the table
* @param rgbColor - This color may either be presented as a hex value (in RRGGBB format),
* or auto to allow a consumer to automatically determine the border color as appropriate.
*/
public void setInsideVBorder(XWPFBorderType type, int size, int space, String rgbColor) {
setBorder(Border.INSIDE_V, type, size, space, rgbColor);
}
/**
* Set Top borders for table
*
* @param type - {@link XWPFBorderType} e.g. single, double, thick
* @param size - Specifies the width of the current border. The width of this border is
* specified in measurements of eighths of a point, with a minimum value of two (onefourth
* of a point) and a maximum value of 96 (twelve points). Any values outside this
* range may be reassigned to a more appropriate value.
* @param space - Specifies the spacing offset that shall be used to place this border on the table
* @param rgbColor - This color may either be presented as a hex value (in RRGGBB format),
* or auto to allow a consumer to automatically determine the border color as appropriate.
*/
public void setTopBorder(XWPFBorderType type, int size, int space, String rgbColor) {
setBorder(Border.TOP, type, size, space, rgbColor);
}
/**
* Set Bottom borders for table
*
* @param type - {@link XWPFBorderType} e.g. single, double, thick
* @param size - Specifies the width of the current border. The width of this border is
* specified in measurements of eighths of a point, with a minimum value of two (onefourth
* of a point) and a maximum value of 96 (twelve points). Any values outside this
* range may be reassigned to a more appropriate value.
* @param space - Specifies the spacing offset that shall be used to place this border on the table
* @param rgbColor - This color may either be presented as a hex value (in RRGGBB format),
* or auto to allow a consumer to automatically determine the border color as appropriate.
*/
public void setBottomBorder(XWPFBorderType type, int size, int space, String rgbColor) {
setBorder(Border.BOTTOM, type, size, space, rgbColor);
}
/**
* Set Left borders for table
*
* @param type - {@link XWPFBorderType} e.g. single, double, thick
* @param size - Specifies the width of the current border. The width of this border is
* specified in measurements of eighths of a point, with a minimum value of two (onefourth
* of a point) and a maximum value of 96 (twelve points). Any values outside this
* range may be reassigned to a more appropriate value.
* @param space - Specifies the spacing offset that shall be used to place this border on the table
* @param rgbColor - This color may either be presented as a hex value (in RRGGBB format),
* or auto to allow a consumer to automatically determine the border color as appropriate.
*/
public void setLeftBorder(XWPFBorderType type, int size, int space, String rgbColor) {
setBorder(Border.LEFT, type, size, space, rgbColor);
}
/**
* Set Right borders for table
*
* @param type - {@link XWPFBorderType} e.g. single, double, thick
* @param size - Specifies the width of the current border. The width of this border is
* specified in measurements of eighths of a point, with a minimum value of two (onefourth
* of a point) and a maximum value of 96 (twelve points). Any values outside this
* range may be reassigned to a more appropriate value.
* @param space - Specifies the spacing offset that shall be used to place this border on the table
* @param rgbColor - This color may either be presented as a hex value (in RRGGBB format),
* or auto to allow a consumer to automatically determine the border color as appropriate.
*/
public void setRightBorder(XWPFBorderType type, int size, int space, String rgbColor) {
setBorder(Border.RIGHT, type, size, space, rgbColor);
}
private void setBorder(Border border, XWPFBorderType type, int size, int space, String rgbColor) {
final CTBorder b = getTblBorder(true, border);
assert(b != null);
b.setVal(xwpfBorderTypeMap.get(type));
b.setSz(BigInteger.valueOf(size));
b.setSpace(BigInteger.valueOf(space));
b.setColor(rgbColor);
}
/**
* Remove inside horizontal borders for table
*/
public void removeInsideHBorder() {
removeBorder(Border.INSIDE_H);
}
/**
* Remove inside vertical borders for table
*/
public void removeInsideVBorder() {
removeBorder(Border.INSIDE_V);
}
/**
* Remove top borders for table
*/
public void removeTopBorder() {
removeBorder(Border.TOP);
}
/**
* Remove bottom borders for table
*/
public void removeBottomBorder() {
removeBorder(Border.BOTTOM);
}
/**
* Remove left borders for table
*/
public void removeLeftBorder() {
removeBorder(Border.LEFT);
}
/**
* Remove right borders for table
*/
public void removeRightBorder() {
removeBorder(Border.RIGHT);
}
/**
* Remove all borders from table
*/
public void removeBorders() {
final CTTblPr pr = getTblPr(false);
if (pr != null && pr.isSetTblBorders()) {
pr.unsetTblBorders();
}
}
private void removeBorder(final Border border) {
final Function<CTTblBorders,Boolean> isSet;
final Consumer<CTTblBorders> unSet;
switch (border) {
case INSIDE_H:
isSet = CTTblBorders::isSetInsideH;
unSet = CTTblBorders::unsetInsideH;
break;
case INSIDE_V:
isSet = CTTblBorders::isSetInsideV;
unSet = CTTblBorders::unsetInsideV;
break;
case LEFT:
isSet = CTTblBorders::isSetLeft;
unSet = CTTblBorders::unsetLeft;
break;
case TOP:
isSet = CTTblBorders::isSetTop;
unSet = CTTblBorders::unsetTop;
break;
case RIGHT:
isSet = CTTblBorders::isSetRight;
unSet = CTTblBorders::unsetRight;
break;
case BOTTOM:
isSet = CTTblBorders::isSetBottom;
unSet = CTTblBorders::unsetBottom;
break;
default:
return;
}
final CTTblBorders tbl = getTblBorders(false);
if (tbl != null && isSet.apply(tbl)) {
unSet.accept(tbl);
cleanupTblBorders();
}
}
/**
* removes the Borders node from Table properties if there are
* no border elements
*/
private void cleanupTblBorders() {
final CTTblPr pr = getTblPr(false);
if (pr != null && pr.isSetTblBorders()) {
final CTTblBorders b = pr.getTblBorders();
if (!(b.isSetInsideH() ||
b.isSetInsideV() ||
b.isSetTop() ||
b.isSetBottom() ||
b.isSetLeft() ||
b.isSetRight())) {
pr.unsetTblBorders();
}
}
}
public int getCellMarginTop() {
return getCellMargin(CTTblCellMar::getTop);
}
public int getCellMarginLeft() {
return getCellMargin(CTTblCellMar::getLeft);
}
public int getCellMarginBottom() {
return getCellMargin(CTTblCellMar::getBottom);
}
public int getCellMarginRight() {
return getCellMargin(CTTblCellMar::getRight);
}
private int getCellMargin(Function<CTTblCellMar,CTTblWidth> margin) {
CTTblPr tblPr = getTblPr(false);
if (tblPr != null) {
CTTblCellMar tcm = tblPr.getTblCellMar();
if (tcm != null) {
CTTblWidth tw = margin.apply(tcm);
if (tw != null) {
return MathUtil.safeDoubleToInt(
Units.toDXA(POIXMLUnits.parseLength(tw.xgetW())));
}
}
}
return 0;
}
public void setCellMargins(int top, int left, int bottom, int right) {
CTTblPr tblPr = getTblPr();
CTTblCellMar tcm = tblPr.isSetTblCellMar() ? tblPr.getTblCellMar() : tblPr.addNewTblCellMar();
setCellMargin(tcm, CTTblCellMar::isSetTop, CTTblCellMar::getTop, CTTblCellMar::addNewTop, CTTblCellMar::unsetTop, top);
setCellMargin(tcm, CTTblCellMar::isSetLeft, CTTblCellMar::getLeft, CTTblCellMar::addNewLeft, CTTblCellMar::unsetLeft, left);
setCellMargin(tcm, CTTblCellMar::isSetBottom, CTTblCellMar::getBottom, CTTblCellMar::addNewBottom, CTTblCellMar::unsetBottom, bottom);
setCellMargin(tcm, CTTblCellMar::isSetRight, CTTblCellMar::getRight, CTTblCellMar::addNewRight, CTTblCellMar::unsetRight, right);
}
private void setCellMargin(CTTblCellMar tcm, Function<CTTblCellMar,Boolean> isSet, Function<CTTblCellMar,CTTblWidth> get, Function<CTTblCellMar,CTTblWidth> addNew, Consumer<CTTblCellMar> unSet, int margin) {
if (margin == 0) {
if (isSet.apply(tcm)) {
unSet.accept(tcm);
}
} else {
CTTblWidth tw = (isSet.apply(tcm) ? get : addNew).apply(tcm);
tw.setType(STTblWidth.DXA);
tw.setW(BigInteger.valueOf(margin));
}
}
/**
* add a new Row to the table
* <p>
* The row's XML is copied into the table and row is updated to use that copy,
* so later changes made through row are kept. Cells fetched from row before
* this call no longer belong to it.
*
* @param row the row which should be added
*/
public void addRow(XWPFTableRow row) {
// Add to end of table
CTRow addedRow = ctTbl.addNewTr();
addedRow.set(row.getCtRow());
row.setCtRow(addedRow);
tableRows.add(row);
}
/**
* add a new Row to the table
* at position pos
* <p>
* If the row currently at pos is inside an SDT row (content control)
* or a custom XML row, the new row is added inside that too.
* <p>
* The row's XML is copied into the table and row is updated to use that copy,
* so later changes made through row are kept. Cells fetched from row before
* this call no longer belong to it.
*
* @param row the row which should be added
*/
public boolean addRow(XWPFTableRow row, int pos) {
if (pos >= 0 && pos <= tableRows.size()) {
CTRow addedRow = pos == tableRows.size()
? ctTbl.addNewTr()
: insertNewTrBefore(tableRows.get(pos).getCtRow());
addedRow.set(row.getCtRow());
row.setCtRow(addedRow);
tableRows.add(pos, row);
return true;
}
return false;
}
/**
* inserts a new tablerow at position pos
* <p>
* If the row currently at pos is inside an SDT row (content control)
* or a custom XML row, the new row is inserted inside that too.
*
* @param pos the position to insert the new row
* @return the inserted row
*/
public XWPFTableRow insertNewTableRow(int pos) {
if (pos >= 0 && pos <= tableRows.size()) {
CTRow insertedRow = pos == tableRows.size()
? ctTbl.addNewTr()
: insertNewTrBefore(tableRows.get(pos).getCtRow());
XWPFTableRow tableRow = new XWPFTableRow(insertedRow, this);
tableRows.add(pos, tableRow);
return tableRow;
}
return null;
}
/**
* Insert a new w:tr just before next, in whatever holds next: the table itself,
* the content of an SDT row or a custom XML row. If next is in none of these,
* add the new row at the end of the table.
*/
private CTRow insertNewTrBefore(CTRow next) {
if (!isRowContainer(getParent(next))) {
return ctTbl.addNewTr();
}
try (XmlCursor cursor = next.newCursor()) {
cursor.beginElement("tr", CTRow.type.getName().getNamespaceURI());
cursor.toParent();
return (CTRow) cursor.getObject();
}
}
/**
* Remove a row at position pos from the table
*
* @param pos position the Row in the Table
*/
public boolean removeRow(int pos) throws IndexOutOfBoundsException {
if (pos >= 0 && pos < tableRows.size()) {
CTRow ctRow = tableRows.get(pos).getCtRow();
// the row is either a direct child of a table or inside an SDT or custom XML row
XmlObject parent = getParent(ctRow);
if (isRowContainer(parent)) {
try (XmlCursor cursor = ctRow.newCursor()) {
cursor.removeXml();
}
removeEmptyRowWrappers(parent);
}
tableRows.remove(pos);
return true;
}
return false;
}
/**
* Remove the SDT row or custom XML row that container belongs to once it holds
* nothing but its properties, and likewise any enclosing wrappers that end up empty.
*/
private static void removeEmptyRowWrappers(XmlObject container) {
while (container instanceof CTSdtContentRow || container instanceof CTCustomXmlRow) {
if (hasContent(container)) {
return;
}
// for an SDT row, container is the w:sdtContent, so remove the w:sdt around it
XmlObject wrapper = container instanceof CTSdtContentRow ? getParent(container) : container;
XmlObject parent = wrapper == null ? null : getParent(wrapper);
if (parent == null) {
return;
}
try (XmlCursor cursor = wrapper.newCursor()) {
cursor.removeXml();
}
container = parent;
}
}
private static boolean hasContent(XmlObject container) {
try (XmlCursor cursor = container.newCursor()) {
if (!cursor.toFirstChild()) {
return false;
}
do {
if (!(cursor.getObject() instanceof CTCustomXmlPr)) {
return true;
}
} while (cursor.toNextSibling());
}
return false;
}
private static boolean isRowContainer(XmlObject xmlObject) {
return xmlObject instanceof CTTbl || xmlObject instanceof CTSdtContentRow
|| xmlObject instanceof CTCustomXmlRow;
}
private static XmlObject getParent(XmlObject xmlObject) {
try (XmlCursor cursor = xmlObject.newCursor()) {
return cursor.toParent() ? cursor.getObject() : null;
}
}
/**
* Get the table that holds a row, looking through any SDT rows
* (w:sdt/w:sdtContent) and custom XML rows (w:customXml) between the two.
*
* @return the table, or null if the row is not in a table
*/
static CTTbl getParentTable(CTRow row) {
XmlObject parent = getParent(row);
while (parent instanceof CTSdtContentRow || parent instanceof CTSdtRow
|| parent instanceof CTCustomXmlRow) {
parent = getParent(parent);
}
return parent instanceof CTTbl tbl ? tbl : null;
}
public List<XWPFTableRow> getRows() {
return Collections.unmodifiableList(tableRows);
}
/**
* returns the type of the BodyElement Table
*/
@Override
public BodyElementType getElementType() {
return BodyElementType.TABLE;
}
@Override
public IBody getBody() {
return part;
}
/**
* returns the part of the bodyElement
*
* @see org.apache.poi.xwpf.usermodel.IBody#getPart()
*/
@Override
public POIXMLDocumentPart getPart() {
if (part != null) {
return part.getPart();
}
return null;
}
/**
* returns the partType of the bodyPart which owns the bodyElement
*
* @see org.apache.poi.xwpf.usermodel.IBody#getPartType()
*/
@Override
public BodyType getPartType() {
return part.getPartType();
}
/**
* returns the XWPFRow which belongs to the CTRow row
* if this row is not existing in the table null will be returned
*/
public XWPFTableRow getRow(CTRow row) {
for (int i = 0; i < getRows().size(); i++) {
if (getRows().get(i).getCtRow() == row) {
return getRow(i);
}
}
return null;
}
/**
* Get the table width as a decimal value.
* <p>If the width type is DXA or AUTO, then the value will always have
* a fractional part of zero (because these values are really integers).
* If the with type is percentage, then value may have a non-zero fractional
* part.
*
* @return Width value as a double-precision decimal.
* @since 4.0.0
*/
public double getWidthDecimal() {
CTTblPr pr = getTblPr(false);
return pr == null ? 0.0 : getWidthDecimal(pr.getTblW());
}
/**
* Get the width as a decimal value.
* <p>This method is also used by table cells.
* @param ctWidth Width value to evaluate.
* @return Width value as a decimal
* @since 4.0.0
*/
protected static double getWidthDecimal(CTTblWidth ctWidth) {
double result = 0.0;
STTblWidth.Enum typeValue = ctWidth.getType();
if (typeValue == STTblWidth.DXA
|| typeValue == STTblWidth.AUTO
|| typeValue == STTblWidth.NIL) {
result = 0.0 + Units.toDXA(POIXMLUnits.parseLength(ctWidth.xgetW()));
} else if (typeValue == STTblWidth.PCT) {
// Percentage values are stored as integers that are 50 times
// percentage.
result = Units.toDXA(POIXMLUnits.parseLength(ctWidth.xgetW())) / 50.0;
} else {
// Should never get here
}
return result;
}
/**
* Get the width type for the table, as an {@link STTblWidth.Enum} value.
* A table width can be specified as an absolute measurement (an integer
* number of twips), a percentage, or the value "AUTO".
*
* @return The width type. If table width information does not exist in the document,
* it returns {@link TableWidthType#AUTO}.
* @since 4.0.0
*/
public TableWidthType getWidthType() {
CTTblPr pr = getTblPr(false);
return pr != null && getTblPr().isSetTblW() ? getWidthType(pr.getTblW()) : TableWidthType.AUTO;
}
/**
* Get the width type from the width value
* @param ctWidth CTTblWidth to evaluate
* @return The table width type
* @since 4.0.0
*/
protected static TableWidthType getWidthType(CTTblWidth ctWidth) {
STTblWidth.Enum typeValue = ctWidth.getType();
if (typeValue == null) {
typeValue = STTblWidth.NIL;
ctWidth.setType(typeValue);
}
return switch (typeValue.intValue()) {
case STTblWidth.INT_NIL -> TableWidthType.NIL;
case STTblWidth.INT_DXA -> TableWidthType.DXA;
case STTblWidth.INT_PCT -> TableWidthType.PCT;
default -> TableWidthType.AUTO;
};
}
/**
* Set the width to the value "auto", an integer value (20ths of a point), or a percentage ("nn.nn%").
*
* @param widthValue String matching one of "auto", [0-9]+, or [0-9]+(\.[0-9]+)%.
* @since 4.0.0
*/
public void setWidth(String widthValue) {
setWidthValue(widthValue, getTblPr().getTblW());
}
/**
* Set the width value from a string
* @param widthValue The width value string
* @param ctWidth CTTblWidth to set the value on.
*/
protected static void setWidthValue(String widthValue, CTTblWidth ctWidth) {
if (!widthValue.matches(REGEX_WIDTH_VALUE)) {
throw new IllegalStateException("Table width value \"" + widthValue + "\" "
+ "must match regular expression \"" + REGEX_WIDTH_VALUE + "\".");
}
if (widthValue.matches("auto")) {
ctWidth.setType(STTblWidth.AUTO);
ctWidth.setW(BigInteger.ZERO);
} else if (widthValue.matches(REGEX_PERCENTAGE)) {
setWidthPercentage(ctWidth, widthValue);
} else {
// Must be an integer
ctWidth.setW(new BigInteger(widthValue));
ctWidth.setType(STTblWidth.DXA);
}
}
/**
* Set the underlying table width value to a percentage value.
* @param ctWidth The CTTblWidth to set the value on
* @param widthValue String width value in form "33.3%" or an integer that is 50 times desired percentage value (e.g,
* 2500 for 50%)
* @since 4.0.0
*/
protected static void setWidthPercentage(CTTblWidth ctWidth, String widthValue) {
ctWidth.setType(STTblWidth.PCT);
if (widthValue.matches(REGEX_PERCENTAGE)) {
String numberPart = widthValue.substring(0, widthValue.length() - 1);
double percentage = Double.parseDouble(numberPart) * 50;
long intValue = Math.round(percentage);
ctWidth.setW(BigInteger.valueOf(intValue));
} else if (widthValue.matches("[0-9]+")) {
ctWidth.setW(new BigInteger(widthValue));
} else {
throw new IllegalStateException("setWidthPercentage(): Width value must be a percentage (\"33.3%\" or an integer, was \"" + widthValue + "\"");
}
}
/**
* Set the width value type for the table.
* <p>If the width type is changed from the current type and the currently-set value
* is not consistent with the new width type, the value is reset to the default value
* for the specified width type.</p>
*
* @param widthType Width type
* @since 4.0.0
*/
public void setWidthType(TableWidthType widthType) {
setWidthType(widthType, getTblPr().getTblW());
}
/**
* Set the width type if different from current width type
* @param widthType The new width type
* @param ctWidth CTTblWidth to set the type on
* @since 4.0.0
*/
protected static void setWidthType(TableWidthType widthType, CTTblWidth ctWidth) {
TableWidthType currentType = getWidthType(ctWidth);
if (!currentType.equals(widthType)) {
STTblWidth.Enum stWidthType = widthType.getStWidthType();
ctWidth.setType(stWidthType);
if (stWidthType.intValue() == STTblWidth.INT_PCT) {
setWidthPercentage(ctWidth, DEFAULT_PERCENTAGE_WIDTH);
} else {
ctWidth.setW(BigInteger.ZERO);
}
}
}
}