Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *  Copyright 2007-2008, Plutext Pty Ltd.
   *   
   *  This file is part of docx4j.
  
      docx4j is licensed under the Apache License, Version 2.0 (the "License"); 
      you may not use this file except in compliance with the License. 
  
      You may obtain a copy of the License at 
 
         http://www.apache.org/licenses/LICENSE-2.0 
 
     Unless required by applicable law or agreed to in writing, software 
     distributed under the License is distributed on an "AS IS" BASIS, 
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     See the License for the specific language governing permissions and 
     limitations under the License.
 
  */
 
 package org.docx4j.openpackaging.parts.WordprocessingML;
 
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 

Author(s):
jharrop
 
 public class MainDocumentPart extends DocumentPart<org.docx4j.wml.Documentimplements ContentAccessor  {
 	
 	private static Logger log = LoggerFactory.getLogger(MainDocumentPart.class);
 		
 	
 	public MainDocumentPart(PartName partNamethrows InvalidFormatException {
 		super(partName);
 		init();
 	}
 		super(new PartName("/word/document.xml"));
 		init();
 	}
 		
 	public void init() {
 		// Used if this Part is added to [Content_Types].xml 
 		
 		/*
		 * From [MS-OE376]
		 * 
		 * 2.1.8 Part 1 Section 11.3.10, Main Document Part
		 * 
		 * a. The standard states that the content type for the Main Document part is: 
		 * 
		 *        application/vnd.openxmlformats-officedocument.wordprocessingml.main+xml.
		 *        
		 *    Office uses the following content type for the Main Document part: 
		 *    
		 *        application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml.
		 *        
		 * This note applies to the following products: 2007, 2007 SP1, 2007 SP2.
		 */
		// Used when this Part is added to a rels 
	}	
	protected void setMceIgnorable() {
	}

    
    

    
Convenience method to getJaxbElement().getBody().getContent()

Since:
2.7
    public List<ObjectgetContent() {
    	
    	if (this.getJaxbElement()==null) {    		
    		this.setJaxbElement( Context.getWmlObjectFactory().createDocument() );
    	}
    	if (this.getJaxbElement().getBody()==null) {
    		this.getJaxbElement().setBody(
    				Context.getWmlObjectFactory().createBody() );
    	}
    	
    	return this.getJaxbElement().getContent();
    }	
		if (==null) {
			try {
catch (Docx4JException e) {
			}			
		}
	}
	public StyleTree getStyleTree() {
		return getStyleTree(false); // preserve existing behaviour
	}
	public StyleTree getStyleTree(boolean refresh) {
		// refresh is post 2.7.1
		if (refresh || ==null) {
			.info("Preparing StyleTree");
		    try {
catch (Docx4JException e) {
				// Shouldn't happen, so catch here
			}
	    	
//			// Get these first, so we can be sure they are defined... 
//			Style defaultParagraphStyle = getStyleDefinitionsPart().getDefaultParagraphStyle();
//			Style defaultCharacterStyle = getStyleDefinitionsPart().getDefaultCharacterStyle();
			// Styles defined in StyleDefinitionsPart
			Map<StringStyleallStyles = new HashMap<StringStyle>();
			for ( org.docx4j.wml.Style s : styles.getStyle() ) {				
				allStyles.put(s.getStyleId(), s);	
				//log.debug("live style: " + s.getStyleId() );
			}
			 = new StyleTree(getStylesInUse(), allStyles);
		}
		return ;
	}


    
    
Traverse the document, looking for fonts which have been applied, either directly, or via a style.

Returns:
    public Set<StringfontsInUse() {
    	
    	.info("fontsInUse..");
    	
    	getPropertyResolver();  // this inits our virtual DocDefaults style
    	
    // Setup 
    	
    	Set<StringfontsDiscovered = new java.util.HashSet<String>();
    	
//    	// Keep track of styles we encounter, so we can
//    	// inspect these for fonts
//    	Set<String> stylesInUse = new java.util.HashSet<String>();
//
//		org.docx4j.wml.Styles styles = null;
//		if (this.getStyleDefinitionsPart()!=null) {
//			styles = (org.docx4j.wml.Styles)this.getStyleDefinitionsPart().getJaxbElement();			
//		}
//		// It is convenient to have a HashMap of styles
//		Map<String, Style> stylesDefined = new java.util.HashMap<String, Style>();
//		if (styles!=null) {
//		     for (Iterator<Style> iter = styles.getStyle().iterator(); iter.hasNext();) {
//		            Style s = iter.next();
//		            stylesDefined.put(s.getStyleId(), s);
//		     }
//		}
//    // We need to know what fonts and styles are used in the document
    	
		Body body =  wmlDocumentEl.getBody();
		List <ObjectbodyChildren = body.getContent();
		FontAndStyleFinder finder = new FontAndStyleFinder(runFontSelectorfontsDiscoverednull);
		finder.defaultCharacterStyle = this.getStyleDefinitionsPart().getDefaultCharacterStyle();
		finder.defaultParagraphStyle = this.getStyleDefinitionsPart().getDefaultParagraphStyle();		
		new TraversalUtil(bodyChildrenfinder);
//		finder.finish();
		fontsDiscovered.add(
				runFontSelector.getDefaultFont() );
		// fonts in headers, footers?
		if (rp!=null) {
			for ( Relationship r : rp.getRelationships().getRelationship() ) {
				Part part = rp.getPart(r);
				if ( part instanceof FooterPart ) {
					Ftr ftr = ((FooterPart)part).getJaxbElement();
					finder.walkJAXBElements(ftr);
else if (part instanceof HeaderPart) {
					Hdr hdr = ((HeaderPart)part).getJaxbElement();
					finder.walkJAXBElements(hdr);
				}
			}
		}
		// Styles in endnotes, footnotes?
		if (this.getEndNotesPart()!=null) {
			.debug("Looking at endnotes");
			finder.walkJAXBElements(endnotes);
		}
		if (this.getFootnotesPart()!=null) {
			.debug("Looking at footnotes");
			finder.walkJAXBElements(footnotes);
		}
		// Comments
		if (this.getCommentsPart()!=null) {
			.debug("Looking at comments");			
			Comments comments = this.getCommentsPart().getJaxbElement();
			finder.walkJAXBElements(comments);
		}
		// Add fonts used in the styles we discovered
		// .. 2013 03 10: no longer necessary
	    
	    // Fonts can also be used in the numbering part
	    // For now, treat any font mentioned in that part as in use.
	    // Ideally, we'd only register fonts used in numbering levels
	    // that were actually used in the document
    	if (getNumberingDefinitionsPart()!=null) {
            for (Numbering.AbstractNum abstractNumNode : numbering.getAbstractNum() ) {
            	for (Lvl lvl : abstractNumNode.getLvl() ) {
            		if (lvl.getRPr()!=null
            				&& lvl.getRPr().getRFonts()!=null ) {
            			String fontName = lvl.getRPr().getRFonts().getAscii();            			
            			if (fontName!=null) {
            				fontsDiscovered.add(fontName);	
            				.debug("Registered " + fontName + " for abstract list " + abstractNumNode.getAbstractNumId() + " lvl " + lvl.getIlvl() );
            			}
            		}
            	}
            }    		
    	}	    
		    	
		return fontsDiscovered;
    }
    
			this. = fontsDiscovered;
		}
    	private Set<StringfontsDiscovered// same set 
    	// look here
		public void fontAction(String fontname) {
			if (fontname==null) {
				.warn("Got null"new Throwable());
				return;
			}
			String englishFromCJK = CJKToEnglish.toEnglishfontname);
			if (englishFromCJK==null) {
				.add(fontname); 
else {
				.add(englishFromCJK);
				// No point adding the original CJK name
			}
		}
		private boolean spanReusable = true;
		public boolean isReusable() {
			return ;
		}
		public void setMustCreateNewFlag(boolean val) {
			 = !val;
		}
		public void setDocument(Document document) {}
		public void addCharacterToCurrent(char c) {}
		public void finishPrevious() {}
		public void createNew() {}
		public void setRunFontSelector(RunFontSelector runFontSelector) {}
		public Object getResult() {return null;}
		public void setFallbackFont(String fontname) {}
	}
    

Traverse the document, and return a map of all styles which are used directly in the document. (IE this does not include styles on which others are just BasedOn).

Returns:
		Body body =  wmlDocumentEl.getBody();
		List <ObjectbodyChildren = body.getContent();
		Set<StringstylesInUse = new HashSet<String>();
		FontAndStyleFinder finder = new FontAndStyleFinder(nullnullstylesInUse);
		finder.defaultCharacterStyle = this.getStyleDefinitionsPart().getDefaultCharacterStyle();
		finder.defaultParagraphStyle = this.getStyleDefinitionsPart().getDefaultParagraphStyle();
		new TraversalUtil(bodyChildrenfinder);
		finder.finish();
		// Styles in headers, footers?
		if (rp!=null) {
			for ( Relationship r : rp.getRelationships().getRelationship() ) {
				Part part = rp.getPart(r);
				if ( part instanceof FooterPart ) {
					Ftr ftr = ((FooterPart)part).getJaxbElement();
					finder.walkJAXBElements(ftr);
else if (part instanceof HeaderPart) {
					Hdr hdr = ((HeaderPart)part).getJaxbElement();
					finder.walkJAXBElements(hdr);
				}
			}
		}
		// Styles in endnotes, footnotes?
		if (this.getEndNotesPart()!=null) {
			.debug("Looking at endnotes");
			finder.walkJAXBElements(endnotes);
		}
		if (this.getFootnotesPart()!=null) {
			.debug("Looking at footnotes");
			finder.walkJAXBElements(footnotes);
		}
		// Comments
		if (this.getCommentsPart()!=null) {
			.debug("Looking at comments");			
			Comments comments = this.getCommentsPart().getJaxbElement();
			finder.walkJAXBElements(comments);
		}
		return stylesInUse;
	}
    

    
Traverse looking for fonts and/or styles
    private static class FontAndStyleFinder extends CallbackImpl {
    	
    	
    	FontAndStyleFinder(RunFontSelector runFontSelector
    			Set<StringfontsDiscoveredSet<StringstylesInUse) {
    		
    		this. = runFontSelector;
    		this. = fontsDiscovered;
    		this. = stylesInUse;
    	}
    	
    	String defaultTableStyle = "TableNormal";
    	
    	private boolean defaultParagraphStyleUsed = false;
    	private boolean defaultCharacterStyleUsed = false;
    	
    	private PPr pPr
    	private RPr rPr;
    	
    	public void finish() {
    		if ( != null) {
    			if (() && ( != null)) {
					}
    			}
    			if (() && ( != null)) {
    			}
    		}
    	}
		public List<Objectapply(Object o) {
			if (o instanceof org.docx4j.wml.P) {
				 = ((P)o).getPPr();
				if ( != null) { //do the styles
					boolean customPStyle = false;
					if ( != null) {
						if (.getPStyle() != null) {
							// Note this paragraph style
							// log.debug("put style " + pPr.getPStyle().getVal());
							customPStyle = true;
						}
						if ((.getRPr() != null) && (.getRPr().getRStyle() != null)) {
			        		// 	Note this run style
			        		//log.debug("put style " + pPr.getRPr().getRStyle().getVal() );
						}
					}
				}
else if ( o instanceof org.docx4j.wml.R) {
				 = ((R)o).getRPr();
				if ( != null) {
					if ( != null) {
						if (.getRStyle() == null) {
						}
						else {
						}
					}
				}
else if ( o instanceof org.docx4j.wml.Text) {
				if ( != null) {
					// discover the fonts which apply to this text
				}
else if (o instanceof org.docx4j.wml.R.Sym ) { 
				if (  !=null ) {
				}
else if (o instanceof org.docx4j.wml.Tbl ) {
				// The table could have a table style;
				// Tables created in Word 2007 default to table style "TableGrid",
				// which is based on "TableNormal".
				if ( !=null && tbl.getTblPr()!=null 
						&& tbl.getTblPr().getTblStyle()!=null) {
//					log.debug("Adding table style: " + tbl.getTblPr().getTblStyle().getVal() );
				}
				// There is no such thing as a tr or a tc style,
				// so we don't need to look for them,
				// but since a tc can contain w:p or nested table,
				// we still need to recurse
			}
			return null;
		}
    	
    	@Override
		public boolean shouldTraverse(Object o) {
    		
    		if (o instanceof org.docx4j.wml.Br
    				|| o instanceof org.docx4j.wml.R.Tab
    				|| o instanceof org.docx4j.wml.R.LastRenderedPageBreak) {
    			return false;
    		}
			return true;
		}
    	
	}	



Create a paragraph containing the string simpleText, styled using the specified style (up to user to ensure it is a paragraph style) and add it to the document.

Parameters:
styleId
text
Returns:
	public org.docx4j.wml.P addStyledParagraphOfText(String styleIdString text) {
		org.docx4j.wml.P p = createStyledParagraphOfText(styleIdtext);
		return p;
	}

Create a paragraph containing the string simpleText, styled using the specified style (up to user to ensure it is a paragraph style) without adding it to the document.

Parameters:
styleId
text
Returns:
	public org.docx4j.wml.P createStyledParagraphOfText(String styleIdString text) {
		StyleDefinitionsPart styleDefinitionsPart 
			// Style is available 
			org.docx4j.wml.PPr  pPr = factory.createPPr();
			p.setPPr(pPr);
			pPr.setPStyle(pStyle);
			pStyle.setVal(styleId);
		return p;
	}


Create a paragraph containing the string simpleText, and add it to the document. If passed null, the result is an empty P.

Parameters:
simpleText
Returns:
	public org.docx4j.wml.P addParagraphOfText(String simpleText) {
		org.docx4j.wml.P  para = createParagraphOfText(simpleText);
		addObject(para);
		return para;
	}

Create a paragraph containing the string simpleText, without adding it to the document. If passed null, the result is an empty P.

Parameters:
simpleText
Returns:
	public org.docx4j.wml.P createParagraphOfText(String simpleText) {
		org.docx4j.wml.P  para = factory.createP();
		if (simpleText!=null) {
			org.docx4j.wml.Text  t = factory.createText();
			t.setValue(simpleText);
			org.docx4j.wml.R  run = factory.createR();
			run.getContent().add(t); // ContentAccessor		
			para.getContent().add(run); // ContentAccessor
		}
		return para;
	}


Add the object o to the document. The same as getContent().add, except that this will ensure any style used is activated.

Parameters:
o
	public void addObject(Object o) {
		this.getContent().addo );
		// If this object contains paragraphs, make sure any style used
		// is activated
    	Set<StringstylesInUse = new java.util.HashSet<String>();
//    	Set<String> fontsDiscovered = new java.util.HashSet<String>(); 
		List list = new java.util.ArrayList<Object>();
		list.add(o);
//		FontDiscoveryCharacterVisitor visitor = new FontDiscoveryCharacterVisitor(fontsDiscovered);
//		RunFontSelector runFontSelector = new RunFontSelector((WordprocessingMLPackage) this.pack, visitor, OutputType.NA); 
		FontAndStyleFinder finder = new FontAndStyleFinder(nullnullstylesInUse);
		finder.defaultCharacterStyle = this.getStyleDefinitionsPart().getDefaultCharacterStyle();
		finder.defaultParagraphStyle = this.getStyleDefinitionsPart().getDefaultParagraphStyle();
		finder.walkJAXBElements(list);
		finder.finish();
		forString styleName : stylesInUse) {
	        .debug("Inspecting style: " + styleName );
	        
	        if (==null) {
	        	
	        	.warn("Style definitions part was null!");
	        	
	        } else if (getPropertyResolver().activateStyle(styleName)) {
	        	// Cool
	        } else {
	        	.warn(styleName + " couldn't be activated!");
	        }
	        
	    }
	}

Create a paragraph from the xml string <w:p>...</w:p> , and add it to the document. You'll need to ensure the string contains namespace declarations (including for w:)

Parameters:
simpleText
Returns:
	public org.docx4j.wml.P addParagraph(String pXmlthrows JAXBException {
		org.docx4j.wml.P  para = (org.docx4j.wml.P)org.docx4j.XmlUtils.unmarshalString(pXml);
		this.getContent().addpara );
		return para;
	}

Create a Hyperlink object, which is suitable for adding to a w:p

Parameters:
bookmarkName
linkText
Returns:
	public static Hyperlink hyperlinkToBookmark(String bookmarkNameString linkText) {
		try {
			String hpl = "<w:hyperlink w:anchor=\"" + bookmarkName + "\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" " +
            "w:history=\"1\" >" +
            "<w:r>" +
            "<w:rPr>" +
            "<w:rStyle w:val=\"Hyperlink\" />" +  // TODO: enable this style in the document!
            "</w:rPr>" +
            "<w:t>" + linkText + "</w:t>" +
            "</w:r>" +
            "</w:hyperlink>";
			return (Hyperlink)XmlUtils.unmarshalString(hpl);
catch (Exception e) {
			// Shouldn't happen
			return null;
		}
	}

Since:
3.0.0
	}
	public boolean setPartShortcut(Part partString relationshipType) {
		if (relationshipType.equals(.)) {
			return true;			
else {
			return super.setPartShortcut(partrelationshipType);
		}
	}
}


New to GrepCode? Check out our FAQ X