FOP-3164: basic-link not navigating to corresponding footnote by João André Gonçalves

10 files changed, 166 insertions, 2 deletions

diff --git a/fop-core/src/main/java/org/apache/fop/area/Area.java b/fop-core/src/main/java/org/apache/fop/area/Area.java
index 87f645dd2..aab0828fb 100644
--- a/fop-core/src/main/java/org/apache/fop/area/Area.java
+++ b/fop-core/src/main/java/org/apache/fop/area/Area.java
@@ -135,6 +135,8 @@ public class Area extends AreaTreeObject implements Serializable {
      */
     private List<ChangeBar> changeBarList;
 
+    private boolean fromFootnote;
+
     /**
      * Returns the active change bar list.
      *
@@ -540,4 +542,12 @@ public class Area extends AreaTreeObject implements Serializable {
             ipd = effectiveIPD;
         }
     }
+
+    public boolean isFromFootnote() {
+        return fromFootnote;
+    }
+
+    public void setFromFootnote(boolean fromFootnote) {
+        this.fromFootnote = fromFootnote;
+    }
 }
diff --git a/fop-core/src/main/java/org/apache/fop/area/inline/InlineParent.java b/fop-core/src/main/java/org/apache/fop/area/inline/InlineParent.java
index f69c3da73..477ce0a84 100644
--- a/fop-core/src/main/java/org/apache/fop/area/inline/InlineParent.java
+++ b/fop-core/src/main/java/org/apache/fop/area/inline/InlineParent.java
@@ -71,8 +71,16 @@ public class InlineParent extends InlineArea {
         }
         updateLevel(childArea.getBidiLevel());
         int childOffset = childArea.getVirtualOffset();
-        minChildOffset = Math.min(minChildOffset, childOffset);
-        maxAfterEdge = Math.max(maxAfterEdge, childOffset + childArea.getVirtualBPD());
+
+        // do not offset if the childArea comes from a footnote
+        // or if the parent itself comes from a footnote
+        if (!(childArea.isFromFootnote() || isFromFootnote())) {
+            minChildOffset = Math.min(minChildOffset, childOffset);
+            maxAfterEdge = Math.max(maxAfterEdge, childOffset + childArea.getVirtualBPD());
+        } else {
+            minChildOffset = Math.min(minChildOffset, childArea.getBlockProgressionOffset());
+            maxAfterEdge = minChildOffset + childArea.getVirtualBPD();
+        }
     }
 
     @Override
@@ -148,5 +156,14 @@ public class InlineParent extends InlineArea {
         }
     }
 
+    @Override
+    public void setFromFootnote(boolean fromFootnote) {
+        super.setFromFootnote(fromFootnote);
 
+        // set all the children to avoid offsetting any of them
+        // otherwise we would offset the parent by offsetting the child
+        for (InlineArea area : inlines) {
+            area.setFromFootnote(fromFootnote);
+        }
+    }
 }
diff --git a/fop-core/src/main/java/org/apache/fop/layoutmgr/AbstractBaseLayoutManager.java b/fop-core/src/main/java/org/apache/fop/layoutmgr/AbstractBaseLayoutManager.java
index ca5d1c507..a84a243b0 100644
--- a/fop-core/src/main/java/org/apache/fop/layoutmgr/AbstractBaseLayoutManager.java
+++ b/fop-core/src/main/java/org/apache/fop/layoutmgr/AbstractBaseLayoutManager.java
@@ -51,6 +51,8 @@ public abstract class AbstractBaseLayoutManager
      */
     private static final Log LOG = LogFactory.getLog(AbstractBaseLayoutManager.class);
 
+    private boolean fromFootnote;
+
     /**
      * Abstract base layout manager.
      */
@@ -294,4 +296,12 @@ public abstract class AbstractBaseLayoutManager
     public void recreateChildrenLMs() {
 
     }
+
+    public boolean isFromFootnote() {
+        return fromFootnote || (getParent() != null && getParent().isFromFootnote());
+    }
+
+    public void setFromFootnote(boolean fromFootnote) {
+        this.fromFootnote = fromFootnote;
+    }
 }
diff --git a/fop-core/src/main/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java b/fop-core/src/main/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java
index 78156d37d..e20826ca3 100644
--- a/fop-core/src/main/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java
+++ b/fop-core/src/main/java/org/apache/fop/layoutmgr/FootnoteBodyLayoutManager.java
@@ -85,6 +85,7 @@ public class FootnoteBodyLayoutManager extends BlockStackingLayoutManager {
             lc.setFlags(LayoutContext.LAST_AREA,
                     (layoutContext.isLastArea() && childLM == lastLM));
             // Add the line areas to Area
+            childLM.setFromFootnote(true);
             childLM.addAreas(childPosIter, lc);
         }
     }
@@ -93,6 +94,7 @@ public class FootnoteBodyLayoutManager extends BlockStackingLayoutManager {
     @Override
     public void addChildArea(Area childArea) {
         childArea.setAreaClass(Area.CLASS_FOOTNOTE);
+        childArea.setFromFootnote(true);
         parentLayoutManager.addChildArea(childArea);
     }
 
diff --git a/fop-core/src/main/java/org/apache/fop/layoutmgr/LayoutManager.java b/fop-core/src/main/java/org/apache/fop/layoutmgr/LayoutManager.java
index 8d1e4001c..97449762b 100644
--- a/fop-core/src/main/java/org/apache/fop/layoutmgr/LayoutManager.java
+++ b/fop-core/src/main/java/org/apache/fop/layoutmgr/LayoutManager.java
@@ -271,4 +271,8 @@ public interface LayoutManager extends PercentBaseContext {
      */
     List getNextKnuthElements(LayoutContext context, int alignment, Stack lmStack,
             Position positionAtIPDChange, LayoutManager restartAtLM);
+
+    boolean isFromFootnote();
+
+    void setFromFootnote(boolean fromFootnote);
 }
diff --git a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java
index 50b88b5b9..06e742434 100644
--- a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java
+++ b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java
@@ -155,6 +155,7 @@ public class FootnoteLayoutManager extends InlineStackingLayoutManager {
         PositionIterator childPosIter = new PositionIterator(positionList.listIterator());
         LayoutManager childLM;
         while ((childLM = childPosIter.getNextChildLM()) != null) {
+            childLM.setFromFootnote(true);
             childLM.addAreas(childPosIter, childContext);
             childContext.setLeadingSpace(childContext.getTrailingSpace());
             childContext.setFlags(LayoutContext.RESOLVE_LEADING_SPACE, true);
diff --git a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java
index 85f545e5e..52418d816 100644
--- a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java
+++ b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java
@@ -540,6 +540,7 @@ public class InlineLayoutManager extends InlineStackingLayoutManager {
         // Not sure if lastPos can legally be null or if that masks a different problem.
         // But it seems to fix bug 38053.
         setTraits(areaCreated, lastPos == null || !isLast(lastPos));
+        getCurrentArea().setFromFootnote(isFromFootnote());
         parentLayoutManager.addChildArea(getCurrentArea());
 
         registerMarkers(
diff --git a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java
index 7a8ac8627..a0acd1cd3 100644
--- a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java
+++ b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java
@@ -187,6 +187,8 @@ public abstract class InlineStackingLayoutManager extends AbstractLayoutManager
                 if (level >= 0) {
                     ls.setBidiLevel(level);
                 }
+                ls.setFromFootnote(isFromFootnote());
+
                 parentArea.addChildArea(ls);
             }
         }
diff --git a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java
index f44bd7bc0..e524b87ac 100644
--- a/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java
+++ b/fop-core/src/main/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java
@@ -333,6 +333,7 @@ public class TextLayoutManager extends LeafNodeLayoutManager {
         textArea.setTextLetterSpaceAdjust(letterSpaceDim);
         textArea.setTextWordSpaceAdjust(wordSpaceDim - spaceCharIPD
                 - 2 * textArea.getTextLetterSpaceAdjust());
+        textArea.setFromFootnote(isFromFootnote());
         if (context.getIPDAdjust() != 0) {
             // add information about space width
             textArea.setSpaceDifference(wordSpaceIPD.getOpt() - spaceCharIPD
diff --git a/fop-core/src/test/java/org/apache/fop/area/inline/InlineParentTestCase.java b/fop-core/src/test/java/org/apache/fop/area/inline/InlineParentTestCase.java
new file mode 100644
index 000000000..f14e05be2
--- /dev/null
+++ b/fop-core/src/test/java/org/apache/fop/area/inline/InlineParentTestCase.java
@@ -0,0 +1,116 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+/* $Id$ */
+
+package org.apache.fop.area.inline;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class InlineParentTestCase {
+
+    private static final int BLOCK_PROG_OFFSET = -12;
+
+    private static final int BPD = 25;
+
+    @Test
+    public void testAddChildAreaMixedFromFootnote() {
+        InlineParent parent = new InlineParent();
+        InlineParent firstChild = createChildInlineParent(BLOCK_PROG_OFFSET, BPD, false);
+        InlineParent secondChild = createChildInlineParent(3 * BLOCK_PROG_OFFSET, 3 * BPD, false);
+        InlineParent thirdChild = createChildInlineParent(2 * BLOCK_PROG_OFFSET, 2 * BPD, true);
+        InlineParent forthChild = createChildInlineParent(0, 0, true);
+
+        assertEquals("Default Values must be zero", 0, parent.minChildOffset);
+        assertEquals("Default Values must be zero", 0, parent.getVirtualBPD());
+
+        assertAddChildArea(parent, firstChild, -12, 0);
+        assertAddChildArea(parent, secondChild, -36, 0);
+        assertAddChildArea(parent, thirdChild, -36, -36);
+        assertAddChildArea(parent, forthChild, -36, -36);
+    }
+
+    @Test
+    public void testAddChildAreaNotFromFootnote() {
+        InlineParent parent = new InlineParent();
+        InlineParent firstChild = createChildInlineParent(BLOCK_PROG_OFFSET, BPD, false);
+        InlineParent secondChild = createChildInlineParent(3 * BLOCK_PROG_OFFSET, 3 * BPD, false);
+        InlineParent thirdChild = createChildInlineParent(2 * BLOCK_PROG_OFFSET, 2 * BPD, false);
+        InlineParent forthChild = createChildInlineParent(0, 0, false);
+
+        assertEquals("Default Values must be zero", 0, parent.minChildOffset);
+        assertEquals("Default Values must be zero", 0, parent.getVirtualBPD());
+
+        assertAddChildArea(parent, firstChild, -12, 0);
+        assertAddChildArea(parent, secondChild, -36, 0);
+        assertAddChildArea(parent, thirdChild, -36, 0);
+        assertAddChildArea(parent, forthChild, -36, 0);
+    }
+
+    @Test
+    public void testAddChildAreaFromFootnote() {
+        InlineParent parent = new InlineParent();
+        InlineParent firstChild = createChildInlineParent(BLOCK_PROG_OFFSET, BPD, true);
+        InlineParent secondChild = createChildInlineParent(3 * BLOCK_PROG_OFFSET, 3 * BPD, true);
+        InlineParent thirdChild = createChildInlineParent(2 * BLOCK_PROG_OFFSET, 2 * BPD, true);
+        InlineParent forthChild = createChildInlineParent(0, 0, true);
+
+        assertEquals("Default Values must be zero", 0, parent.minChildOffset);
+        assertEquals("Default Values must be zero", 0, parent.getVirtualBPD());
+
+        assertAddChildArea(parent, firstChild, -12, -12);
+        assertAddChildArea(parent, secondChild, -36, -36);
+        assertAddChildArea(parent, thirdChild, -36, -36);
+        assertAddChildArea(parent, forthChild, -36, -36);
+    }
+
+    private void assertAddChildArea(InlineParent parent, InlineParent child,
+                                    int minChildOffset, int maxAfterEdge) {
+        parent.addChildArea(child);
+
+        // the virtualBPD is the subtraction of the maxAfterEdge with the minChildOffset
+        // by adding the minChildOffset to the virtualBPD we get the maxAfterEdge alone
+        int parentMaxAfterEdge = parent.getVirtualBPD() + parent.minChildOffset;
+
+        if (!child.isFromFootnote()) {
+            assertEquals("Must be set to the min of the current minChildOffset and the "
+                            + "sum of the child's virtualOffset with the current value of the minChildOffset",
+                    minChildOffset, parent.minChildOffset);
+            assertEquals("Must be set to the max of the current maxAfterEdge and the "
+                            + "result of the sum of the child's virtualOffset with child's the virtualBPD",
+                    maxAfterEdge, parentMaxAfterEdge);
+        } else {
+            assertEquals("Must be set to the min of the current minChildOffset and the "
+                            + "sum of the child's blockProgressionOffset with the current value "
+                            + "of the minChildOffset",
+                    minChildOffset, parent.minChildOffset);
+            assertEquals("Must be the result of the sum of the maxAfterEdge "
+                    + "with the child's virtualBPD", maxAfterEdge, parentMaxAfterEdge);
+        }
+    }
+
+    private InlineParent createChildInlineParent(int bpo, int bpd, boolean footnote) {
+        InlineParent child = new InlineParent();
+        child.setBlockProgressionOffset(bpo);
+        child.setBPD(bpd);
+        child.setFromFootnote(footnote);
+
+        return child;
+    }
+}