/**
* 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.core.styles;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.xwpf.usermodel.ParagraphAlignment;
import org.apache.poi.xwpf.usermodel.UnderlinePatterns;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRelation;
import org.apache.poi.xwpf.usermodel.XWPFRun;
import org.apache.poi.xwpf.usermodel.XWPFSettings;
import org.apache.poi.xwpf.usermodel.XWPFTable;
import org.apache.poi.xwpf.usermodel.XWPFTableCell;
import org.apache.poi.xwpf.usermodel.XWPFTableRow;
import org.apache.xmlbeans.XmlException;
import org.openxmlformats.schemas.drawingml.x2006.main.ThemeDocument;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDocDefaults;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFont;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTP;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRow;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSettings;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTStyle;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTStyles;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTbl;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblPrBase;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblPrEx;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTblStylePr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTc;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTcPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTrPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTwipsMeasure;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.FontsDocument;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STMerge;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STVerticalJc.Enum;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.SettingsDocument;
import fr.opensagres.poi.xwpf.converter.core.BorderSide;
import fr.opensagres.poi.xwpf.converter.core.Color;
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.openxmlformats.IOpenXMLFormatsPartProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphAlignmentValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphBackgroundColorValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphBorderBottomValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphBorderLeftValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphBorderRightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphBorderTopValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphIndentationFirstLineValueProvider;
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.styles.paragraph.ParagraphIndentationRightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphLineSpacingValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphNumPrValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphSpacingAfterValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphSpacingBeforeValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.paragraph.ParagraphTabsValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunBackgroundColorValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontColorValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontFamilyAsciiValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontFamilyEastAsiaValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontFamilyHAnsiValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontSizeValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontStyleBoldValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontStyleItalicValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunFontStyleStrikeValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunTextHighlightingValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.run.RunUnderlineValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableAlignmentValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableBorderBottomValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableBorderInsideHValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableBorderInsideVValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableBorderLeftValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableBorderRightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableBorderTopValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableIndentationValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableMarginBottomValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableMarginLeftValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableMarginRightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableMarginTopValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.TableWidthValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellBackgroundColorValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellBorderBottomValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellBorderInsideHValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellBorderInsideVValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellBorderLeftValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellBorderRightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellBorderTopValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellGridSpanValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellMarginBottomValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellMarginLeftValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellMarginRightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellMarginTopValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellNoWrapValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellTextDirectionValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellVMergeValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellVerticalAlignmentValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.cell.TableCellWidthValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.row.TableRowHeaderValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.row.TableRowHeightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.row.TableRowMarginBottomValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.row.TableRowMarginLeftValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.row.TableRowMarginRightValueProvider;
import fr.opensagres.poi.xwpf.converter.core.styles.table.row.TableRowMarginTopValueProvider;
import fr.opensagres.poi.xwpf.converter.core.utils.DxaUtil;
import fr.opensagres.poi.xwpf.converter.core.utils.StringUtils;
public class XWPFStylesDocument
{
public static final Object EMPTY_VALUE = new Object();
private static final float DEFAULT_TAB_STOP_POINT = DxaUtil.dxa2points( 720f );
private final Map<String, CTStyle> stylesByStyleId;
private CTStyle defaultParagraphStyle;
private CTStyle defaultTableStyle;
private final Map<String, Object> values;
private CTStyle defaultCharacterStyle;
private CTStyle defaultNumberingStyle;
private Map<XWPFTable, TableInfo> tableInfos;
private Float defaultTabStop;
private CTSettings ctSettings;
private List<ThemeDocument> themeDocuments;
private final Map<String, List<String>> fontsAltName;
private final Map<String, String> fontsToUse;
private CTStyles styles;
public XWPFStylesDocument( XWPFDocument document )
throws XmlException, IOException
{
this( document, true );
}
public XWPFStylesDocument( XWPFDocument document, boolean lazyInitialization )
throws XmlException, IOException
{
this( document.getStyle(), getFontsDocument( document ), getThemeDocuments( document ),
getCTSettings( document ), lazyInitialization );
}
public XWPFStylesDocument( IOpenXMLFormatsPartProvider provider )
throws Exception
{
this( provider, true );
}
public XWPFStylesDocument( IOpenXMLFormatsPartProvider provider, boolean lazyInitialization )
throws Exception
{
this( provider.getStyle(), provider.getFontsDocument(), provider.getThemeDocuments(), provider.getSettings(),
lazyInitialization );
}
public XWPFStylesDocument( CTStyles styles, List<FontsDocument> fontsDocuments, List<ThemeDocument> themeDocuments,
CTSettings ctSettings, boolean lazyInitialization )
throws XmlException, IOException
{
this.styles = styles;
this.stylesByStyleId = new HashMap<String, CTStyle>();
this.values = new HashMap<String, Object>();
this.fontsAltName = updateFonts( fontsDocuments );
this.fontsToUse = new HashMap<String, String>();
this.themeDocuments = themeDocuments;
this.ctSettings = ctSettings;
if ( lazyInitialization )
{
initialize();
}
}
private Map<String, List<String>> updateFonts( List<FontsDocument> fontsDocuments )
{
Map<String, List<String>> fontsAltName = new HashMap<String, List<String>>();
// Compute fonts alt name
// see spec 17.8.3.1 altName (Alternate Names for Font)
for ( FontsDocument fontsDocument : fontsDocuments )
{
CTString altName = null;
List<CTFont> fonts = fontsDocument.getFonts().getFontList();
for ( CTFont font : fonts )
{
altName = font.getAltName();
if ( altName != null && StringUtils.isNotEmpty( altName.getVal() ) )
{
List<String> altNames = new ArrayList<String>();
// This element specifies a set of alternative names which can be used to locate the font
// specified by the parent
// element. This set of alternative names is stored in a comma-delimited list, with all
// adjacent commas ignored (i.e.
// a value of Name A, Name B is equivalent to Name A,,,,,,,,, Name B).
String[] names = altName.getVal().split( "," );
String name = null;
for ( int i = 0; i < names.length; i++ )
{
name = names[i];
if ( StringUtils.isNotEmpty( name ) )
{
altNames.add( name );
}
}
fontsAltName.put( font.getName(), altNames );
}
}
}
return fontsAltName;
}
protected void initialize()
throws XmlException, IOException
{
List<CTStyle> s = styles.getStyleList();
for ( CTStyle style : s )
{
org.openxmlformats.schemas.wordprocessingml.x2006.main.STOnOff.Enum isDefault = style.getDefault();
org.openxmlformats.schemas.wordprocessingml.x2006.main.STStyleType.Enum type = style.getType();
boolean isDefaultStyle =
( isDefault != null && isDefault.intValue() == org.openxmlformats.schemas.wordprocessingml.x2006.main.STOnOff.INT_X_1 );
if ( isDefaultStyle )
{
// default
if ( type != null )
{
switch ( type.intValue() )
{
case org.openxmlformats.schemas.wordprocessingml.x2006.main.STStyleType.INT_CHARACTER:
defaultCharacterStyle = style;
break;
case org.openxmlformats.schemas.wordprocessingml.x2006.main.STStyleType.INT_NUMBERING:
defaultNumberingStyle = style;
break;
case org.openxmlformats.schemas.wordprocessingml.x2006.main.STStyleType.INT_PARAGRAPH:
defaultParagraphStyle = style;
break;
case org.openxmlformats.schemas.wordprocessingml.x2006.main.STStyleType.INT_TABLE:
defaultTableStyle = style;
break;
}
}
}
visitStyle( style, isDefaultStyle );
stylesByStyleId.put( style.getStyleId(), style );
}
}
protected void visitStyle( CTStyle style, boolean defaultStyle )
{
}
public CTStyle getDefaultParagraphStyle()
{
return defaultParagraphStyle;
}
public CTStyle getStyle( String styleId )
{
return stylesByStyleId.get( styleId );
}
public CTDocDefaults getDocDefaults()
{
try
{
return styles.getDocDefaults();
}
catch ( Exception e )
{
return null;
}
}
// -------------------- Paragraph
/**
* @param docxParagraph
* @return
*/
public Float getSpacingBefore( XWPFParagraph docxParagraph )
{
return ParagraphSpacingBeforeValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public Float getSpacingBefore( CTPPr pPr )
{
return ParagraphSpacingBeforeValueProvider.INSTANCE.getValue( pPr );
}
public Float getSpacingBefore( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphSpacingBeforeValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public Float getSpacingAfter( XWPFParagraph docxParagraph )
{
return ParagraphSpacingAfterValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public Float getSpacingAfter( CTPPr pPr )
{
return ParagraphSpacingAfterValueProvider.INSTANCE.getValue( pPr );
}
public Float getSpacingAfter( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphSpacingAfterValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public Float getIndentationLeft( XWPFParagraph paragraph )
{
return ParagraphIndentationLeftValueProvider.INSTANCE.getValue( paragraph, this );
}
public Float getIndentationLeft( CTPPr pPr )
{
return ParagraphIndentationLeftValueProvider.INSTANCE.getValue( pPr );
}
public Float getIndentationLeft( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphIndentationLeftValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public Float getIndentationRight( XWPFParagraph paragraph )
{
return ParagraphIndentationRightValueProvider.INSTANCE.getValue( paragraph, this );
}
public Float getIndentationRight( CTPPr pPr )
{
return ParagraphIndentationRightValueProvider.INSTANCE.getValue( pPr );
}
public Float getIndentationRight( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphIndentationRightValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public Float getIndentationFirstLine( XWPFParagraph paragraph )
{
return ParagraphIndentationFirstLineValueProvider.INSTANCE.getValue( paragraph, this );
}
public Float getIndentationFirstLine( CTPPr pPr )
{
return ParagraphIndentationFirstLineValueProvider.INSTANCE.getValue( pPr );
}
public Float getIndentationFirstLine( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphIndentationFirstLineValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public Float getIndentationHanging( XWPFParagraph paragraph )
{
return ParagraphIndentationHangingValueProvider.INSTANCE.getValue( paragraph, this );
}
public Float getIndentationHanging( CTPPr pPr )
{
return ParagraphIndentationHangingValueProvider.INSTANCE.getValue( pPr );
}
public Float getIndentationHanging( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphIndentationHangingValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public Color getBackgroundColor( XWPFParagraph paragraph )
{
return ParagraphBackgroundColorValueProvider.INSTANCE.getValue( paragraph, this );
}
public Color getBackgroundColor( CTPPr pPr )
{
return ParagraphBackgroundColorValueProvider.INSTANCE.getValue( pPr );
}
/**
* @param paragraph
* @return
*/
public ParagraphAlignment getParagraphAlignment( XWPFParagraph paragraph )
{
return ParagraphAlignmentValueProvider.INSTANCE.getValue( paragraph, this );
}
public ParagraphAlignment getParagraphAlignment( CTPPr pPr )
{
return ParagraphAlignmentValueProvider.INSTANCE.getValue( pPr );
}
public ParagraphAlignment getParagraphAlignment( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphAlignmentValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public CTBorder getBorderTop( XWPFParagraph docxParagraph )
{
return ParagraphBorderTopValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public CTBorder getBorderTop( CTPPr pPr )
{
return ParagraphBorderTopValueProvider.INSTANCE.getValue( pPr );
}
public CTBorder getBorderBottom( XWPFParagraph docxParagraph )
{
return ParagraphBorderBottomValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public CTBorder getBorderBottom( CTPPr pPr )
{
return ParagraphBorderBottomValueProvider.INSTANCE.getValue( pPr );
}
public CTBorder getBorderLeft( XWPFParagraph docxParagraph )
{
return ParagraphBorderLeftValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public CTBorder getBorderLeft( CTPPr pPr )
{
return ParagraphBorderLeftValueProvider.INSTANCE.getValue( pPr );
}
public CTBorder getBorderRight( XWPFParagraph docxParagraph )
{
return ParagraphBorderRightValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public CTBorder getBorderRight( CTPPr pPr )
{
return ParagraphBorderRightValueProvider.INSTANCE.getValue( pPr );
}
public CTTabs getParagraphTabs( XWPFParagraph docxParagraph )
{
return ParagraphTabsValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public CTTabs getParagraphTabs( CTPPr pPr )
{
return ParagraphTabsValueProvider.INSTANCE.getValue( pPr );
}
public ParagraphLineSpacing getParagraphSpacing( XWPFParagraph docxParagraph )
{
return ParagraphLineSpacingValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public ParagraphLineSpacing getParagraphSpacing( CTPPr pPr )
{
return ParagraphLineSpacingValueProvider.INSTANCE.getValue( pPr );
}
public ParagraphLineSpacing getParagraphSpacing( CTP paragraph, CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.paragraph.ParagraphLineSpacingValueProvider.INSTANCE.getValue( paragraph,
table,
this );
}
public CTNumPr getParagraphNumPr( XWPFParagraph docxParagraph )
{
return ParagraphNumPrValueProvider.INSTANCE.getValue( docxParagraph, this );
}
public CTNumPr getParagraphNumPr( CTPPr pPr )
{
return ParagraphNumPrValueProvider.INSTANCE.getValue( pPr );
}
// -------------------- Run
/**
* @param run
* @return
*/
public String getFontFamilyAscii( XWPFRun run )
{
return RunFontFamilyAsciiValueProvider.INSTANCE.getValue( run, this );
}
public String getFontFamilyAscii( CTRPr rPr )
{
return RunFontFamilyAsciiValueProvider.INSTANCE.getValue( rPr, this );
}
public String getFontFamilyAscii( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontFamilyAsciiValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public String getFontFamilyEastAsia( XWPFRun run )
{
return RunFontFamilyEastAsiaValueProvider.INSTANCE.getValue( run, this );
}
public String getFontFamilyEastAsia( CTRPr rPr )
{
return RunFontFamilyEastAsiaValueProvider.INSTANCE.getValue( rPr, this );
}
public String getFontFamilyEastAsia( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontFamilyEastAsiaValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public String getFontFamilyHAnsi( XWPFRun run )
{
return RunFontFamilyHAnsiValueProvider.INSTANCE.getValue( run, this );
}
public String getFontFamilyHAnsi( CTRPr rPr )
{
return RunFontFamilyHAnsiValueProvider.INSTANCE.getValue( rPr, this );
}
public String getFontFamilyHAnsi( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontFamilyHAnsiValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public Float getFontSize( XWPFRun run )
{
return RunFontSizeValueProvider.INSTANCE.getValue( run, this );
}
public Float getFontSize( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontSizeValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public Float getFontSize( CTRPr rPr )
{
return RunFontSizeValueProvider.INSTANCE.getValue( rPr, this );
}
public Boolean getFontStyleBold( XWPFRun run )
{
return RunFontStyleBoldValueProvider.INSTANCE.getValue( run, this );
}
public Boolean getFontStyleBold( CTRPr rPr )
{
return RunFontStyleBoldValueProvider.INSTANCE.getValue( rPr, this );
}
public Boolean getFontStyleBold( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontStyleBoldValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public Boolean getFontStyleItalic( XWPFRun run )
{
return RunFontStyleItalicValueProvider.INSTANCE.getValue( run, this );
}
public Boolean getFontStyleItalic( CTRPr rPr )
{
return RunFontStyleItalicValueProvider.INSTANCE.getValue( rPr, this );
}
public Boolean getFontStyleItalic( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontStyleItalicValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public Boolean getFontStyleStrike( XWPFRun run )
{
return RunFontStyleStrikeValueProvider.INSTANCE.getValue( run, this );
}
public Boolean getFontStyleStrike( CTRPr rPr )
{
return RunFontStyleStrikeValueProvider.INSTANCE.getValue( rPr, this );
}
public Boolean getFontStyleStrike( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontStyleStrikeValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public Color getFontColor( XWPFRun run )
{
return RunFontColorValueProvider.INSTANCE.getValue( run, this );
}
public Color getFontColor( CTRPr rPr )
{
return RunFontColorValueProvider.INSTANCE.getValue( rPr, this );
}
public Color getFontColor( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunFontColorValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public UnderlinePatterns getUnderline( CTRPr rPr )
{
return RunUnderlineValueProvider.INSTANCE.getValue( rPr, this );
}
public UnderlinePatterns getUnderline( XWPFRun run )
{
return RunUnderlineValueProvider.INSTANCE.getValue( run, this );
}
public UnderlinePatterns getUnderline( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunUnderlineValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public Color getBackgroundColor( XWPFRun run )
{
return RunBackgroundColorValueProvider.INSTANCE.getValue( run, this );
}
public Color getBackgroundColor( CTRPr rPr )
{
return RunBackgroundColorValueProvider.INSTANCE.getValue( rPr, this );
}
public Color getBackgroundColor( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunBackgroundColorValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
public Color getTextHighlighting( XWPFRun run )
{
return RunTextHighlightingValueProvider.INSTANCE.getValue( run, this );
}
public Color getTextHighlighting( CTRPr rPr )
{
return RunTextHighlightingValueProvider.INSTANCE.getValue( rPr, this );
}
public Color getTextHighlighting( CTR run, CTP paragraph )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.run.RunTextHighlightingValueProvider.INSTANCE.getValue( run,
paragraph,
this );
}
// ------------------------ Table
/**
* @param table
* @return
*/
public TableWidth getTableWidth( XWPFTable table )
{
return TableWidthValueProvider.INSTANCE.getValue( table, this );
}
public TableWidth getTableWidth( CTTblPr tblPr )
{
return TableWidthValueProvider.INSTANCE.getValue( tblPr );
}
public TableWidth getTableWidth( CTTblPrBase tblPr )
{
return TableWidthValueProvider.INSTANCE.getValue( tblPr );
}
public TableWidth getTableWidth( CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.table.TableWidthValueProvider.INSTANCE.getValue( table,
this );
}
public ParagraphAlignment getTableAlignment( XWPFTable table )
{
return TableAlignmentValueProvider.INSTANCE.getValue( table, this );
}
public ParagraphAlignment getTableAlignment( CTTblPr tblPr )
{
return TableAlignmentValueProvider.INSTANCE.getValue( tblPr );
}
public ParagraphAlignment getTableAlignment( CTTblPrBase tblPr )
{
return TableAlignmentValueProvider.INSTANCE.getValue( tblPr );
}
public ParagraphAlignment getTableAlignment( CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.table.TableAlignmentValueProvider.INSTANCE.getValue( table,
this );
}
public Float getTableIndentation( XWPFTable table )
{
return TableIndentationValueProvider.INSTANCE.getValue( table, this );
}
public Float getTableIndentation( CTTblPr tblPr )
{
return TableIndentationValueProvider.INSTANCE.getValue( tblPr );
}
public Float getTableIndentation( CTTblPrBase tblPr )
{
return TableIndentationValueProvider.INSTANCE.getValue( tblPr );
}
public Float getTableIndentation( CTTbl table )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.table.TableIndentationValueProvider.INSTANCE.getValue( table,
this );
}
public TableCellBorder getTableBorderTop( XWPFTable table )
{
return TableBorderTopValueProvider.INSTANCE.getValue( table, this );
}
public TableCellBorder getTableBorderTop( CTTblPr tblPr )
{
return TableBorderTopValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderTop( CTTblPrBase tblPr )
{
return TableBorderTopValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderBottom( XWPFTable table )
{
return TableBorderBottomValueProvider.INSTANCE.getValue( table, this );
}
public TableCellBorder getTableBorderBottom( CTTblPr tblPr )
{
return TableBorderBottomValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderBottom( CTTblPrBase tblPr )
{
return TableBorderBottomValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderLeft( XWPFTable table )
{
return TableBorderLeftValueProvider.INSTANCE.getValue( table, this );
}
public TableCellBorder getTableBorderLeft( CTTblPr tblPr )
{
return TableBorderLeftValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderLeft( CTTblPrBase tblPr )
{
return TableBorderLeftValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderRight( XWPFTable table )
{
return TableBorderRightValueProvider.INSTANCE.getValue( table, this );
}
public TableCellBorder getTableBorderRight( CTTblPr tblPr )
{
return TableBorderRightValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderRight( CTTblPrBase tblPr )
{
return TableBorderRightValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderInsideH( XWPFTable table )
{
return TableBorderInsideHValueProvider.INSTANCE.getValue( table, this );
}
public TableCellBorder getTableBorderInsideH( CTTblPr tblPr )
{
return TableBorderInsideHValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderInsideH( CTTblPrBase tblPr )
{
return TableBorderInsideHValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderInsideV( XWPFTable table )
{
return TableBorderInsideVValueProvider.INSTANCE.getValue( table, this );
}
public TableCellBorder getTableBorderInsideV( CTTblPr tblPr )
{
return TableBorderInsideVValueProvider.INSTANCE.getValue( tblPr );
}
public TableCellBorder getTableBorderInsideV( CTTblPrBase tblPr )
{
return TableBorderInsideVValueProvider.INSTANCE.getValue( tblPr );
}
public Float getTableMarginTop( XWPFTable table )
{
return TableMarginTopValueProvider.INSTANCE.getValue( table, this );
}
public Float getTableMarginTop( CTTblPrBase tcPr )
{
return TableMarginTopValueProvider.INSTANCE.getValue( tcPr );
}
public Float getTableMarginBottom( XWPFTable table )
{
return TableMarginBottomValueProvider.INSTANCE.getValue( table, this );
}
public Float getTableMarginBottom( CTTblPrBase tcPr )
{
return TableMarginBottomValueProvider.INSTANCE.getValue( tcPr );
}
public Float getTableMarginLeft( XWPFTable table )
{
return TableMarginLeftValueProvider.INSTANCE.getValue( table, this );
}
public Float getTableMarginLeft( CTTblPrBase tcPr )
{
return TableMarginLeftValueProvider.INSTANCE.getValue( tcPr );
}
public Float getTableMarginRight( XWPFTable table )
{
return TableMarginRightValueProvider.INSTANCE.getValue( table, this );
}
public Float getTableMarginRight( CTTblPrBase tcPr )
{
return TableMarginRightValueProvider.INSTANCE.getValue( tcPr );
}
// ------------------------ Table row
/**
* @param row
* @return
*/
public TableHeight getTableRowHeight( XWPFTableRow row )
{
return TableRowHeightValueProvider.INSTANCE.getValue( row, this );
}
/**
* @param cell
* @return
*/
public TableHeight getTableRowHeight( CTTrPr trPr )
{
return TableRowHeightValueProvider.INSTANCE.getValue( trPr );
}
public Float getTableRowMarginTop( XWPFTableRow row )
{
return TableRowMarginTopValueProvider.INSTANCE.getValue( row, this );
}
public Float getTableRowMarginTop( CTTblPrEx tblPrEx )
{
return TableRowMarginTopValueProvider.INSTANCE.getValue( tblPrEx );
}
public Float getTableRowMarginBottom( XWPFTableRow row )
{
return TableRowMarginBottomValueProvider.INSTANCE.getValue( row, this );
}
public Float getTableRowMarginBottom( CTTblPrEx tblPrEx )
{
return TableRowMarginBottomValueProvider.INSTANCE.getValue( tblPrEx );
}
public Float getTableRowMarginLeft( XWPFTableRow row )
{
return TableRowMarginLeftValueProvider.INSTANCE.getValue( row, this );
}
public Float getTableRowMarginLeft( CTTblPrEx tblPrEx )
{
return TableRowMarginLeftValueProvider.INSTANCE.getValue( tblPrEx );
}
public Float getTableRowMarginRight( XWPFTableRow row )
{
return TableRowMarginRightValueProvider.INSTANCE.getValue( row, this );
}
public Float getTableRowMarginRight( CTTblPrEx tblPrEx )
{
return TableRowMarginRightValueProvider.INSTANCE.getValue( tblPrEx );
}
public boolean isTableRowHeader( XWPFTableRow row )
{
return TableRowHeaderValueProvider.INSTANCE.getValue( row, this );
}
public boolean isTableRowHeader( CTRow row )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.table.row.TableRowHeaderValueProvider.INSTANCE.getValue( row,
this );
}
// ------------------------ Table cell
/**
* @param cell
* @return
*/
public Enum getTableCellVerticalAlignment( XWPFTableCell cell )
{
return TableCellVerticalAlignmentValueProvider.INSTANCE.getValue( cell, this );
}
public Color getTableCellBackgroundColor( XWPFTableCell cell )
{
return TableCellBackgroundColorValueProvider.INSTANCE.getValue( cell, this );
}
public Color getTableCellBackgroundColor( CTTcPr tcPr )
{
return TableCellBackgroundColorValueProvider.INSTANCE.getValue( tcPr );
}
public Color getTableCellBackgroundColor( CTTc cell )
{
return fr.opensagres.poi.xwpf.converter.core.openxmlformats.styles.table.cell.TableCellBackgroundColorValueProvider.INSTANCE.getValue( cell,
this );
}
public BigInteger getTableCellGridSpan( XWPFTableCell cell )
{
return TableCellGridSpanValueProvider.INSTANCE.getValue( cell, this );
}
public BigInteger getTableCellGridSpan( CTTcPr tcPr )
{
return TableCellGridSpanValueProvider.INSTANCE.getValue( tcPr );
}
public TableWidth getTableCellWith( XWPFTableCell cell )
{
return TableCellWidthValueProvider.INSTANCE.getValue( cell, this );
}
public TableWidth getTableCellWith( CTTcPr tcPr )
{
return TableCellWidthValueProvider.INSTANCE.getValue( tcPr );
}
public CTTextDirection getTextDirection( XWPFTableCell cell )
{
return TableCellTextDirectionValueProvider.INSTANCE.getValue( cell, this );
}
public CTTextDirection getTextDirection( CTTcPr tcPr )
{
return TableCellTextDirectionValueProvider.INSTANCE.getValue( tcPr );
}
public STMerge.Enum getTableCellVMerge( XWPFTableCell cell )
{
return TableCellVMergeValueProvider.INSTANCE.getValue( cell, this );
}
public STMerge.Enum getTableCellVMerge( CTTcPr tcPr )
{
return TableCellVMergeValueProvider.INSTANCE.getValue( tcPr );
}
/**
* Returns the table cell borders with conflicts.
*
* @param cell
* @param borderSide
* @return
* @see http://officeopenxml.com/WPtableCellBorderConflicts.php
*/
public TableCellBorder getTableCellBorderWithConflicts( XWPFTableCell cell, BorderSide borderSide )
{
/**
* Conflicts between cell borders and table and table-level exception borders If the cell spacing is zero, then
* there is a conflict. The following rules apply as between cell borders and table and table-level exception
* (row) borders (Reference: ECMA-376, 3rd Edition (June, 2011), Fundamentals and Markup Language Reference
* 17.4.40.):
*/
/**
* 1) If there is a cell border, then the cell border is displayed.
*/
/**
* 2) If there is no cell border but there is a table-level exception border on the row, then that table-level
* exception border is displayed.
*/
TableCellBorder border = getTableCellBorder( cell, borderSide );
if ( border == null )
{
XWPFTable table = cell.getTableRow().getTable();
boolean borderInside = isBorderInside( cell, borderSide );
if ( borderInside )
{
border = getTableCellBorderInside( cell, borderSide );
if ( border == null )
{
border = getTableBorderInside( table, borderSide );
}
}
if ( border == null && !borderInside )
{
/**
* 3) If there is no cell or table-level exception border, then the table border is displayed.
*/
border = getTableBorder( table, borderSide );
}
}
return border;
}
public boolean isBorderInside( XWPFTableCell cell, BorderSide borderSide )
{
TableCellInfo cellInfo = getTableCellInfo( cell );
boolean borderInside = cellInfo.isInside( borderSide );
return borderInside;
}
public TableCellBorder getTableBorder( XWPFTable table, BorderSide borderSide )
{
switch ( borderSide )
{
case TOP:
return getTableBorderTop( table );
case BOTTOM:
return getTableBorderBottom( table );
case LEFT:
return getTableBorderLeft( table );
case RIGHT:
return getTableBorderRight( table );
}
return null;
}
public TableCellBorder getTableBorderInside( XWPFTable table, BorderSide borderSide )
{
switch ( borderSide )
{
case TOP:
case BOTTOM:
return getTableBorderInsideH( table );
default:
return getTableBorderInsideV( table );
}
}
public TableCellBorder getTableCellBorderInside( XWPFTableCell cell, BorderSide borderSide )
{
switch ( borderSide )
{
case TOP:
case BOTTOM:
return getTableCellBorderInsideH( cell );
default:
return getTableCellBorderInsideV( cell );
}
}
public TableCellBorder getTableCellBorder( XWPFTableCell cell, BorderSide borderSide )
{
switch ( borderSide )
{
case TOP:
return getTableCellBorderTop( cell );
case BOTTOM:
return getTableCellBorderBottom( cell );
case LEFT:
return getTableCellBorderLeft( cell );
case RIGHT:
return getTableCellBorderRight( cell );
}
return null;
}
public TableCellBorder getTableCellBorderTop( XWPFTableCell cell )
{
return TableCellBorderTopValueProvider.INSTANCE.getValue( cell, this );
}
public TableCellBorder getTableCellBorderTop( CTTcPr tcPr )
{
return TableCellBorderTopValueProvider.INSTANCE.getValue( tcPr );
}
public TableCellBorder getTableCellBorderBottom( XWPFTableCell cell )
{
return TableCellBorderBottomValueProvider.INSTANCE.getValue( cell, this );
}
public TableCellBorder getTableCellBorderBottom( CTTcPr tcPr )
{
return TableCellBorderBottomValueProvider.INSTANCE.getValue( tcPr );
}
public TableCellBorder getTableCellBorderLeft( XWPFTableCell cell )
{
return TableCellBorderLeftValueProvider.INSTANCE.getValue( cell, this );
}
public TableCellBorder getTableCellBorderLeft( CTTcPr tcPr )
{
return TableCellBorderLeftValueProvider.INSTANCE.getValue( tcPr );
}
public TableCellBorder getTableCellBorderRight( XWPFTableCell cell )
{
return TableCellBorderRightValueProvider.INSTANCE.getValue( cell, this );
}
public TableCellBorder getTableCellBorderRight( CTTcPr tcPr )
{
return TableCellBorderRightValueProvider.INSTANCE.getValue( tcPr );
}
public TableCellBorder getTableCellBorderInsideH( XWPFTableCell cell )
{
return TableCellBorderInsideHValueProvider.INSTANCE.getValue( cell, this );
}
public TableCellBorder getTableCellBorderInsideH( CTTcPr tcPr )
{
return TableCellBorderInsideHValueProvider.INSTANCE.getValue( tcPr );
}
public TableCellBorder getTableCellBorderInsideV( XWPFTableCell cell )
{
return TableCellBorderInsideVValueProvider.INSTANCE.getValue( cell, this );
}
public TableCellBorder getTableCellBorderInsideV( CTTcPr tcPr )
{
return TableCellBorderInsideVValueProvider.INSTANCE.getValue( tcPr );
}
public Float getTableCellMarginTop( XWPFTableCell cell )
{
return TableCellMarginTopValueProvider.INSTANCE.getValue( cell, this );
}
public Float getTableCellMarginTop( CTTcPr tcPr )
{
return TableCellMarginTopValueProvider.INSTANCE.getValue( tcPr );
}
public Float getTableCellMarginBottom( XWPFTableCell cell )
{
return TableCellMarginBottomValueProvider.INSTANCE.getValue( cell, this );
}
public Float getTableCellMarginBottom( CTTcPr tcPr )
{
return TableCellMarginBottomValueProvider.INSTANCE.getValue( tcPr );
}
public Float getTableCellMarginLeft( XWPFTableCell cell )
{
return TableCellMarginLeftValueProvider.INSTANCE.getValue( cell, this );
}
public Float getTableCellMarginLeft( CTTcPr tcPr )
{
return TableCellMarginLeftValueProvider.INSTANCE.getValue( tcPr );
}
public Float getTableCellMarginRight( XWPFTableCell cell )
{
return TableCellMarginRightValueProvider.INSTANCE.getValue( cell, this );
}
public Float getTableCellMarginRight( CTTcPr tcPr )
{
return TableCellMarginRightValueProvider.INSTANCE.getValue( tcPr );
}
public Boolean getTableCellNoWrap( XWPFTableCell cell )
{
return TableCellNoWrapValueProvider.INSTANCE.getValue( cell, this );
}
public Boolean getTableCellNoWrap( CTTcPr tcPr )
{
return TableCellNoWrapValueProvider.INSTANCE.getValue( tcPr );
}
public CTStyle getDefaultCharacterStyle()
{
return defaultCharacterStyle;
}
public CTStyle getDefaultNumberingStyle()
{
return defaultNumberingStyle;
}
public CTStyle getDefaultTableStyle()
{
return defaultTableStyle;
}
public CTStyle getStyle( CTString basedOn )
{
if ( basedOn == null )
{
return null;
}
return getStyle( basedOn.getVal() );
}
public <T> T getValue( String key )
{
return (T) values.get( key );
}
public <T> void setValue( String key, T value )
{
values.put( key, value );
}
public TableCellInfo getTableCellInfo( XWPFTableCell cell )
{
XWPFTable table = cell.getTableRow().getTable();
return getTableInfo( table ).getCellInfo( cell );
}
public TableInfo getTableInfo( XWPFTable table )
{
if ( tableInfos == null )
{
tableInfos = new HashMap<XWPFTable, TableInfo>();
}
TableInfo tableInfo = tableInfos.get( table );
if ( tableInfo == null )
{
tableInfo = new TableInfo( table, this );
tableInfos.put( table, tableInfo );
}
return tableInfo;
}
public CTTblStylePr getTableStyle( String tableStyleID,
org.openxmlformats.schemas.wordprocessingml.x2006.main.STTblStyleOverrideType.Enum type )
{
CTStyle style = getStyle( tableStyleID );
if ( style == null )
{
return null;
}
// TODO cache it
List<CTTblStylePr> tblStylePrs = style.getTblStylePrList();
for ( CTTblStylePr tblStylePr : tblStylePrs )
{
if ( type.equals( tblStylePr.getType() ) )
{
return tblStylePr;
}
}
return null;
}
/**
* 17.15.1.25 defaultTabStop (Distance Between Automatic Tab Stops) This element specifies the value which shall be
* used as the multiplier to generate automatic tab stops in this document. Automatic tab stops refer to the tab
* stop locations which occur after all custom tab stops in the current paragraph have been surpassed. If this
* element is omitted, then automatic tab stops should be generated at 720 twentieths of a point (0.5") intervals
* across the displayed page. [Example: Consider a WordprocessingML document
*
* @return
*/
public float getDefaultTabStop()
{
if ( defaultTabStop == null )
{
CTSettings settings = getCTSettings();
if ( settings != null )
{
CTTwipsMeasure value = settings.getDefaultTabStop();
if ( value != null )
{
if ( !value.isNil() )
{
this.defaultTabStop = DxaUtil.dxa2points( value.getVal() );
}
}
}
if ( defaultTabStop == null )
{
this.defaultTabStop = DEFAULT_TAB_STOP_POINT;
}
}
return defaultTabStop;
}
public CTSettings getCTSettings()
{
return ctSettings;
}
private static CTSettings getCTSettings( XWPFDocument document )
{
XWPFSettings settings = getSettings( document );
if ( settings != null )
{
try
{
InputStream inputStream = settings.getPackagePart().getInputStream();
return SettingsDocument.Factory.parse( inputStream ).getSettings();
}
catch ( Exception e )
{
}
}
return null;
}
private static abstract class DocumentVisitor {
protected abstract boolean acceptRelationshipType(String relationshipType);
protected abstract boolean visitDocumentPart(String relationshipType, POIXMLDocumentPart p);
final void visitDocument(XWPFDocument document) {
Method partCollectionGetter = null;
boolean useLegacyPoi = false;
try {
try {
partCollectionGetter = document.getClass().getMethod("getRelationParts"); // POI 3.16
} catch (NoSuchMethodException nsmEx) {
partCollectionGetter = document.getClass().getMethod("getRelations"); // older POI
useLegacyPoi = true;
}
if (partCollectionGetter != null) {
@SuppressWarnings("unchecked")
Collection<Object> partCollection = (Collection<Object>) partCollectionGetter.invoke(document);
for (Object currentPartObject : partCollection) {
Method relationshipAccessor = null;
if (useLegacyPoi) {
relationshipAccessor = currentPartObject.getClass().getMethod("getPackageRelationship");
} else {
relationshipAccessor = currentPartObject.getClass().getMethod("getRelationship");
}
Object relationship = relationshipAccessor.invoke(currentPartObject);
if (relationship != null) {
Method relationshipTypeAccessor = relationship.getClass().getMethod("getRelationshipType");
String relationshipType = (String) relationshipTypeAccessor.invoke(relationship);
if (this.acceptRelationshipType(relationshipType)) {
POIXMLDocumentPart currentPart = null;
if (useLegacyPoi) {
currentPart = (POIXMLDocumentPart) currentPartObject;
} else {
Method documentPartAccessor = currentPartObject.getClass()
.getMethod("getDocumentPart");
currentPart = (POIXMLDocumentPart) documentPartAccessor.invoke(currentPartObject);
}
if (currentPart != null) {
boolean breakLoop = this.visitDocumentPart(relationshipType, currentPart);
if (breakLoop) {
return;
}
}
}
}
}
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
}
}
}
private static class SettingsDocumentVisitor extends DocumentVisitor {
private XWPFSettings result = null;
@Override
protected boolean acceptRelationshipType(String relationshipType) {
return XWPFRelation.SETTINGS.getRelation().equals(relationshipType);
}
@Override
protected boolean visitDocumentPart(String relationshipType, POIXMLDocumentPart p) {
result = (XWPFSettings)p;
return true;
}
XWPFSettings getResult() {
return result;
}
}
private static XWPFSettings getSettings( XWPFDocument document )
{
final SettingsDocumentVisitor visitor = new SettingsDocumentVisitor();
visitor.visitDocument(document);
return visitor.getResult();
}
public List<ThemeDocument> getThemeDocuments()
{
return themeDocuments;
}
private static class ThemeDocumentVisitor extends DocumentVisitor {
private final List<ThemeDocument> themeDocuments = new ArrayList<ThemeDocument>();
@Override
protected boolean acceptRelationshipType(String relationshipType) {
return "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme".equals( relationshipType );
}
@Override
protected boolean visitDocumentPart(String relationshipType, POIXMLDocumentPart p) {
try {
InputStream inputStream = p.getPackagePart().getInputStream();
ThemeDocument theme = ThemeDocument.Factory.parse( inputStream );
themeDocuments.add( theme );
} catch ( IOException e ) {
e.printStackTrace();
} catch (XmlException e) {
e.printStackTrace();
}
return false;
}
List<ThemeDocument> getThemeDocuments() {
return themeDocuments;
}
}
private static List<ThemeDocument> getThemeDocuments( XWPFDocument document )
{
final ThemeDocumentVisitor visitor = new ThemeDocumentVisitor();
visitor.visitDocument(document);
return visitor.getThemeDocuments();
}
private static class FontsDocumentVisitor extends DocumentVisitor {
private final List<FontsDocument> fontsDocuments = new ArrayList<FontsDocument>();
@Override
protected boolean acceptRelationshipType(String relationshipType) {
return XWPFRelation.FONT_TABLE.getRelation().equals( relationshipType );
}
@Override
protected boolean visitDocumentPart(String relationshipType, POIXMLDocumentPart p) {
try {
InputStream inputStream = p.getPackagePart().getInputStream();
FontsDocument fontsDocument = FontsDocument.Factory.parse(inputStream);
fontsDocuments.add(fontsDocument);
} catch (IOException e) {
e.printStackTrace();
} catch (XmlException e) {
e.printStackTrace();
}
return false;
}
List<FontsDocument> getFontsDocuments() {
return fontsDocuments;
}
}
private static List<FontsDocument> getFontsDocument( XWPFDocument document )
{
final FontsDocumentVisitor visitor = new FontsDocumentVisitor();
visitor.visitDocument(document);
return visitor.getFontsDocuments();
}
public List<String> getFontsAltName( String fontName )
throws Exception
{
return fontsAltName.get( fontName );
}
public String getFontNameToUse( String fontName )
{
return fontsToUse.get( fontName );
}
public void setFontNameToUse( String fontName, String altFfontName )
{
fontsToUse.put( fontName, altFfontName );
}
}