fop-core/src/main/java/org/apache/fop/layoutmgr/LayoutContext.java - xmlgraphics-fop - Git at Google

 /*
  * 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 java.util.Collections;
 import java.util.List;

 import org.apache.fop.fo.Constants;
 import org.apache.fop.layoutmgr.inline.AlignmentContext;
 import org.apache.fop.layoutmgr.inline.HyphContext;
 import org.apache.fop.traits.MinOptMax;
 import org.apache.fop.traits.WritingMode;


 /**
  * This class is used to pass information to the getNextKnuthElements()
  * method. It is set up by higher level LM and used by lower level LM.
  */
 public final class LayoutContext {

     /** Generated break possibility is first in a new area */
     public static final int NEW_AREA = 0x01;

     /**
      * If this flag is set, it indicates that any break-before values other than "auto" should
      * not cause a mandatory break as this break was already handled by a parent layout manager.
      */
     public static final int SUPPRESS_BREAK_BEFORE = 0x02;

     public static final int FIRST_AREA = 0x04;

     public static final int LAST_AREA = 0x08;

     public static final int RESOLVE_LEADING_SPACE = 0x10;

     private static final int TREAT_AS_ARTIFACT = 0x20;

     private int flags; // Contains some set of flags defined above

     /**
      * Total available stacking dimension for a "galley-level" layout
      * manager in block-progression-direction. It is passed by the
      * parent LM.
      * These LM <b>may</b> wish to pass this information down to lower
      * level LM to allow them to optimize returned break possibilities.
      */
     private MinOptMax stackLimitBP;

     /** to keep track of spanning in multi-column layout */
     private int currentSpan = Constants.NOT_SET;
     private int nextSpan = Constants.NOT_SET;

     /** inline-progression-dimension of nearest ancestor reference area */
     private int refIPD;
     //TODO After the split of stackLimit into stackLimitBP and stackLimitIP there's now some
     //overlap with refIPD. Need to investigate how best to refactor that.

     /** the writing mode established by the nearest ancestor reference area */
     private WritingMode writingMode = WritingMode.LR_TB;

     /** Current pending space-after or space-end from preceding area */
     private SpaceSpecifier trailingSpace;

     /** Current pending space-before or space-start from ancestor areas */
     private SpaceSpecifier leadingSpace;

     /**
      * A list of pending marks (border and padding) on the after edge when a page break occurs.
      * May be null.
      */
     private List pendingAfterMarks;

     /**
      * A list of pending marks (border and padding) on the before edge when a page break occurs.
      * May be null.
      */
     private List pendingBeforeMarks;

     /** Current hyphenation context. May be null. */
     private HyphContext hyphContext;

     /** Alignment in BP direction */
     private int bpAlignment = Constants.EN_START;

     /** Stretch or shrink value when making areas. */
     private double ipdAdjust;

     /** Stretch or shrink value when adding spaces. */
     private double dSpaceAdjust;

     private AlignmentContext alignmentContext;

     /** Amount of space before / start */
     private int spaceBefore;
     /** Amount of space after / end */
     private int spaceAfter;

     /** Amount of space to reserve at the beginning of each line */
     private int lineStartBorderAndPaddingWidth;
     /** Amount of space to reserve at the end of each line */
     private int lineEndBorderAndPaddingWidth;

     private int breakBefore;
     private int breakAfter;

     private Keep pendingKeepWithNext = Keep.KEEP_AUTO;
     private Keep pendingKeepWithPrevious = Keep.KEEP_AUTO;

     private int disableColumnBalancing;

     public static LayoutContext newInstance() {
         return new LayoutContext(0);
     }

     public static LayoutContext copyOf(LayoutContext copy) {
         return new LayoutContext(copy);
     }

     /**
      * Returns a descendant of the given layout context. The new context is the same as
      * what would have been created by {@link #newInstance()}, except for inheritable
      * properties that are passed on by the parent. At the moment, the only inheritable
      * property is the value returned by {@link #treatAsArtifact()}.
      */
     public static LayoutContext offspringOf(LayoutContext parent) {
         LayoutContext offspring = new LayoutContext(0);
         offspring.setTreatAsArtifact(parent.treatAsArtifact());
         return offspring;
     }

     private LayoutContext(LayoutContext parentLC) {
         this.flags = parentLC.flags;
         this.refIPD = parentLC.refIPD;
         this.writingMode = parentLC.writingMode;
         setStackLimitBP(parentLC.getStackLimitBP());
         this.leadingSpace = parentLC.leadingSpace; //???
         this.trailingSpace = parentLC.trailingSpace; //???
         this.hyphContext = parentLC.hyphContext;
         this.bpAlignment = parentLC.bpAlignment;
         this.dSpaceAdjust = parentLC.dSpaceAdjust;
         this.ipdAdjust = parentLC.ipdAdjust;
         this.alignmentContext = parentLC.alignmentContext;
         this.lineStartBorderAndPaddingWidth = parentLC.lineStartBorderAndPaddingWidth;
         this.lineEndBorderAndPaddingWidth = parentLC.lineEndBorderAndPaddingWidth;
         copyPendingMarksFrom(parentLC);
         this.pendingKeepWithNext = parentLC.pendingKeepWithNext;
         this.pendingKeepWithPrevious = parentLC.pendingKeepWithPrevious;
         // Copy other fields as necessary.
         this.disableColumnBalancing = parentLC.disableColumnBalancing;
     }

     private LayoutContext(int flags) {
         this.flags = flags;
         this.refIPD = 0;
         stackLimitBP = MinOptMax.ZERO;
         leadingSpace = null;
         trailingSpace = null;
     }

     /** @param source from which pending marks are copied */
     public void copyPendingMarksFrom(LayoutContext source) {
         if (source.pendingAfterMarks != null) {
             this.pendingAfterMarks = new java.util.ArrayList(source.pendingAfterMarks);
         }
         if (source.pendingBeforeMarks != null) {
             this.pendingBeforeMarks = new java.util.ArrayList(source.pendingBeforeMarks);
         }
     }

     /** @param flags to set */
     public void setFlags(int flags) {
         setFlags(flags, true);
     }

     /**
      * @param flags to set or clear
      * @param bSet true to set, false to clear
      */
     public void setFlags(int flags, boolean bSet) {
         if (bSet) {
             this.flags |= flags;
         } else {
             this.flags &= ~flags;
         }
     }

     /** @param flags to clear */
     public void unsetFlags(int flags) {
         setFlags(flags, false);
     }

     /** @return true if new area is set */
     public boolean isStart() {
         return ((this.flags & NEW_AREA) != 0);
     }

     /** @return true if new area is set and leading space is non-null */
     public boolean startsNewArea() {
         return ((this.flags & NEW_AREA) != 0 && leadingSpace != null);
     }

     /** @return true if first area is set */
     public boolean isFirstArea() {
         return ((this.flags & FIRST_AREA) != 0);
     }

     /** @return true if last area is set */
     public boolean isLastArea() {
         return ((this.flags & LAST_AREA) != 0);
     }

     /** @return true if suppress break before is set */
     public boolean suppressBreakBefore() {
         return ((this.flags & SUPPRESS_BREAK_BEFORE) != 0);
     }

     /**
      * Returns the strength of a keep-with-next currently pending.
      * @return the keep-with-next strength
      */
     public Keep getKeepWithNextPending() {
         return this.pendingKeepWithNext;
     }

     /**
      * Returns the strength of a keep-with-previous currently pending.
      * @return the keep-with-previous strength
      */
     public Keep getKeepWithPreviousPending() {
         return this.pendingKeepWithPrevious;
     }

     /**
      * Clears any pending keep-with-next strength.
      */
     public void clearKeepWithNextPending() {
         this.pendingKeepWithNext = Keep.KEEP_AUTO;
     }

     /**
      * Clears any pending keep-with-previous strength.
      */
     public void clearKeepWithPreviousPending() {
         this.pendingKeepWithPrevious = Keep.KEEP_AUTO;
     }

     /**
      * Clears both keep-with-previous and keep-with-next strengths.
      */
     public void clearKeepsPending() {
         clearKeepWithPreviousPending();
         clearKeepWithNextPending();
     }

     /**
      * Updates the currently pending keep-with-next strength.
      * @param keep the new strength to consider
      */
     public void updateKeepWithNextPending(Keep keep) {
         this.pendingKeepWithNext = this.pendingKeepWithNext.compare(keep);
     }

     /**
      * Updates the currently pending keep-with-previous strength.
      * @param keep the new strength to consider
      */
     public void updateKeepWithPreviousPending(Keep keep) {
         this.pendingKeepWithPrevious = this.pendingKeepWithPrevious.compare(keep);
     }

     /**
      * Indicates whether a keep-with-next constraint is pending.
      * @return true if a keep-with-next constraint is pending
      */
     public boolean isKeepWithNextPending() {
         return !getKeepWithNextPending().isAuto();
     }

     /**
      * Indicates whether a keep-with-previous constraint is pending.
      * @return true if a keep-with-previous constraint is pending
      */
     public boolean isKeepWithPreviousPending() {
         return !getKeepWithPreviousPending().isAuto();
     }

     /** @param space leading space */
     public void setLeadingSpace(SpaceSpecifier space) {
         leadingSpace = space;
     }

     /** @return leading space */
     public SpaceSpecifier getLeadingSpace() {
         return leadingSpace;
     }

     /** @return true if resolve leading space is set */
     public boolean resolveLeadingSpace() {
         return ((this.flags & RESOLVE_LEADING_SPACE) != 0);
     }

     /** @param space trailing space */
     public void setTrailingSpace(SpaceSpecifier space) {
         trailingSpace = space;
     }

     /** @return trailing space */
     public SpaceSpecifier getTrailingSpace() {
         return trailingSpace;
     }

     /**
      * Adds a border or padding element to the pending list which will be used to generate
      * the right element list for break possibilities. Conditionality resolution will be done
      * elsewhere.
      * @param element the border, padding or space element
      */
     public void addPendingAfterMark(UnresolvedListElementWithLength element) {
         if (this.pendingAfterMarks == null) {
             this.pendingAfterMarks = new java.util.ArrayList();
         }
         this.pendingAfterMarks.add(element);
     }

     /**
      * @return the pending border and padding elements at the after edge
      * @see #addPendingAfterMark(UnresolvedListElementWithLength)
      */
     public List getPendingAfterMarks() {
         if (this.pendingAfterMarks != null) {
             return Collections.unmodifiableList(this.pendingAfterMarks);
         } else {
             return null;
         }
     }

     /**
      * Clears all pending marks on the LayoutContext.
      */
     public void clearPendingMarks() {
         this.pendingBeforeMarks = null;
         this.pendingAfterMarks = null;
     }

     /**
      * Adds a border or padding element to the pending list which will be used to generate
      * the right element list for break possibilities. Conditionality resolution will be done
      * elsewhere.
      * @param element the border, padding or space element
      */
     public void addPendingBeforeMark(UnresolvedListElementWithLength element) {
         if (this.pendingBeforeMarks == null) {
             this.pendingBeforeMarks = new java.util.ArrayList();
         }
         this.pendingBeforeMarks.add(element);
     }

     /**
      * @return the pending border and padding elements at the before edge
      * @see #addPendingBeforeMark(UnresolvedListElementWithLength)
      */
     public List getPendingBeforeMarks() {
         if (this.pendingBeforeMarks != null) {
             return Collections.unmodifiableList(this.pendingBeforeMarks);
         } else {
             return null;
         }
     }

     /**
      * Sets the stack limit in block-progression-dimension.
      * @param limit the stack limit
      */
     public void setStackLimitBP(MinOptMax limit) {
         stackLimitBP = limit;
     }

     /**
      * Returns the stack limit in block-progression-dimension.
      * @return the stack limit
      */
     public MinOptMax getStackLimitBP() {
         return stackLimitBP;
     }

     /**
      * Sets the inline-progression-dimension of the nearest ancestor reference area.
      * @param ipd of nearest ancestor reference area
      */
     public void setRefIPD(int ipd) {
         refIPD = ipd;
     }

     /**
      * Returns the inline-progression-dimension of the nearest ancestor reference area.
      *
      * @return the inline-progression-dimension of the nearest ancestor reference area
      */
     public int getRefIPD() {
         return refIPD;
     }

     /** @param hyph a hyphenation context */
     public void setHyphContext(HyphContext hyph) {
         hyphContext = hyph;
     }

     /** @return hyphenation context */
     public HyphContext getHyphContext() {
         return hyphContext;
     }

     /**
      * Sets the currently applicable alignment in BP direction.
      * @param alignment one of EN_START, EN_JUSTIFY etc.
      */
     public void setBPAlignment(int alignment) {
         this.bpAlignment = alignment;
     }

     /** @return the currently applicable alignment in BP direction (EN_START, EN_JUSTIFY...) */
     public int getBPAlignment() {
         return this.bpAlignment;
     }

     /** @param adjust space adjustment */
     public void setSpaceAdjust(double adjust) {
         dSpaceAdjust = adjust;
     }

     /** @return space adjustment */
     public double getSpaceAdjust() {
         return dSpaceAdjust;
     }

     /** @param ipdA ipd adjustment */
     public void setIPDAdjust(double ipdA) {
         ipdAdjust = ipdA;
     }

     /** @return ipd adjustment */
     public double getIPDAdjust() {
         return ipdAdjust;
     }

     /** @param alignmentContext alignment context */
     public void setAlignmentContext(AlignmentContext alignmentContext) {
         this.alignmentContext = alignmentContext;
     }

     /** @return alignment context */
     public AlignmentContext getAlignmentContext() {
         return this.alignmentContext;
     }

     /**
      * Reset alignment context.
      */
     public void resetAlignmentContext() {
         if (this.alignmentContext != null) {
             this.alignmentContext = this.alignmentContext.getParentAlignmentContext();
         }
     }

     /**
      * Get the width to be reserved for border and padding at the start of the line.
      * @return the width to be reserved
      */
     public int getLineStartBorderAndPaddingWidth() {
         return lineStartBorderAndPaddingWidth;
     }

     /**
      * Set the width to be reserved for border and padding at the start of the line.
      * @param lineStartBorderAndPaddingWidth the width to be reserved
      */
     public void setLineStartBorderAndPaddingWidth(int lineStartBorderAndPaddingWidth) {
         this.lineStartBorderAndPaddingWidth = lineStartBorderAndPaddingWidth;
     }

     /**
      * Get the width to be reserved for border and padding at the end of the line.
      * @return the width to be reserved
      */
     public int getLineEndBorderAndPaddingWidth() {
         return lineEndBorderAndPaddingWidth;
     }

     /**
      * Set the width to be reserved for border and padding at the end of the line.
      * @param lineEndBorderAndPaddingWidth the width to be reserved
      */
     public void setLineEndBorderAndPaddingWidth(int lineEndBorderAndPaddingWidth) {
         this.lineEndBorderAndPaddingWidth = lineEndBorderAndPaddingWidth;
     }

     /**
      * @return one of: {@link Constants#NOT_SET}, {@link Constants#EN_NONE}
      *                  {@link Constants#EN_ALL}
      */
     public int getNextSpan() {
         return nextSpan;
     }

     /**
      * @return one of: {@link Constants#NOT_SET}, {@link Constants#EN_NONE}
      *                  {@link Constants#EN_ALL}
      */
     public int getCurrentSpan() {
         return (currentSpan == Constants.NOT_SET)
                 ? Constants.EN_NONE : currentSpan;
     }

     /**
      * Used to signal the PSLM that the element list ends early because of a span change in
      * multi-column layout.
      * @param span the new span value (legal values: NOT_SET, EN_NONE, EN_ALL)
      */
     public void signalSpanChange(int span) {
         switch (span) {
         case Constants.NOT_SET:
         case Constants.EN_NONE:
         case Constants.EN_ALL:
             this.currentSpan = this.nextSpan;
             this.nextSpan = span;
             break;
         default:
             assert false;
             throw new IllegalArgumentException("Illegal value on signalSpanChange() for span: "
                     + span);
         }
     }

     /**
      * Get the writing mode of the relevant reference area.
      * @return the applicable writing mode
      */
     public WritingMode getWritingMode() {
         return writingMode;
     }

     /**
      * Set the writing mode.
      * @param writingMode the writing mode
      */
     public void setWritingMode(WritingMode writingMode) {
         this.writingMode = writingMode;
     }

     /**
      * Get the current amount of space before / start
      * @return the space before / start amount
      */
     public int getSpaceBefore() {
         return spaceBefore;
     }

     /**
      * Set the amount of space before / start
      * @param spaceBefore the amount of space before / start
      */
     public void setSpaceBefore(int spaceBefore) {
         this.spaceBefore = spaceBefore;
     }

     /**
      * Get the current amount of space after / end
      * @return the space after / end amount
      */
     public int getSpaceAfter() {
         return spaceAfter;
     }

     /**
      * Set the amount of space after / end
      * @param spaceAfter the amount of space after / end
      */
     public void setSpaceAfter(int spaceAfter) {
         this.spaceAfter = spaceAfter;
     }

     /**
      * Returns the value of the break before the element whose
      * {@link LayoutManager#getNextKnuthElements(LayoutContext, int)} method has just been
      * called.
      *
      * @return one of {@link Constants#EN_AUTO}, {@link Constants#EN_COLUMN},
      * {@link Constants#EN_PAGE}, {@link Constants#EN_EVEN_PAGE}, or
      * {@link Constants#EN_ODD_PAGE}
      */
     public int getBreakBefore() {
         return breakBefore;
     }

     /**
      * Sets the value of the break before the current element.
      *
      * @param breakBefore the value of the break-before
      * @see #getBreakBefore()
      */
     public void setBreakBefore(int breakBefore) {
         this.breakBefore = breakBefore;
     }

     /**
      * Returns the value of the break after the element whose
      * {@link LayoutManager#getNextKnuthElements(LayoutContext, int)} method has just been
      * called.
      *
      * @return one of {@link Constants#EN_AUTO}, {@link Constants#EN_COLUMN},
      * {@link Constants#EN_PAGE}, {@link Constants#EN_EVEN_PAGE}, or
      * {@link Constants#EN_ODD_PAGE}
      */
     public int getBreakAfter() {
         return breakAfter;
     }


     /**
      * Sets the value of the break after the current element.
      *
      * @param breakAfter the value of the break-after
      * @see #getBreakAfter()
      */
     public void setBreakAfter(int breakAfter) {
         this.breakAfter = breakAfter;
     }

     /** {@inheritDoc} */
     @Override
     public String toString() {
         return "Layout Context:"
                 + "\nStack Limit BPD: \t"
                 + (getStackLimitBP() == null ? "null" : getStackLimitBP().toString())
                 + "\nTrailing Space: \t"
                 + (getTrailingSpace() == null ? "null" : getTrailingSpace().toString())
                 + "\nLeading Space: \t"
                 + (getLeadingSpace() == null ? "null" : getLeadingSpace().toString())
                 + "\nReference IPD: \t" + getRefIPD()
                 + "\nSpace Adjust: \t" + getSpaceAdjust()
                 + "\nIPD Adjust: \t" + getIPDAdjust()
                 + "\nResolve Leading Space: \t" + resolveLeadingSpace()
                 + "\nSuppress Break Before: \t" + suppressBreakBefore()
                 + "\nIs First Area: \t" + isFirstArea()
                 + "\nStarts New Area: \t" + startsNewArea()
                 + "\nIs Last Area: \t" + isLastArea()
                 + "\nKeeps: \t[keep-with-next=" + getKeepWithNextPending()
                 + "][keep-with-previous=" + getKeepWithPreviousPending() + "] pending"
                 + "\nBreaks: \tforced [" + (breakBefore != Constants.EN_AUTO ? "break-before" : "") + "]["
                 + (breakAfter != Constants.EN_AUTO ? "break-after" : "") + "]";
     }

     /**
      * Returns whether the column balancer should be disabled before a spanning block
      *
      * @return one of {@link Constants#EN_TRUE}, {@link Constants#EN_FALSE}
      */
     public int getDisableColumnBalancing() {
         return disableColumnBalancing;
     }

     /**
      * Sets whether the column balancer should be disabled before a spanning block
      *
      * @param disableColumnBalancing the value of the fox:disable-column-balancing property
      * @see #getDisableColumnBalancing()
      */
     public void setDisableColumnBalancing(int disableColumnBalancing) {
         this.disableColumnBalancing = disableColumnBalancing;
     }

     public boolean treatAsArtifact() {
         return (flags & TREAT_AS_ARTIFACT) != 0;
     }

     public void setTreatAsArtifact(boolean treatAsArtifact) {
         setFlags(TREAT_AS_ARTIFACT, treatAsArtifact);
     }
 }
	/*
	* 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 java.util.Collections;
	import java.util.List;

	import org.apache.fop.fo.Constants;
	import org.apache.fop.layoutmgr.inline.AlignmentContext;
	import org.apache.fop.layoutmgr.inline.HyphContext;
	import org.apache.fop.traits.MinOptMax;
	import org.apache.fop.traits.WritingMode;


	/**
	* This class is used to pass information to the getNextKnuthElements()
	* method. It is set up by higher level LM and used by lower level LM.
	*/
	public final class LayoutContext {

	/** Generated break possibility is first in a new area */
	public static final int NEW_AREA = 0x01;

	/**
	* If this flag is set, it indicates that any break-before values other than "auto" should
	* not cause a mandatory break as this break was already handled by a parent layout manager.
	*/
	public static final int SUPPRESS_BREAK_BEFORE = 0x02;

	public static final int FIRST_AREA = 0x04;

	public static final int LAST_AREA = 0x08;

	public static final int RESOLVE_LEADING_SPACE = 0x10;

	private static final int TREAT_AS_ARTIFACT = 0x20;

	private int flags; // Contains some set of flags defined above

	/**
	* Total available stacking dimension for a "galley-level" layout
	* manager in block-progression-direction. It is passed by the
	* parent LM.
	* These LM <b>may</b> wish to pass this information down to lower
	* level LM to allow them to optimize returned break possibilities.
	*/
	private MinOptMax stackLimitBP;

	/** to keep track of spanning in multi-column layout */
	private int currentSpan = Constants.NOT_SET;
	private int nextSpan = Constants.NOT_SET;

	/** inline-progression-dimension of nearest ancestor reference area */
	private int refIPD;
	//TODO After the split of stackLimit into stackLimitBP and stackLimitIP there's now some
	//overlap with refIPD. Need to investigate how best to refactor that.

	/** the writing mode established by the nearest ancestor reference area */
	private WritingMode writingMode = WritingMode.LR_TB;

	/** Current pending space-after or space-end from preceding area */
	private SpaceSpecifier trailingSpace;

	/** Current pending space-before or space-start from ancestor areas */
	private SpaceSpecifier leadingSpace;

	/**
	* A list of pending marks (border and padding) on the after edge when a page break occurs.
	* May be null.
	*/
	private List pendingAfterMarks;

	/**
	* A list of pending marks (border and padding) on the before edge when a page break occurs.
	* May be null.
	*/
	private List pendingBeforeMarks;

	/** Current hyphenation context. May be null. */
	private HyphContext hyphContext;

	/** Alignment in BP direction */
	private int bpAlignment = Constants.EN_START;

	/** Stretch or shrink value when making areas. */
	private double ipdAdjust;

	/** Stretch or shrink value when adding spaces. */
	private double dSpaceAdjust;

	private AlignmentContext alignmentContext;

	/** Amount of space before / start */
	private int spaceBefore;
	/** Amount of space after / end */
	private int spaceAfter;

	/** Amount of space to reserve at the beginning of each line */
	private int lineStartBorderAndPaddingWidth;
	/** Amount of space to reserve at the end of each line */
	private int lineEndBorderAndPaddingWidth;

	private int breakBefore;
	private int breakAfter;

	private Keep pendingKeepWithNext = Keep.KEEP_AUTO;
	private Keep pendingKeepWithPrevious = Keep.KEEP_AUTO;

	private int disableColumnBalancing;

	public static LayoutContext newInstance() {
	return new LayoutContext(0);
	}

	public static LayoutContext copyOf(LayoutContext copy) {
	return new LayoutContext(copy);
	}

	/**
	* Returns a descendant of the given layout context. The new context is the same as
	* what would have been created by {@link #newInstance()}, except for inheritable
	* properties that are passed on by the parent. At the moment, the only inheritable
	* property is the value returned by {@link #treatAsArtifact()}.
	*/
	public static LayoutContext offspringOf(LayoutContext parent) {
	LayoutContext offspring = new LayoutContext(0);
	offspring.setTreatAsArtifact(parent.treatAsArtifact());
	return offspring;
	}

	private LayoutContext(LayoutContext parentLC) {
	this.flags = parentLC.flags;
	this.refIPD = parentLC.refIPD;
	this.writingMode = parentLC.writingMode;
	setStackLimitBP(parentLC.getStackLimitBP());
	this.leadingSpace = parentLC.leadingSpace; //???
	this.trailingSpace = parentLC.trailingSpace; //???
	this.hyphContext = parentLC.hyphContext;
	this.bpAlignment = parentLC.bpAlignment;
	this.dSpaceAdjust = parentLC.dSpaceAdjust;
	this.ipdAdjust = parentLC.ipdAdjust;
	this.alignmentContext = parentLC.alignmentContext;
	this.lineStartBorderAndPaddingWidth = parentLC.lineStartBorderAndPaddingWidth;
	this.lineEndBorderAndPaddingWidth = parentLC.lineEndBorderAndPaddingWidth;
	copyPendingMarksFrom(parentLC);
	this.pendingKeepWithNext = parentLC.pendingKeepWithNext;
	this.pendingKeepWithPrevious = parentLC.pendingKeepWithPrevious;
	// Copy other fields as necessary.
	this.disableColumnBalancing = parentLC.disableColumnBalancing;
	}

	private LayoutContext(int flags) {
	this.flags = flags;
	this.refIPD = 0;
	stackLimitBP = MinOptMax.ZERO;
	leadingSpace = null;
	trailingSpace = null;
	}

	/** @param source from which pending marks are copied */
	public void copyPendingMarksFrom(LayoutContext source) {
	if (source.pendingAfterMarks != null) {
	this.pendingAfterMarks = new java.util.ArrayList(source.pendingAfterMarks);
	}
	if (source.pendingBeforeMarks != null) {
	this.pendingBeforeMarks = new java.util.ArrayList(source.pendingBeforeMarks);
	}
	}

	/** @param flags to set */
	public void setFlags(int flags) {
	setFlags(flags, true);
	}

	/**
	* @param flags to set or clear
	* @param bSet true to set, false to clear
	*/
	public void setFlags(int flags, boolean bSet) {
	if (bSet) {
	this.flags \|= flags;
	} else {
	this.flags &= ~flags;
	}
	}

	/** @param flags to clear */
	public void unsetFlags(int flags) {
	setFlags(flags, false);
	}

	/** @return true if new area is set */
	public boolean isStart() {
	return ((this.flags & NEW_AREA) != 0);
	}

	/** @return true if new area is set and leading space is non-null */
	public boolean startsNewArea() {
	return ((this.flags & NEW_AREA) != 0 && leadingSpace != null);
	}

	/** @return true if first area is set */
	public boolean isFirstArea() {
	return ((this.flags & FIRST_AREA) != 0);
	}

	/** @return true if last area is set */
	public boolean isLastArea() {
	return ((this.flags & LAST_AREA) != 0);
	}

	/** @return true if suppress break before is set */
	public boolean suppressBreakBefore() {
	return ((this.flags & SUPPRESS_BREAK_BEFORE) != 0);
	}

	/**
	* Returns the strength of a keep-with-next currently pending.
	* @return the keep-with-next strength
	*/
	public Keep getKeepWithNextPending() {
	return this.pendingKeepWithNext;
	}

	/**
	* Returns the strength of a keep-with-previous currently pending.
	* @return the keep-with-previous strength
	*/
	public Keep getKeepWithPreviousPending() {
	return this.pendingKeepWithPrevious;
	}

	/**
	* Clears any pending keep-with-next strength.
	*/
	public void clearKeepWithNextPending() {
	this.pendingKeepWithNext = Keep.KEEP_AUTO;
	}

	/**
	* Clears any pending keep-with-previous strength.
	*/
	public void clearKeepWithPreviousPending() {
	this.pendingKeepWithPrevious = Keep.KEEP_AUTO;
	}

	/**
	* Clears both keep-with-previous and keep-with-next strengths.
	*/
	public void clearKeepsPending() {
	clearKeepWithPreviousPending();
	clearKeepWithNextPending();
	}

	/**
	* Updates the currently pending keep-with-next strength.
	* @param keep the new strength to consider
	*/
	public void updateKeepWithNextPending(Keep keep) {
	this.pendingKeepWithNext = this.pendingKeepWithNext.compare(keep);
	}

	/**
	* Updates the currently pending keep-with-previous strength.
	* @param keep the new strength to consider
	*/
	public void updateKeepWithPreviousPending(Keep keep) {
	this.pendingKeepWithPrevious = this.pendingKeepWithPrevious.compare(keep);
	}

	/**
	* Indicates whether a keep-with-next constraint is pending.
	* @return true if a keep-with-next constraint is pending
	*/
	public boolean isKeepWithNextPending() {
	return !getKeepWithNextPending().isAuto();
	}

	/**
	* Indicates whether a keep-with-previous constraint is pending.
	* @return true if a keep-with-previous constraint is pending
	*/
	public boolean isKeepWithPreviousPending() {
	return !getKeepWithPreviousPending().isAuto();
	}

	/** @param space leading space */
	public void setLeadingSpace(SpaceSpecifier space) {
	leadingSpace = space;
	}

	/** @return leading space */
	public SpaceSpecifier getLeadingSpace() {
	return leadingSpace;
	}

	/** @return true if resolve leading space is set */
	public boolean resolveLeadingSpace() {
	return ((this.flags & RESOLVE_LEADING_SPACE) != 0);
	}

	/** @param space trailing space */
	public void setTrailingSpace(SpaceSpecifier space) {
	trailingSpace = space;
	}

	/** @return trailing space */
	public SpaceSpecifier getTrailingSpace() {
	return trailingSpace;
	}

	/**
	* Adds a border or padding element to the pending list which will be used to generate
	* the right element list for break possibilities. Conditionality resolution will be done
	* elsewhere.
	* @param element the border, padding or space element
	*/
	public void addPendingAfterMark(UnresolvedListElementWithLength element) {
	if (this.pendingAfterMarks == null) {
	this.pendingAfterMarks = new java.util.ArrayList();
	}
	this.pendingAfterMarks.add(element);
	}

	/**
	* @return the pending border and padding elements at the after edge
	* @see #addPendingAfterMark(UnresolvedListElementWithLength)
	*/
	public List getPendingAfterMarks() {
	if (this.pendingAfterMarks != null) {
	return Collections.unmodifiableList(this.pendingAfterMarks);
	} else {
	return null;
	}
	}

	/**
	* Clears all pending marks on the LayoutContext.
	*/
	public void clearPendingMarks() {
	this.pendingBeforeMarks = null;
	this.pendingAfterMarks = null;
	}

	/**
	* Adds a border or padding element to the pending list which will be used to generate
	* the right element list for break possibilities. Conditionality resolution will be done
	* elsewhere.
	* @param element the border, padding or space element
	*/
	public void addPendingBeforeMark(UnresolvedListElementWithLength element) {
	if (this.pendingBeforeMarks == null) {
	this.pendingBeforeMarks = new java.util.ArrayList();
	}
	this.pendingBeforeMarks.add(element);
	}

	/**
	* @return the pending border and padding elements at the before edge
	* @see #addPendingBeforeMark(UnresolvedListElementWithLength)
	*/
	public List getPendingBeforeMarks() {
	if (this.pendingBeforeMarks != null) {
	return Collections.unmodifiableList(this.pendingBeforeMarks);
	} else {
	return null;
	}
	}

	/**
	* Sets the stack limit in block-progression-dimension.
	* @param limit the stack limit
	*/
	public void setStackLimitBP(MinOptMax limit) {
	stackLimitBP = limit;
	}

	/**
	* Returns the stack limit in block-progression-dimension.
	* @return the stack limit
	*/
	public MinOptMax getStackLimitBP() {
	return stackLimitBP;
	}

	/**
	* Sets the inline-progression-dimension of the nearest ancestor reference area.
	* @param ipd of nearest ancestor reference area
	*/
	public void setRefIPD(int ipd) {
	refIPD = ipd;
	}

	/**
	* Returns the inline-progression-dimension of the nearest ancestor reference area.
	*
	* @return the inline-progression-dimension of the nearest ancestor reference area
	*/
	public int getRefIPD() {
	return refIPD;
	}

	/** @param hyph a hyphenation context */
	public void setHyphContext(HyphContext hyph) {
	hyphContext = hyph;
	}

	/** @return hyphenation context */
	public HyphContext getHyphContext() {
	return hyphContext;
	}

	/**
	* Sets the currently applicable alignment in BP direction.
	* @param alignment one of EN_START, EN_JUSTIFY etc.
	*/
	public void setBPAlignment(int alignment) {
	this.bpAlignment = alignment;
	}

	/** @return the currently applicable alignment in BP direction (EN_START, EN_JUSTIFY...) */
	public int getBPAlignment() {
	return this.bpAlignment;
	}

	/** @param adjust space adjustment */
	public void setSpaceAdjust(double adjust) {
	dSpaceAdjust = adjust;
	}

	/** @return space adjustment */
	public double getSpaceAdjust() {
	return dSpaceAdjust;
	}

	/** @param ipdA ipd adjustment */
	public void setIPDAdjust(double ipdA) {
	ipdAdjust = ipdA;
	}

	/** @return ipd adjustment */
	public double getIPDAdjust() {
	return ipdAdjust;
	}

	/** @param alignmentContext alignment context */
	public void setAlignmentContext(AlignmentContext alignmentContext) {
	this.alignmentContext = alignmentContext;
	}

	/** @return alignment context */
	public AlignmentContext getAlignmentContext() {
	return this.alignmentContext;
	}

	/**
	* Reset alignment context.
	*/
	public void resetAlignmentContext() {
	if (this.alignmentContext != null) {
	this.alignmentContext = this.alignmentContext.getParentAlignmentContext();
	}
	}

	/**
	* Get the width to be reserved for border and padding at the start of the line.
	* @return the width to be reserved
	*/
	public int getLineStartBorderAndPaddingWidth() {
	return lineStartBorderAndPaddingWidth;
	}

	/**
	* Set the width to be reserved for border and padding at the start of the line.
	* @param lineStartBorderAndPaddingWidth the width to be reserved
	*/
	public void setLineStartBorderAndPaddingWidth(int lineStartBorderAndPaddingWidth) {
	this.lineStartBorderAndPaddingWidth = lineStartBorderAndPaddingWidth;
	}

	/**
	* Get the width to be reserved for border and padding at the end of the line.
	* @return the width to be reserved
	*/
	public int getLineEndBorderAndPaddingWidth() {
	return lineEndBorderAndPaddingWidth;
	}

	/**
	* Set the width to be reserved for border and padding at the end of the line.
	* @param lineEndBorderAndPaddingWidth the width to be reserved
	*/
	public void setLineEndBorderAndPaddingWidth(int lineEndBorderAndPaddingWidth) {
	this.lineEndBorderAndPaddingWidth = lineEndBorderAndPaddingWidth;
	}

	/**
	* @return one of: {@link Constants#NOT_SET}, {@link Constants#EN_NONE}
	* {@link Constants#EN_ALL}
	*/
	public int getNextSpan() {
	return nextSpan;
	}

	/**
	* @return one of: {@link Constants#NOT_SET}, {@link Constants#EN_NONE}
	* {@link Constants#EN_ALL}
	*/
	public int getCurrentSpan() {
	return (currentSpan == Constants.NOT_SET)
	? Constants.EN_NONE : currentSpan;
	}

	/**
	* Used to signal the PSLM that the element list ends early because of a span change in
	* multi-column layout.
	* @param span the new span value (legal values: NOT_SET, EN_NONE, EN_ALL)
	*/
	public void signalSpanChange(int span) {
	switch (span) {
	case Constants.NOT_SET:
	case Constants.EN_NONE:
	case Constants.EN_ALL:
	this.currentSpan = this.nextSpan;
	this.nextSpan = span;
	break;
	default:
	assert false;
	throw new IllegalArgumentException("Illegal value on signalSpanChange() for span: "
	+ span);
	}
	}

	/**
	* Get the writing mode of the relevant reference area.
	* @return the applicable writing mode
	*/
	public WritingMode getWritingMode() {
	return writingMode;
	}

	/**
	* Set the writing mode.
	* @param writingMode the writing mode
	*/
	public void setWritingMode(WritingMode writingMode) {
	this.writingMode = writingMode;
	}

	/**
	* Get the current amount of space before / start
	* @return the space before / start amount
	*/
	public int getSpaceBefore() {
	return spaceBefore;
	}

	/**
	* Set the amount of space before / start
	* @param spaceBefore the amount of space before / start
	*/
	public void setSpaceBefore(int spaceBefore) {
	this.spaceBefore = spaceBefore;
	}

	/**
	* Get the current amount of space after / end
	* @return the space after / end amount
	*/
	public int getSpaceAfter() {
	return spaceAfter;
	}

	/**
	* Set the amount of space after / end
	* @param spaceAfter the amount of space after / end
	*/
	public void setSpaceAfter(int spaceAfter) {
	this.spaceAfter = spaceAfter;
	}

	/**
	* Returns the value of the break before the element whose
	* {@link LayoutManager#getNextKnuthElements(LayoutContext, int)} method has just been
	* called.
	*
	* @return one of {@link Constants#EN_AUTO}, {@link Constants#EN_COLUMN},
	* {@link Constants#EN_PAGE}, {@link Constants#EN_EVEN_PAGE}, or
	* {@link Constants#EN_ODD_PAGE}
	*/
	public int getBreakBefore() {
	return breakBefore;
	}

	/**
	* Sets the value of the break before the current element.
	*
	* @param breakBefore the value of the break-before
	* @see #getBreakBefore()
	*/
	public void setBreakBefore(int breakBefore) {
	this.breakBefore = breakBefore;
	}

	/**
	* Returns the value of the break after the element whose
	* {@link LayoutManager#getNextKnuthElements(LayoutContext, int)} method has just been
	* called.
	*
	* @return one of {@link Constants#EN_AUTO}, {@link Constants#EN_COLUMN},
	* {@link Constants#EN_PAGE}, {@link Constants#EN_EVEN_PAGE}, or
	* {@link Constants#EN_ODD_PAGE}
	*/
	public int getBreakAfter() {
	return breakAfter;
	}


	/**
	* Sets the value of the break after the current element.
	*
	* @param breakAfter the value of the break-after
	* @see #getBreakAfter()
	*/
	public void setBreakAfter(int breakAfter) {
	this.breakAfter = breakAfter;
	}

	/** {@inheritDoc} */
	@Override
	public String toString() {
	return "Layout Context:"
	+ "\nStack Limit BPD: \t"
	+ (getStackLimitBP() == null ? "null" : getStackLimitBP().toString())
	+ "\nTrailing Space: \t"
	+ (getTrailingSpace() == null ? "null" : getTrailingSpace().toString())
	+ "\nLeading Space: \t"
	+ (getLeadingSpace() == null ? "null" : getLeadingSpace().toString())
	+ "\nReference IPD: \t" + getRefIPD()
	+ "\nSpace Adjust: \t" + getSpaceAdjust()
	+ "\nIPD Adjust: \t" + getIPDAdjust()
	+ "\nResolve Leading Space: \t" + resolveLeadingSpace()
	+ "\nSuppress Break Before: \t" + suppressBreakBefore()
	+ "\nIs First Area: \t" + isFirstArea()
	+ "\nStarts New Area: \t" + startsNewArea()
	+ "\nIs Last Area: \t" + isLastArea()
	+ "\nKeeps: \t[keep-with-next=" + getKeepWithNextPending()
	+ "][keep-with-previous=" + getKeepWithPreviousPending() + "] pending"
	+ "\nBreaks: \tforced [" + (breakBefore != Constants.EN_AUTO ? "break-before" : "") + "]["
	+ (breakAfter != Constants.EN_AUTO ? "break-after" : "") + "]";
	}

	/**
	* Returns whether the column balancer should be disabled before a spanning block
	*
	* @return one of {@link Constants#EN_TRUE}, {@link Constants#EN_FALSE}
	*/
	public int getDisableColumnBalancing() {
	return disableColumnBalancing;
	}

	/**
	* Sets whether the column balancer should be disabled before a spanning block
	*
	* @param disableColumnBalancing the value of the fox:disable-column-balancing property
	* @see #getDisableColumnBalancing()
	*/
	public void setDisableColumnBalancing(int disableColumnBalancing) {
	this.disableColumnBalancing = disableColumnBalancing;
	}

	public boolean treatAsArtifact() {
	return (flags & TREAT_AS_ARTIFACT) != 0;
	}

	public void setTreatAsArtifact(boolean treatAsArtifact) {
	setFlags(TREAT_AS_ARTIFACT, treatAsArtifact);
	}
	}