First bits of support for fo:inline-container

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

4 files changed, 305 insertions, 162 deletions

diff --git a/src/java/org/apache/fop/fo/flow/InlineContainer.java b/src/java/org/apache/fop/fo/flow/InlineContainer.java
index 748eb593a..d3a80eb3f 100644
--- a/src/java/org/apache/fop/fo/flow/InlineContainer.java
+++ b/src/java/org/apache/fop/fo/flow/InlineContainer.java
@@ -29,6 +29,7 @@ import org.apache.fop.fo.FObj;
 import org.apache.fop.fo.PropertyList;
 import org.apache.fop.fo.ValidationException;
 import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
+import org.apache.fop.fo.properties.CommonFont;
 import org.apache.fop.fo.properties.CommonMarginInline;
 import org.apache.fop.fo.properties.KeepProperty;
 import org.apache.fop.fo.properties.LengthRangeProperty;
@@ -37,78 +38,72 @@ import org.apache.fop.traits.Direction;
 import org.apache.fop.traits.WritingMode;
 import org.apache.fop.traits.WritingModeTraits;
 
-/**
- * Class modelling the <a href="http://www.w3.org/TR/xsl/#fo_inline-container">
- * <code>fo:inline-container</code></a> object.
- */
 public class InlineContainer extends FObj {
 
-    // The value of FO traits (refined properties) that apply to fo:inline-container.
-    private Length alignmentAdjust;
-    private int alignmentBaseline;
-    private Length baselineShift;
+    private LengthRangeProperty inlineProgressionDimension;
     private LengthRangeProperty blockProgressionDimension;
+    private int overflow;
     private CommonBorderPaddingBackground commonBorderPaddingBackground;
     private CommonMarginInline commonMarginInline;
-    private int clip;
-    private int dominantBaseline;
-    private LengthRangeProperty inlineProgressionDimension;
+    private Numeric referenceOrientation;
+    private int displayAlign;
     private KeepProperty keepTogether;
+    private KeepProperty keepWithNext;
+    private KeepProperty keepWithPrevious;
     private SpaceProperty lineHeight;
-    private int overflow;
-    private Numeric referenceOrientation;
+    private Length alignmentAdjust;
+    private int alignmentBaseline;
+    private Length baselineShift;
+    private int dominantBaseline;
     private WritingModeTraits writingModeTraits;
-    // Unused but valid items, commented out for performance:
-    //     private CommonRelativePosition commonRelativePosition;
-    //     private int displayAlign;
-    //     private Length height;
-    //     private KeepProperty keepWithNext;
-    //     private KeepProperty keepWithPrevious;
-    //     private Length width;
-    // End of FO trait values
 
     /** used for FO validation */
-    private boolean blockItemFound = false;
+    private boolean blockItemFound;
+    private CommonFont commonFont;
 
     /**
-     * Base constructor
+     * Creates a new instance.
      *
-     * @param parent {@link FONode} that is the parent of this object
+     * @param parent the parent of this inline-container
      */
     public InlineContainer(FONode parent) {
         super(parent);
     }
 
-    /** {@inheritDoc} */
+    @Override
     public void bind(PropertyList pList) throws FOPException {
         super.bind(pList);
+        commonFont = pList.getFontProps(); // TODO get directly from parent?
         alignmentAdjust = pList.get(PR_ALIGNMENT_ADJUST).getLength();
         alignmentBaseline = pList.get(PR_ALIGNMENT_BASELINE).getEnum();
         baselineShift = pList.get(PR_BASELINE_SHIFT).getLength();
         blockProgressionDimension = pList.get(PR_BLOCK_PROGRESSION_DIMENSION).getLengthRange();
         commonBorderPaddingBackground = pList.getBorderPaddingBackgroundProps();
         commonMarginInline = pList.getMarginInlineProps();
-        clip = pList.get(PR_CLIP).getEnum();
+        displayAlign = pList.get(PR_DISPLAY_ALIGN).getEnum();
         dominantBaseline = pList.get(PR_DOMINANT_BASELINE).getEnum();
         inlineProgressionDimension = pList.get(PR_INLINE_PROGRESSION_DIMENSION).getLengthRange();
         keepTogether = pList.get(PR_KEEP_TOGETHER).getKeep();
+        keepWithNext = pList.get(PR_KEEP_WITH_NEXT).getKeep();
+        keepWithPrevious = pList.get(PR_KEEP_WITH_PREVIOUS).getKeep();
         lineHeight = pList.get(PR_LINE_HEIGHT).getSpace();
         overflow = pList.get(PR_OVERFLOW).getEnum();
         referenceOrientation = pList.get(PR_REFERENCE_ORIENTATION).getNumeric();
         writingModeTraits = new WritingModeTraits(
-            WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
+                WritingMode.valueOf(pList.get(PR_WRITING_MODE).getEnum()));
     }
 
     /**
      * {@inheritDoc}
      * <br>XSL Content Model: marker* (%block;)+
      */
+    @Override
     protected void validateChildNode(Locator loc, String nsURI, String localName)
                 throws ValidationException {
         if (FO_URI.equals(nsURI)) {
             if (localName.equals("marker")) {
                 if (blockItemFound) {
-                   nodesOutOfOrderError(loc, "fo:marker", "(%block;)");
+                   nodesOutOfOrderError(loc, "fo:marker", "(%block;)+");
                 }
             } else if (!isBlockItem(nsURI, localName)) {
                 invalidChildError(loc, nsURI, localName);
@@ -118,142 +113,109 @@ public class InlineContainer extends FObj {
         }
     }
 
-    /** {@inheritDoc} */
+    @Override
     public void endOfNode() throws FOPException {
         if (!blockItemFound) {
             missingChildElementError("marker* (%block;)+");
         }
     }
 
-    /** @return the "alignment-adjust" FO trait */
-    public Length getAlignmentAdjust() {
-        return alignmentAdjust;
+    /** {@inheritDoc} */
+    public String getLocalName() {
+        return "inline-container";
     }
 
-    /** @return the "alignment-baseline" FO trait */
-    public int getAlignmentBaseline() {
-        return alignmentBaseline;
+    /**
+     * {@inheritDoc}
+     * @return {@link org.apache.fop.fo.Constants#FO_INLINE_CONTAINER}
+     */
+    public int getNameId() {
+        return FO_INLINE_CONTAINER;
     }
 
-    /** @return the "baseline-shift" FO trait */
-    public Length getBaselineShift() {
-        return baselineShift;
+    public LengthRangeProperty getInlineProgressionDimension() {
+        return inlineProgressionDimension;
     }
 
-    /** @return the "block-progression-dimension" FO trait */
     public LengthRangeProperty getBlockProgressionDimension() {
         return blockProgressionDimension;
     }
 
-    /** @return the "clip" FO trait */
-    public int getClip() {
-        return clip;
+    public int getOverflow() {
+        return overflow;
     }
 
-    /**@return Returns the {@link CommonBorderPaddingBackground} */
     public CommonBorderPaddingBackground getCommonBorderPaddingBackground() {
         return this.commonBorderPaddingBackground;
     }
 
-    /** @return Returns the {@link CommonMarginInline} */
     public CommonMarginInline getCommonMarginInline() {
         return this.commonMarginInline;
     }
 
-    /** @return the "dominant-baseline" FO trait */
-    public int getDominantBaseline() {
-        return dominantBaseline;
+    public int getReferenceOrientation() {
+        return referenceOrientation.getValue();
     }
 
-    /** @return the "keep-together" FO trait */
-    public KeepProperty getKeepTogether() {
-        return keepTogether;
+    public int getDisplayAlign() {
+        return this.displayAlign;
     }
 
-    /** @return the "inline-progression-dimension" FO trait */
-    public LengthRangeProperty getInlineProgressionDimension() {
-        return inlineProgressionDimension;
+    public KeepProperty getKeepTogether() {
+        return keepTogether;
     }
 
-    /** @return the "line-height" FO trait */
     public SpaceProperty getLineHeight() {
         return lineHeight;
     }
 
-    /** @return the "overflow" FO trait */
-    public int getOverflow() {
-        return overflow;
+    public Length getAlignmentAdjust() {
+        return alignmentAdjust;
     }
 
-    /** @return the "reference-orientation" FO trait */
-    public int getReferenceOrientation() {
-        return referenceOrientation.getValue();
+    public int getAlignmentBaseline() {
+        return alignmentBaseline;
+    }
+
+    public Length getBaselineShift() {
+        return baselineShift;
+    }
+
+    public int getDominantBaseline() {
+        return dominantBaseline;
+    }
+
+    public WritingMode getWritingMode() {
+        return writingModeTraits.getWritingMode();
     }
 
-    /**
-     * Obtain inline progression direction.
-     * @return the inline progression direction
-     */
     public Direction getInlineProgressionDirection() {
         return writingModeTraits.getInlineProgressionDirection();
     }
 
-    /**
-     * Obtain block progression direction.
-     * @return the block progression direction
-     */
     public Direction getBlockProgressionDirection() {
         return writingModeTraits.getBlockProgressionDirection();
     }
 
-    /**
-     * Obtain column progression direction.
-     * @return the column progression direction
-     */
     public Direction getColumnProgressionDirection() {
         return writingModeTraits.getColumnProgressionDirection();
     }
 
-    /**
-     * Obtain row progression direction.
-     * @return the row progression direction
-     */
     public Direction getRowProgressionDirection() {
         return writingModeTraits.getRowProgressionDirection();
     }
 
-    /**
-     * Obtain (baseline) shift direction.
-     * @return the (baseline) shift direction
-     */
     public Direction getShiftDirection() {
         return writingModeTraits.getShiftDirection();
     }
 
-    /**
-     * Obtain writing mode.
-     * @return the writing mode
-     */
-    public WritingMode getWritingMode() {
-        return writingModeTraits.getWritingMode();
-    }
-
-    /** {@inheritDoc} */
-    public String getLocalName() {
-        return "inline-container";
-    }
-
-    /**
-     * {@inheritDoc}
-     * @return {@link org.apache.fop.fo.Constants#FO_INLINE_CONTAINER}
-     */
-    public int getNameId() {
-        return FO_INLINE_CONTAINER;
-    }
-
     @Override
     public boolean isDelimitedTextRangeBoundary(int boundary) {
         return false;
     }
 
+    public CommonFont getCommonFont() {
+        return commonFont;
+    }
+
 }
diff --git a/src/java/org/apache/fop/layoutmgr/LayoutManagerMapping.java b/src/java/org/apache/fop/layoutmgr/LayoutManagerMapping.java
index 292251a84..0e333d219 100644
--- a/src/java/org/apache/fop/layoutmgr/LayoutManagerMapping.java
+++ b/src/java/org/apache/fop/layoutmgr/LayoutManagerMapping.java
@@ -73,7 +73,7 @@ import org.apache.fop.layoutmgr.inline.CharacterLayoutManager;
 import org.apache.fop.layoutmgr.inline.ContentLayoutManager;
 import org.apache.fop.layoutmgr.inline.ExternalGraphicLayoutManager;
 import org.apache.fop.layoutmgr.inline.FootnoteLayoutManager;
-import org.apache.fop.layoutmgr.inline.ICLayoutManager;
+import org.apache.fop.layoutmgr.inline.InlineContainerLayoutManager;
 import org.apache.fop.layoutmgr.inline.InlineLayoutManager;
 import org.apache.fop.layoutmgr.inline.InstreamForeignObjectLM;
 import org.apache.fop.layoutmgr.inline.LeaderLayoutManager;
@@ -257,9 +257,9 @@ public class LayoutManagerMapping implements LayoutManagerMaker {
     /** a layout manager maker */
     public static class InlineLayoutManagerMaker extends Maker {
         /** {@inheritDoc} */
-         public void make(FONode node, List lms) {
-             lms.add(new InlineLayoutManager((InlineLevel) node));
-         }
+        public void make(FONode node, List lms) {
+            lms.add(new InlineLayoutManager((InlineLevel) node));
+        }
     }
 
     /** a layout manager maker */
@@ -274,9 +274,7 @@ public class LayoutManagerMapping implements LayoutManagerMaker {
     public static class InlineContainerLayoutManagerMaker extends Maker {
         /** {@inheritDoc} */
         public void make(FONode node, List lms) {
-            ArrayList childList = new ArrayList();
-            super.make(node, childList);
-            lms.add(new ICLayoutManager((InlineContainer) node, childList));
+            lms.add(new InlineContainerLayoutManager((InlineContainer) node));
         }
     }
 
diff --git a/src/java/org/apache/fop/layoutmgr/inline/ICLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/ICLayoutManager.java
deleted file mode 100644
index 7fe90f63c..000000000
--- a/src/java/org/apache/fop/layoutmgr/inline/ICLayoutManager.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * 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.layoutmgr.inline;
-
-// Java
-import java.util.List;
-
-// FOP
-import org.apache.fop.area.inline.InlineArea;
-import org.apache.fop.fo.flow.InlineContainer;
-/**
- * This creates a single inline container area after
- * laying out the child block areas. All footnotes, floats
- * and id areas are maintained for later retrieval.
- */
-public class ICLayoutManager extends LeafNodeLayoutManager {
-    private List childrenLM;
-
-    /**
-     * Construct inline container layout manager.
-     * @param node inline container FO node
-     * @param childLM child layout manager
-     */
-    public ICLayoutManager(InlineContainer node, List childLM) {
-        super(node);
-        childrenLM = childLM;
-    }
-
-    /**
-     * @param index an integer
-     * @return an inline area or null
-     */
-    public InlineArea get(int index) {
-        return null;
-    }
-
-}
diff --git a/src/java/org/apache/fop/layoutmgr/inline/InlineContainerLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/InlineContainerLayoutManager.java
new file mode 100644
index 000000000..548225ad7
--- /dev/null
+++ b/src/java/org/apache/fop/layoutmgr/inline/InlineContainerLayoutManager.java
@@ -0,0 +1,237 @@
+/*
+ * 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.layoutmgr.inline;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.apache.fop.area.Area;
+import org.apache.fop.area.Block;
+import org.apache.fop.area.Trait;
+import org.apache.fop.area.inline.Container;
+import org.apache.fop.area.inline.InlineViewport;
+import org.apache.fop.fo.flow.InlineContainer;
+import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
+import org.apache.fop.fo.properties.LengthRangeProperty;
+import org.apache.fop.fo.properties.Property;
+import org.apache.fop.fonts.Font;
+import org.apache.fop.fonts.FontInfo;
+import org.apache.fop.fonts.FontTriplet;
+import org.apache.fop.layoutmgr.AbstractLayoutManager;
+import org.apache.fop.layoutmgr.InlineKnuthSequence;
+import org.apache.fop.layoutmgr.KnuthPossPosIter;
+import org.apache.fop.layoutmgr.KnuthSequence;
+import org.apache.fop.layoutmgr.LayoutContext;
+import org.apache.fop.layoutmgr.LayoutManager;
+import org.apache.fop.layoutmgr.ListElement;
+import org.apache.fop.layoutmgr.Position;
+import org.apache.fop.layoutmgr.PositionIterator;
+import org.apache.fop.layoutmgr.SpaceResolver;
+import org.apache.fop.layoutmgr.TraitSetter;
+
+/**
+ * This creates a single inline container area after
+ * laying out the child block areas. All footnotes, floats
+ * and id areas are maintained for later retrieval.
+ */
+public class InlineContainerLayoutManager extends AbstractLayoutManager implements InlineLevelLayoutManager {
+
+    private CommonBorderPaddingBackground borderProps;
+    private int alignmentBaseline = EN_BASELINE;
+    private int contentAreaIPD;
+    private int contentAreaBPD;
+
+    private List<ListElement> childElements;
+    private InlineViewport currentViewport;
+    private Container referenceArea;
+
+    public InlineContainerLayoutManager(InlineContainer node) {
+        super(node);
+    }
+
+    @Override
+    public void initialize() {
+        InlineContainer node = (InlineContainer) fobj;
+        borderProps = node.getCommonBorderPaddingBackground();
+    }
+
+    @Override
+    public List<KnuthSequence> getNextKnuthElements(LayoutContext context, int alignment) {
+        InlineContainer ic = (InlineContainer) fobj;
+        contentAreaIPD = getLength(ic.getInlineProgressionDimension());
+        contentAreaBPD = getLength(ic.getBlockProgressionDimension());
+        LayoutContext childLC = LayoutContext.offspringOf(context); // TODO copyOf?
+        childLC.setRefIPD(contentAreaIPD);
+        childElements = getChildKnuthElements(childLC, alignment); // TODO which alignment?
+        AlignmentContext alignmentContext = makeAlignmentContext(context); // TODO correct?
+        Position position = new Position(this, 0);
+        KnuthSequence knuthSequence = new InlineKnuthSequence();
+        knuthSequence.add(new KnuthInlineBox(contentAreaIPD, alignmentContext, position, false));
+        List<KnuthSequence> knuthElements = new ArrayList<KnuthSequence>(1);
+        knuthElements.add(knuthSequence);
+        setFinished(true);
+        return knuthElements;
+    }
+
+    private int getLength(LengthRangeProperty property) {
+        Property optimum = property.getOptimum(this); // TODO percent base context
+        if (optimum.isAuto()) {
+            throw new UnsupportedOperationException("auto dimension not supported");
+        }
+        return optimum.getLength().getValue(this); // TODO percent base context
+    }
+
+    private List<ListElement> getChildKnuthElements(LayoutContext layoutContext, int alignment) {
+        List<ListElement> allChildElements = new LinkedList<ListElement>();
+        LayoutManager childLM;
+        while ((childLM = getChildLM()) != null) {
+            LayoutContext childLC = LayoutContext.offspringOf(layoutContext); // TODO copyOf? newInstance?
+            childLC.setRefIPD(layoutContext.getRefIPD());
+            @SuppressWarnings("unchecked")
+            List<ListElement> childElements = childLM.getNextKnuthElements(childLC, alignmentBaseline);
+            allChildElements.addAll(childElements);
+            // TODO breaks, keeps, empty content
+        }
+        SpaceResolver.resolveElementList(allChildElements);
+        // TODO break-before, break-after
+        return allChildElements;
+    }
+
+    @Override
+    public void addAreas(PositionIterator posIter, LayoutContext context) {
+        Position inlineContainerPosition = null;
+        while (posIter.hasNext()) {
+            Position pos = posIter.next();
+            if (pos.getLM() == this) {
+                inlineContainerPosition = pos;
+            }
+        }
+        addId();
+//        addMarkersToPage(
+//                true,
+//                true,
+//                lastPos == null || isLast(lastPos));
+
+        if (inlineContainerPosition != null) {
+            LayoutManager childLM;
+            KnuthPossPosIter childPosIter = new KnuthPossPosIter(childElements);
+            while ((childLM = childPosIter.getNextChildLM()) != null) {
+                LayoutContext childLC = LayoutContext.copyOf(context); // TODO correct?
+                childLM.addAreas(childPosIter, childLC);
+            }
+        }
+
+//        addMarkersToPage(
+//                false,
+//                true,
+//                lastPos == null || isLast(lastPos));
+
+//        boolean isLast = (context.isLastArea() && prevLM == lastChildLM);
+//        context.setFlags(LayoutContext.LAST_AREA, isLast);
+    }
+
+    @Override
+    public Area getParentArea(Area childArea) {
+        if (referenceArea == null) {
+            referenceArea = new Container();
+            referenceArea.addTrait(Trait.IS_REFERENCE_AREA, Boolean.TRUE);
+            TraitSetter.setProducerID(referenceArea, fobj.getId());
+            referenceArea.setIPD(contentAreaIPD);
+            currentViewport = new InlineViewport(referenceArea);
+            currentViewport.addTrait(Trait.IS_VIEWPORT_AREA, Boolean.TRUE);
+            currentViewport.setIPD(getContentAreaIPD());
+            currentViewport.setBPD(getContentAreaBPD());
+            TraitSetter.setProducerID(currentViewport, fobj.getId());
+            TraitSetter.addBorders(currentViewport,
+                    borderProps,
+                    false, false, false, false, this);
+            TraitSetter.addPadding(currentViewport,
+                    borderProps,
+                    false, false, false, false, this);
+            TraitSetter.addBackground(currentViewport,
+                    borderProps,
+                    this);
+            currentViewport.setClip(needClip());
+            currentViewport.setContentPosition(
+                    new java.awt.geom.Rectangle2D.Float(0, 0, getContentAreaIPD(), getContentAreaBPD()));
+            getParent().addChildArea(currentViewport);
+        }
+        return referenceArea;
+    }
+
+    @Override
+    public int getContentAreaIPD() {
+        return contentAreaIPD;
+    }
+
+    @Override
+    public int getContentAreaBPD() {
+        return contentAreaBPD;
+    }
+
+    @Override
+    public void addChildArea(Area childArea) {
+        referenceArea.addBlock((Block) childArea);
+    }
+
+    private boolean needClip() {
+        int overflow = ((InlineContainer) fobj).getOverflow();
+        return (overflow == EN_HIDDEN || overflow == EN_ERROR_IF_OVERFLOW);
+    }
+
+    protected AlignmentContext makeAlignmentContext(LayoutContext context) {
+        InlineContainer ic = (InlineContainer) fobj;
+        FontInfo fi = fobj.getFOEventHandler().getFontInfo();
+        FontTriplet[] fontkeys = ic.getCommonFont().getFontState(fi);
+        Font fs = fi.getFontInstance(fontkeys[0], ic.getCommonFont().fontSize.getValue(this));
+        return new AlignmentContext(fs, ic.getLineHeight().getOptimum(this).getLength().getValue(this), // TODO
+                context.getWritingMode());
+    }
+
+    public List addALetterSpaceTo(List oldList) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public List addALetterSpaceTo(List oldList, int depth) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public String getWordChars(Position pos) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public void hyphenate(Position pos, HyphContext hyphContext) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public boolean applyChanges(List oldList) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public boolean applyChanges(List oldList, int depth) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public List getChangedKnuthElements(List oldList, int alignment, int depth) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+}