org.apache.poi.xwpf.usermodel.IBodyElement Java Examples

/**
 * Updates bookmarks for the given output {@link XWPFTable} according to its input {@link XWPFTable}.
 * 
 * @param bookmarkManager
 *            the {@link BookmarkManager}
 * @param outputTable
 *            the output {@link XWPFTable}
 * @param inputTable
 *            the input {@link XWPFTable}
 */
private void updateBookmarks(BookmarkManager bookmarkManager, final XWPFTable outputTable,
        final XWPFTable inputTable) {
    final List<XWPFTableRow> inputRows = inputTable.getRows();
    final List<XWPFTableRow> outputRows = outputTable.getRows();
    for (int rowIndex = 0; rowIndex < inputRows.size(); rowIndex++) {
        final XWPFTableRow inputRow = inputRows.get(rowIndex);
        final XWPFTableRow outputRow = outputRows.get(rowIndex);
        final List<XWPFTableCell> inputCells = inputRow.getTableCells();
        final List<XWPFTableCell> outputCells = outputRow.getTableCells();
        for (int cellIndex = 0; cellIndex < inputCells.size(); cellIndex++) {
            final XWPFTableCell inputCell = inputCells.get(cellIndex);
            final XWPFTableCell outputCell = outputCells.get(cellIndex);
            final List<IBodyElement> inputBodyElements = inputCell.getBodyElements();
            final List<IBodyElement> outputBodyElements = outputCell.getBodyElements();
            for (int bodyElementIndex = 0; bodyElementIndex < inputBodyElements.size(); bodyElementIndex++) {
                final IBodyElement inputBodyElement = inputBodyElements.get(bodyElementIndex);
                if (inputBodyElement instanceof XWPFParagraph) {
                    final IBodyElement outputBodyElement = outputBodyElements.get(bodyElementIndex);
                    updateBookmarks(bookmarkManager, ((XWPFParagraph) outputBodyElement).getCTP(),
                            ((XWPFParagraph) inputBodyElement).getCTP());
                }
            }
        }
    }
}
 

/**
 * Gets the {@link CTSdtBlock} corresponding to the given {@link ContentControl}.
 * 
 * @param body
 *            the {@link IBody}
 * @param sdt
 *            the {@link XWPFSDT}
 * @return the {@link CTSdtBlock} corresponding to the given {@link ContentControl}
 */
public static CTSdtBlock getCTSdtBlock(IBody body, XWPFSDT sdt) {
    final CTSdtBlock res;

    int sdtIndex = -1;
    for (IBodyElement element : body.getBodyElements()) {
        if (element instanceof XWPFSDT) {
            sdtIndex++;
            if (element == sdt) {
                break;
            }
        }
    }

    if (sdtIndex > -1) {
        res = getCTSdtBlock(body, sdtIndex);
    } else {
        res = null;
    }

    return res;
}
 

@Override
public int getPosOfParagraphCTP(CTP startCtp) {
    IBodyElement current;
    List<IBodyElement> bodyElements = headerFooter.getBodyElements();
    for (int i = 0; i < bodyElements.size(); i++) {
        current = bodyElements.get(i);
        if (current.getElementType() == BodyElementType.PARAGRAPH) {
            if (((XWPFParagraph) current).getCTP().equals(startCtp)) {
                return i;
            }
        }
    }
    return -1;
}
 

@Override
public List<MetaTemplate> resolveBodyElements(List<IBodyElement> bodyElements) {
    List<MetaTemplate> metaTemplates = new ArrayList<>();
    if (null == bodyElements) return metaTemplates;

    // current iterable templates state
    Deque<BlockTemplate> stack = new LinkedList<BlockTemplate>();

    for (IBodyElement element : bodyElements) {
        if (element == null) continue;
        if (element.getElementType() == BodyElementType.PARAGRAPH) {
            XWPFParagraph paragraph = (XWPFParagraph) element;
            RunningRunParagraph runningRun = new RunningRunParagraph(paragraph, templatePattern);
            List<XWPFRun> refactorRuns = runningRun.refactorRun();
            if (null == refactorRuns) continue;
            Collections.reverse(refactorRuns);
            resolveXWPFRuns(refactorRuns, metaTemplates, stack);
        } else if (element.getElementType() == BodyElementType.TABLE) {
            XWPFTable table = (XWPFTable) element;
            List<XWPFTableRow> rows = table.getRows();
            if (null == rows) continue;
            for (XWPFTableRow row : rows) {
                List<XWPFTableCell> cells = row.getTableCells();
                if (null == cells) continue;
                cells.forEach(cell -> {
                    List<MetaTemplate> visitBodyElements = resolveBodyElements(cell.getBodyElements());
                    if (stack.isEmpty()) {
                        metaTemplates.addAll(visitBodyElements);
                    } else {
                        stack.peek().getTemplates().addAll(visitBodyElements);
                    }
                });
            }
        }
    }

    checkStack(stack);
    return metaTemplates;
}
 

@Override
public void updateBodyElements(IBodyElement insertNewParagraph, IBodyElement copy) {
    int pos = -1;
    List<IBodyElement> bodyElements = getBodyElements();
    for (int i = 0; i < bodyElements.size(); i++) {
        if (bodyElements.get(i) == insertNewParagraph) {
            pos = i;
        }
    }
    if (-1 != pos) bodyElements.set(pos, copy);

}
 

@Override
public int getPosOfParagraphCTP(CTP startCtp) {
    IBodyElement current;
    List<IBodyElement> bodyElements = cell.getBodyElements();
    for (int i = 0; i < bodyElements.size(); i++) {
        current = bodyElements.get(i);
        if (current.getElementType() == BodyElementType.PARAGRAPH) {
            if (((XWPFParagraph) current).getCTP().equals(startCtp)) { return i; }
        }
    }
    return -1;
}
 

@Override
public void updateBodyElements(IBodyElement insertNewParagraph, IBodyElement copy) {
    int pos = -1;
    List<IBodyElement> bodyElements = getBodyElements();
    for (int i = 0; i < bodyElements.size(); i++) {
        if (bodyElements.get(i) == insertNewParagraph) {
            pos = i;
        }
    }
    if (-1 != pos) bodyElements.set(pos, copy);

}
 

@Override
public void removeBodyElement(int pos) {
    List<IBodyElement> bodyElements = getBodyElements();
    if (pos >= 0 && pos < bodyElements.size()) {
        BodyElementType type = bodyElements.get(pos).getElementType();
        if (type == BodyElementType.TABLE) {
            headerFooter.removeTable((XWPFTable) bodyElements.get(pos));
        }
        if (type == BodyElementType.PARAGRAPH) {
            headerFooter.removeParagraph((XWPFParagraph) bodyElements.get(pos));
        }
    }
}
 

public void updateBodyElements(IBodyElement insertNewParagraph, IBodyElement copy) {
    int pos = -1;
    for (int i = 0; i < bodyElements.size(); i++) {
        if (bodyElements.get(i) == insertNewParagraph) {
            pos =  i;
        }
    }
    if (-1 != pos) bodyElements.set(pos, copy);
    
}
 

public int getPosOfTableCTTbl(CTTbl bodyObj) {
    IBodyElement current;
    for (int i = 0; i < bodyElements.size(); i++) {
        current = bodyElements.get(i);
        if (current.getElementType() == BodyElementType.TABLE) {
            if (((XWPFTable)current).getCTTbl().equals(bodyObj)) {
                return i;
            }
        }
    }
    return -1;
}
 

public int getPosOfParagraphCTP(CTP bodyObj) {
    IBodyElement current;
    for (int i = 0; i < bodyElements.size(); i++) {
        current = bodyElements.get(i);
        if (current.getElementType() == BodyElementType.PARAGRAPH) {
            if (((XWPFParagraph)current).getCTP().equals(bodyObj)) {
                return i;
            }
        }
    }
    return -1;
}
 

/**
 * Marks the {@link CTSimpleField} of the given {@link IBody} as
 * {@link CTSimpleField#setDirty(org.openxmlformats.schemas.wordprocessingml.x2006.main.STOnOff.Enum) dirty}.
 * 
 * @param body
 *            the {@link IBody}
 */
public void markFieldsAsDirty(IBody body) {
    if (body instanceof XWPFDocument) {
        final XWPFDocument document = (XWPFDocument) body;
        for (XWPFHeader header : document.getHeaderList()) {
            markFieldsAsDirty(header);
        }
        for (XWPFFooter footer : document.getFooterList()) {
            markFieldsAsDirty(footer);
        }
    }
    for (IBodyElement element : body.getBodyElements()) {
        markFieldsAsDirty(element);
    }
}
 

/**
 * Create a new iterator for a single {@link IBodyElement}.
 * 
 * @param bodyElement
 *            the {@link IBodyElement}
 */
public BodyElementIterator(IBodyElement bodyElement) {
    final List<IBodyElement> list = new ArrayList<IBodyElement>();

    list.add(bodyElement);

    this.iterator = list.iterator();
}
 

/**
 * Put the iterator in a state where it is finished or there's a token to
 * consume in the currentIterator.
 */
private void moveToNextToken() {
    if (tokenIterator == null || !tokenIterator.hasNext()) {
        while (elementIterator.hasNext() && (tokenIterator == null || !tokenIterator.hasNext())) {
            final IBodyElement element = elementIterator.next();
            switch (element.getElementType()) {
                case PARAGRAPH:
                    // create an empty run if there's no run in the paragraph.
                    // this eases the processing of documents. The processing is based on runs and a paragraph that has no run in it
                    // won't
                    // be seen by the generator and, as a consequence, won't be inserted as a static part in the result.
                    XWPFParagraph paragraph = (XWPFParagraph) element;
                    if (paragraph.getRuns().size() == 0) {
                        paragraph.createRun().setText("");
                    }
                    tokenIterator = new RunIterator(((XWPFParagraph) element).getRuns());
                    break;

                case TABLE:
                    tokenIterator = new BodyElementIterator(element);
                    break;

                case CONTENTCONTROL:
                    tokenIterator = new BodyElementIterator(element);
                    break;

                default:
                    throw new UnsupportedOperationException(
                            "Unsupported type of body element : " + element.getElementType());
            }
        }
    }
}
 

@Override
public List<IBodyElement> getBodyElements() {
    return doc.getBodyElements();
}
 

@Test
void testGetBodyElements() {
    List<IBodyElement> bodyElements = container.getBodyElements();
    assertEquals(bodyElements.size(), 6);
}
 

@Test
void testGetBodyElements() {
    List<IBodyElement> bodyElements = container.getBodyElements();
    assertEquals(bodyElements.size(), 6);
}
 

@Test
void testGetBodyElements() {
    List<IBodyElement> bodyElements = container.getBodyElements();
    assertEquals(bodyElements.size(), 6);
}
 

@SuppressWarnings("unchecked")
@Override
public List<IBodyElement> getBodyElements() {
    return (List<IBodyElement>) ReflectionUtils.getValue("bodyElements", cell);
}
 

@SuppressWarnings("unchecked")
@Override
public List<IBodyElement> getBodyElements() {
    return (List<IBodyElement>) ReflectionUtils.getValue("bodyElements", headerFooter);
}
 

/**
 * Copies the given {@link IBody} to the given {@link XWPFParagraph}.
 * 
 * @param outputParagraph
 *            the output {@link XWPFParagraph}
 * @param body
 *            the {@link IBody}
 * @param bookmarkManager
 *            the {@link BookmarkManager} to update or <code>null</code>
 * @return the new current {@link XWPFParagraph}
 * @throws Exception
 *             if something goes wrong
 */
public XWPFParagraph copyBody(XWPFParagraph outputParagraph, IBody body, BookmarkManager bookmarkManager)
        throws Exception {
    XWPFParagraph res = null;

    if (body.getBodyElements().isEmpty()) {
        res = outputParagraph;
    } else {
        final IBody outputBody = outputParagraph.getBody();
        boolean inline;
        if (!(outputBody instanceof XWPFTableCell) && outputParagraph.getRuns().size() == 1
            && outputParagraph.getRuns().get(0).getText(0).length() == 0) {
            removeParagraph(outputBody, outputParagraph);
            inline = false;
        } else {
            inline = true;
        }

        final Map<String, String> inputRelationIdToOutputMap = new HashMap<>();
        final Map<URI, URI> inputPartURIToOutputPartURI = new HashMap<>();
        for (IBodyElement element : body.getBodyElements()) {
            if (element instanceof XWPFParagraph) {
                final XWPFParagraph inputParagraph = (XWPFParagraph) element;
                if (inline) {
                    // inline the all paragraph
                    copyParagraphFragment(inputRelationIdToOutputMap, inputPartURIToOutputPartURI, outputParagraph,
                            inputParagraph, null, null);
                    res = outputParagraph;
                } else {
                    res = copyParagraph(outputBody, inputRelationIdToOutputMap, inputPartURIToOutputPartURI,
                            inputParagraph, bookmarkManager);
                }
            } else if (element instanceof XWPFTable) {
                final XWPFTable inputTable = (XWPFTable) element;
                copyTable(outputBody, inputRelationIdToOutputMap, inputPartURIToOutputPartURI, inputTable,
                        bookmarkManager);
                res = null;
            } else if (element instanceof XWPFSDT) {
                copyCTSdtBlock(outputBody, AbstractBodyParser.getCTSdtBlock(outputBody, (XWPFSDT) element));
                res = null;
            } else {
                throw new IllegalStateException("unknown body element.");
            }
            inline = false;
        }

        if (res != null && outputBody instanceof XWPFTableCell && res.getRuns().isEmpty()) {
            res.createRun();
        }
    }

    return res;
}
 

public static NumberingContinue of(BodyContainer bodyContainer, int start, int end, IterableTemplate iterable) {
    if (start + 1 >= end) return new NumberingContinue();

    final List<IBodyElement> elements = bodyContainer.getBodyElements().subList(start + 1, end);
    if (elements.isEmpty()) return new NumberingContinue();

    CTNumPr first = null;
    int firstPos = -1;
    for (IBodyElement element : elements) {
        if (element.getElementType() == BodyElementType.PARAGRAPH) {
            XWPFParagraph paragraph = (XWPFParagraph) element;
            CTP ctp = paragraph.getCTP();
            if (ctp.getPPr() != null && ctp.getPPr().getNumPr() != null) {
                CTNumPr numPr = ctp.getPPr().getNumPr();
                // find first
                if (null == first) {
                    first = numPr;
                    firstPos = bodyContainer.getPosOfParagraphCTP(ctp);
                } else {
                    // first is not unique
                    if ((Objects.equals(numPr.getIlvl().getVal(), first.getIlvl().getVal())
                            && Objects.equals(numPr.getNumId().getVal(), first.getNumId().getVal()))) {
                        first = null;
                        break;
                    }
                }
            }
        }
    }
    if (null == first) return new NumberingContinue();

    // the first is unique, if first inside other iterable section
    List<MetaTemplate> templates = iterable.getTemplates();
    for (MetaTemplate template : templates) {
        if (template instanceof IterableTemplate) {
            CTP startCtp = ((XWPFParagraph) ((IterableTemplate) template).getStartRun().getParent()).getCTP();
            CTP endCtp = ((XWPFParagraph) ((IterableTemplate) template).getEndRun().getParent()).getCTP();

            int startPos = bodyContainer.getPosOfParagraphCTP(startCtp);
            if (startPos >= firstPos) break;

            int endPos = bodyContainer.getPosOfParagraphCTP(endCtp);
            if (firstPos > startPos && firstPos < endPos) { return new NumberingContinue(); }
        }
    }
    return new NumberingContinue(first.getNumId().getVal());
}
 

@Override
public void updateBodyElements(IBodyElement insertNewTbl, IBodyElement copy) {
    doc.updateBodyElements(insertNewTbl, copy);
}
 

/**
 * Gets the {@link IBodyElement}.
 * 
 * @return the {@link IBodyElement} if the {@link #getKind() kind} is not {@link ParsingTokenKind#RUN}, <code>null</code> otherwise
 */
public IBodyElement getBodyElement() {
    return bodyElement;
}
 

/**
 * Creates a new parsing token that corresponds to a {@link IBodyElement}.
 * 
 * @param bodyElement
 *            the {@link IBodyElement}
 */
public ParsingToken(IBodyElement bodyElement) {
    this.bodyElement = bodyElement;
    run = null;
    kind = ParsingTokenKind.getParsingTokenKind(bodyElement.getElementType());
}
 

/**
 * resolve body elements
 * 
 * @param bodyElements
 * @return
 */
List<MetaTemplate> resolveBodyElements(List<IBodyElement> bodyElements);
 

void updateBodyElements(IBodyElement insertNewParagraph, IBodyElement copy); 

List<IBodyElement> getBodyElements();