Changeset 1745 for trunk/docx4j/src/main/java/org

Timestamp:

01/10/12 11:46:36 (5 months ago)

Author:

jharrop

Message:

Support <w:startOverride w:val="10"/>.
A single counter is maintained for an abstract list level, and shared by all instances.

Location:

trunk/docx4j/src/main/java/org/docx4j/model/listnumbering

Files:

• AbstractListNumberingDefinition.java (modified) (1 diff)
• ListLevel.java (modified) (15 diffs)
• ListNumberingDefinition.java (modified) (6 diffs)

trunk/docx4j/src/main/java/org/docx4j/model/listnumbering/AbstractListNumberingDefinition.java

@@ -98 +98 @@
 import org.docx4j.wml.PPrBase.NumPr;
 
+/**
+ * Represents:
+ * 
+          <w:abstractNum w:abstractNumId="0">
+            <w:nsid w:val="2DD860C0"/>
+            <w:multiLevelType w:val="multilevel"/>
+            <w:tmpl w:val="0409001D"/>
+            <w:lvl w:ilvl="0">
+              <w:start w:val="1"/>
+              <w:numFmt w:val="decimal"/>
+              <w:lvlText w:val="%1)"/>
+              <w:lvlJc w:val="left"/>
+              <w:pPr>
+                <w:ind w:left="360" w:hanging="360"/>
+              </w:pPr>
+            </w:lvl>
+            <w:lvl w:ilvl="1">
+              <w:start w:val="1"/>
+              <w:numFmt w:val="lowerLetter"/>
+              <w:lvlText w:val="%2)"/>
+              <w:lvlJc w:val="left"/>
+              <w:pPr>
+                <w:ind w:left="720" w:hanging="360"/>
+              </w:pPr>
+            </w:lvl>
+            etc
+            
+            (layered on top of the JAXB object representing same)
+    
+ */
 public class AbstractListNumberingDefinition {
         

trunk/docx4j/src/main/java/org/docx4j/model/listnumbering/ListLevel.java

@@ -103 +103 @@
          * for each story! 
          * 
+         * 2012 01 10: numbering set up on a per-part basis
+         * seems the most sensible approach.
+         * 
          */
         
@@ -117 +120 @@
         }
         
+        /**
+         *  The counter is kept at the abstract level, since
+         *  each instance definition shares a single counter.
+         *  
+         */
+        private Counter counter; 
+        
+        private boolean encounteredAlready = false;
+        
+        
+    /**
+     * Constructor for a ListLevel in an abstract definition.
+     */
     public ListLevel(Lvl levelNode)
     {
@@ -122 +138 @@
         
         this.id = levelNode.getIlvl().toString(); 
+        
+        counter = new Counter();
 
         Lvl.Start startValueNode = levelNode.getStart();
@@ -129 +147 @@
                         // Start value is one less than the user set it to,
                         // since whenever we fetch the number, we first increment it.
-            this.counter = this.startValue;
+            counter.setCurrentValue(this.startValue);                        
         }
 
@@ -163 +181 @@
     }
 
-    /** copy constructor
-     * 
-     * @param masterCopy
+    /** 
+     * Constructor for a ListLevel in an instance definition.
      */
     public ListLevel(ListLevel masterCopy)
@@ -174 +191 @@
         this.levelText = masterCopy.levelText;
         this.startValue = masterCopy.startValue;
-        this.counter = this.startValue;
+        //this.counter = this.startValue;
+        this.counter = masterCopy.counter;  // reference the abstract one, since this is shared
         this.font = masterCopy.font;
         this.isBullet = masterCopy.isBullet;
@@ -191 +209 @@
         if (startValueNode != null)
         {
-                this.startValue = startValueNode.getVal(); 
-        }
-        this.counter = this.startValue;
+                this.startValue = startValueNode.getVal().subtract(BigInteger.ONE);
+                // Start value is one less than the user set it to,
+                // since whenever we fetch the number, we first increment it.
+                counter.setCurrentValue(this.startValue);                        
+        }
 
         Lvl.LvlText levelTextNode = levelNode.getLvlText();
@@ -238 +258 @@
     private BigInteger startValue = BigInteger.ZERO;
 
-    /**
+    public void setStartValue(BigInteger startValue) {
+                this.startValue = startValue;
+        }
+
+        /**
      * start value of that level
      * @return
@@ -247 +271 @@
     }
 
-    private BigInteger counter;
-
-    /**
-     * returns the current count of list items of that level
-     * @return
-     */
-    public BigInteger getCurrentValueRaw()
-    {           
-            return this.counter;
-    }
 
     /**
@@ -286 +300 @@
         
         if (numFmt.equals( NumberFormat.DECIMAL ) ) {
-                return this.counter.toString();
+                return this.counter.getCurrentValue().toString();
         }
         
@@ -301 +315 @@
         }
                         
-        int current = this.counter.intValue();
+        int current = this.counter.getCurrentValue().intValue();
         
         if (numFmt.equals( NumberFormat.UPPER_ROMAN ) ) {                       
@@ -321 +335 @@
         
         log.error("Unhandled numFmt: " + numFmt.name() );
-        return this.counter.toString();
+        return this.counter.getCurrentValue().toString();
     }
     
@@ -330 +344 @@
     public void IncrementCounter()
     {
-        this.counter = this.counter.add(BigInteger.ONE); 
+        if (!encounteredAlready) {
+                // Defer setting the startValue until the list
+                // is actually encountered in the main document part,
+                // since otherwise earlier numbering (using the
+                // same abstract number) would use this startValue
+                counter.setCurrentValue(this.startValue);  
+                encounteredAlready = true;
+        }
+        
+        
+        counter.IncrementCounter();
         
-        log.debug("counter now: " + this.counter.toString() );
-        
     }
 
@@ -341 +363 @@
     public void ResetCounter()
     {
-        this.counter = this.startValue;
+        counter.setCurrentValue(this.startValue);
     }
 
@@ -387 +409 @@
             return this.isBullet;
     }
+    
+    protected class Counter {
+        
+        private BigInteger currentValue;
+        
+        Counter() {
+                currentValue = BigInteger.ZERO;
+        }
+
+        public void setCurrentValue(BigInteger currentValue) {
+                        this.currentValue = currentValue;
+                }
+
+                /**
+         * returns the current count of list items of that level
+         * @return
+         */
+        public BigInteger getCurrentValue()
+        {               
+                log.debug("counter: " + currentValue.intValue() );
+            return this.currentValue;
+        }
+        
+        /**
+         * increments the current count of list items of that level 
+         */
+        public void IncrementCounter()
+        {
+                setCurrentValue( currentValue.add(BigInteger.ONE)); 
+            
+            log.debug("counter now: " + currentValue.intValue() );
+            
+        }
+        
+    }
 
 }

trunk/docx4j/src/main/java/org/docx4j/model/listnumbering/ListNumberingDefinition.java

@@ -84 +84 @@
 package org.docx4j.model.listnumbering;
 
+import java.math.BigInteger;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -90 +91 @@
 
 import org.apache.log4j.Logger;
+import org.docx4j.XmlUtils;
 import org.docx4j.wml.Lvl;
 import org.docx4j.wml.Numbering;
-
+import org.docx4j.wml.Numbering.Num.LvlOverride.StartOverride;
+
+/**
+ * Represents:
+ * 
+          <w:num w:numId="1">
+            <w:abstractNumId w:val="0"/>
+          </w:num>
+          
+          or 
+          
+          <w:num w:numId="2">
+            <w:abstractNumId w:val="0"/>
+            <w:lvlOverride w:ilvl="0">
+              <w:startOverride w:val="10"/>
+            </w:lvlOverride>
+          </w:num>
+                    
+            (layered on top of the JAXB object representing same)
+    
+ */
 public class ListNumberingDefinition {
-        
-        /* There should be only one Emulator object per 
-         * WordprocessingML package.  It is set on the 
-         * numbering part.
-         */
-        
+                
         // The underlying JAXB object 
         private Numbering.Num numNode;
@@ -108 +125 @@
         protected static Logger log = Logger.getLogger(ListNumberingDefinition.class);
         
-    /// <summary>
-    /// constructor
-    /// </summary>
-    /// <param name="numNode"></param>
-    /// <param name="nsm"></param>
-    /// <param name="abstractListDefinitions"></param>
+    /**
+     * @param numNode
+     * @param abstractListDefinitions
+     */
     public ListNumberingDefinition(Numbering.Num numNode, 
                 HashMap<String, AbstractListNumberingDefinition> abstractListDefinitions)
@@ -120 +135 @@
         
         this.listNumberId =  numNode.getNumId().toString(); //getAttributeValue(numNode, "w:numId");
+        log.debug("Constructing model for numId=" + listNumberId);
 
         //XmlNode abstractNumNode = numNode.SelectSingleNode("./w:abstractNumId", nsm);
@@ -146 +162 @@
             if (levelOverrideNodes != null)
             {
+                /*
+                 *     <w:lvlOverride w:ilvl="0">
+                                              <w:startOverride w:val="10"/>
+                                            </w:lvlOverride>
+                 */
                 for (Numbering.Num.LvlOverride overrideNode : levelOverrideNodes)
                 {
-                    //XmlNode node = overrideNode.SelectSingleNode("./w:lvl", nsm);
-                        Lvl node = overrideNode.getLvl();
-                    if (node != null)
+                        log.debug("found LvlOverride " + XmlUtils.marshaltoString(overrideNode, true));
+                    if (overrideNode.getIlvl() != null)
                     {
-                        String overrideLevelId = node.getIlvl().toString(); //getAttributeValue(node, "w:ilvl");
-
-                        if (overrideLevelId!=null && !overrideLevelId.equals("") )
-                        {
-                            this.levels.get(overrideLevelId).SetOverrides(node);
+                        String overrideLevelId = overrideNode.getIlvl().toString(); //getAttributeValue(node, "w:ilvl");
+                        log.debug(".. " + overrideLevelId );
+
+                        if (!overrideLevelId.equals("") )
+                        {                            
+                            // Is there a w:startOverride?
+                                // This is given effect the first time the instance is encountered in the document
+                            StartOverride startOverride = overrideNode.getStartOverride();
+                            if (startOverride!=null
+                                        && startOverride.getVal()!=null) {
+                                this.levels.get(overrideLevelId).setStartValue(startOverride.getVal().subtract(BigInteger.ONE));
+                                log.debug("level " + overrideLevelId + "starts at " + startOverride.getVal() );
+                            }
                         }
                     }
+//                      Lvl ilvl = overrideNode.getLvl();
+//                    if (ilvl != null)
+//                    {
+//                    this.levels.get(overrideLevelId).SetOverrides(overrideLevelId);
+//                    }                    
                 }
             }
@@ -181 +214 @@
     public void IncrementCounter(String level)
     {
+        
         log.debug("Increment level " + level);
         this.levels.get(level).IncrementCounter();