Java tutorial
/** * Copyright (C) 2011-2015 The XDocReport Team <xdocreport@googlegroups.com> * * All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ package fr.opensagres.poi.xwpf.converter.pdf.internal; import static fr.opensagres.poi.xwpf.converter.core.utils.DxaUtil.emu2points; import java.io.OutputStream; import java.math.BigInteger; import java.util.List; import java.util.logging.Logger; import org.apache.poi.xwpf.usermodel.*; import org.openxmlformats.schemas.drawingml.x2006.main.CTPositiveSize2D; import org.openxmlformats.schemas.drawingml.x2006.picture.CTPicture; import org.openxmlformats.schemas.drawingml.x2006.wordprocessingDrawing.STRelFromH; import org.openxmlformats.schemas.drawingml.x2006.wordprocessingDrawing.STRelFromV; import org.openxmlformats.schemas.drawingml.x2006.wordprocessingDrawing.STWrapText; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBr; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHdrFtrRef; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLvl; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPPr; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPTab; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPr; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSectPr; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabStop; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTText; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection; import org.openxmlformats.schemas.wordprocessingml.x2006.main.STTabJc; import org.openxmlformats.schemas.wordprocessingml.x2006.main.STTabTlc; import org.openxmlformats.schemas.wordprocessingml.x2006.main.STTextDirection; import org.openxmlformats.schemas.wordprocessingml.x2006.main.STVerticalJc; import org.openxmlformats.schemas.wordprocessingml.x2006.main.STVerticalJc.Enum; import com.lowagie.text.Chunk; import com.lowagie.text.DocumentException; import com.lowagie.text.Element; import com.lowagie.text.Font; import com.lowagie.text.Image; import com.lowagie.text.Paragraph; import com.lowagie.text.Rectangle; import com.lowagie.text.pdf.PdfPCell; import com.lowagie.text.pdf.PdfPTable; import com.lowagie.text.pdf.draw.DottedLineSeparator; import com.lowagie.text.pdf.draw.LineSeparator; import com.lowagie.text.pdf.draw.VerticalPositionMark; import fr.opensagres.poi.xwpf.converter.core.BorderSide; import fr.opensagres.poi.xwpf.converter.core.Color; import fr.opensagres.poi.xwpf.converter.core.ListItemContext; import fr.opensagres.poi.xwpf.converter.core.ParagraphLineSpacing; import fr.opensagres.poi.xwpf.converter.core.TableCellBorder; import fr.opensagres.poi.xwpf.converter.core.TableHeight; import fr.opensagres.poi.xwpf.converter.core.TableWidth; import fr.opensagres.poi.xwpf.converter.core.XWPFDocumentVisitor; import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphIndentationHangingValueProvider; import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphIndentationLeftValueProvider; import fr.opensagres.poi.xwpf.converter.core.utils.DxaUtil; import fr.opensagres.poi.xwpf.converter.core.utils.StringUtils; import fr.opensagres.poi.xwpf.converter.pdf.PdfOptions; import fr.opensagres.poi.xwpf.converter.pdf.internal.elements.StylableAnchor; import fr.opensagres.poi.xwpf.converter.pdf.internal.elements.StylableDocument; import fr.opensagres.poi.xwpf.converter.pdf.internal.elements.StylableHeaderFooter; import fr.opensagres.poi.xwpf.converter.pdf.internal.elements.StylableMasterPage; import fr.opensagres.poi.xwpf.converter.pdf.internal.elements.StylableParagraph; import fr.opensagres.poi.xwpf.converter.pdf.internal.elements.StylableTable; import fr.opensagres.poi.xwpf.converter.pdf.internal.elements.StylableTableCell; import fr.opensagres.xdocreport.itext.extension.ExtendedChunk; import fr.opensagres.xdocreport.itext.extension.ExtendedImage; import fr.opensagres.xdocreport.itext.extension.ExtendedParagraph; import fr.opensagres.xdocreport.itext.extension.ExtendedPdfPCell; import fr.opensagres.xdocreport.itext.extension.ExtendedPdfPTable; import fr.opensagres.xdocreport.itext.extension.IITextContainer; import fr.opensagres.xdocreport.itext.extension.font.FontGroup; public class PdfMapper extends XWPFDocumentVisitor<IITextContainer, PdfOptions, StylableMasterPage> { private static final String TAB = "\t"; /** * Logger for this class */ private static final Logger LOGGER = Logger.getLogger(PdfMapper.class.getName()); private final OutputStream out; // Instance of PDF document private StylableDocument pdfDocument; private Font currentRunFontAscii; private Font currentRunFontEastAsia; private Font currentRunFontHAnsi; private UnderlinePatterns currentRunUnderlinePatterns; private Color currentRunBackgroundColor; private Float currentRunX; private Float currentPageWidth; private StylableHeaderFooter pdfHeader; private StylableHeaderFooter pdfFooter; private Integer expectedPageCount; public PdfMapper(XWPFDocument document, OutputStream out, PdfOptions options, Integer expectedPageCount) throws Exception { super(document, options != null ? options : PdfOptions.getDefault()); this.out = out; this.expectedPageCount = expectedPageCount; } // ------------------------- Document @Override protected IITextContainer startVisitDocument() throws Exception { // Create instance of PDF document this.pdfDocument = new StylableDocument(out, options.getConfiguration()); this.pdfDocument.setMasterPageManager(getMasterPageManager()); return pdfDocument; } @Override protected void endVisitDocument() throws Exception { pdfDocument.close(); out.close(); } @Override protected IITextContainer startVisitSDT(XWPFSDT contents, IITextContainer container) { return null; } @Override protected void endVisitSDT(XWPFSDT contents, IITextContainer container, IITextContainer sdtContainer) { } @Override protected void visitSDTBody(XWPFSDT contents, IITextContainer sdtContainer) throws Exception { } // ------------------------- Header/Footer @Override protected void visitHeader(XWPFHeader header, CTHdrFtrRef headerRef, CTSectPr sectPr, StylableMasterPage masterPage) throws Exception { BigInteger headerY = sectPr.getPgMar() != null ? sectPr.getPgMar().getHeader() : null; this.currentPageWidth = sectPr.getPgMar() != null ? DxaUtil.dxa2points(sectPr.getPgSz().getW()) : null; this.pdfHeader = new StylableHeaderFooter(pdfDocument, headerY, true); // List<IBodyElement> bodyElements = header.getBodyElements(); List<IBodyElement> bodyElements = super.getBodyElements(header); StylableTableCell tableCell = getHeaderFooterTableCell(pdfHeader, bodyElements); visitBodyElements(bodyElements, tableCell); masterPage.setHeader(pdfHeader); this.currentPageWidth = null; this.pdfHeader = null; } @Override protected void visitFooter(XWPFFooter footer, CTHdrFtrRef footerRef, CTSectPr sectPr, StylableMasterPage masterPage) throws Exception { BigInteger footerY = sectPr.getPgMar() != null ? sectPr.getPgMar().getFooter() : null; this.currentPageWidth = sectPr.getPgMar() != null ? DxaUtil.dxa2points(sectPr.getPgSz().getW()) : null; this.pdfFooter = new StylableHeaderFooter(pdfDocument, footerY, false); List<IBodyElement> bodyElements = super.getBodyElements(footer); StylableTableCell tableCell = getHeaderFooterTableCell(pdfFooter, bodyElements); visitBodyElements(bodyElements, tableCell); masterPage.setFooter(pdfFooter); this.currentPageWidth = null; this.pdfFooter = null; } private StylableTableCell getHeaderFooterTableCell(StylableHeaderFooter pdfHeaderFooter, List<IBodyElement> bodyElements) throws DocumentException { return pdfHeaderFooter.getTableCell(); } public void setActiveMasterPage(StylableMasterPage masterPage) { pdfDocument.setActiveMasterPage(masterPage); } public StylableMasterPage createMasterPage(CTSectPr sectPr) { return new StylableMasterPage(sectPr); } // ------------------------- Paragraph @Override protected IITextContainer startVisitParagraph(XWPFParagraph docxParagraph, ListItemContext itemContext, IITextContainer pdfParentContainer) throws Exception { this.currentRunX = null; // create PDF paragraph StylableParagraph pdfParagraph = pdfDocument.createParagraph(pdfParentContainer); // indentation left Float indentationLeft = stylesDocument.getIndentationLeft(docxParagraph); if (indentationLeft != null) { pdfParagraph.setIndentationLeft(indentationLeft); } // indentation right Float indentationRight = stylesDocument.getIndentationRight(docxParagraph); if (indentationRight != null) { pdfParagraph.setIndentationRight(indentationRight); } // indentation first line Float indentationFirstLine = stylesDocument.getIndentationFirstLine(docxParagraph); if (indentationFirstLine != null) { pdfParagraph.setFirstLineIndent(indentationFirstLine); } // indentation hanging (remove first line) Float indentationHanging = stylesDocument.getIndentationHanging(docxParagraph); if (indentationHanging != null) { pdfParagraph.setFirstLineIndent(-indentationHanging); } // // spacing before Float spacingBefore = stylesDocument.getSpacingBefore(docxParagraph); if (spacingBefore != null) { pdfParagraph.setSpacingBefore(spacingBefore); } // spacing after Float spacingAfter = stylesDocument.getSpacingAfter(docxParagraph); if (spacingAfter != null) { pdfParagraph.setSpacingAfter(spacingAfter); } ParagraphLineSpacing lineSpacing = stylesDocument.getParagraphSpacing(docxParagraph); if (lineSpacing != null) { if (lineSpacing.getLeading() != null && lineSpacing.getMultipleLeading() != null) { pdfParagraph.setLeading(lineSpacing.getLeading(), lineSpacing.getMultipleLeading()); } else { if (lineSpacing.getLeading() != null) { pdfParagraph.setLeading(lineSpacing.getLeading()); } if (lineSpacing.getMultipleLeading() != null) { pdfParagraph.setMultipliedLeading(lineSpacing.getMultipleLeading()); } } } // text-align ParagraphAlignment alignment = stylesDocument.getParagraphAlignment(docxParagraph); if (alignment != null) { switch (alignment) { case LEFT: pdfParagraph.setAlignment(Element.ALIGN_LEFT); break; case RIGHT: pdfParagraph.setAlignment(Element.ALIGN_RIGHT); break; case CENTER: pdfParagraph.setAlignment(Element.ALIGN_CENTER); break; case BOTH: pdfParagraph.setAlignment(Element.ALIGN_JUSTIFIED); break; default: break; } } // background-color Color backgroundColor = stylesDocument.getBackgroundColor(docxParagraph); if (backgroundColor != null) { pdfParagraph.setBackgroundColor(Converter.toAwtColor(backgroundColor)); } // border CTBorder borderTop = stylesDocument.getBorderTop(docxParagraph); pdfParagraph.setBorder(borderTop, Rectangle.TOP); CTBorder borderBottom = stylesDocument.getBorderBottom(docxParagraph); pdfParagraph.setBorder(borderBottom, Rectangle.BOTTOM); CTBorder borderLeft = stylesDocument.getBorderLeft(docxParagraph); pdfParagraph.setBorder(borderLeft, Rectangle.LEFT); CTBorder borderRight = stylesDocument.getBorderRight(docxParagraph); pdfParagraph.setBorder(borderRight, Rectangle.RIGHT); if (itemContext != null) { CTLvl lvl = itemContext.getLvl(); CTPPr lvlPPr = lvl.getPPr(); if (lvlPPr != null) { if (ParagraphIndentationLeftValueProvider.INSTANCE .getValue(docxParagraph.getCTP().getPPr()) == null) { // search the indentation from the level properties only if // paragraph has not override it // see // https://code.google.com/p/xdocreport/issues/detail?id=239 Float indLeft = ParagraphIndentationLeftValueProvider.INSTANCE.getValue(lvlPPr); if (indLeft != null) { pdfParagraph.setIndentationLeft(indLeft); } } if (ParagraphIndentationHangingValueProvider.INSTANCE .getValue(docxParagraph.getCTP().getPPr()) == null) { // search the hanging from the level properties only if // paragraph has not override it // see // https://code.google.com/p/xdocreport/issues/detail?id=239 Float hanging = stylesDocument.getIndentationHanging(lvlPPr); if (hanging != null) { pdfParagraph.setFirstLineIndent(-hanging); } } } CTRPr lvlRPr = lvl.getRPr(); if (lvlRPr != null) { // Font family String listItemFontFamily = stylesDocument.getFontFamilyAscii(lvlRPr); // Get font size Float listItemFontSize = stylesDocument.getFontSize(lvlRPr); // Get font style int listItemFontStyle = Font.NORMAL; Boolean bold = stylesDocument.getFontStyleBold(lvlRPr); if (bold != null && bold) { listItemFontStyle |= Font.BOLD; } Boolean italic = stylesDocument.getFontStyleItalic(lvlRPr); if (italic != null && italic) { listItemFontStyle |= Font.ITALIC; } Boolean strike = stylesDocument.getFontStyleStrike(lvlRPr); if (strike != null && strike) { listItemFontStyle |= Font.STRIKETHRU; } // Font color Color listItemFontColor = stylesDocument.getFontColor(lvlRPr); pdfParagraph.setListItemFontFamily(listItemFontFamily); pdfParagraph.setListItemFontSize(listItemFontSize); pdfParagraph.setListItemFontStyle(listItemFontStyle); pdfParagraph.setListItemFontColor(Converter.toAwtColor(listItemFontColor)); } pdfParagraph.setListItemText(itemContext.getText()); } return pdfParagraph; } @Override protected void endVisitParagraph(XWPFParagraph docxParagraph, IITextContainer pdfParentContainer, IITextContainer pdfParagraphContainer) throws Exception { // add the iText paragraph in the current parent container. ExtendedParagraph pdfParagraph = (ExtendedParagraph) pdfParagraphContainer; pdfParentContainer.addElement(pdfParagraph.getElement()); this.currentRunX = null; } // ------------------------- Run @Override protected void visitEmptyRun(IITextContainer pdfParagraphContainer) throws Exception { StylableParagraph paragraph = (StylableParagraph) pdfParagraphContainer; IITextContainer parent = paragraph.getParent(); if (parent instanceof StylableTableCell) { StylableTableCell cell = (StylableTableCell) parent; if (cell.getRotation() > 0) { // Run paragraph belongs to Cell which has rotation, ignore the // empty run. return; } } // Add new PDF line pdfParagraphContainer.addElement(Chunk.NEWLINE); } @Override protected void visitRun(XWPFRun docxRun, boolean pageNumber, String url, IITextContainer pdfParagraphContainer) throws Exception { // Font family String fontFamilyAscii = stylesDocument.getFontFamilyAscii(docxRun); String fontFamilyEastAsia = stylesDocument.getFontFamilyEastAsia(docxRun); String fontFamilyHAnsi = stylesDocument.getFontFamilyHAnsi(docxRun); // Get font size Float fontSize = stylesDocument.getFontSize(docxRun); if (fontSize == null) { fontSize = -1f; } // Get font style int fontStyle = Font.NORMAL; Boolean bold = stylesDocument.getFontStyleBold(docxRun); if (bold != null && bold) { fontStyle |= Font.BOLD; } Boolean italic = stylesDocument.getFontStyleItalic(docxRun); if (italic != null && italic) { fontStyle |= Font.ITALIC; } Boolean strike = stylesDocument.getFontStyleStrike(docxRun); if (strike != null && strike) { fontStyle |= Font.STRIKETHRU; } // Font color Color fontColor = stylesDocument.getFontColor(docxRun); // Font this.currentRunFontAscii = getFont(fontFamilyAscii, fontSize, fontStyle, fontColor); this.currentRunFontEastAsia = getFont(fontFamilyEastAsia, fontSize, fontStyle, fontColor); this.currentRunFontHAnsi = getFont(fontFamilyHAnsi, fontSize, fontStyle, fontColor); // Underline patterns this.currentRunUnderlinePatterns = stylesDocument.getUnderline(docxRun); // background color this.currentRunBackgroundColor = stylesDocument.getBackgroundColor(docxRun); // highlight if (currentRunBackgroundColor == null) { this.currentRunBackgroundColor = stylesDocument.getTextHighlighting(docxRun); } StylableParagraph pdfParagraph = (StylableParagraph) pdfParagraphContainer; pdfParagraph.adjustMultipliedLeading(currentRunFontAscii); // addd symbol list item chunk if needed. String listItemText = pdfParagraph.getListItemText(); if (StringUtils.isNotEmpty(listItemText)) { // FIXME: add some space after the list item listItemText += " "; String listItemFontFamily = pdfParagraph.getListItemFontFamily(); Float listItemFontSize = pdfParagraph.getListItemFontSize(); int listItemFontStyle = pdfParagraph.getListItemFontStyle(); java.awt.Color listItemFontColor = pdfParagraph.getListItemFontColor(); Font listItemFont = options.getFontProvider().getFont( listItemFontFamily != null ? listItemFontFamily : fontFamilyAscii, options.getFontEncoding(), listItemFontSize != null ? listItemFontSize : fontSize, listItemFontStyle != Font.NORMAL ? listItemFontStyle : fontStyle, listItemFontColor != null ? listItemFontColor : Converter.toAwtColor(fontColor)); Chunk symbol = createTextChunk(listItemText, false, listItemFont, currentRunUnderlinePatterns, currentRunBackgroundColor); pdfParagraph.add(symbol); pdfParagraph.setListItemText(null); } IITextContainer container = pdfParagraphContainer; if (url != null) { // URL is not null, generate a PDF hyperlink. StylableAnchor pdfAnchor = new StylableAnchor(); pdfAnchor.setReference(url); pdfAnchor.setITextContainer(container); container = pdfAnchor; } super.visitRun(docxRun, pageNumber, url, container); if (url != null) { // URL is not null, add the PDF hyperlink in the PDF paragraph pdfParagraphContainer.addElement((StylableAnchor) container); } this.currentRunFontAscii = null; this.currentRunFontEastAsia = null; this.currentRunFontHAnsi = null; this.currentRunUnderlinePatterns = null; this.currentRunBackgroundColor = null; } private Font getFont(String fontFamily, Float fontSize, int fontStyle, Color fontColor) { String fontToUse = stylesDocument.getFontNameToUse(fontFamily); if (StringUtils.isNotEmpty(fontToUse)) { return options.getFontProvider().getFont(fontToUse, options.getFontEncoding(), fontSize, fontStyle, Converter.toAwtColor(fontColor)); } Font font = options.getFontProvider().getFont(fontFamily, options.getFontEncoding(), fontSize, fontStyle, Converter.toAwtColor(fontColor)); if (!isFontExists(font)) { // font is not found try { List<String> altNames = stylesDocument.getFontsAltName(fontFamily); if (altNames != null) { // Loop for each alternative names font (from the // fontTable.xml) to find the well font. for (String altName : altNames) { // check if the current font name is not the same that // original (o avoid StackOverFlow : see // https://code.google.com/p/xdocreport/issues/detail?id=393) if (!fontFamily.equals(altName)) { font = getFont(altName, fontSize, fontStyle, fontColor); if (isFontExists(font)) { stylesDocument.setFontNameToUse(fontFamily, altName); return font; } } } } } catch (Exception e) { LOGGER.severe(e.getMessage()); } } return font; } /** * Returns true if the iText font exists and false otherwise. * * @param font * @return */ private boolean isFontExists(Font font) { // FIXME : is it like this to test that font exists? return font != null && font.getBaseFont() != null; } @Override protected void visitText(CTText docxText, boolean pageNumber, IITextContainer pdfParagraphContainer) throws Exception { Font font = currentRunFontAscii; Font fontAsian = currentRunFontEastAsia; Font fontComplex = currentRunFontHAnsi; createAndAddChunks(pdfParagraphContainer, docxText.getStringValue(), currentRunUnderlinePatterns, currentRunBackgroundColor, pageNumber, font, fontAsian, fontComplex); } private Chunk createTextChunk(String text, boolean pageNumber, Font currentRunFont, UnderlinePatterns currentRunUnderlinePatterns, Color currentRunBackgroundColor) { // Chunk textChunk = // pageNumber ? new ExtendedChunk( pdfDocument, true, currentRunFont ) : // new Chunk( text, currentRunFont ); Chunk textChunk = null; if (processingTotalPageCountField && expectedPageCount != null) { textChunk = new Chunk(String.valueOf(expectedPageCount), currentRunFont); } else { textChunk = pageNumber ? new ExtendedChunk(pdfDocument, true, currentRunFont) : new Chunk(text, currentRunFont); } if (currentRunUnderlinePatterns != null) { // underlined boolean singleUnderlined = false; switch (currentRunUnderlinePatterns) { case SINGLE: singleUnderlined = true; break; default: break; } if (singleUnderlined) { textChunk.setUnderline(1, -2); } } // background color if (currentRunBackgroundColor != null) { textChunk.setBackground(Converter.toAwtColor(currentRunBackgroundColor)); } if (currentRunX != null) { this.currentRunX += textChunk.getWidthPoint(); } return textChunk; } private void createAndAddChunks(IITextContainer parent, String textContent, UnderlinePatterns underlinePatterns, Color backgroundColor, boolean pageNumber, Font font, Font fontAsian, Font fontComplex) { StringBuilder sbuf = new StringBuilder(); FontGroup currentGroup = FontGroup.WESTERN; for (int i = 0; i < textContent.length(); i++) { char ch = textContent.charAt(i); FontGroup group = FontGroup.getUnicodeGroup(ch, font, fontAsian, fontComplex); if (sbuf.length() == 0 || currentGroup.equals(group)) { // continue current chunk sbuf.append(ch); } else { // end chunk Font chunkFont = getFont(font, fontAsian, fontComplex, currentGroup); Chunk chunk = createTextChunk(sbuf.toString(), pageNumber, chunkFont, underlinePatterns, backgroundColor); parent.addElement(chunk); // start new chunk sbuf.setLength(0); sbuf.append(ch); } currentGroup = group; } // end chunk Font chunkFont = getFont(font, fontAsian, fontComplex, currentGroup); Chunk chunk = createTextChunk(sbuf.toString(), pageNumber, chunkFont, underlinePatterns, backgroundColor); parent.addElement(chunk); } private Font getFont(Font font, Font fontAsian, Font fontComplex, FontGroup group) { switch (group) { case WESTERN: return font; case ASIAN: return fontAsian; case COMPLEX: return fontComplex; } return font; } @Override protected void visitTab(CTPTab tab, IITextContainer pdfParagraphContainer) throws Exception { // TODO manage this case. // // if ( tab == null ) // { // float defaultTabStop = stylesDocument.getDefaultTabStop(); // Chunk pdfTab = new Chunk( new VerticalPositionMark(), defaultTabStop, // false ); // pdfParagraphContainer.addElement( pdfTab ); // } // else // { // Chunk pdfTab = new Chunk( new VerticalPositionMark() ); // pdfParagraphContainer.addElement( pdfTab ); // } } @Override protected void visitTabs(CTTabs tabs, IITextContainer pdfParagraphContainer) throws Exception { if (currentRunX == null) { Paragraph paragraph = null; if (pdfParagraphContainer instanceof Paragraph) { paragraph = (Paragraph) pdfParagraphContainer; } else { paragraph = (Paragraph) ((StylableAnchor) pdfParagraphContainer).getITextContainer(); } currentRunX = paragraph.getFirstLineIndent(); List<Chunk> chunks = paragraph.getChunks(); for (Chunk chunk : chunks) { currentRunX += chunk.getWidthPoint(); } } else { if (currentRunX >= pdfDocument.getPageWidth()) { currentRunX = 0f; } } Float tabPosition = null; STTabTlc.Enum tabLeader = null; STTabJc.Enum tabVal = null; boolean useDefaultTabStop = false; if (tabs != null) { List<CTTabStop> tabList = tabs.getTabList(); CTTabStop tabStop = getTabStop(tabList); if (tabStop != null) { float lastX = DxaUtil.dxa2points(tabStop.getPos().floatValue()); if (lastX > currentRunX) { tabPosition = lastX; tabLeader = tabStop.getLeader(); tabVal = tabStop.getVal(); } else { useDefaultTabStop = true; } } } if (tabs == null || useDefaultTabStop) { // default tab float defaultTabStop = stylesDocument.getDefaultTabStop(); float pageWidth = pdfDocument.getPageWidth(); int nbInterval = (int) (pageWidth / defaultTabStop); Float lastX = getTabStopPosition(currentRunX, defaultTabStop, nbInterval); if (lastX != null) { tabPosition = lastX; } } if (tabPosition != null) { currentRunX = tabPosition; // tab leader : Specifies the character which shall be used to fill // in the space created by a tab // which // ends // at this custom tab stop. This character shall be repeated as // required to completely fill the // tab spacing generated by the tab character. VerticalPositionMark mark = createVerticalPositionMark(tabLeader); Chunk pdfTab = null; if (STTabJc.RIGHT.equals(tabVal)) { pdfTab = new Chunk(mark); } else { pdfTab = new Chunk(mark, currentRunX); } pdfParagraphContainer.addElement(pdfTab); } } private Float getTabStopPosition(float currentPosition, float interval, int nbInterval) { Float nextPosition = null; float newPosition = 0f; for (int i = 1; i < nbInterval; i++) { newPosition = interval * i; if (currentPosition < newPosition) { nextPosition = newPosition; break; } } return nextPosition; } private VerticalPositionMark createVerticalPositionMark( org.openxmlformats.schemas.wordprocessingml.x2006.main.STTabTlc.Enum leader) { if (leader != null) { if (leader == STTabTlc.DOT) { return new DottedLineSeparator(); } else if (leader == STTabTlc.UNDERSCORE) { return new LineSeparator(); } } return new VerticalPositionMark(); } private CTTabStop getTabStop(List<CTTabStop> tabList) { if (tabList.size() == 1) { CTTabStop tabStop = tabList.get(0); if (isClearTab(tabStop)) { return null; } return tabStop; } CTTabStop selectedTabStop = null; for (CTTabStop tabStop : tabList) { if (isClearTab(tabStop)) { continue; } if (canApplyTabStop(tabStop)) { return tabStop; } // // if ( selectedTabStop == null ) // { // selectedTabStop = tabStop; // } // else // { // if ( tabStop.getPos().floatValue() > // selectedTabStop.getPos().floatValue() ) // { // selectedTabStop = tabStop; // } // } } // TODO : retrieve the well tab stop according the current width of the // line. return null; } private boolean canApplyTabStop(CTTabStop tabStop) { if (tabStop.getVal().equals(STTabJc.LEFT)) { if (currentRunX < DxaUtil.dxa2points(tabStop.getPos().floatValue())) { return true; } } else if (tabStop.getVal().equals(STTabJc.RIGHT)) { if (isWordDocumentPartParsing()) { if (pdfDocument.getWidthLimit() - (currentRunX + DxaUtil.dxa2points(tabStop.getPos().floatValue())) <= 0) { return true; } } else { if (currentPageWidth == null) { return true; } if (currentPageWidth.floatValue() - (currentRunX + DxaUtil.dxa2points(tabStop.getPos().floatValue())) <= 0) { return true; } } } else if (tabStop.getVal().equals(STTabJc.CENTER)) { } return false; } private boolean isClearTab(CTTabStop tabStop) { org.openxmlformats.schemas.wordprocessingml.x2006.main.STTabJc.Enum tabVal = tabStop.getVal(); if (tabVal != null) { if (tabVal.equals(STTabJc.CLEAR)) { // Specifies that the current tab stop is cleared and shall be // removed and ignored when processing // the contents of this document return true; } } return false; } @Override protected void addNewLine(CTBr br, IITextContainer pdfParagraphContainer) throws Exception { pdfParagraphContainer.addElement(Chunk.NEWLINE); } @Override protected void visitBR(CTBr br, IITextContainer paragraphContainer) throws Exception { currentRunX = 0f; super.visitBR(br, paragraphContainer); } @Override protected void pageBreak() throws Exception { pdfDocument.pageBreak(); } @Override protected void visitBookmark(CTBookmark bookmark, XWPFParagraph paragraph, IITextContainer paragraphContainer) throws Exception { // destination for a local anchor // chunk with empty text does not work as local anchor // so we create chunk with invisible but not empty text content // if bookmark is the last chunk in a paragraph something must be added // after or it does not work Chunk chunk = new Chunk(TAB); chunk.setLocalDestination(bookmark.getName()); paragraphContainer.addElement(chunk); } // ----------------- Table @Override protected IITextContainer startVisitTable(XWPFTable table, float[] colWidths, IITextContainer pdfParentContainer) throws Exception { StylableTable pdfPTable = createPDFTable(table, colWidths, pdfParentContainer); return pdfPTable; } private StylableTable createPDFTable(XWPFTable table, float[] colWidths, IITextContainer pdfParentContainer) throws DocumentException { // 2) Compute tableWith TableWidth tableWidth = stylesDocument.getTableWidth(table); StylableTable pdfPTable = pdfDocument.createTable(pdfParentContainer, colWidths.length); pdfPTable.setTotalWidth(colWidths); if (tableWidth != null && tableWidth.width > 0) { if (tableWidth.percentUnit) { pdfPTable.setWidthPercentage(tableWidth.width); } else { pdfPTable.setTotalWidth(tableWidth.width); } } pdfPTable.setLockedWidth(true); // Table alignment ParagraphAlignment alignment = stylesDocument.getTableAlignment(table); if (alignment != null) { switch (alignment) { case LEFT: pdfPTable.setHorizontalAlignment(Element.ALIGN_LEFT); break; case RIGHT: pdfPTable.setHorizontalAlignment(Element.ALIGN_RIGHT); break; case CENTER: pdfPTable.setHorizontalAlignment(Element.ALIGN_CENTER); break; case BOTH: pdfPTable.setHorizontalAlignment(Element.ALIGN_JUSTIFIED); break; default: break; } } // Table indentation Float indentation = stylesDocument.getTableIndentation(table); if (indentation != null) { pdfPTable.setPaddingLeft(indentation); } return pdfPTable; } @Override protected void endVisitTable(XWPFTable table, IITextContainer pdfParentContainer, IITextContainer pdfTableContainer) throws Exception { pdfParentContainer.addElement(((ExtendedPdfPTable) pdfTableContainer).getElement()); } // ------------------------- Table Row @Override protected void startVisitTableRow(XWPFTableRow row, IITextContainer tableContainer, int rowIndex, boolean headerRow) throws Exception { if (headerRow) { PdfPTable table = (PdfPTable) tableContainer; table.setHeaderRows(table.getHeaderRows() + 1); } super.startVisitTableRow(row, tableContainer, rowIndex, headerRow); } // ------------------------- Table Cell @Override protected IITextContainer startVisitTableCell(final XWPFTableCell cell, IITextContainer pdfTableContainer, boolean firstRow, boolean lastRow, boolean firstCol, boolean lastCol, List<XWPFTableCell> vMergeCells) throws Exception { XWPFTableRow row = cell.getTableRow(); XWPFTable table = row.getTable(); // 1) store table cell info stylesDocument.getTableInfo(table).addCellInfo(cell, firstRow, lastRow, firstCol, lastCol); // 2) create PDF cell StylableTable pdfPTable = (StylableTable) pdfTableContainer; StylableTableCell pdfPCell = pdfDocument.createTableCell(pdfPTable); // pdfPCell.setUseAscender( true ); // pdfPCell.setUseDescender( true ); XWPFTableCell lastVMergedCell = null; if (vMergeCells != null) { pdfPCell.setRowspan(vMergeCells.size()); lastVMergedCell = vMergeCells.get(vMergeCells.size() - 1); stylesDocument.getTableInfo(table).addCellInfo(lastVMergedCell, false, lastRow, firstCol, lastCol); } // border-top TableCellBorder borderTop = stylesDocument.getTableCellBorderWithConflicts(cell, BorderSide.TOP); if (borderTop != null) { boolean borderTopInside = stylesDocument.isBorderInside(cell, BorderSide.TOP); if (borderTopInside) { // Manage conflict border with the adjacent border bottom } } pdfPCell.setBorderTop(borderTop, false); // border-bottom XWPFTableCell theCell = lastVMergedCell != null ? lastVMergedCell : cell; TableCellBorder borderBottom = stylesDocument.getTableCellBorderWithConflicts(theCell, BorderSide.BOTTOM); pdfPCell.setBorderBottom(borderBottom, stylesDocument.isBorderInside(theCell, BorderSide.BOTTOM)); // border-left TableCellBorder borderLeft = stylesDocument.getTableCellBorderWithConflicts(cell, BorderSide.LEFT); pdfPCell.setBorderLeft(borderLeft, stylesDocument.isBorderInside(cell, BorderSide.LEFT)); // border-right TableCellBorder borderRight = stylesDocument.getTableCellBorderWithConflicts(cell, BorderSide.RIGHT); pdfPCell.setBorderRight(borderRight, stylesDocument.isBorderInside(cell, BorderSide.RIGHT)); // Text direction <w:textDirection CTTextDirection direction = stylesDocument.getTextDirection(cell); if (direction != null) { int dir = direction.getVal().intValue(); switch (dir) { case STTextDirection.INT_BT_LR: pdfPCell.setRotation(90); break; case STTextDirection.INT_TB_RL: pdfPCell.setRotation(270); break; } } // Colspan BigInteger gridSpan = stylesDocument.getTableCellGridSpan(cell); if (gridSpan != null) { pdfPCell.setColspan(gridSpan.intValue()); } // Background Color Color backgroundColor = stylesDocument.getTableCellBackgroundColor(cell); if (backgroundColor != null) { pdfPCell.setBackgroundColor(Converter.toAwtColor(backgroundColor)); } // Vertical aligment Enum jc = stylesDocument.getTableCellVerticalAlignment(cell); if (jc != null) { switch (jc.intValue()) { case STVerticalJc.INT_BOTTOM: pdfPCell.setVerticalAlignment(Element.ALIGN_BOTTOM); break; case STVerticalJc.INT_CENTER: pdfPCell.setVerticalAlignment(Element.ALIGN_MIDDLE); break; case STVerticalJc.INT_TOP: pdfPCell.setVerticalAlignment(Element.ALIGN_TOP); break; } } // Cell margin Float marginTop = stylesDocument.getTableCellMarginTop(cell); if (marginTop == null) { marginTop = stylesDocument.getTableRowMarginTop(row); if (marginTop == null) { marginTop = stylesDocument.getTableMarginTop(table); } } if (marginTop != null) { pdfPCell.setPaddingTop(marginTop); } Float marginBottom = stylesDocument.getTableCellMarginBottom(cell); if (marginBottom == null) { marginBottom = stylesDocument.getTableRowMarginBottom(row); if (marginBottom == null) { marginBottom = stylesDocument.getTableMarginBottom(table); } } if (marginBottom != null && marginBottom > 0) { pdfPCell.setPaddingBottom(marginBottom); } Float marginLeft = stylesDocument.getTableCellMarginLeft(cell); if (marginLeft == null) { marginLeft = stylesDocument.getTableRowMarginLeft(row); if (marginLeft == null) { marginLeft = stylesDocument.getTableMarginLeft(table); } } if (marginLeft != null) { pdfPCell.setPaddingLeft(marginLeft); } Float marginRight = stylesDocument.getTableCellMarginRight(cell); if (marginRight == null) { marginRight = stylesDocument.getTableRowMarginRight(row); if (marginRight == null) { marginRight = stylesDocument.getTableMarginRight(table); } } if (marginRight != null) { pdfPCell.setPaddingRight(marginRight); } // Row height TableHeight tableHeight = stylesDocument.getTableRowHeight(row); if (tableHeight != null) { if (tableHeight.minimum) { pdfPCell.setMinimumHeight(tableHeight.height); } else { pdfPCell.setFixedHeight(tableHeight.height); } } // No wrap Boolean noWrap = stylesDocument.getTableCellNoWrap(cell); if (noWrap != null) { pdfPCell.setNoWrap(noWrap); } return pdfPCell; } @Override protected void endVisitTableCell(XWPFTableCell cell, IITextContainer tableContainer, IITextContainer tableCellContainer) { ExtendedPdfPTable pdfPTable = (ExtendedPdfPTable) tableContainer; ExtendedPdfPCell pdfPCell = (ExtendedPdfPCell) tableCellContainer; pdfPTable.addCell(pdfPCell); } @Override protected void visitPicture(CTPicture picture, Float offsetX, org.openxmlformats.schemas.drawingml.x2006.wordprocessingDrawing.STRelFromH.Enum relativeFromH, Float offsetY, org.openxmlformats.schemas.drawingml.x2006.wordprocessingDrawing.STRelFromV.Enum relativeFromV, STWrapText.Enum wrapText, IITextContainer pdfParentContainer) throws Exception { CTPositiveSize2D ext = picture.getSpPr().getXfrm().getExt(); long x = ext.getCx(); long y = ext.getCy(); XWPFPictureData pictureData = super.getPictureData(picture); if (pictureData != null) { try { Image img = Image.getInstance(pictureData.getData()); img.scaleAbsolute(emu2points(x), emu2points(y)); IITextContainer parentOfParentContainer = pdfParentContainer.getITextContainer(); if (parentOfParentContainer != null && parentOfParentContainer instanceof PdfPCell) { parentOfParentContainer.addElement(img); } else { float chunkOffsetX = 0; if (offsetX != null) { if (STRelFromH.CHARACTER.equals(relativeFromH)) { chunkOffsetX = offsetX; } else if (STRelFromH.COLUMN.equals(relativeFromH)) { chunkOffsetX = offsetX; } else if (STRelFromH.INSIDE_MARGIN.equals(relativeFromH)) { chunkOffsetX = offsetX; } else if (STRelFromH.LEFT_MARGIN.equals(relativeFromH)) { chunkOffsetX = offsetX; } else if (STRelFromH.MARGIN.equals(relativeFromH)) { chunkOffsetX = pdfDocument.left() + offsetX; } else if (STRelFromH.OUTSIDE_MARGIN.equals(relativeFromH)) { chunkOffsetX = offsetX; } else if (STRelFromH.PAGE.equals(relativeFromH)) { chunkOffsetX = offsetX - pdfDocument.left(); } } float chunkOffsetY = 0; boolean useExtendedImage = false; if (STRelFromV.PARAGRAPH.equals(relativeFromV)) { useExtendedImage = true; } if (useExtendedImage) { ExtendedImage extImg = new ExtendedImage(img, -offsetY); if (STRelFromV.PARAGRAPH.equals(relativeFromV)) { chunkOffsetY = -extImg.getScaledHeight(); } Chunk chunk = new Chunk(extImg, chunkOffsetX, chunkOffsetY, false); pdfParentContainer.addElement(chunk); } /* * float chunkOffsetY = 0; if ( wrapText != null ) { * chunkOffsetY = -img.getScaledHeight(); } boolean * useExtendedImage = offsetY != null; // if ( * STRelFromV.PARAGRAPH.equals( relativeFromV ) ) // { // * useExtendedImage = true; // } // if ( useExtendedImage ) * { float imgY = -offsetY; if ( pdfHeader != null ) { float * headerY = pdfHeader.getY() != null ? pdfHeader.getY() : * 0; imgY += - img.getScaledHeight() + headerY; } * ExtendedImage extImg = new ExtendedImage( img, imgY ); // * if ( STRelFromV.PARAGRAPH.equals( relativeFromV ) ) // { * // chunkOffsetY = -extImg.getScaledHeight(); // } Chunk * chunk = new Chunk( extImg, chunkOffsetX, chunkOffsetY, * false ); pdfParentContainer.addElement( chunk ); } */ else { if (pdfParentContainer instanceof Paragraph) { // I don't know why but we need add some spacing // before in the paragraph // otherwise the image cut the text of the below // paragraph (see FormattingTests JUnit)? Paragraph paragraph = (Paragraph) pdfParentContainer; paragraph.setSpacingBefore(paragraph.getSpacingBefore() + 5f); } pdfParentContainer.addElement(new Chunk(img, chunkOffsetX, chunkOffsetY, false)); } } } catch (Exception e) { LOGGER.severe(e.getMessage()); } } } public int getPageCount() { if (pdfDocument.isOpen()) { return pdfDocument.getPageNumber(); } else { return pdfDocument.getPageNumber() - 1; } } public boolean useTotalPageField() { return totalPageFieldUsed; } }