1.) Modified TextLayoutManager to take an additional length

parameter, indicating the maximum valid index of the passed-in
character array.

2.)  Removed from AddLMVisitor (which calls the above class), the
re-fitting of the FOText character array to the size of the maximum
valid index.

3.)  Various small cleanup issues.

git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@197402 13f79535-47bb-0310-9956-ffa450edef68

diff --git a/src/java/org/apache/fop/apps/Driver.java b/src/java/org/apache/fop/apps/Driver.java
index feb646a8172ab8561729a55dc1cfc27d3696bd72..ec4b11aa4f0269acdcf068cb763a2867f44189cf 100644 (file)
--- a/src/java/org/apache/fop/apps/Driver.java
+++ b/src/java/org/apache/fop/apps/Driver.java
@@ -540,8 +540,7 @@ public class Driver implements LogEnabled {
 
         treeBuilder.setUserAgent(getUserAgent());
         treeBuilder.setFOInputHandler(foInputHandler);
-        treeBuilder.foTreeControl = currentDocument;
-
+        treeBuilder.setFOTreeControl(currentDocument);
 
         return new ProxyContentHandler(treeBuilder) {
             

diff --git a/src/java/org/apache/fop/fo/FOText.java b/src/java/org/apache/fop/fo/FOText.java
index 549a0fff0329eeeb2b7333de72971129b6be731e..4e0a84de3d50d17afaa3a73be7982e97d39c8bd0 100644 (file)
--- a/src/java/org/apache/fop/fo/FOText.java
+++ b/src/java/org/apache/fop/fo/FOText.java
@@ -44,7 +44,12 @@ public class FOText extends FObj {
     public char[] ca;
 
     /**
-     * the length of the character array containing the text
+     * The actual length of the text to be rendered within ca,
+     * starting from position 0 of the array.  
+     *
+     * This value is originally equal to ca.length, but becomes decremented
+     * during whitespace removal by the flow.Block class, via the 
+     * TextCharIterator.remove() method below.
      */
     public int length;
 
@@ -87,7 +92,7 @@ public class FOText extends FObj {
     /**
      *
      * @param chars array of chars which contains the text in this object (may
-     * be a superset of the text in this object
+     * be a superset of the text in this object)
      * @param start starting index into char[] for the text in this object
      * @param end ending index into char[] for the text in this object
      * @param ti TextInfo object for the text in this object
@@ -163,6 +168,10 @@ public class FOText extends FObj {
             } else if (curIndex == length) {
                 curIndex = --length;
             }
+//          Temporary until leading space problem in 1.0 fixed
+//          System.out.println("\n\nremove called: ca = \"" + 
+//              new String(ca) + "\", length/node length: " + length 
+//              + ", " + ca.length);
         }
 
 

diff --git a/src/java/org/apache/fop/fo/FOTreeBuilder.java b/src/java/org/apache/fop/fo/FOTreeBuilder.java
index b483f88a8a63500bd93fcc9d5e3ee3deef5f0c15..4542c8e3e971f3e395cc7860851601ab18c2da18 100644 (file)
--- a/src/java/org/apache/fop/fo/FOTreeBuilder.java
+++ b/src/java/org/apache/fop/fo/FOTreeBuilder.java
@@ -77,7 +77,7 @@ public class FOTreeBuilder extends DefaultHandler {
     private FOUserAgent userAgent;
 
     /** The FOTreeControl object managing the FO Tree that is being built */
-    public FOTreeControl foTreeControl;
+    private FOTreeControl foTreeControl;
 
     /** The SAX locator object maneging the line and column counters */
     private Locator locator; 
@@ -105,6 +105,14 @@ public class FOTreeBuilder extends DefaultHandler {
         return userAgent;
     }
 
+    /**
+     * Sets the FO Tree Control for this object
+     * @param fotc FOTreeControl instance
+     */
+    public void setFOTreeControl(FOTreeControl fotc) {
+        this.foTreeControl = fotc;
+    }
+
     /**
      * Sets the structure handler to receive events.
      * @param foih FOInputHandler instance

diff --git a/src/java/org/apache/fop/fo/FObjMixed.java b/src/java/org/apache/fop/fo/FObjMixed.java
index 19e47f2f5361c6856c7b9caf209352f4c7be57a1..8803992a503988b61135bfab98ac1f698e5c7b0a 100644 (file)
--- a/src/java/org/apache/fop/fo/FObjMixed.java
+++ b/src/java/org/apache/fop/fo/FObjMixed.java
@@ -55,7 +55,7 @@ public class FObjMixed extends FObj {
         ft.setName("text");
         
         /* characters() processing empty for FOTreeHandler, not empty for RTF & MIFHandlers */
-        getFOTreeControl().getFOInputHandler().characters(ft.ca, 0, ft.length);
+        getFOTreeControl().getFOInputHandler().characters(ft.ca, 0, ft.ca.length);
 
         addChild(ft);
     }

diff --git a/src/java/org/apache/fop/layoutmgr/AddLMVisitor.java b/src/java/org/apache/fop/layoutmgr/AddLMVisitor.java
index 04ad2e30698bbdb5fe475c6322cfe6488268474b..852f198c0858ec3faf9faafd0fd3923d5c7615a2 100644 (file)
--- a/src/java/org/apache/fop/layoutmgr/AddLMVisitor.java
+++ b/src/java/org/apache/fop/layoutmgr/AddLMVisitor.java
@@ -180,17 +180,11 @@ public class AddLMVisitor implements FOTreeVisitor {
     }
 
     public void serveFOText(FOText node) {
-        if (node.length == 0) {
-            return;
-        }
-        if (node.length < node.ca.length) {
-            char[] tmp = node.ca;
-            node.ca = new char[node.length];
-            System.arraycopy(tmp, 0, node.ca, 0, node.length);
+        if (node.length > 0) {
+            LayoutManager lm = new TextLayoutManager(node.ca, node.length, node.textInfo);
+            lm.setFObj(node);
+            currentLMList.add(lm);
         }
-        LayoutManager lm = new TextLayoutManager(node.ca, node.textInfo);
-        lm.setFObj(node);
-        currentLMList.add(lm);
     }
 
     public void serveFObjMixed(FObjMixed node) {

diff --git a/src/java/org/apache/fop/layoutmgr/TextLayoutManager.java b/src/java/org/apache/fop/layoutmgr/TextLayoutManager.java
index b679a32681fb4d54f88e8cd558a191a3989dcdfc..08db32806c71e79d2c2ec7d2c7470f74bff28808 100644 (file)
--- a/src/java/org/apache/fop/layoutmgr/TextLayoutManager.java
+++ b/src/java/org/apache/fop/layoutmgr/TextLayoutManager.java
@@ -62,7 +62,8 @@ public class TextLayoutManager extends AbstractLayoutManager {
     /** Non-space characters on which we can end a line. */
     private static final String BREAK_CHARS = "-/" ;
 
-    private char[] chars;
+    private char[] textArray;
+    private int textArrayLength;
     private TextInfo textInfo;
 
     private static final char NEWLINE = '\n';
@@ -93,11 +94,13 @@ public class TextLayoutManager extends AbstractLayoutManager {
     /**
      * Create a Text layout manager.
      *
-     * @param chars the characters
+     * @param chars character array
+     * @param length length of the above array to be processed
      * @param textInfo the text information for doing layout
      */
-    public TextLayoutManager(char[] chars, TextInfo textInfo) {
-        this.chars = chars;
+    public TextLayoutManager(char[] chars, int length, TextInfo textInfo) {
+        this.textArray = chars;
+        this.textArrayLength = length;
         this.textInfo = textInfo;
         this.vecAreaInfo = new java.util.ArrayList();
 
@@ -136,11 +139,11 @@ public class TextLayoutManager extends AbstractLayoutManager {
         // Skip all leading spaces for hyphenation
         int i;
         for (i = ai.iStartIndex;
-                i < ai.iBreakIndex && CharUtilities.isAnySpace(chars[i]) == true;
+                i < ai.iBreakIndex && CharUtilities.isAnySpace(textArray[i]) == true;
                 i++) {
             //nop
         }
-        sbChars.append(new String(chars, i, ai.iBreakIndex - i));
+        sbChars.append(new String(textArray, i, ai.iBreakIndex - i));
     }
 
     /**
@@ -153,11 +156,11 @@ public class TextLayoutManager extends AbstractLayoutManager {
      * @return true if can break before this text
      */
     public boolean canBreakBefore(LayoutContext context) {
-        char c = chars[iNextStart];
+        char c = textArray[iNextStart];
         return ((c == NEWLINE) || (textInfo.bWrap 
                     && (CharUtilities.isBreakableSpace(c)
                     || (BREAK_CHARS.indexOf(c) >= 0 && (iNextStart == 0 
-                        || Character.isLetterOrDigit(chars[iNextStart-1]))))));
+                        || Character.isLetterOrDigit(textArray[iNextStart-1]))))));
     }
 
     /**
@@ -198,14 +201,14 @@ public class TextLayoutManager extends AbstractLayoutManager {
         boolean bCanHyphenate = true;
         int iStopIndex = iNextStart + hc.getNextHyphPoint();
 
-        if (chars.length < iStopIndex || textInfo.bCanHyphenate == false) {
-            iStopIndex = chars.length;
+        if (textArrayLength < iStopIndex || textInfo.bCanHyphenate == false) {
+            iStopIndex = textArrayLength;
             bCanHyphenate = false;
         }
         hc.updateOffset(iStopIndex - iNextStart);
 
         for (; iNextStart < iStopIndex; iNextStart++) {
-            char c = chars[iNextStart];
+            char c = textArray[iNextStart];
             hyphIPD.opt += textInfo.fs.getCharWidth(c);
             // letter-space?
         }
@@ -254,11 +257,11 @@ public class TextLayoutManager extends AbstractLayoutManager {
          * retained.
          */
         if (context.suppressLeadingSpace()) {
-            for (; iNextStart < chars.length
-                    && chars[iNextStart] == SPACE; iNextStart++) {
+            for (; iNextStart < textArrayLength
+                    && textArray[iNextStart] == SPACE; iNextStart++) {
             }
             // If now at end, nothing to compose here!
-            if (iNextStart >= chars.length) {
+            if (iNextStart >= textArrayLength) {
                 setFinished(true);
                 return null; // Or an "empty" BreakPoss?
             }
@@ -279,8 +282,8 @@ public class TextLayoutManager extends AbstractLayoutManager {
         short iWScount = 0; // Count of word spaces
         boolean bSawNonSuppressible = false;
 
-        for (; iNextStart < chars.length; iNextStart++) {
-            char c = chars[iNextStart];
+        for (; iNextStart < textArrayLength; iNextStart++) {
+            char c = textArray[iNextStart];
             if (CharUtilities.isAnySpace(c) == false) {
                 break;
             }
@@ -317,7 +320,7 @@ public class TextLayoutManager extends AbstractLayoutManager {
             }
         }
 
-        if (iNextStart < chars.length) {
+        if (iNextStart < textArrayLength) {
             spaceIPD.add(pendingSpace.resolve(false));
         } else {
             // This FO ended with spaces. Return the BP
@@ -340,13 +343,13 @@ public class TextLayoutManager extends AbstractLayoutManager {
             // Look for a legal line-break: breakable white-space and certain
             // characters such as '-' which can serve as word breaks.
             // Don't look for hyphenation points here though
-            for (; iNextStart < chars.length; iNextStart++) {
-                char c = chars[iNextStart];
+            for (; iNextStart < textArrayLength; iNextStart++) {
+                char c = textArray[iNextStart];
                 // Include any breakable white-space as break char
                 if ((c == NEWLINE) || (textInfo.bWrap 
                     && (CharUtilities.isBreakableSpace(c)
                     || (BREAK_CHARS.indexOf(c) >= 0 && (iNextStart == 0 
-                        || Character.isLetterOrDigit(chars[iNextStart-1])))))) {
+                        || Character.isLetterOrDigit(textArray[iNextStart-1])))))) {
                             iFlags |= BreakPoss.CAN_BREAK_AFTER;
                             if (c != SPACE) {
                                 iNextStart++;
@@ -360,11 +363,11 @@ public class TextLayoutManager extends AbstractLayoutManager {
                     // line-end, set a flag for parent LM.
                     int iLastChar;
                     for (iLastChar = iNextStart;
-                            iLastChar < chars.length
-                            && chars[iLastChar] == SPACE; iLastChar++) {
+                            iLastChar < textArrayLength
+                            && textArray[iLastChar] == SPACE; iLastChar++) {
                         //nop
                     }
-                    if (iLastChar == chars.length) {
+                    if (iLastChar == textArrayLength) {
                         iFlags |= BreakPoss.REST_ARE_SUPPRESS_AT_LB;
                     }
                     return makeBreakPoss(iThisStart, spaceIPD, wordIPD,
@@ -413,7 +416,7 @@ public class TextLayoutManager extends AbstractLayoutManager {
          */
         //bp.setDescender(textInfo.fs.getDescender());
         //bp.setAscender(textInfo.fs.getAscender());
-        if (iNextStart == chars.length) {
+        if (iNextStart == textArrayLength) {
             flags |= BreakPoss.ISLAST;
             setFinished(true);
         }
@@ -486,10 +489,10 @@ public class TextLayoutManager extends AbstractLayoutManager {
         int adjust = 0;
         
         // ignore newline character
-        if (chars[ai.iBreakIndex - 1] == NEWLINE) {
+        if (textArray[ai.iBreakIndex - 1] == NEWLINE) {
             adjust = 1;
         }
-        String str = new String(chars, iStart, ai.iBreakIndex - iStart - adjust);
+        String str = new String(textArray, iStart, ai.iBreakIndex - iStart - adjust);
 
         if (" ".equals(str)) {
             word = new Space();
@@ -504,24 +507,24 @@ public class TextLayoutManager extends AbstractLayoutManager {
             }
             word = t;
         }
-        if ((chars[iStart] == SPACE || chars[iStart] == NBSPACE)
+        if ((textArray[iStart] == SPACE || textArray[iStart] == NBSPACE)
                 && context.getLeadingSpace().hasSpaces()) {
             context.getLeadingSpace().addSpace(halfWS);
         }
         // Set LAST flag if done making characters
         int iLastChar;
         for (iLastChar = ai.iBreakIndex;
-                iLastChar < chars.length && chars[iLastChar] == SPACE;
+                iLastChar < textArrayLength && textArray[iLastChar] == SPACE;
                 iLastChar++) {
             //nop
         }
         context.setFlags(LayoutContext.LAST_AREA,
-                         iLastChar == chars.length);
+                         iLastChar == textArrayLength);
 
         // Can we have any trailing space? Yes, if last char was a space!
         context.setTrailingSpace(new SpaceSpecifier(false));
-        if (chars[ai.iBreakIndex - 1] == SPACE
-                || chars[ai.iBreakIndex - 1] == NBSPACE) {
+        if (textArray[ai.iBreakIndex - 1] == SPACE
+                || textArray[ai.iBreakIndex - 1] == NBSPACE) {
             context.getTrailingSpace().addSpace(halfWS);
         }
         if (word != null) {