internal static float?AdjustFloatedBlockLayoutBox(AbstractRenderer renderer, Rectangle parentBBox, float?
blockWidth, IList <Rectangle> floatRendererAreas, FloatPropertyValue?floatPropertyValue, OverflowPropertyValue?
overflowX)
{
renderer.SetProperty(Property.HORIZONTAL_ALIGNMENT, null);
float floatElemWidth;
bool overflowFit = AbstractRenderer.IsOverflowFit(overflowX);
if (blockWidth != null)
{
floatElemWidth = (float)blockWidth + AbstractRenderer.CalculateAdditionalWidth(renderer);
if (overflowFit && floatElemWidth > parentBBox.GetWidth())
{
floatElemWidth = parentBBox.GetWidth();
}
}
else
{
MinMaxWidth minMaxWidth = CalculateMinMaxWidthForFloat(renderer, floatPropertyValue);
float maxWidth = minMaxWidth.GetMaxWidth();
if (maxWidth > parentBBox.GetWidth())
{
maxWidth = parentBBox.GetWidth();
}
if (!overflowFit && minMaxWidth.GetMinWidth() > parentBBox.GetWidth())
{
maxWidth = minMaxWidth.GetMinWidth();
}
floatElemWidth = maxWidth + AbstractRenderer.EPS;
blockWidth = maxWidth - minMaxWidth.GetAdditionalWidth() + AbstractRenderer.EPS;
}
AdjustBlockAreaAccordingToFloatRenderers(floatRendererAreas, parentBBox, floatElemWidth, FloatPropertyValue
.LEFT.Equals(floatPropertyValue));
return(blockWidth);
}
public virtual void MultipleDivTest()
{
String outFileName = destinationFolder + "multipleDivTest01.pdf";
String cmpFileName = sourceFolder + "cmp_multipleDivTest01.pdf";
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(outFileName));
Document doc = new Document(pdfDocument);
Border[] borders = new Border[] { new SolidBorder(ColorConstants.BLUE, 2f), new SolidBorder(ColorConstants
.RED, 2f), new SolidBorder(ColorConstants.GREEN, 2f) };
Div externalDiv = new Div().SetPadding(2f).SetBorder(borders[2]);
Div curr = externalDiv;
for (int i = 0; i < 100; ++i)
{
Div d = new Div().SetBorder(borders[i % 3]);
curr.Add(d);
curr = d;
}
String str = "Hello. I am a fairly long paragraph. I really want you to process me correctly. You heard that? Correctly!!! Even if you will have to wrap me.";
Paragraph p = new Paragraph(new Text(str)).SetPadding(1f).SetBorder(new SolidBorder(ColorConstants.BLACK,
2)).SetMargin(3).SetBackgroundColor(ColorConstants.LIGHT_GRAY);
curr.Add(p);
MinMaxWidth result = ((AbstractRenderer)externalDiv.CreateRendererSubTree().SetParent(doc.GetRenderer())).
GetMinMaxWidth();
externalDiv.SetWidth(ToEffectiveWidth(externalDiv, result.GetMinWidth()));
doc.Add(externalDiv);
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
public virtual void CalculateColumnWidthsNotPointValue()
{
PdfDocument pdfDoc = new PdfDocument(new PdfWriter(new ByteArrayOutputStream()));
Document doc = new Document(pdfDoc);
Rectangle layoutBox = new Rectangle(0, 0, 1000, 100);
Table table = new Table(UnitValue.CreatePercentArray(new float[] { 10, 10, 80 }));
// Set margins and paddings in percents, which is not expected
table.SetProperty(Property.MARGIN_RIGHT, UnitValue.CreatePercentValue(7));
table.SetProperty(Property.MARGIN_LEFT, UnitValue.CreatePercentValue(7));
table.SetProperty(Property.PADDING_RIGHT, UnitValue.CreatePercentValue(7));
table.SetProperty(Property.PADDING_LEFT, UnitValue.CreatePercentValue(7));
// Fill the table somehow. The layout area is wide enough to calculate the widths as expected
for (int i = 0; i < 3; i++)
{
table.AddCell("Hello");
}
// Create a TableRenderer, the instance of which will be used to test the application of margins and paddings
TableRenderer tableRenderer = (TableRenderer)table.CreateRendererSubTree().SetParent(doc.GetRenderer());
tableRenderer.bordersHandler = (TableBorders) new SeparatedTableBorders(tableRenderer.rows, 3, tableRenderer
.GetBorders(), 0);
tableRenderer.ApplyMarginsAndPaddingsAndCalculateColumnWidths(layoutBox);
// Specify that the render is not original in order not to recalculate the column widths
tableRenderer.isOriginalNonSplitRenderer = false;
MinMaxWidth minMaxWidth = tableRenderer.GetMinMaxWidth();
// TODO DEVSIX-3676: currently margins and paddings are still applied as if they are in points. After the mentioned ticket is fixed, the expected values should be updated.
NUnit.Framework.Assert.AreEqual(minMaxWidth.GetMaxWidth(), 332.46f, 0.001);
NUnit.Framework.Assert.AreEqual(minMaxWidth.GetMinWidth(), 332.46f, 0.001);
}
public virtual void ImageWidthTest02()
{
PdfImageXObject xObject = new PdfImageXObject(ImageDataFactory.Create(imageFolder + "Desert.jpg"));
iText.Layout.Element.Image image = new iText.Layout.Element.Image(xObject);
ImageRenderer renderer = new ImageRenderer(image);
image.SetProperty(Property.MAX_WIDTH, UnitValue.CreatePointValue(50));
MinMaxWidth minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(50.0, minMaxWidth.GetMaxWidth(), EPSILON);
NUnit.Framework.Assert.AreEqual(0.0, minMaxWidth.GetMaxWidth() - minMaxWidth.GetMinWidth(), EPSILON);
image.SetProperty(Property.MAX_WIDTH, UnitValue.CreatePercentValue(50));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(1024.0, minMaxWidth.GetMaxWidth(), EPSILON);
image.SetProperty(Property.MAX_HEIGHT, UnitValue.CreatePointValue(100f));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(100.0 * 1024.0 / 768.0, minMaxWidth.GetMaxWidth(), EPSILON);
image = new iText.Layout.Element.Image(xObject);
renderer = new ImageRenderer(image);
image.SetProperty(Property.MIN_WIDTH, UnitValue.CreatePointValue(2000));
image.SetProperty(Property.MAX_WIDTH, UnitValue.CreatePointValue(3000));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(2000.0, minMaxWidth.GetMaxWidth(), EPSILON);
NUnit.Framework.Assert.AreEqual(0.0, minMaxWidth.GetMaxWidth() - minMaxWidth.GetMinWidth(), EPSILON);
image.SetProperty(Property.MIN_HEIGHT, UnitValue.CreatePointValue(100f));
image.SetProperty(Property.HEIGHT, UnitValue.CreatePointValue(100f));
minMaxWidth = renderer.GetMinMaxWidth();
NUnit.Framework.Assert.AreEqual(100.0 * 1024.0 / 768.0, minMaxWidth.GetMaxWidth(), EPSILON);
}
public WidthDimensionContainer(CssContextNode node, float maxWidth, IRenderer renderer, float additionalWidthFix
)
{
String width = node.GetStyles().Get(CssConstants.WIDTH);
if (width != null && !CssConstants.AUTO.Equals(width))
{
dimension = ParseDimension(node, width, maxWidth, additionalWidthFix);
}
minDimension = GetMinWidth(node, maxWidth, additionalWidthFix);
maxDimension = GetMaxWidth(node, maxWidth, additionalWidthFix);
if (!IsAutoDimension())
{
// According to point 3 of paragraph "5.3.2.3. Handling min-width and max-width" of the specification
// maxContentDimension and minContentDimension will always be equal
maxContentDimension = dimension;
minContentDimension = dimension;
}
else
{
if (renderer is BlockRenderer)
{
MinMaxWidth minMaxWidth = ((BlockRenderer)renderer).GetMinMaxWidth();
maxContentDimension = minMaxWidth.GetMaxWidth();
minContentDimension = minMaxWidth.GetMinWidth();
}
}
}
protected override bool SetMinMaxWidthBasedOnFixedWidth(MinMaxWidth minMaxWidth)
{
bool result = false;
if (HasRelativeUnitValue(Property.WIDTH))
{
UnitValue widthUV = this.GetProperty <UnitValue>(Property.WIDTH);
bool restoreWidth = HasOwnProperty(Property.WIDTH);
SetProperty(Property.WIDTH, null);
float?width = RetrieveWidth(0);
if (width != null)
{
// the field can be shrinked if necessary so only max width is set here
minMaxWidth.SetChildrenMaxWidth((float)width);
result = true;
}
if (restoreWidth)
{
SetProperty(Property.WIDTH, widthUV);
}
else
{
DeleteOwnProperty(Property.WIDTH);
}
}
else
{
result = base.SetMinMaxWidthBasedOnFixedWidth(minMaxWidth);
}
return(result);
}
public virtual void DivWithRotatedPercentImage()
{
String outFileName = destinationFolder + "divRotatedPercentImage.pdf";
String cmpFileName = sourceFolder + "cmp_divRotatedPercentImage.pdf";
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(outFileName));
Document doc = new Document(pdfDocument);
PdfImageXObject imageXObject = new PdfImageXObject(ImageDataFactory.Create(sourceFolder + "itis.jpg"));
iText.Layout.Element.Image img = new iText.Layout.Element.Image(imageXObject).SetRotationAngle(Math.PI * 3
/ 8);
Div d = new Div().Add(img).SetBorder(new SolidBorder(ColorConstants.BLUE, 2f)).SetMarginBottom(10);
iText.Layout.Element.Image imgPercent = new iText.Layout.Element.Image(imageXObject).SetWidth(UnitValue.CreatePercentValue
(50)).SetRotationAngle(Math.PI * 3 / 8);
Div dPercent = new Div().Add(imgPercent).SetBorder(new SolidBorder(ColorConstants.BLUE, 2f));
MinMaxWidth result = ((AbstractRenderer)d.CreateRendererSubTree().SetParent(doc.GetRenderer())).GetMinMaxWidth
();
d.SetWidth(ToEffectiveWidth(d, result.GetMinWidth()));
MinMaxWidth resultPercent = ((AbstractRenderer)dPercent.CreateRendererSubTree().SetParent(doc.GetRenderer(
))).GetMinMaxWidth();
dPercent.SetWidth(ToEffectiveWidth(dPercent, resultPercent.GetMaxWidth()));
doc.Add(d);
doc.Add(dPercent);
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
public WidthDimensionContainer(CssContextNode node, float maxWidth, IRenderer renderer, float additionalWidthFix
)
{
String width = node.GetStyles().Get(CssConstants.WIDTH);
if (width != null && !width.Equals(CssConstants.AUTO))
{
dimension = ParseDimension(node, width, maxWidth, additionalWidthFix);
}
minDimension = GetMinWidth(node, maxWidth, additionalWidthFix);
maxDimension = GetMaxWidth(node, maxWidth, additionalWidthFix);
if (!IsAutoDimension())
{
maxContentDimension = dimension;
maxContentDimension = dimension;
}
else
{
if (renderer is BlockRenderer)
{
MinMaxWidth minMaxWidth = ((BlockRenderer)renderer).GetMinMaxWidth();
maxContentDimension = minMaxWidth.GetMaxWidth();
minContentDimension = minMaxWidth.GetMinWidth();
}
}
}
public virtual void UpdateMinMaxWidth(MinMaxWidth minMaxWidth)
{
if (minMaxWidth != null)
{
UpdateMaxChildWidth(minMaxWidth.GetMaxWidth());
UpdateMinChildWidth(minMaxWidth.GetMinWidth());
}
}
/* (non-Javadoc)
* @see com.itextpdf.layout.renderer.BlockRenderer#getMinMaxWidth(float)
*/
public override MinMaxWidth GetMinMaxWidth()
{
childRenderers.Clear();
flatRenderer = null;
IRenderer renderer = CreateFlatRenderer();
AddChild(renderer);
MinMaxWidth minMaxWidth = base.GetMinMaxWidth();
return(minMaxWidth);
}
public override MinMaxWidth GetMinMaxWidth()
{
IList <IRenderer> realChildRenderers = childRenderers;
childRenderers = new List <IRenderer>();
childRenderers.Add(minMaxWidthRenderer);
MinMaxWidth minMaxWidth = base.GetMinMaxWidth();
childRenderers = realChildRenderers;
return(minMaxWidth);
}
/// <summary>
/// This method tries to calculate min-max-width of rotated element using heuristics
/// of
/// <see cref="iText.Layout.Minmaxwidth.RotationMinMaxWidth.Calculate(double, double, iText.Layout.Minmaxwidth.MinMaxWidth)
/// "/>.
/// </summary>
/// <remarks>
/// This method tries to calculate min-max-width of rotated element using heuristics
/// of
/// <see cref="iText.Layout.Minmaxwidth.RotationMinMaxWidth.Calculate(double, double, iText.Layout.Minmaxwidth.MinMaxWidth)
/// "/>.
/// This method may call
/// <see cref="IRenderer.Layout(iText.Layout.Layout.LayoutContext)"/>
/// once in best case
/// (if the width is set on element, or if we are really lucky) and three times in worst case.
/// </remarks>
/// <param name="minMaxWidth">the minMaxWidth of NOT rotated renderer</param>
/// <param name="renderer">the actual renderer</param>
/// <returns>minMaxWidth of rotated renderer or original value in case rotated value can not be calculated, or renderer isn't rotated.
/// </returns>
public static MinMaxWidth CountRotationMinMaxWidth(MinMaxWidth minMaxWidth, AbstractRenderer renderer)
{
RotationUtils.PropertiesBackup backup = new RotationUtils.PropertiesBackup(renderer);
float?rotation = backup.StoreFloatProperty(Property.ROTATION_ANGLE);
if (rotation != null)
{
float angle = (float)rotation;
//This width results in more accurate values for min-width calculations.
float layoutWidth = minMaxWidth.GetMaxWidth() + MinMaxWidthUtils.GetEps();
LayoutResult layoutResult = renderer.Layout(new LayoutContext(new LayoutArea(1, new Rectangle(layoutWidth,
AbstractRenderer.INF))));
if (layoutResult.GetOccupiedArea() != null)
{
Rectangle layoutBBox = layoutResult.GetOccupiedArea().GetBBox();
if (MinMaxWidthUtils.IsEqual(minMaxWidth.GetMinWidth(), minMaxWidth.GetMaxWidth()))
{
backup.RestoreProperty(Property.ROTATION_ANGLE);
float rotatedWidth = (float)RotationMinMaxWidth.CalculateRotatedWidth(layoutBBox, angle);
return(new MinMaxWidth(rotatedWidth, rotatedWidth, 0));
}
double area = layoutResult.GetOccupiedArea().GetBBox().GetWidth() * layoutResult.GetOccupiedArea().GetBBox
().GetHeight();
RotationMinMaxWidth rotationMinMaxWidth = RotationMinMaxWidth.Calculate(angle, area, minMaxWidth);
float?rotatedMinWidth = GetLayoutRotatedWidth(renderer, (float)rotationMinMaxWidth.GetMinWidthOrigin(), layoutBBox
, angle);
if (rotatedMinWidth != null)
{
if (rotatedMinWidth > rotationMinMaxWidth.GetMaxWidth())
{
rotationMinMaxWidth.SetChildrenMinWidth((float)rotatedMinWidth);
float?rotatedMaxWidth = GetLayoutRotatedWidth(renderer, (float)rotationMinMaxWidth.GetMaxWidthOrigin(), layoutBBox
, angle);
if (rotatedMaxWidth != null && rotatedMaxWidth > rotatedMinWidth)
{
rotationMinMaxWidth.SetChildrenMaxWidth((float)rotatedMaxWidth);
}
else
{
rotationMinMaxWidth.SetChildrenMaxWidth((float)rotatedMinWidth);
}
}
else
{
rotationMinMaxWidth.SetChildrenMinWidth((float)rotatedMinWidth);
}
backup.RestoreProperty(Property.ROTATION_ANGLE);
return(rotationMinMaxWidth);
}
}
}
backup.RestoreProperty(Property.ROTATION_ANGLE);
return(minMaxWidth);
}
public virtual void MinMaxWidthWithOneRenderer()
{
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(new MemoryStream()));
Document document = new Document(pdfDocument);
TextRenderer textRenderer = new TextRenderer(new Text(""));
textRenderer.SetParent(document.GetRenderer());
textRenderer.SetProperty(Property.FONT, PdfFontFactory.CreateFont(THAI_FONT, PdfEncodings.IDENTITY_H));
textRenderer.SetText(THAI_TEXT);
textRenderer.SetSpecialScriptsWordBreakPoints(new List <int>(JavaUtil.ArraysAsList(3, 8, 10, 12, 15, 20, 23
, 26, 28, 30, 36)));
MinMaxWidth minMaxWidth = textRenderer.GetMinMaxWidth();
NUnit.Framework.Assert.IsTrue(minMaxWidth.GetMinWidth() < minMaxWidth.GetMaxWidth());
}
public virtual void OverflowWrapAnywhereProperty()
{
PdfDocument pdfDoc = new PdfDocument(new PdfWriter(new MemoryStream()));
pdfDoc.AddNewPage();
Document doc = new Document(pdfDoc);
RootRenderer documentRenderer = doc.GetRenderer();
Text text = new Text("wow");
text.SetProperty(Property.OVERFLOW_WRAP, OverflowWrapPropertyValue.ANYWHERE);
TextRenderer textRenderer = (TextRenderer)text.GetRenderer();
textRenderer.SetParent(documentRenderer);
MinMaxWidth minMaxWidth = textRenderer.GetMinMaxWidth();
NUnit.Framework.Assert.IsTrue(minMaxWidth.GetMinWidth() < minMaxWidth.GetMaxWidth());
}
public virtual void SpecialScriptsWordBreakPointsSplit()
{
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(new MemoryStream()));
Document document = new Document(pdfDocument);
TextRenderer textRenderer = new TextRenderer(new Text(""));
textRenderer.SetProperty(Property.FONT, PdfFontFactory.CreateFont(THAI_FONT, PdfEncodings.IDENTITY_H));
textRenderer.SetText(THAI_TEXT);
textRenderer.SetSpecialScriptsWordBreakPoints(new List <int>(JavaUtil.ArraysAsList(3, 8, 10, 12, 15, 20, 23
, 26, 28, 30, 36)));
LineRenderer lineRenderer = new LineRenderer();
lineRenderer.SetParent(document.GetRenderer());
lineRenderer.AddChild(textRenderer);
MinMaxWidth minMaxWidth = lineRenderer.GetMinMaxWidth();
float width = minMaxWidth.GetMinWidth() + minMaxWidth.GetMaxWidth() / 2;
LayoutResult layoutResult = lineRenderer.Layout(new LayoutContext(new LayoutArea(1, new Rectangle(width, 500
))));
IRenderer lineSplitRenderer = layoutResult.GetSplitRenderer();
NUnit.Framework.Assert.IsNotNull(lineSplitRenderer);
NUnit.Framework.Assert.IsNotNull(lineSplitRenderer.GetChildRenderers());
NUnit.Framework.Assert.IsTrue(lineSplitRenderer.GetChildRenderers()[0] is TextRenderer);
TextRenderer textSplitRenderer = (TextRenderer)lineSplitRenderer.GetChildRenderers()[0];
NUnit.Framework.Assert.IsNotNull(textSplitRenderer.GetSpecialScriptsWordBreakPoints());
IRenderer lineOverflowRenderer = layoutResult.GetOverflowRenderer();
NUnit.Framework.Assert.IsNotNull(lineOverflowRenderer);
NUnit.Framework.Assert.IsNotNull(lineOverflowRenderer.GetChildRenderers());
NUnit.Framework.Assert.IsTrue(lineOverflowRenderer.GetChildRenderers()[0] is TextRenderer);
TextRenderer textOverflowRenderer = (TextRenderer)lineOverflowRenderer.GetChildRenderers()[0];
NUnit.Framework.Assert.IsNotNull(textOverflowRenderer.GetSpecialScriptsWordBreakPoints());
int textSplitRendererTextLength = textSplitRenderer.text.ToString().Length;
foreach (int specialScriptsWordBreakPoint in textSplitRenderer.GetSpecialScriptsWordBreakPoints())
{
NUnit.Framework.Assert.IsTrue(specialScriptsWordBreakPoint <= textSplitRendererTextLength);
}
foreach (int specialScriptsWordBreakPoint in textOverflowRenderer.GetSpecialScriptsWordBreakPoints())
{
NUnit.Framework.Assert.IsTrue(specialScriptsWordBreakPoint > textSplitRendererTextLength && specialScriptsWordBreakPoint
<= textOverflowRenderer.text.Size());
}
}
/// <summary>This method tries to calculate width of not rotated renderer, so after rotation it fits availableWidth.
/// </summary>
/// <remarks>
/// This method tries to calculate width of not rotated renderer, so after rotation it fits availableWidth.
/// This method uses heuristics of
/// <see cref="iText.Layout.Minmaxwidth.RotationMinMaxWidth.Calculate(double, double, iText.Layout.Minmaxwidth.MinMaxWidth, double)
/// "/>.
/// It doesn't take into account any of height properties of renderer or height of layoutArea.
/// The minMaxWidth calculations and initial layout may take long time, but they won't be called if the renderer have width property.
/// </remarks>
/// <param name="availableWidth">the width of layoutArea</param>
/// <param name="renderer">the actual renderer</param>
/// <returns>
/// the width that should be set as width of layout area to properly layout element, or fallback to
/// <see cref="AbstractRenderer.RetrieveWidth(float)"/>
/// in case it can not be calculated, or renderer isn't rotated.
/// </returns>
public static float?RetrieveRotatedLayoutWidth(float availableWidth, AbstractRenderer renderer)
{
RotationUtils.PropertiesBackup backup = new RotationUtils.PropertiesBackup(renderer);
float?rotation = backup.StoreFloatProperty(Property.ROTATION_ANGLE);
if (rotation != null && renderer.GetProperty <UnitValue>(Property.WIDTH) == null)
{
float angle = (float)rotation;
backup.StoreProperty <UnitValue>(Property.HEIGHT);
backup.StoreProperty <UnitValue>(Property.MIN_HEIGHT);
backup.StoreProperty <UnitValue>(Property.MAX_HEIGHT);
MinMaxWidth minMaxWidth = renderer.GetMinMaxWidth();
//Using this width for initial layout helps in case of small elements. They may have more free spaces but it's more likely they fit.
float length = (minMaxWidth.GetMaxWidth() + minMaxWidth.GetMinWidth()) / 2 + MinMaxWidthUtils.GetEps();
LayoutResult layoutResult = renderer.Layout(new LayoutContext(new LayoutArea(1, new Rectangle(length, AbstractRenderer
.INF))));
backup.RestoreProperty(Property.HEIGHT);
backup.RestoreProperty(Property.MIN_HEIGHT);
backup.RestoreProperty(Property.MAX_HEIGHT);
Rectangle additions = new Rectangle(0, 0);
renderer.ApplyPaddings(additions, true);
renderer.ApplyBorderBox(additions, true);
renderer.ApplyMargins(additions, true);
if (layoutResult.GetOccupiedArea() != null)
{
double area = layoutResult.GetOccupiedArea().GetBBox().GetWidth() * layoutResult.GetOccupiedArea().GetBBox
().GetHeight();
RotationMinMaxWidth result = RotationMinMaxWidth.Calculate(angle, area, minMaxWidth, availableWidth);
if (result != null)
{
backup.RestoreProperty(Property.ROTATION_ANGLE);
if (result.GetMaxWidthHeight() > result.GetMinWidthHeight())
{
return((float)(result.GetMinWidthOrigin() - additions.GetWidth() + MinMaxWidthUtils.GetEps()));
}
else
{
return((float)(result.GetMaxWidthOrigin() - additions.GetWidth() + MinMaxWidthUtils.GetEps()));
}
}
}
}
backup.RestoreProperty(Property.ROTATION_ANGLE);
return(renderer.RetrieveWidth(availableWidth));
}
internal static MinMaxWidth CalculateMinMaxWidthForFloat(AbstractRenderer renderer, FloatPropertyValue?floatPropertyVal
)
{
bool floatPropIsRendererOwn = renderer.HasOwnProperty(Property.FLOAT);
renderer.SetProperty(Property.FLOAT, FloatPropertyValue.NONE);
MinMaxWidth kidMinMaxWidth = renderer.GetMinMaxWidth();
if (floatPropIsRendererOwn)
{
renderer.SetProperty(Property.FLOAT, floatPropertyVal);
}
else
{
renderer.DeleteOwnProperty(Property.FLOAT);
}
return(kidMinMaxWidth);
}
public virtual void ParagraphTest()
{
String outFileName = destinationFolder + "paragraphTest01.pdf";
String cmpFileName = sourceFolder + "cmp_paragraphTest01.pdf";
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(outFileName));
Document doc = new Document(pdfDocument);
String str = "Hello. I am a fairly long paragraph. I really want you to process me correctly. You heard that? Correctly!!! Even if you will have to wrap me.";
Paragraph p = new Paragraph(new Text(str).SetBorder(new SolidBorder(ColorConstants.BLACK, 5))).SetBorder(new
SolidBorder(ColorConstants.BLUE, 5));
MinMaxWidth result = ((AbstractRenderer)p.CreateRendererSubTree().SetParent(doc.GetRenderer())).GetMinMaxWidth
();
p.SetWidth(ToEffectiveWidth(p, result.GetMinWidth()));
doc.Add(p);
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
public override MinMaxWidth GetMinMaxWidth()
{
MinMaxWidth minMaxWidth = new MinMaxWidth();
float? rotation = this.GetPropertyAsFloat(Property.ROTATION_ANGLE);
if (!SetMinMaxWidthBasedOnFixedWidth(minMaxWidth))
{
float?minWidth = HasAbsoluteUnitValue(Property.MIN_WIDTH) ? RetrieveMinWidth(0) : null;
float?maxWidth = HasAbsoluteUnitValue(Property.MAX_WIDTH) ? RetrieveMaxWidth(0) : null;
if (minWidth == null || maxWidth == null)
{
bool restoreRotation = HasOwnProperty(Property.ROTATION_ANGLE);
SetProperty(Property.ROTATION_ANGLE, null);
MinMaxWidthLayoutResult result = (MinMaxWidthLayoutResult)Layout(new LayoutContext(new LayoutArea(1, new Rectangle
(MinMaxWidthUtils.GetInfWidth(), AbstractRenderer.INF))));
if (restoreRotation)
{
SetProperty(Property.ROTATION_ANGLE, rotation);
}
else
{
DeleteOwnProperty(Property.ROTATION_ANGLE);
}
minMaxWidth = result.GetMinMaxWidth();
}
if (minWidth != null)
{
minMaxWidth.SetChildrenMinWidth((float)minWidth);
}
if (maxWidth != null)
{
minMaxWidth.SetChildrenMaxWidth((float)maxWidth);
}
if (minMaxWidth.GetChildrenMinWidth() > minMaxWidth.GetChildrenMaxWidth())
{
minMaxWidth.SetChildrenMaxWidth(minMaxWidth.GetChildrenMaxWidth());
}
}
else
{
minMaxWidth.SetAdditionalWidth(CalculateAdditionalWidth(this));
}
return(rotation != null?RotationUtils.CountRotationMinMaxWidth(minMaxWidth, this) : minMaxWidth);
}
protected override bool SetMinMaxWidthBasedOnFixedWidth(MinMaxWidth minMaxWidth)
{
if (!HasAbsoluteUnitValue(Property.WIDTH))
{
UnitValue width = this.GetProperty <UnitValue>(Property.WIDTH);
bool restoreWidth = HasOwnProperty(Property.WIDTH);
SetProperty(Property.WIDTH, null);
bool result = base.SetMinMaxWidthBasedOnFixedWidth(minMaxWidth);
if (restoreWidth)
{
SetProperty(Property.WIDTH, width);
}
else
{
DeleteOwnProperty(Property.WIDTH);
}
return(result);
}
return(base.SetMinMaxWidthBasedOnFixedWidth(minMaxWidth));
}
public virtual void DivWithBigRotatedParagraph()
{
String outFileName = destinationFolder + "divBigRotatedParagraphTest01.pdf";
String cmpFileName = sourceFolder + "cmp_divBigRotatedParagraphTest01.pdf";
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(outFileName));
Document doc = new Document(pdfDocument);
String str = "Hello. I am a fairly long paragraph. I really want you to process me correctly. You heard that? Correctly!!! Even if you will have to wrap me.";
Paragraph p = new Paragraph(new Text(str)).SetPadding(1f).SetBorder(new SolidBorder(ColorConstants.BLACK,
2)).SetMargin(3).SetBackgroundColor(ColorConstants.LIGHT_GRAY).SetRotationAngle(Math.PI / 8);
Div d = new Div().SetPadding(4f).SetBorder(new SolidBorder(ColorConstants.GREEN, 5)).SetMargin(6);
d.Add(p);
d.Add(new Paragraph(("iText")));
MinMaxWidth result = ((AbstractRenderer)d.CreateRendererSubTree().SetParent(doc.GetRenderer())).GetMinMaxWidth
();
d.SetWidth(ToEffectiveWidth(d, result.GetMinWidth()));
doc.Add(d);
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
public virtual void HeaderFooterTableTest()
{
String outFileName = destinationFolder + "headerFooterTableTest.pdf";
String cmpFileName = sourceFolder + "cmp_headerFooterTableTest.pdf";
Document doc = new Document(new PdfDocument(new PdfWriter(outFileName)));
Cell bigCell = new Cell().Add(new Paragraph("veryveryveryvery big cell")).SetBorder(new SolidBorder(ColorConstants
.RED, 40)).SetBorderBottom(Border.NO_BORDER).SetBorderTop(Border.NO_BORDER).SetPadding(0);
Cell mediumCell = new Cell().Add(new Paragraph("mediumsize cell")).SetBorder(new SolidBorder(ColorConstants
.GREEN, 30)).SetBorderBottom(Border.NO_BORDER).SetBorderTop(Border.NO_BORDER).SetPadding(0);
Cell cell = new Cell().Add(new Paragraph("cell")).SetBorder(new SolidBorder(ColorConstants.BLUE, 10)).SetBorderBottom
(Border.NO_BORDER).SetBorderTop(Border.NO_BORDER).SetPadding(0);
Table table = new Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth().SetBorder(new SolidBorder(
ColorConstants.BLACK, 20)).AddCell(mediumCell.Clone(true)).AddCell(mediumCell.Clone(true)).AddCell(mediumCell
.Clone(true)).AddFooterCell(cell.Clone(true)).AddFooterCell(cell.Clone(true)).AddFooterCell(bigCell.Clone
(true)).AddHeaderCell(bigCell.Clone(true)).AddHeaderCell(cell.Clone(true)).AddHeaderCell(cell.Clone(true
));
TableRenderer renderer = (TableRenderer)table.CreateRendererSubTree().SetParent(doc.GetRenderer());
MinMaxWidth minMaxWidth = renderer.GetMinMaxWidth();
Table minTable = new Table(new float[] { -1, -1, -1 }).SetWidth(UnitValue.CreatePointValue(1)).SetBorder(new
SolidBorder(ColorConstants.BLACK, 20)).SetMarginTop(20).AddCell(mediumCell.Clone(true)).AddCell(mediumCell
.Clone(true)).AddCell(mediumCell.Clone(true)).AddFooterCell(cell.Clone(true)).AddFooterCell(cell.Clone
(true)).AddFooterCell(bigCell.Clone(true)).AddHeaderCell(bigCell.Clone(true)).AddHeaderCell(cell.Clone
(true)).AddHeaderCell(cell.Clone(true));
Table maxTable = new Table(new float[] { -1, -1, -1 }).SetBorder(new SolidBorder(ColorConstants.BLACK, 20)
).SetMarginTop(20).AddCell(mediumCell.Clone(true)).AddCell(mediumCell.Clone(true)).AddCell(mediumCell.
Clone(true)).AddFooterCell(cell.Clone(true)).AddFooterCell(cell.Clone(true)).AddFooterCell(bigCell.Clone
(true)).AddHeaderCell(bigCell.Clone(true)).AddHeaderCell(cell.Clone(true)).AddHeaderCell(cell.Clone(true
));
doc.Add(table);
doc.Add(minTable);
doc.Add(maxTable);
doc.Close();
NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outFileName, cmpFileName, destinationFolder
, "diff"));
}
public MinMaxWidthLayoutResult(int status, LayoutArea occupiedArea, IRenderer splitRenderer, IRenderer overflowRenderer
, IRenderer cause)
: base(status, occupiedArea, splitRenderer, overflowRenderer, cause)
{
minMaxWidth = new MinMaxWidth();
}
public MaxSumWidthHandler(MinMaxWidth minMaxWidth)
: base(minMaxWidth)
{
}
public override LayoutResult Layout(LayoutContext layoutContext)
{
LayoutArea area = layoutContext.GetArea().Clone();
Rectangle layoutBox = area.GetBBox().Clone();
AffineTransform t = new AffineTransform();
Image modelElement = (Image)(GetModelElement());
PdfXObject xObject = modelElement.GetXObject();
imageWidth = modelElement.GetImageWidth();
imageHeight = modelElement.GetImageHeight();
CalculateImageDimensions(layoutBox, t, xObject);
OverflowPropertyValue?overflowX = null != parent?parent.GetProperty <OverflowPropertyValue?>(Property.OVERFLOW_X
) : OverflowPropertyValue.FIT;
bool nowrap = false;
if (parent is LineRenderer)
{
nowrap = true.Equals(this.parent.GetOwnProperty <bool?>(Property.NO_SOFT_WRAP_INLINE));
}
IList <Rectangle> floatRendererAreas = layoutContext.GetFloatRendererAreas();
float clearHeightCorrection = FloatingHelper.CalculateClearHeightCorrection(this, floatRendererAreas, layoutBox
);
FloatPropertyValue?floatPropertyValue = this.GetProperty <FloatPropertyValue?>(Property.FLOAT);
if (FloatingHelper.IsRendererFloating(this, floatPropertyValue))
{
layoutBox.DecreaseHeight(clearHeightCorrection);
FloatingHelper.AdjustFloatedBlockLayoutBox(this, layoutBox, width, floatRendererAreas, floatPropertyValue,
overflowX);
}
else
{
clearHeightCorrection = FloatingHelper.AdjustLayoutBoxAccordingToFloats(floatRendererAreas, layoutBox, width
, clearHeightCorrection, null);
}
ApplyMargins(layoutBox, false);
Border[] borders = GetBorders();
ApplyBorderBox(layoutBox, borders, false);
float?declaredMaxHeight = RetrieveMaxHeight();
OverflowPropertyValue?overflowY = null == parent || ((null == declaredMaxHeight || declaredMaxHeight > layoutBox
.GetHeight()) && !layoutContext.IsClippedHeight()) ? OverflowPropertyValue.FIT : parent.GetProperty <OverflowPropertyValue?
>(Property.OVERFLOW_Y);
bool processOverflowX = !IsOverflowFit(overflowX) || nowrap;
bool processOverflowY = !IsOverflowFit(overflowY);
if (IsAbsolutePosition())
{
ApplyAbsolutePosition(layoutBox);
}
occupiedArea = new LayoutArea(area.GetPageNumber(), new Rectangle(layoutBox.GetX(), layoutBox.GetY() + layoutBox
.GetHeight(), 0, 0));
float imageItselfScaledWidth = (float)width;
float imageItselfScaledHeight = (float)height;
if (IsFixedLayout())
{
fixedXPosition = this.GetPropertyAsFloat(Property.LEFT);
fixedYPosition = this.GetPropertyAsFloat(Property.BOTTOM);
}
float?angle = this.GetPropertyAsFloat(Property.ROTATION_ANGLE);
// See in adjustPositionAfterRotation why angle = 0 is necessary
if (null == angle)
{
angle = 0f;
}
t.Rotate((float)angle);
initialOccupiedAreaBBox = GetOccupiedAreaBBox().Clone();
float scaleCoef = AdjustPositionAfterRotation((float)angle, layoutBox.GetWidth(), layoutBox.GetHeight());
imageItselfScaledHeight *= scaleCoef;
imageItselfScaledWidth *= scaleCoef;
initialOccupiedAreaBBox.MoveDown(imageItselfScaledHeight);
initialOccupiedAreaBBox.SetHeight(imageItselfScaledHeight);
initialOccupiedAreaBBox.SetWidth(imageItselfScaledWidth);
if (xObject is PdfFormXObject)
{
t.Scale(scaleCoef, scaleCoef);
}
GetMatrix(t, imageItselfScaledWidth, imageItselfScaledHeight);
// indicates whether the placement is forced
bool isPlacingForced = false;
if (width > layoutBox.GetWidth() || height > layoutBox.GetHeight())
{
if (true.Equals(GetPropertyAsBoolean(Property.FORCED_PLACEMENT)) || (width > layoutBox.GetWidth() && processOverflowX
) || (height > layoutBox.GetHeight() && processOverflowY))
{
isPlacingForced = true;
}
else
{
ApplyMargins(initialOccupiedAreaBBox, true);
ApplyBorderBox(initialOccupiedAreaBBox, true);
occupiedArea.GetBBox().SetHeight(initialOccupiedAreaBBox.GetHeight());
return(new MinMaxWidthLayoutResult(LayoutResult.NOTHING, occupiedArea, null, this, this));
}
}
occupiedArea.GetBBox().MoveDown((float)height);
if (borders[3] != null)
{
height += (float)Math.Sin((float)angle) * borders[3].GetWidth();
}
occupiedArea.GetBBox().SetHeight((float)height);
occupiedArea.GetBBox().SetWidth((float)width);
UnitValue leftMargin = this.GetPropertyAsUnitValue(Property.MARGIN_LEFT);
if (!leftMargin.IsPointValue())
{
ILog logger = LogManager.GetLogger(typeof(iText.Layout.Renderer.ImageRenderer));
logger.Error(MessageFormatUtil.Format(iText.IO.LogMessageConstant.PROPERTY_IN_PERCENTS_NOT_SUPPORTED, Property
.MARGIN_LEFT));
}
UnitValue topMargin = this.GetPropertyAsUnitValue(Property.MARGIN_TOP);
if (!topMargin.IsPointValue())
{
ILog logger = LogManager.GetLogger(typeof(iText.Layout.Renderer.ImageRenderer));
logger.Error(MessageFormatUtil.Format(iText.IO.LogMessageConstant.PROPERTY_IN_PERCENTS_NOT_SUPPORTED, Property
.MARGIN_TOP));
}
if (0 != leftMargin.GetValue() || 0 != topMargin.GetValue())
{
TranslateImage(leftMargin.GetValue(), topMargin.GetValue(), t);
GetMatrix(t, imageItselfScaledWidth, imageItselfScaledHeight);
}
ApplyBorderBox(occupiedArea.GetBBox(), borders, true);
ApplyMargins(occupiedArea.GetBBox(), true);
if (angle != 0)
{
ApplyRotationLayout((float)angle);
}
float unscaledWidth = occupiedArea.GetBBox().GetWidth() / scaleCoef;
MinMaxWidth minMaxWidth = new MinMaxWidth(unscaledWidth, unscaledWidth, 0);
UnitValue rendererWidth = this.GetProperty <UnitValue>(Property.WIDTH);
if (rendererWidth != null && rendererWidth.IsPercentValue())
{
minMaxWidth.SetChildrenMinWidth(0);
float coeff = imageWidth / (float)RetrieveWidth(area.GetBBox().GetWidth());
minMaxWidth.SetChildrenMaxWidth(unscaledWidth * coeff);
}
else
{
bool autoScale = HasProperty(Property.AUTO_SCALE) && (bool)this.GetProperty <bool?>(Property.AUTO_SCALE);
bool autoScaleWidth = HasProperty(Property.AUTO_SCALE_WIDTH) && (bool)this.GetProperty <bool?>(Property.AUTO_SCALE_WIDTH
);
if (autoScale || autoScaleWidth)
{
minMaxWidth.SetChildrenMinWidth(0);
}
}
FloatingHelper.RemoveFloatsAboveRendererBottom(floatRendererAreas, this);
LayoutArea editedArea = FloatingHelper.AdjustResultOccupiedAreaForFloatAndClear(this, floatRendererAreas,
layoutContext.GetArea().GetBBox(), clearHeightCorrection, false);
ApplyAbsolutePositionIfNeeded(layoutContext);
return(new MinMaxWidthLayoutResult(LayoutResult.FULL, editedArea, null, null, isPlacingForced ? this : null
).SetMinMaxWidth(minMaxWidth));
}
public AbstractWidthHandler(MinMaxWidth minMaxWidth)
{
this.minMaxWidth = minMaxWidth;
}
protected internal virtual LayoutResult DirectLayout(LayoutContext layoutContext)
{
bool wasHeightClipped = false;
bool wasParentsHeightClipped = layoutContext.IsClippedHeight();
int pageNumber = layoutContext.GetArea().GetPageNumber();
bool anythingPlaced = false;
bool firstLineInBox = true;
LineRenderer currentRenderer = (LineRenderer) new LineRenderer().SetParent(this);
Rectangle parentBBox = layoutContext.GetArea().GetBBox().Clone();
MarginsCollapseHandler marginsCollapseHandler = null;
bool marginsCollapsingEnabled = true.Equals(GetPropertyAsBoolean(Property.COLLAPSING_MARGINS));
if (marginsCollapsingEnabled)
{
marginsCollapseHandler = new MarginsCollapseHandler(this, layoutContext.GetMarginsCollapseInfo());
}
OverflowPropertyValue?overflowX = this.GetProperty <OverflowPropertyValue?>(Property.OVERFLOW_X);
bool?nowrapProp = this.GetPropertyAsBoolean(Property.NO_SOFT_WRAP_INLINE);
currentRenderer.SetProperty(Property.NO_SOFT_WRAP_INLINE, nowrapProp);
bool notAllKidsAreFloats = false;
IList <Rectangle> floatRendererAreas = layoutContext.GetFloatRendererAreas();
FloatPropertyValue?floatPropertyValue = this.GetProperty <FloatPropertyValue?>(Property.FLOAT);
float clearHeightCorrection = FloatingHelper.CalculateClearHeightCorrection(this, floatRendererAreas, parentBBox
);
FloatingHelper.ApplyClearance(parentBBox, marginsCollapseHandler, clearHeightCorrection, FloatingHelper.IsRendererFloating
(this));
float?blockWidth = RetrieveWidth(parentBBox.GetWidth());
if (FloatingHelper.IsRendererFloating(this, floatPropertyValue))
{
blockWidth = FloatingHelper.AdjustFloatedBlockLayoutBox(this, parentBBox, blockWidth, floatRendererAreas,
floatPropertyValue, overflowX);
floatRendererAreas = new List <Rectangle>();
}
if (0 == childRenderers.Count)
{
anythingPlaced = true;
currentRenderer = null;
}
bool isPositioned = IsPositioned();
float?rotation = this.GetPropertyAsFloat(Property.ROTATION_ANGLE);
float?blockMaxHeight = RetrieveMaxHeight();
OverflowPropertyValue?overflowY = (null == blockMaxHeight || blockMaxHeight > parentBBox.GetHeight()) &&
!wasParentsHeightClipped ? OverflowPropertyValue.FIT : this.GetProperty <OverflowPropertyValue?>(Property
.OVERFLOW_Y);
if (rotation != null || IsFixedLayout())
{
parentBBox.MoveDown(AbstractRenderer.INF - parentBBox.GetHeight()).SetHeight(AbstractRenderer.INF);
}
if (rotation != null && !FloatingHelper.IsRendererFloating(this))
{
blockWidth = RotationUtils.RetrieveRotatedLayoutWidth(parentBBox.GetWidth(), this);
}
if (marginsCollapsingEnabled)
{
marginsCollapseHandler.StartMarginsCollapse(parentBBox);
}
Border[] borders = GetBorders();
UnitValue[] paddings = GetPaddings();
float additionalWidth = ApplyBordersPaddingsMargins(parentBBox, borders, paddings);
ApplyWidth(parentBBox, blockWidth, overflowX);
wasHeightClipped = ApplyMaxHeight(parentBBox, blockMaxHeight, marginsCollapseHandler, false, wasParentsHeightClipped
, overflowY);
MinMaxWidth minMaxWidth = new MinMaxWidth(additionalWidth);
AbstractWidthHandler widthHandler = new MaxMaxWidthHandler(minMaxWidth);
IList <Rectangle> areas;
if (isPositioned)
{
areas = JavaCollectionsUtil.SingletonList(parentBBox);
}
else
{
areas = InitElementAreas(new LayoutArea(pageNumber, parentBBox));
}
occupiedArea = new LayoutArea(pageNumber, new Rectangle(parentBBox.GetX(), parentBBox.GetY() + parentBBox.
GetHeight(), parentBBox.GetWidth(), 0));
ShrinkOccupiedAreaForAbsolutePosition();
int currentAreaPos = 0;
Rectangle layoutBox = areas[0].Clone();
lines = new List <LineRenderer>();
foreach (IRenderer child in childRenderers)
{
notAllKidsAreFloats = notAllKidsAreFloats || !FloatingHelper.IsRendererFloating(child);
currentRenderer.AddChild(child);
}
float lastYLine = layoutBox.GetY() + layoutBox.GetHeight();
float previousDescent = 0;
float lastLineBottomLeadingIndent = 0;
bool onlyOverflowedFloatsLeft = false;
IList <IRenderer> inlineFloatsOverflowedToNextPage = new List <IRenderer>();
bool floatOverflowedToNextPageWithNothing = false;
// rectangles are compared by instances
ICollection <Rectangle> nonChildFloatingRendererAreas = new HashSet <Rectangle>(floatRendererAreas);
if (marginsCollapsingEnabled && childRenderers.Count > 0)
{
// passing null is sufficient to notify that there is a kid, however we don't care about it and it's margins
marginsCollapseHandler.StartChildMarginsHandling(null, layoutBox);
}
bool includeFloatsInOccupiedArea = BlockFormattingContextUtil.IsRendererCreateBfc(this);
while (currentRenderer != null)
{
currentRenderer.SetProperty(Property.TAB_DEFAULT, this.GetPropertyAsFloat(Property.TAB_DEFAULT));
currentRenderer.SetProperty(Property.TAB_STOPS, this.GetProperty <Object>(Property.TAB_STOPS));
float lineIndent = anythingPlaced ? 0 : (float)this.GetPropertyAsFloat(Property.FIRST_LINE_INDENT);
Rectangle childLayoutBox = new Rectangle(layoutBox.GetX(), layoutBox.GetY(), layoutBox.GetWidth(), layoutBox
.GetHeight());
currentRenderer.SetProperty(Property.OVERFLOW_X, overflowX);
currentRenderer.SetProperty(Property.OVERFLOW_Y, overflowY);
LineLayoutContext lineLayoutContext = new LineLayoutContext(new LayoutArea(pageNumber, childLayoutBox), null
, floatRendererAreas, wasHeightClipped || wasParentsHeightClipped).SetTextIndent(lineIndent).SetFloatOverflowedToNextPageWithNothing
(floatOverflowedToNextPageWithNothing);
LineLayoutResult result = (LineLayoutResult)((LineRenderer)currentRenderer.SetParent(this)).Layout(lineLayoutContext
);
if (result.GetStatus() == LayoutResult.NOTHING)
{
float?lineShiftUnderFloats = FloatingHelper.CalculateLineShiftUnderFloats(floatRendererAreas, layoutBox);
if (lineShiftUnderFloats != null)
{
layoutBox.DecreaseHeight((float)lineShiftUnderFloats);
firstLineInBox = true;
continue;
}
bool allRemainingKidsAreFloats = !currentRenderer.childRenderers.IsEmpty();
foreach (IRenderer renderer in currentRenderer.childRenderers)
{
allRemainingKidsAreFloats = allRemainingKidsAreFloats && FloatingHelper.IsRendererFloating(renderer);
}
if (allRemainingKidsAreFloats)
{
onlyOverflowedFloatsLeft = true;
}
}
floatOverflowedToNextPageWithNothing = lineLayoutContext.IsFloatOverflowedToNextPageWithNothing();
if (result.GetFloatsOverflowedToNextPage() != null)
{
inlineFloatsOverflowedToNextPage.AddAll(result.GetFloatsOverflowedToNextPage());
}
float minChildWidth = 0;
float maxChildWidth = 0;
if (result is MinMaxWidthLayoutResult)
{
minChildWidth = ((MinMaxWidthLayoutResult)result).GetMinMaxWidth().GetMinWidth();
maxChildWidth = ((MinMaxWidthLayoutResult)result).GetMinMaxWidth().GetMaxWidth();
}
widthHandler.UpdateMinChildWidth(minChildWidth);
widthHandler.UpdateMaxChildWidth(maxChildWidth);
LineRenderer processedRenderer = null;
if (result.GetStatus() == LayoutResult.FULL)
{
processedRenderer = currentRenderer;
}
else
{
if (result.GetStatus() == LayoutResult.PARTIAL)
{
processedRenderer = (LineRenderer)result.GetSplitRenderer();
}
}
if (onlyOverflowedFloatsLeft)
{
// This is done to trick ParagraphRenderer to break rendering and to overflow to the next page.
// The `onlyOverflowedFloatsLeft` is set to true only when no other content is left except
// overflowed floating elements.
processedRenderer = null;
}
TextAlignment?textAlignment = (TextAlignment?)this.GetProperty <TextAlignment?>(Property.TEXT_ALIGNMENT, TextAlignment
.LEFT);
ApplyTextAlignment(textAlignment, result, processedRenderer, layoutBox, floatRendererAreas, onlyOverflowedFloatsLeft
, lineIndent);
Leading leading = RenderingMode.HTML_MODE.Equals(this.GetProperty <RenderingMode?>(Property.RENDERING_MODE)
) ? null : this.GetProperty <Leading>(Property.LEADING);
// could be false if e.g. line contains only floats
bool lineHasContent = processedRenderer != null && processedRenderer.GetOccupiedArea().GetBBox().GetHeight
() > 0;
bool isFit = processedRenderer != null;
float deltaY = 0;
if (isFit && !RenderingMode.HTML_MODE.Equals(this.GetProperty <RenderingMode?>(Property.RENDERING_MODE)))
{
if (lineHasContent)
{
float indentFromLastLine = previousDescent - lastLineBottomLeadingIndent - (leading != null ? processedRenderer
.GetTopLeadingIndent(leading) : 0) - processedRenderer.GetMaxAscent();
// TODO this is a workaround. To be refactored
if (processedRenderer != null && processedRenderer.ContainsImage())
{
indentFromLastLine += previousDescent;
}
deltaY = lastYLine + indentFromLastLine - processedRenderer.GetYLine();
lastLineBottomLeadingIndent = leading != null?processedRenderer.GetBottomLeadingIndent(leading) : 0;
// TODO this is a workaround. To be refactored
if (lastLineBottomLeadingIndent < 0 && processedRenderer.ContainsImage())
{
lastLineBottomLeadingIndent = 0;
}
}
// for the first and last line in a paragraph, leading is smaller
if (firstLineInBox)
{
deltaY = processedRenderer != null && leading != null ? -processedRenderer.GetTopLeadingIndent(leading) :
0;
}
isFit = leading == null || processedRenderer.GetOccupiedArea().GetBBox().GetY() + deltaY >= layoutBox.GetY
();
}
if (!isFit && (null == processedRenderer || IsOverflowFit(overflowY)))
{
if (currentAreaPos + 1 < areas.Count)
{
layoutBox = areas[++currentAreaPos].Clone();
lastYLine = layoutBox.GetY() + layoutBox.GetHeight();
firstLineInBox = true;
}
else
{
bool keepTogether = IsKeepTogether();
if (keepTogether)
{
floatRendererAreas.RetainAll(nonChildFloatingRendererAreas);
return(new MinMaxWidthLayoutResult(LayoutResult.NOTHING, null, null, this, null == result.GetCauseOfNothing
() ? this : result.GetCauseOfNothing()));
}
else
{
if (marginsCollapsingEnabled)
{
if (anythingPlaced && notAllKidsAreFloats)
{
marginsCollapseHandler.EndChildMarginsHandling(layoutBox);
}
}
// On page split, if not only overflowed floats left, content will be drawn on next page, i.e. under all floats on this page
bool includeFloatsInOccupiedAreaOnSplit = !onlyOverflowedFloatsLeft || includeFloatsInOccupiedArea;
if (includeFloatsInOccupiedAreaOnSplit)
{
FloatingHelper.IncludeChildFloatsInOccupiedArea(floatRendererAreas, this, nonChildFloatingRendererAreas);
FixOccupiedAreaIfOverflowedX(overflowX, layoutBox);
}
if (marginsCollapsingEnabled)
{
marginsCollapseHandler.EndMarginsCollapse(layoutBox);
}
bool minHeightOverflowed = false;
if (!includeFloatsInOccupiedAreaOnSplit)
{
AbstractRenderer minHeightOverflow = ApplyMinHeight(overflowY, layoutBox);
minHeightOverflowed = minHeightOverflow != null;
ApplyVerticalAlignment();
}
iText.Layout.Renderer.ParagraphRenderer[] split = Split();
split[0].lines = lines;
foreach (LineRenderer line in lines)
{
split[0].childRenderers.AddAll(line.GetChildRenderers());
}
split[1].childRenderers.AddAll(inlineFloatsOverflowedToNextPage);
if (processedRenderer != null)
{
split[1].childRenderers.AddAll(processedRenderer.GetChildRenderers());
}
if (result.GetOverflowRenderer() != null)
{
split[1].childRenderers.AddAll(result.GetOverflowRenderer().GetChildRenderers());
}
if (onlyOverflowedFloatsLeft && !includeFloatsInOccupiedArea && !minHeightOverflowed)
{
FloatingHelper.RemoveParentArtifactsOnPageSplitIfOnlyFloatsOverflow(split[1]);
}
float usedHeight = occupiedArea.GetBBox().GetHeight();
if (!includeFloatsInOccupiedAreaOnSplit)
{
Rectangle commonRectangle = Rectangle.GetCommonRectangle(layoutBox, occupiedArea.GetBBox());
usedHeight = commonRectangle.GetHeight();
}
UpdateHeightsOnSplit(usedHeight, wasHeightClipped, this, split[1], includeFloatsInOccupiedAreaOnSplit);
CorrectFixedLayout(layoutBox);
ApplyPaddings(occupiedArea.GetBBox(), paddings, true);
ApplyBorderBox(occupiedArea.GetBBox(), borders, true);
ApplyMargins(occupiedArea.GetBBox(), true);
ApplyAbsolutePositionIfNeeded(layoutContext);
LayoutArea editedArea = FloatingHelper.AdjustResultOccupiedAreaForFloatAndClear(this, layoutContext.GetFloatRendererAreas
(), layoutContext.GetArea().GetBBox(), clearHeightCorrection, marginsCollapsingEnabled);
if (wasHeightClipped)
{
return(new MinMaxWidthLayoutResult(LayoutResult.FULL, editedArea, split[0], null).SetMinMaxWidth(minMaxWidth
));
}
else
{
if (anythingPlaced)
{
return(new MinMaxWidthLayoutResult(LayoutResult.PARTIAL, editedArea, split[0], split[1]).SetMinMaxWidth(minMaxWidth
));
}
else
{
if (true.Equals(GetPropertyAsBoolean(Property.FORCED_PLACEMENT)))
{
occupiedArea.SetBBox(Rectangle.GetCommonRectangle(occupiedArea.GetBBox(), currentRenderer.GetOccupiedArea(
).GetBBox()));
FixOccupiedAreaIfOverflowedX(overflowX, layoutBox);
parent.SetProperty(Property.FULL, true);
lines.Add(currentRenderer);
// Force placement of children we have and do not force placement of the others
if (LayoutResult.PARTIAL == result.GetStatus())
{
IRenderer childNotRendered = result.GetCauseOfNothing();
int firstNotRendered = currentRenderer.childRenderers.IndexOf(childNotRendered);
currentRenderer.childRenderers.RetainAll(currentRenderer.childRenderers.SubList(0, firstNotRendered));
split[1].childRenderers.RemoveAll(split[1].childRenderers.SubList(0, firstNotRendered));
return(new MinMaxWidthLayoutResult(LayoutResult.PARTIAL, editedArea, this, split[1], null).SetMinMaxWidth(
minMaxWidth));
}
else
{
return(new MinMaxWidthLayoutResult(LayoutResult.FULL, editedArea, null, null, this).SetMinMaxWidth(minMaxWidth
));
}
}
else
{
floatRendererAreas.RetainAll(nonChildFloatingRendererAreas);
return(new MinMaxWidthLayoutResult(LayoutResult.NOTHING, null, null, this, null == result.GetCauseOfNothing
() ? this : result.GetCauseOfNothing()));
}
}
}
}
}
}
else
{
if (leading != null)
{
processedRenderer.ApplyLeading(deltaY);
if (lineHasContent)
{
lastYLine = processedRenderer.GetYLine();
}
}
if (lineHasContent)
{
occupiedArea.SetBBox(Rectangle.GetCommonRectangle(occupiedArea.GetBBox(), processedRenderer.GetOccupiedArea
().GetBBox()));
FixOccupiedAreaIfOverflowedX(overflowX, layoutBox);
}
firstLineInBox = false;
layoutBox.SetHeight(processedRenderer.GetOccupiedArea().GetBBox().GetY() - layoutBox.GetY());
lines.Add(processedRenderer);
anythingPlaced = true;
currentRenderer = (LineRenderer)result.GetOverflowRenderer();
previousDescent = processedRenderer.GetMaxDescent();
if (!inlineFloatsOverflowedToNextPage.IsEmpty() && result.GetOverflowRenderer() == null)
{
onlyOverflowedFloatsLeft = true;
// dummy renderer to trick paragraph renderer to continue kids loop
currentRenderer = new LineRenderer();
}
}
}
if (!RenderingMode.HTML_MODE.Equals(this.GetProperty <RenderingMode?>(Property.RENDERING_MODE)))
{
float moveDown = lastLineBottomLeadingIndent;
if (IsOverflowFit(overflowY) && moveDown > occupiedArea.GetBBox().GetY() - layoutBox.GetY())
{
moveDown = occupiedArea.GetBBox().GetY() - layoutBox.GetY();
}
occupiedArea.GetBBox().MoveDown(moveDown);
occupiedArea.GetBBox().SetHeight(occupiedArea.GetBBox().GetHeight() + moveDown);
}
if (marginsCollapsingEnabled)
{
if (childRenderers.Count > 0 && notAllKidsAreFloats)
{
marginsCollapseHandler.EndChildMarginsHandling(layoutBox);
}
}
if (includeFloatsInOccupiedArea)
{
FloatingHelper.IncludeChildFloatsInOccupiedArea(floatRendererAreas, this, nonChildFloatingRendererAreas);
FixOccupiedAreaIfOverflowedX(overflowX, layoutBox);
}
if (wasHeightClipped)
{
FixOccupiedAreaIfOverflowedY(overflowY, layoutBox);
}
if (marginsCollapsingEnabled)
{
marginsCollapseHandler.EndMarginsCollapse(layoutBox);
}
AbstractRenderer overflowRenderer = ApplyMinHeight(overflowY, layoutBox);
if (overflowRenderer != null && IsKeepTogether())
{
floatRendererAreas.RetainAll(nonChildFloatingRendererAreas);
return(new LayoutResult(LayoutResult.NOTHING, null, null, this, this));
}
CorrectFixedLayout(layoutBox);
ApplyPaddings(occupiedArea.GetBBox(), paddings, true);
ApplyBorderBox(occupiedArea.GetBBox(), borders, true);
ApplyMargins(occupiedArea.GetBBox(), true);
ApplyAbsolutePositionIfNeeded(layoutContext);
if (rotation != null)
{
ApplyRotationLayout(layoutContext.GetArea().GetBBox().Clone());
if (IsNotFittingLayoutArea(layoutContext.GetArea()))
{
if (IsNotFittingWidth(layoutContext.GetArea()) && !IsNotFittingHeight(layoutContext.GetArea()))
{
LogManager.GetLogger(GetType()).Warn(MessageFormatUtil.Format(iText.IO.LogMessageConstant.ELEMENT_DOES_NOT_FIT_AREA
, "It fits by height so it will be forced placed"));
}
else
{
if (!true.Equals(GetPropertyAsBoolean(Property.FORCED_PLACEMENT)))
{
floatRendererAreas.RetainAll(nonChildFloatingRendererAreas);
return(new MinMaxWidthLayoutResult(LayoutResult.NOTHING, null, null, this, this));
}
}
}
}
ApplyVerticalAlignment();
FloatingHelper.RemoveFloatsAboveRendererBottom(floatRendererAreas, this);
LayoutArea editedArea_1 = FloatingHelper.AdjustResultOccupiedAreaForFloatAndClear(this, layoutContext.GetFloatRendererAreas
(), layoutContext.GetArea().GetBBox(), clearHeightCorrection, marginsCollapsingEnabled);
if (null == overflowRenderer)
{
return(new MinMaxWidthLayoutResult(LayoutResult.FULL, editedArea_1, null, null, null).SetMinMaxWidth(minMaxWidth
));
}
else
{
return(new MinMaxWidthLayoutResult(LayoutResult.PARTIAL, editedArea_1, this, overflowRenderer, null).SetMinMaxWidth
(minMaxWidth));
}
}
public virtual iText.Layout.Layout.MinMaxWidthLayoutResult SetMinMaxWidth(MinMaxWidth minMaxWidth)
{
this.minMaxWidth = minMaxWidth;
return(this);
}
