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;
 
 
 
 
 
 
 
 public final class NumberingDefinitionsPart extends JaxbXmlPartXPathAware<Numbering> {
 	
 	private static Logger log = LoggerFactory.getLogger(NumberingDefinitionsPart.class);	
 	
 		super(partName);
 		init();
 	}
 	
 		super(new PartName("/word/numbering.xml"));
 		init();
 	}
 
 	public void init() {	
 		// Used if this Part is added to [Content_Types].xml 
 
 		// Used when this Part is added to a rels 
 	}
 	
 	}
 
 		
	}
    public void initialiseMaps()
    {
    	Numbering numbering = getJaxbElement();
    	
        // count the number of different list numbering schemes
    	if (numbering.getNum().size() == 0)
        {
    		.debug("No num defined");
    		// Don't return; init empty lists.
        }
        
        // initialize the abstract number list
         
        	= new HashMap<StringAbstractListNumberingDefinition>(numbering.getAbstractNum().size() );
                
        // initialize the instance number list
         
        	= new HashMap<StringListNumberingDefinition>( numbering.getNum().size() );
        // store the abstract list type definitions
        for (Numbering.AbstractNum abstractNumNode : numbering.getAbstractNum() )
        {
            AbstractListNumberingDefinition absNumDef 
            	= new AbstractListNumberingDefinition(abstractNumNode);
            .put(absNumDef.getID(), absNumDef);
        }
        // instantiate the list number definitions
        forNumbering.Num numNode : numbering.getNum() )
        {
            ListNumberingDefinition listDef 
            	= new ListNumberingDefinition(numNode);
            .put(listDef.getListNumberId(), listDef);
//            log.debug("Added list: " + listDef.getListNumberId() );
        }
    }
    
    public void resolveLinkedAbstractNum(StyleDefinitionsPart sdp) {
    	
    	if (sdp==null) {
    		.warn("No StyleDefinitionsPart found");
    		return;
    	}
    	
        for (Numbering.AbstractNum abstractNum : getJaxbElement().getAbstractNum() ) {
        	
        	// <w:numStyleLink w:val="MyListStyle"/>
        	if (abstractNum.getNumStyleLink()==nullcontinue;
        	
        	// there is also abstractNum.getStyleLink(), but ignore that
        	
        	String numStyleId = abstractNum.getNumStyleLink().getVal();
        	
        	Style s = sdp.getStyleById(numStyleId);
        	if (s==null) {
        		.warn("For w:numStyleLink, couldn't find style " + numStyleId);
        		continue;
        	}
        	if (s.getPPr()==null || s.getPPr().getNumPr()==null) {
        		.warn("For w:numStyleLink, style " + numStyleId + " has no w:numPr");
        		continue;        		
        	}
        	
        	NumPr styleNumPr = s.getPPr().getNumPr();
        	
        	// Get the concrete list this point to
        	if (styleNumPr.getNumId()==null) {
        		.warn("For w:numStyleLink, style " + numStyleId + " w:numPr has no w:numId");
        		continue;        		        		
        	}
        	BigInteger concreteListId = styleNumPr.getNumId().getVal();
        	
        	// Get the target abstract num
        	ListNumberingDefinition lnd = getInstanceListDefinitions().get(concreteListId.toString());
        	if (lnd==null) {
        		.warn("No ListNumberingDefinition entry with ID " + concreteListId.toString());
        	}
        	Numbering.AbstractNum linkedNum = lnd.getAbstractListDefinition().getAbstractNumNode();
        	// OK, update
            AbstractListNumberingDefinition absNumDef 
            	= .get(abstractNum.getAbstractNumId().toString());
            
            absNumDef.updateDefinitionFromLinkedStyle(linkedNum);
            
            // Also update the underlying abstract list
            if (abstractNum.getLvl().size()>0) {
            	.warn("Cowardly refusing to overwrite existing List<Lvl>" );
            } else {
            	abstractNum.getLvl().clear();
            	abstractNum.getLvl().addAll(linkedNum.getLvl());
            		// This list is treated as a separate list by Word (ie its numbers are incremented
            		// independently), and this code honours that.
            }
            
            
            .info("Updated abstract list def " + abstractNum.getAbstractNumId().toString() + " based on w:numStyleLink " + numStyleId );
        }
    	
    	
    }
    
    
For the given list numId, restart the numbering on the specified level at value val. This is done by creating a new list (ie <w:num>) which uses the existing w:abstractNum.

Parameters:
numId
ilvl
val
Returns:
    public long restart(long numIdlong ilvllong val
    	throws InvalidOperationException {
    	
    	// Find the abstractNumId
    	
    	// (Ensure maps are initialised)
    	if ( == null ) { 
    		getEmulator();
    	}
    	ListNumberingDefinition existingLnd = .get( Long.toString(numId) );
    	if (existingLnd==null) {
    		throw new InvalidOperationException("List " + numId + " does not exist");
    	}
    	BigInteger abstractNumIdVal = existingLnd.getNumNode().getAbstractNumId().getVal();
    	
    	// Generate the new <w:num
    	long newNumId = .size() + 1;
    	
		Num newNum = factory.createNumberingNum();
		newNum.setNumId( BigInteger.valueOf(newNumId) );
		AbstractNumId abstractNumId = factory.createNumberingNumAbstractNumId();
		abstractNumId.setVal(abstractNumIdVal);
		newNum.setAbstractNumId(abstractNumId);
		LvlOverride lvlOverride = factory.createNumberingNumLvlOverride();
		lvlOverride.setIlvl(BigInteger.valueOf(ilvl));
		newNum.getLvlOverride().add(lvlOverride);
		start.setVal(BigInteger.valueOf(val));
		lvlOverride.setStartOverride(start);
    	
    	// Add it to the jaxb object and our hashmap
        ListNumberingDefinition listDef 
        .put(listDef.getListNumberId(), listDef);		
    	
    	// Return the new numId
    	return newNumId;
    	
    }
	private Emulator em;
//	public void setEmulator(Emulator em) {
//		this.em = em;
//	}
	public Emulator getEmulator() {
		    	
		return getEmulator(false);
	}


Parameters:
reset
Returns:
Since:
3.0.0
	public Emulator getEmulator(boolean reset) {
    	if ( == null 
    			|| reset) { 
    		initialiseMaps();
    		 = new Emulator();    		
    	}
		return ;
	}
	public Ind getInd(NumPr numPr) { //, StyleDefinitionsPart sdp, String styleId) {
		String ilvlString = "0";
		if (numPr.getIlvl()!=nullilvlString = numPr.getIlvl().getVal().toString();
		if (numPr.getNumId()==null) {
			.warn("numPr without numId: " + XmlUtils.marshaltoString(numPrtruetrue));
			return null;
else {		
			return getInd(numPr.getNumId().getVal().toString(), ilvlString );
		}
	}
	public Ind getInd(String numIdString ilvl) {
		// Operating on the docx4j.listnumbering plane,
		// not the JAXB plane..
		if (lnd==null) {
			.debug("couldn't find list for numId: " + numId);
			return null;
		}
		if (ilvl==nullilvl = "0";
		ListLevel ll = lnd.getLevel(ilvl);
		if (ll==null) {
			.warn("No ListLevel defined for level " + ilvl + " in list " + numId);
			return null;
		}
		// OK, now on the JAXB plane
		Lvl jaxbOverrideLvl = ll.getJaxbOverrideLvl();
		.debug("Looking at override/instance definition..");
		if (jaxbOverrideLvl!=null) {
			Ind ind = getIndFromLvl(jaxbOverrideLvl);
			if (ind!=null) {
				.debug("Got it..");
				return ind;
			}
		}
		// Now do the same for the abstract definition
		.debug("Looking at abstract definition..");
		Lvl abstractLvl = ll.getJaxbAbstractLvl();
		Ind ind = getIndFromLvl(abstractLvl);
		return ind;
	}
	private Ind getIndFromLvl(Lvl lvl) {
		// If there is a style reference in the instance,
		// as a sibling of pPr,
		// use any w:ind in it (or TODO styles it is based on)
		if (lvl.getPStyle()!=null) {
			// Get the style
//			StyleDefinitionsPart stylesPart = ((WordprocessingMLPackage)this.getPackage()).
//				getMainDocumentPart().getStyleDefinitionsPart();
			PropertyResolver propertyResolver 
			.debug("override level has linked style: " + lvl.getPStyle().getVal() );
			org.docx4j.wml.Style style = propertyResolver.getStylelvl.getPStyle().getVal() );
			if (style==null) {
				.error("Couldn't find style " + lvl.getPStyle().getVal());
				return null;
			}
			// If the style has a w:ind, return it.
			// Otherwise, continue
			if (style.getPPr() != null
					&& style.getPPr().getInd()!=null ) {
				return style.getPPr().getInd();
			}
		}
		// If there is a style reference in pPr,
		// but not also one as a sibling of pPr,
		// then no number appears at all!
			// TODO: throw ShouldNotBeNumbered??
		// If there is a w:ind in the instance use that
		if ( lvl.getPPr()!=null
				&& lvl.getPPr().getInd() !=null ) {
			return lvl.getPPr().getInd();
		}
		return null;		
	}

Add the specified definition, allocating it a new w:abstractNumId. Also create and add an associated ListNumberingDefinition, and return this associated ListNumberingDefinition (since that is what you are likely to use in the document).

Parameters:
abstractNum
Returns:
		//////////////////////////////////////////////
		// Numbering.AbstractNum abstractNum
		// Generate a unique w:abstractNumId for it
		int nextId = getAbstractListDefinitions().size();		
    	do {
    		nextId++;    		
    	} while (getAbstractListDefinitions().containsKey"" + nextId ));    	
    	abstractNum.setAbstractNumId( BigInteger.valueOf(nextId) );
    	
    	// Add it to our JAXB object
    	this.getJaxbElement().getAbstractNum().add(abstractNum);
    	
    	// Add it to our hashmap
        AbstractListNumberingDefinition absNumDef = new AbstractListNumberingDefinition(abstractNum);
        .put(absNumDef.getID(), absNumDef);
		//////////////////////////////////////////////
		// Numbering.Num num
        
        // Now make an associated ListNumberingDefinition
		//	<w:num w:numId="1">
		//	  <w:abstractNumId w:val="1"/>
		//	</w:num>"        
        Numbering.Num num = Context.getWmlObjectFactory().createNumberingNum();
        Numbering.Num.AbstractNumId abstractNumId = Context.getWmlObjectFactory().createNumberingNumAbstractNumId();
        abstractNumId.setVal(BigInteger.valueOf(nextId) );
        num.setAbstractNumId(abstractNumId);
        
        nextId = getInstanceListDefinitions().size();		
    	do {
    		nextId++;    		
    	} while (getInstanceListDefinitions().containsKey"" + nextId ));    	
    	num.setNumId( BigInteger.valueOf(nextId) );  
    	
    	// Add it to our JAXB object
    	this.getJaxbElement().getNum().add(num);
    	
    	// Add it to our hashmap
        .put(listDef.getListNumberId(), listDef);
        
        // 
    	return num;
	}
    	    	    	 
		java.io.InputStream is = null;
		try {
			is = org.docx4j.utils.ResourceUtils.getResource(
					"org/docx4j/openpackaging/parts/WordprocessingML/numbering.xml");
catch (IOException e) {
			// TODO Auto-generated catch block
		}    		
    	
    	return unmarshalis );    // side-effect is to set jaxbElement 	
    }
New to GrepCode? Check out our FAQ X