public LayoutContext(LayoutArea area, MarginsCollapseInfo marginsCollapseInfo, IList <Rectangle> floatedRendererAreas
)
: this(area, marginsCollapseInfo)
{
if (floatedRendererAreas != null)
{
this.floatRendererAreas = floatedRendererAreas;
}
}
public LayoutContext(LayoutArea area, MarginsCollapseInfo marginsCollapseInfo, IList <Rectangle> floatedRendererAreas
, bool clippedHeight)
: this(area, marginsCollapseInfo)
{
if (floatedRendererAreas != null)
{
this.floatRendererAreas = floatedRendererAreas;
}
this.clippedHeight = clippedHeight;
}
private static LayoutResult HandleAttemptAsSuccessful(OrphansWidowsLayoutHelper.OrphansWidowsLayoutAttempt
attemptResult, LayoutContext originalContext)
{
originalContext.GetFloatRendererAreas().Clear();
originalContext.GetFloatRendererAreas().AddAll(attemptResult.attemptContext.GetFloatRendererAreas());
if (originalContext.GetMarginsCollapseInfo() != null)
{
MarginsCollapseInfo.UpdateFromCopy(originalContext.GetMarginsCollapseInfo(), attemptResult.attemptContext.
GetMarginsCollapseInfo());
}
return(attemptResult.attemptResult);
}
private static OrphansWidowsLayoutHelper.OrphansWidowsLayoutAttempt AttemptLayout(ParagraphRenderer renderer
, LayoutContext originalContext, LayoutArea attemptArea)
{
OrphansWidowsLayoutHelper.OrphansWidowsLayoutAttempt attemptResult = new OrphansWidowsLayoutHelper.OrphansWidowsLayoutAttempt
();
MarginsCollapseInfo copiedMarginsCollapseInfo = null;
if (originalContext.GetMarginsCollapseInfo() != null)
{
copiedMarginsCollapseInfo = MarginsCollapseInfo.CreateDeepCopy(originalContext.GetMarginsCollapseInfo());
}
List <Rectangle> attemptFloatRectsList = new List <Rectangle>(originalContext.GetFloatRendererAreas());
LayoutContext attemptContext = new LayoutContext(attemptArea, copiedMarginsCollapseInfo, attemptFloatRectsList
, originalContext.IsClippedHeight());
attemptResult.attemptContext = attemptContext;
attemptResult.attemptResult = renderer.DirectLayout(attemptContext);
return(attemptResult);
}
public override void AddChild(IRenderer renderer)
{
LayoutTaggingHelper taggingHelper = this.GetProperty <LayoutTaggingHelper>(Property.TAGGING_HELPER);
if (taggingHelper != null)
{
LayoutTaggingHelper.AddTreeHints(taggingHelper, renderer);
}
// Some positioned renderers might have been fetched from non-positioned child and added to this renderer,
// so we use this generic mechanism of determining which renderers have been just added.
int numberOfChildRenderers = childRenderers.Count;
int numberOfPositionedChildRenderers = positionedRenderers.Count;
base.AddChild(renderer);
IList <IRenderer> addedRenderers = new List <IRenderer>(1);
IList <IRenderer> addedPositionedRenderers = new List <IRenderer>(1);
while (childRenderers.Count > numberOfChildRenderers)
{
addedRenderers.Add(childRenderers[numberOfChildRenderers]);
childRenderers.JRemoveAt(numberOfChildRenderers);
}
while (positionedRenderers.Count > numberOfPositionedChildRenderers)
{
addedPositionedRenderers.Add(positionedRenderers[numberOfPositionedChildRenderers]);
positionedRenderers.JRemoveAt(numberOfPositionedChildRenderers);
}
bool marginsCollapsingEnabled = true.Equals(GetPropertyAsBoolean(Property.COLLAPSING_MARGINS));
if (currentArea == null)
{
UpdateCurrentAndInitialArea(null);
if (marginsCollapsingEnabled)
{
marginsCollapseHandler = new MarginsCollapseHandler(this, null);
}
}
// Static layout
for (int i = 0; currentArea != null && i < addedRenderers.Count; i++)
{
renderer = addedRenderers[i];
bool rendererIsFloat = FloatingHelper.IsRendererFloating(renderer);
bool clearanceOverflowsToNextPage = FloatingHelper.IsClearanceApplied(waitingNextPageRenderers, renderer.GetProperty
<ClearPropertyValue?>(Property.CLEAR));
if (rendererIsFloat && (floatOverflowedCompletely || clearanceOverflowsToNextPage))
{
waitingNextPageRenderers.Add(renderer);
floatOverflowedCompletely = true;
continue;
}
ProcessWaitingKeepWithNextElement(renderer);
IList <IRenderer> resultRenderers = new List <IRenderer>();
LayoutResult result = null;
RootLayoutArea storedArea = null;
RootLayoutArea nextStoredArea = null;
MarginsCollapseInfo childMarginsInfo = null;
if (marginsCollapsingEnabled && currentArea != null && renderer != null)
{
childMarginsInfo = marginsCollapseHandler.StartChildMarginsHandling(renderer, currentArea.GetBBox());
}
while (clearanceOverflowsToNextPage || currentArea != null && renderer != null && (result = renderer.SetParent
(this).Layout(new LayoutContext(currentArea.Clone(), childMarginsInfo, floatRendererAreas))).GetStatus
() != LayoutResult.FULL)
{
bool currentAreaNeedsToBeUpdated = false;
if (clearanceOverflowsToNextPage)
{
result = new LayoutResult(LayoutResult.NOTHING, null, null, renderer);
currentAreaNeedsToBeUpdated = true;
}
if (result.GetStatus() == LayoutResult.PARTIAL)
{
if (rendererIsFloat)
{
waitingNextPageRenderers.Add(result.GetOverflowRenderer());
break;
}
else
{
ProcessRenderer(result.GetSplitRenderer(), resultRenderers);
if (nextStoredArea != null)
{
currentArea = nextStoredArea;
currentPageNumber = nextStoredArea.GetPageNumber();
nextStoredArea = null;
}
else
{
currentAreaNeedsToBeUpdated = true;
}
}
}
else
{
if (result.GetStatus() == LayoutResult.NOTHING && !clearanceOverflowsToNextPage)
{
if (result.GetOverflowRenderer() is ImageRenderer)
{
float imgHeight = ((ImageRenderer)result.GetOverflowRenderer()).GetOccupiedArea().GetBBox().GetHeight();
if (!floatRendererAreas.IsEmpty() || currentArea.GetBBox().GetHeight() < imgHeight && !currentArea.IsEmptyArea
())
{
if (rendererIsFloat)
{
waitingNextPageRenderers.Add(result.GetOverflowRenderer());
floatOverflowedCompletely = true;
break;
}
currentAreaNeedsToBeUpdated = true;
}
else
{
((ImageRenderer)result.GetOverflowRenderer()).AutoScale(currentArea);
result.GetOverflowRenderer().SetProperty(Property.FORCED_PLACEMENT, true);
ILog logger = LogManager.GetLogger(typeof(RootRenderer));
logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.ELEMENT_DOES_NOT_FIT_AREA, ""));
}
}
else
{
if (currentArea.IsEmptyArea() && result.GetAreaBreak() == null)
{
if (true.Equals(result.GetOverflowRenderer().GetModelElement().GetProperty <bool?>(Property.KEEP_TOGETHER))
)
{
result.GetOverflowRenderer().GetModelElement().SetProperty(Property.KEEP_TOGETHER, false);
ILog logger = LogManager.GetLogger(typeof(RootRenderer));
logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.ELEMENT_DOES_NOT_FIT_AREA, "KeepTogether property will be ignored."
));
if (storedArea != null)
{
nextStoredArea = currentArea;
currentArea = storedArea;
currentPageNumber = storedArea.GetPageNumber();
}
storedArea = currentArea;
}
else
{
if (null != result.GetCauseOfNothing() && true.Equals(result.GetCauseOfNothing().GetProperty <bool?>(Property
.KEEP_TOGETHER)))
{
// set KEEP_TOGETHER false on the deepest parent (maybe the element itself) to have KEEP_TOGETHER == true
IRenderer theDeepestKeptTogether = result.GetCauseOfNothing();
IRenderer parent;
while (null == theDeepestKeptTogether.GetModelElement() || null == theDeepestKeptTogether.GetModelElement(
).GetOwnProperty <bool?>(Property.KEEP_TOGETHER))
{
parent = ((AbstractRenderer)theDeepestKeptTogether).parent;
if (parent == null)
{
break;
}
theDeepestKeptTogether = parent;
}
theDeepestKeptTogether.GetModelElement().SetProperty(Property.KEEP_TOGETHER, false);
ILog logger = LogManager.GetLogger(typeof(RootRenderer));
logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.ELEMENT_DOES_NOT_FIT_AREA, "KeepTogether property of inner element will be ignored."
));
}
else
{
if (!true.Equals(renderer.GetProperty <bool?>(Property.FORCED_PLACEMENT)))
{
result.GetOverflowRenderer().SetProperty(Property.FORCED_PLACEMENT, true);
ILog logger = LogManager.GetLogger(typeof(RootRenderer));
logger.Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.ELEMENT_DOES_NOT_FIT_AREA, ""));
}
else
{
// FORCED_PLACEMENT was already set to the renderer and
// LogMessageConstant.ELEMENT_DOES_NOT_FIT_AREA message was logged.
// This else-clause should never be hit, otherwise there is a bug in FORCED_PLACEMENT implementation.
System.Diagnostics.Debug.Assert(false);
// Still handling this case in order to avoid nasty infinite loops.
break;
}
}
}
}
else
{
storedArea = currentArea;
if (nextStoredArea != null)
{
currentArea = nextStoredArea;
currentPageNumber = nextStoredArea.GetPageNumber();
nextStoredArea = null;
}
else
{
if (rendererIsFloat)
{
waitingNextPageRenderers.Add(result.GetOverflowRenderer());
floatOverflowedCompletely = true;
break;
}
currentAreaNeedsToBeUpdated = true;
}
}
}
}
}
renderer = result.GetOverflowRenderer();
if (marginsCollapsingEnabled)
{
marginsCollapseHandler.EndChildMarginsHandling(currentArea.GetBBox());
}
if (currentAreaNeedsToBeUpdated)
{
UpdateCurrentAndInitialArea(result);
}
if (marginsCollapsingEnabled)
{
marginsCollapseHandler = new MarginsCollapseHandler(this, null);
childMarginsInfo = marginsCollapseHandler.StartChildMarginsHandling(renderer, currentArea.GetBBox());
}
clearanceOverflowsToNextPage = clearanceOverflowsToNextPage && FloatingHelper.IsClearanceApplied(waitingNextPageRenderers
, renderer.GetProperty <ClearPropertyValue?>(Property.CLEAR));
}
if (marginsCollapsingEnabled)
{
marginsCollapseHandler.EndChildMarginsHandling(currentArea.GetBBox());
}
if (null != result && null != result.GetSplitRenderer())
{
renderer = result.GetSplitRenderer();
}
// Keep renderer until next element is added for future keep with next adjustments
if (renderer != null && result != null)
{
if (true.Equals(renderer.GetProperty <bool?>(Property.KEEP_WITH_NEXT)))
{
if (true.Equals(renderer.GetProperty <bool?>(Property.FORCED_PLACEMENT)))
{
ILog logger = LogManager.GetLogger(typeof(RootRenderer));
logger.Warn(iText.IO.LogMessageConstant.ELEMENT_WAS_FORCE_PLACED_KEEP_WITH_NEXT_WILL_BE_IGNORED);
ShrinkCurrentAreaAndProcessRenderer(renderer, resultRenderers, result);
}
else
{
keepWithNextHangingRenderer = renderer;
keepWithNextHangingRendererLayoutResult = result;
}
}
else
{
if (result.GetStatus() != LayoutResult.NOTHING)
{
ShrinkCurrentAreaAndProcessRenderer(renderer, resultRenderers, result);
}
}
}
}
for (int i = 0; i < addedPositionedRenderers.Count; i++)
{
positionedRenderers.Add(addedPositionedRenderers[i]);
renderer = positionedRenderers[positionedRenderers.Count - 1];
int?positionedPageNumber = renderer.GetProperty <int?>(Property.PAGE_NUMBER);
if (positionedPageNumber == null)
{
positionedPageNumber = currentPageNumber;
}
LayoutArea layoutArea;
// For position=absolute, if none of the top, bottom, left, right properties are provided,
// the content should be displayed in the flow of the current content, not overlapping it.
// The behavior is just if it would be statically positioned except it does not affect other elements
if (Convert.ToInt32(LayoutPosition.ABSOLUTE).Equals(renderer.GetProperty <int?>(Property.POSITION)) && AbstractRenderer
.NoAbsolutePositionInfo(renderer))
{
layoutArea = new LayoutArea((int)positionedPageNumber, currentArea.GetBBox().Clone());
}
else
{
layoutArea = new LayoutArea((int)positionedPageNumber, initialCurrentArea.GetBBox().Clone());
}
Rectangle fullBbox = layoutArea.GetBBox().Clone();
PreparePositionedRendererAndAreaForLayout(renderer, fullBbox, layoutArea.GetBBox());
renderer.Layout(new PositionedLayoutContext(new LayoutArea(layoutArea.GetPageNumber(), fullBbox), layoutArea
));
if (immediateFlush)
{
FlushSingleRenderer(renderer);
positionedRenderers.JRemoveAt(positionedRenderers.Count - 1);
}
}
}
public LayoutContext(LayoutArea area, MarginsCollapseInfo marginsCollapseInfo)
{
this.area = area;
this.marginsCollapseInfo = marginsCollapseInfo;
}
public LineLayoutContext(LayoutArea area, MarginsCollapseInfo marginsCollapseInfo, IList <Rectangle> floatedRendererAreas
, bool clippedHeight)
: base(area, marginsCollapseInfo, floatedRendererAreas, clippedHeight)
{
}
