/*

 * 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.LinkedList;

import java.util.List;

import java.util.ListIterator;

import org.apache.fop.area.Area;

import org.apache.fop.area.Block;

import org.apache.fop.area.Trait;

import org.apache.fop.area.inline.InlineArea;

import org.apache.fop.area.inline.InlineBlockParent;

import org.apache.fop.area.inline.Viewport;

import org.apache.fop.datatypes.FODimension;

import org.apache.fop.datatypes.Length;

import org.apache.fop.fo.flow.InlineContainer;

import org.apache.fop.fo.properties.CommonBorderPaddingBackground;

import org.apache.fop.fo.properties.SpaceProperty;

import org.apache.fop.layoutmgr.AbstractContainerBreaker;

import org.apache.fop.layoutmgr.AreaAdditionUtil;

import org.apache.fop.layoutmgr.BlockStackingLayoutManager;

import org.apache.fop.layoutmgr.InlineKnuthSequence;

import org.apache.fop.layoutmgr.KnuthElement;

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.NonLeafPosition;

import org.apache.fop.layoutmgr.Position;

import org.apache.fop.layoutmgr.PositionIterator;

import org.apache.fop.layoutmgr.SpaceResolver;

import org.apache.fop.layoutmgr.SubBreakerPosition;

import org.apache.fop.layoutmgr.TraitSetter;

import org.apache.fop.traits.MinOptMax;

/**

 * 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 LeafNodeLayoutManager {

    Viewport currentViewport;

    InlineArea referenceArea;

    Block baseBlockArea;

    /** The Common Border, Padding and Background properties */

    private CommonBorderPaddingBackground borderProps = null;

    /** The alignment adjust property */

    private Length alignmentAdjust;

    /** The alignment baseline property */

    private int alignmentBaseline = EN_BASELINE;

    /** The baseline shift property */

    private Length baselineShift;

    /** The dominant baseline property */

    private int dominantBaseline;

    /** The line height property */

    private SpaceProperty lineHeight;

    private Length height;

    private Length width;

    private boolean autoHeight;

    private boolean autoWidth;

    private int contentAreaIPD;

    private int viewportContentBPD;

    private int referenceIPD;

    private FODimension relDims;

    private LayoutManager lastChildLM = null;

    /**

     * Construct a new InlineContainerLayoutManager

     * for the the given {@link InlineContainer}

     *

     * @param node  the base {@link InlineContainer}

     */

    public InlineContainerLayoutManager(InlineContainer node) {

        super(node);

    }

    /** {@inheritDoc} */

    @Override

    public void initialize() {

        InlineContainer node = (InlineContainer) fobj;

        borderProps = node.getCommonBorderPaddingBackground();

        alignmentAdjust = node.getAlignmentAdjust();

        alignmentBaseline = node.getAlignmentBaseline();

        baselineShift = node.getBaselineShift();

        dominantBaseline = node.getDominantBaseline();

        boolean rotated = (node.getReferenceOrientation() % 180 != 0);

        if (rotated) {

            height = node.getInlineProgressionDimension()

                            .getOptimum(this).getLength();

            width = node.getBlockProgressionDimension()

                            .getOptimum(this).getLength();

        } else {

            height = node.getBlockProgressionDimension()

                            .getOptimum(this).getLength();

            width = node.getInlineProgressionDimension()

                            .getOptimum(this).getLength();

        }

    }

    /**

     * Sets the IPD of the content area

     * @param contentAreaIPD the IPD of the content area

     */

    protected void setContentAreaIPD(int contentAreaIPD) {

        this.contentAreaIPD = contentAreaIPD;

    }

    /** {@inheritDoc} */

    @Override

    public List getNextKnuthElements(LayoutContext context, int alignment) {

        InlineContainer ic = (InlineContainer) fobj;

        boolean rotated = (ic.getReferenceOrientation() % 180 != 0);

        autoHeight = false;

        int maxbpd = context.getStackLimitBP().getOpt();

        referenceIPD = context.getRefIPD();

        int allocBPD;

        if (height.getEnum() == EN_AUTO

                || (!height.isAbsolute() && getAncestorBlockAreaBPD() <= 0)) {

            //auto height when height="auto" or "if that dimension is not specified explicitly

            //(i.e., it depends on content's block-progression-dimension)" (XSL 1.0, 7.14.1)

            allocBPD = 0;

            autoHeight = true;

        } else {

            allocBPD = height.getValue(this); //this is the content-height

            allocBPD += borderProps.getBPPaddingAndBorder(false, this);

        }

        if (width.getEnum() == EN_AUTO) {

            setContentAreaIPD(referenceIPD);

            autoWidth = true;

        }

        viewportContentBPD = allocBPD - borderProps.getBPPaddingAndBorder(false, this);

        //double contentRectOffsetX = 0;

        //contentRectOffsetX += ic.getCommonMarginInline().spaceStart.getLength().getValue(this);

        //double contentRectOffsetY = 0;

        //contentRectOffsetY += borderProps.getBorderBeforeWidth(false);

        //contentRectOffsetY += borderProps.getPaddingBefore(false, this);

        updateRelDims();

        LinkedList<KnuthSequence> returnList = new LinkedList<KnuthSequence>();

        KnuthSequence inlineSeq = new InlineKnuthSequence();

        addKnuthElementsForBorderPaddingStart(inlineSeq);

        MinOptMax refIPD = MinOptMax.getInstance(autoWidth ? referenceIPD : width.getValue(this));

        InlineContainerBreaker breaker = new InlineContainerBreaker(this, refIPD);

        breaker.doLayout(height.getValue(this), autoHeight);

        if (!breaker.isEmpty()) {

            if (autoHeight) {

                //Update content BPD now that it is known

                int newHeight = breaker.getTotalWidth();

                if (rotated) {

                    setContentAreaIPD(newHeight);

                } else {

                    viewportContentBPD = newHeight;

                }

                updateRelDims();

            }

            Position icPosition = new SubBreakerPosition(this, breaker);

            inlineSeq.add(

                    new KnuthInlineBox(

                        refIPD.getOpt(),

                        makeAlignmentContext(context),

                        notifyPos(icPosition),

                        false));

        }

        addKnuthElementsForBorderPaddingEnd(inlineSeq);

        returnList.add(inlineSeq);

        setFinished(true);

        return returnList;

    }

    /** {@inheritDoc} */

    @Override

    public void addChildArea(Area childArea) {

        baseBlockArea.addBlock((Block) childArea);

    }

    /** {@inheritDoc} */

    @Override

    public void addAreas(PositionIterator posIter, LayoutContext context) {

        LinkedList<Position> positionList = new LinkedList<Position>();

        Position pos;

        LayoutManager lastLM = null; // last child LM in this iterator

        Position lastPos = null;

        SubBreakerPosition icPos = null;

        while (posIter.hasNext()) {

            pos = posIter.next();

            Position innerPosition = pos;

            if (pos instanceof NonLeafPosition) {

                innerPosition = pos.getPosition();

            }

            if (pos instanceof SubBreakerPosition) {

                if (icPos != null) {

                    throw new IllegalStateException("Only one SubBreakerPosition allowed");

                }

                icPos = (SubBreakerPosition) pos;

            } else if (innerPosition == null) {

                //ignore (probably a Position for a simple penalty between blocks)

            } else {

                // innerPosition was created by another LM

                positionList.add(innerPosition);

                lastLM = innerPosition.getLM();

                lastPos = innerPosition;

            }

        }

        addId();

        addMarkersToPage(

                true,

                true,

                lastPos == null || isLast(lastPos));

        LayoutManager prevLM = null;

        if (icPos == null) {

            PositionIterator childPosIter

                = new PositionIterator(positionList.listIterator());

            LayoutManager childLM;

            while ((childLM = childPosIter.getNextChildLM()) != null) {

                context.setFlags(LayoutContext.LAST_AREA,

                                      context.isLastArea() && childLM == lastLM);

                childLM.addAreas(childPosIter, context);

                context.setLeadingSpace(context.getTrailingSpace());

                context.setFlags(LayoutContext.RESOLVE_LEADING_SPACE, true);

                prevLM = childLM;

            }

            currentViewport.setContent(referenceArea);

            getParent().addChildArea(currentViewport);

        } else {

            ((AbstractContainerBreaker)icPos.getBreaker()).addContainedAreas();

        }

        addMarkersToPage(

                false,

                true,

                lastPos == null || isLast(lastPos));

        boolean isLast = (context.isLastArea() && prevLM == lastChildLM);

        context.setFlags(LayoutContext.LAST_AREA, isLast);

    }

    /** {@inheritDoc} */

    @Override

    public int getContentAreaIPD() {

        return width.getEnum() == EN_AUTO

                ? contentAreaIPD

                    : width.getValue(this);

    }

    /** {@inheritDoc} */

    @Override

    public int getContentAreaBPD() {

        return height.getEnum() == EN_AUTO

                ? viewportContentBPD

                    : height.getValue(this);

    }

    /**

     * Get the parent area for children of this inline-container.

     * This returns the current inline-container area

     * and creates it if required.

     *

     * {@inheritDoc}

     */

    @Override

    public Area getParentArea(Area childArea) {

        if (referenceArea == null) {

            currentViewport = new Viewport(childArea);

            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.setCTM(relativeCTM);

            currentViewport.setClip(needClip());

            currentViewport.setContentPosition(

                    new java.awt.geom.Rectangle2D.Float(0, 0, getContentAreaIPD(), getContentAreaBPD()));

            referenceArea = new InlineBlockParent();

            referenceArea.addTrait(Trait.IS_REFERENCE_AREA, Boolean.TRUE);

            TraitSetter.setProducerID(referenceArea, fobj.getId());

            // Set up dimensions

            // Must get dimensions from parent area

            getParent().getParentArea(referenceArea);

            referenceArea.setIPD(referenceIPD);

            baseBlockArea = new Block();

            referenceArea.addChildArea(baseBlockArea);

            // Get reference IPD from parentArea

            setCurrentArea(currentViewport); // ??? for generic operations

        }

        return referenceArea;

    }

    private boolean needClip() {

        int overflow = ((InlineContainer) fobj).getOverflow();

        return (overflow == EN_HIDDEN || overflow == EN_ERROR_IF_OVERFLOW);

    }

    /** {@inheritDoc} */

    @Override

    protected AlignmentContext makeAlignmentContext(LayoutContext context) {

        return new AlignmentContext(

                viewportContentBPD

                , alignmentAdjust

                , alignmentBaseline

                , baselineShift

                , dominantBaseline

                , context.getAlignmentContext()

            );

    }

    /**

     * Get the allocation ipd of the inline area.

     * This method may be overridden to handle percentage values.

     * @param refIPD the ipd of the parent reference area

     * @return the min/opt/max ipd of the inline area

     */

    @Override

    protected MinOptMax getAllocationIPD(int refIPD) {

        return MinOptMax.getInstance(curArea.getIPD());

    }

    /**

     * "wrap" the Position inside each element moving the elements from

     * SourceList to targetList

     * @param sourceList source list

     * @param targetList target list receiving the wrapped position elements

     */

    private void wrapPositionElements(List sourceList, List targetList) {

        wrapPositionElements(sourceList, targetList, false);

    }

    /**

     * "wrap" the Position inside each element moving the elements from

     * SourceList to targetList

     * @param sourceList source list

     * @param targetList target list receiving the wrapped position elements

     * @param force if true, every Position is wrapped regardless of its LM of origin

     */

    private void wrapPositionElements(List sourceList, List targetList, boolean force) {

        ListIterator listIter = sourceList.listIterator();

        Object tempElement;

        while (listIter.hasNext()) {

            tempElement = listIter.next();

            if (tempElement instanceof ListElement) {

                wrapPositionElement(

                        (ListElement) tempElement,

                        targetList,

                        force);

            } else if (tempElement instanceof List) {

                wrapPositionElements(

                        (List) tempElement,

                        targetList,

                        force);

            }

        }

    }

    /**

     * "wrap" the Position inside the given element and add it to the target list.

     * @param el the list element

     * @param targetList target list receiving the wrapped position elements

     * @param force if true, every Position is wrapped regardless of its LM of origin

     */

    private void wrapPositionElement(ListElement el, List targetList, boolean force) {

        if (force || el.getLayoutManager() != this) {

            el.setPosition(notifyPos(new NonLeafPosition(this,

                    el.getPosition())));

        }

        targetList.add(el);

    }

    private void updateRelDims() {

        relDims = new FODimension(0, 0);

        /*

        CTM relativeCTM = CTM.getCTMandRelDims(

                ((InlineContainer) fobj).getReferenceOrientation(),

                ((InlineContainer) fobj).getWritingMode(),

                rect, relDims);

         */

    }

    private class InlineContainerBreaker extends AbstractContainerBreaker {

        InlineContainerBreaker(InlineContainerLayoutManager iclm, MinOptMax ipd) {

            super(iclm, ipd);

        }

        /** {@inheritDoc} */

        @Override

        public boolean isOverflow() {

            return !isEmpty()

                    && (deferredAlg.getPageBreaks().size() > 1);

                        //|| (deferredAlg.getOverflowAmount() > 0));

        }

        /** {@inheritDoc} */

        @Override

        public int getOverflowAmount() {

            return 0; //deferredAlg.getOverflowAmount();

        }

        /** {@inheritDoc}Ê*/

        @Override

        protected LayoutContext createLayoutContext() {

            LayoutContext lc = super.createLayoutContext();

            lc.setWritingMode(((InlineContainer) fobj).getWritingMode());

            return lc;

        }

        /** {@inheritDoc} */

        protected List<KnuthElement> getNextKnuthElements(LayoutContext context, int alignment) {

            LayoutManager curLM; // currently active LM

            List<KnuthElement> returnList = new LinkedList<KnuthElement>();

            while ((curLM = getChildLM()) != null) {

                LayoutContext childLC = new LayoutContext(0);

                childLC.setStackLimitBP(context.getStackLimitBP());

                childLC.setRefIPD(context.getRefIPD());

                childLC.setWritingMode(((InlineContainer)fobj).getWritingMode());

                List<ListElement> returnedList = null;

                if (!curLM.isFinished()) {

                    returnedList = curLM.getNextKnuthElements(childLC, alignment);

                }

                if (returnedList != null) {

                    wrapPositionElements(returnedList, returnList);

                }

            }

            SpaceResolver.resolveElementList(returnList);

            setFinished(true);

            return returnList;

        }

        /** {@inheritDoc} */

        @Override

        protected void addAreas(PositionIterator posIter, LayoutContext context) {

            getTopLevelLM().addAreas(posIter, context);

        }

        /** {@inheritDoc}Ê*/

        @Override

        protected int getCurrentDisplayAlign() {

            return ((InlineContainer)fobj).getDisplayAlign();

        }

    }

}

/*

 * 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;

import org.apache.fop.fo.Constants;

import org.apache.fop.traits.MinOptMax;

import java.util.List;

public abstract class AbstractContainerBreaker extends AbstractBreaker {

    private AbstractLayoutManager layoutManager;

    private MinOptMax ipd;

    //Info for deferred adding of areas

    protected PageBreakingAlgorithm deferredAlg;

    private BlockSequence deferredOriginalList;

    private BlockSequence deferredEffectiveList;

    /**

     * Create a new instance for the given layout manager, and

     * set the available inline-progression-dimension to the given value

     * @param layoutManager the layout manager

     * @param ipd   the inline-progression-dimension

     */

    public AbstractContainerBreaker(AbstractLayoutManager layoutManager, MinOptMax ipd) {

        this.layoutManager = layoutManager;

        this.ipd = ipd;

    }

    /** {@inheritDoc} */

    @Override

    protected void observeElementList(List elementList) {

        ElementListObserver.observe(elementList,

                layoutManager.getFObj().getLocalName(),

                layoutManager.getFObj().getId());

    }

    /** {@inheritDoc} */

    @Override

    protected boolean isPartOverflowRecoveryActivated() {

        //disabled by default because of wanted overflow.

        return false;

    }

    /** {@inheritDoc} */

    @Override

    protected boolean isSinglePartFavored() {

        return true;

    }

    /** {@inheritDoc} */

    @Override

    protected LayoutManager getTopLevelLM() {

        return layoutManager;

    }

    /** {@inheritDoc} */

    @Override

    protected LayoutContext createLayoutContext() {

        LayoutContext lc = super.createLayoutContext();

        lc.setRefIPD(ipd.getOpt());

        return lc;

    }

    /** {@inheritDoc} */

    @Override

    protected List<KnuthElement> getNextKnuthElements(LayoutContext context, int alignment) {

        /*

        LayoutManager curLM; // currently active LM

        List<KnuthElement> returnList = new LinkedList<KnuthElement>();

        while ((curLM = getChildLM()) != null) {

            LayoutContext childLC = makeChildLayoutContext(context);

            List<ListElement> returnedList = null;

            if (!curLM.isFinished()) {

                returnedList = curLM.getNextKnuthElements(childLC, alignment);

            }

            if (returnedList != null) {

                wrapPositionElements(returnedList, returnList);

            }

        }

        SpaceResolver.resolveElementList(returnList);

        layoutManager.setFinished(true);

        return returnList;

        */

        return null;

    }

    /** {@inheritDoc} */

    @Override

    protected boolean hasMoreContent() {

        return !layoutManager.isFinished();

    }

    /** {@inheritDoc} */

    @Override

    protected void doPhase3(PageBreakingAlgorithm alg, int partCount,

            AbstractBreaker.BlockSequence originalList, AbstractBreaker.BlockSequence effectiveList) {

        //Defer adding of areas until addAreas is called by the parent LM

        this.deferredAlg = alg;

        this.deferredOriginalList = originalList;

        this.deferredEffectiveList = effectiveList;

    }

    /** {@inheritDoc} */

    @Override

    protected void finishPart(PageBreakingAlgorithm alg, AbstractBreaker.PageBreakPosition pbp) {

        //nop

    }

    /** {@inheritDoc} */

    @Override

    protected LayoutManager getCurrentChildLM() {

        return layoutManager.curChildLM;

    }

    /**

     * Adds contained areas

     */

    public void addContainedAreas() {

        if (isEmpty()) {

            return;

        }

        //Rendering all parts (not just the first) at once for the case where the parts that

        //overflow should be visible.

        this.deferredAlg.removeAllPageBreaks();

        this.addAreas(this.deferredAlg,

                      this.deferredAlg.getPageBreaks().size(),

                      this.deferredOriginalList, this.deferredEffectiveList);

    }

    public boolean isOverflow() {

        return !isEmpty()

                && ((deferredAlg.getPageBreaks().size() > 1)

                    || (deferredAlg.totalWidth - deferredAlg.totalShrink)

                        > deferredAlg.getLineWidth());

    }

    public int getOverflowAmount() {

        return (deferredAlg.totalWidth - deferredAlg.totalShrink)

            - deferredAlg.getLineWidth();

    }

    public int getTotalWidth() {

        return deferredAlg.totalWidth;

    }

}

/*

 * 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;

/**

 * Special type of {@link Position}, meant for use with sub-breakers.

 */

public class SubBreakerPosition extends NonLeafPosition {

    private AbstractBreaker breaker;

    /**

     * Create a new instance for the given layout manager and breaker

     * @param lm        the layout manager

     * @param breaker   the associated breaker

     */

    public SubBreakerPosition(LayoutManager lm, AbstractBreaker breaker) {

        super(lm, null);

        this.breaker = breaker;

    }

    /**

     * Return the breaker

     * @return  the breaker

     */

    public AbstractBreaker getBreaker() {

        return this.breaker;

    }

}

    private int displayAlign;

        displayAlign = pList.get(PR_DISPLAY_ALIGN).getEnum();

    /** @return the value of the <code>display-align</code> property */

    public int getDisplayAlign() {

        return this.displayAlign;

    }