Cover several layout classes with documentation

DEVSIX-6675

Autoported commit.
Original commit hash: [2237853e4]

Author: AnhelinaM

itext/itext.layout/itext/layout/element/AbstractElement.cs

@@ -181,6 +181,11 @@ public virtual T SetPageNumber(int pageNumber) {
             return (T)(Object)this;
         }
 
+        /// <summary>Creates new renderer instance.</summary>
+        /// <returns>
+        /// new
+        /// <see cref="iText.Layout.Renderer.IRenderer"/>
+        /// </returns>
         protected internal abstract IRenderer MakeNewRenderer();
     }
 }

itext/itext.layout/itext/layout/element/Cell.cs

@@ -243,6 +243,15 @@ protected internal override IRenderer MakeNewRenderer() {
             return new CellRenderer(this);
         }
 
+        /// <summary>Updates cell indexes.</summary>
+        /// <param name="row">the number of the row to update</param>
+        /// <param name="col">the number of the col to update</param>
+        /// <param name="numberOfColumns">to evaluate new colspan</param>
+        /// <returns>
+        /// this
+        /// <see cref="Cell"/>
+        /// with updated fields
+        /// </returns>
         protected internal virtual iText.Layout.Element.Cell UpdateCellIndexes(int row, int col, int numberOfColumns
             ) {
             this.row = row;

itext/itext.layout/itext/layout/element/FlexContainer.cs

@@ -43,7 +43,17 @@ source product.
 using iText.Layout.Renderer;
 
 namespace iText.Layout.Element {
+    /// <summary>
+    /// A
+    /// <see cref="FlexContainer"/>
+    /// represents a container of the flex objects.
+    /// </summary>
     internal class FlexContainer : Div {
+        /// <summary>
+        /// Creates new
+        /// <see cref="FlexContainer"/>
+        /// instance.
+        /// </summary>
         public FlexContainer()
             : base() {
         }

itext/itext.layout/itext/layout/element/IBlockElement.cs

@@ -41,6 +41,14 @@ source product.
 address: [email protected]
 */
 namespace iText.Layout.Element {
+    /// <summary>This class represents a block layout element with special margins, tabbing, and alignment.</summary>
+    /// <remarks>
+    /// This class represents a block layout element with special margins, tabbing, and alignment.
+    /// An
+    /// <see cref="IBlockElement"/>
+    /// will try to take up as much horizontal space as available to it
+    /// on the canvas or page. The concept is comparable to the block element in HTML.
+    /// </remarks>
     public interface IBlockElement : IAbstractElement {
     }
 }

itext/itext.layout/itext/layout/element/TabStop.cs

@@ -128,30 +128,80 @@ public TabStop(float tabPosition, TabAlignment tabAlignment, ILineDrawer tabLead
             this.tabAnchor = '.';
         }
 
+        /// <summary>Returns the position of a tab stop.</summary>
+        /// <returns>tabPosition, measured in absolute points</returns>
         public virtual float GetTabPosition() {
             return tabPosition;
         }
 
+        /// <summary>
+        /// Returns the alignment of a tab stop, which defines the way the textual content
+        /// should be positioned in regard to this tab stop.
+        /// </summary>
+        /// <returns>
+        /// a
+        /// <see cref="iText.Layout.Properties.TabAlignment"/>
+        /// value
+        /// </returns>
         public virtual TabAlignment GetTabAlignment() {
             return tabAlignment;
         }
 
+        /// <summary>
+        /// Sets the alignment, which defines the way the textual content
+        /// should be positioned in regard to this tab stop.
+        /// </summary>
+        /// <param name="tabAlignment">
+        /// a
+        /// <see cref="iText.Layout.Properties.TabAlignment"/>
+        /// value
+        /// </param>
         public virtual void SetTabAlignment(TabAlignment tabAlignment) {
             this.tabAlignment = tabAlignment;
         }
 
+        /// <summary>Returns the anchor of a tab stop.</summary>
+        /// <returns>
+        /// a
+        /// <see cref="char?"/>
+        /// value
+        /// </returns>
         public virtual char? GetTabAnchor() {
             return tabAnchor;
         }
 
+        /// <summary>Sets the anchor of a tab stop.</summary>
+        /// <param name="tabAnchor">
+        /// a
+        /// <see cref="char?"/>
+        /// value
+        /// </param>
         public virtual void SetTabAnchor(char? tabAnchor) {
             this.tabAnchor = tabAnchor;
         }
 
+        /// <summary>
+        /// Returns the tab leader of a tab stop, which defines a pattern that
+        /// should be repeated until the TabStop is reached.
+        /// </summary>
+        /// <returns>
+        /// a
+        /// <see cref="iText.Kernel.Pdf.Canvas.Draw.ILineDrawer"/>
+        /// value, a pattern drawing object
+        /// </returns>
         public virtual ILineDrawer GetTabLeader() {
             return tabLeader;
         }
 
+        /// <summary>
+        /// Sets the tab leader of a tab stop, which defines a pattern that
+        /// should be repeated until the TabStop is reached.
+        /// </summary>
+        /// <param name="tabLeader">
+        /// a
+        /// <see cref="iText.Kernel.Pdf.Canvas.Draw.ILineDrawer"/>
+        /// value
+        /// </param>
         public virtual void SetTabLeader(ILineDrawer tabLeader) {
             this.tabLeader = tabLeader;
         }

itext/itext.layout/itext/layout/element/Table.cs

@@ -1103,6 +1103,12 @@ private static UnitValue[] NormalizeColumnWidths(int numberOfColumns) {
             return normalized;
         }
 
+        /// <summary>Returns the list of all row groups.</summary>
+        /// <returns>
+        /// a list of a
+        /// <see cref="RowRange"/>
+        /// which holds the row numbers of a section of a table
+        /// </returns>
         protected internal virtual IList<Table.RowRange> GetRowGroups() {
             int lastRowWeCanFlush = currentColumn == columnWidths.Length ? currentRow : currentRow - 1;
             int[] cellBottomRows = new int[columnWidths.Length];

itext/itext.layout/itext/layout/hyphenation/HyphenationConstants.cs

@@ -43,6 +43,7 @@ source product.
 using System;
 
 namespace iText.Layout.Hyphenation {
+    /// <summary>Class containing constants to be used in hyphenation on layout level.</summary>
     public class HyphenationConstants {
         public const String HYPHENATION_DEFAULT_RESOURCE = "iText.Hyph.";
     }

itext/itext.layout/itext/layout/hyphenation/TernaryTreeIterator.cs

@@ -82,6 +82,11 @@ public Item(TernaryTreeIterator _enclosing, char p, char c) {
                 this.child = c;
             }
 
+            /// <summary>Construct item.</summary>
+            /// <param name="i">
+            /// an
+            /// <see cref="Item"/>
+            /// </param>
             public Item(TernaryTreeIterator _enclosing, TernaryTreeIterator.Item i) {
                 this._enclosing = _enclosing;
                 this.parent = i.parent;

itext/itext.layout/itext/layout/renderer/AreaBreakRenderer.cs

@@ -49,12 +49,12 @@ source product.
 
 namespace iText.Layout.Renderer {
     /// <summary>
-    /// Renderer object for the
+    /// Renderer for the
     /// <see cref="iText.Layout.Element.AreaBreak"/>
     /// layout element.
     /// </summary>
     /// <remarks>
-    /// Renderer object for the
+    /// Renderer for the
     /// <see cref="iText.Layout.Element.AreaBreak"/>
     /// layout element. Will terminate the
     /// current content area and initialize a new one.

itext/itext.layout/itext/layout/renderer/BlockRenderer.cs

@@ -60,7 +60,14 @@ source product.
 using iText.Layout.Tagging;
 
 namespace iText.Layout.Renderer {
+    /// <summary>Represents a renderer for block elements.</summary>
     public abstract class BlockRenderer : AbstractRenderer {
+        /// <summary>Creates a BlockRenderer from its corresponding layout object.</summary>
+        /// <param name="modelElement">
+        /// the
+        /// <see cref="iText.Layout.Element.IElement"/>
+        /// which this object should manage
+        /// </param>
         protected internal BlockRenderer(IElement modelElement)
             : base(modelElement) {
         }
@@ -514,6 +521,13 @@ public override Rectangle GetOccupiedAreaBBox() {
             return bBox;
         }
 
+        /// <summary>Creates a split renderer.</summary>
+        /// <param name="layoutResult">the result of content layouting</param>
+        /// <returns>
+        /// a new
+        /// <see cref="AbstractRenderer"/>
+        /// instance
+        /// </returns>
         protected internal virtual AbstractRenderer CreateSplitRenderer(int layoutResult) {
             AbstractRenderer splitRenderer = (AbstractRenderer)GetNextRenderer();
             splitRenderer.parent = parent;
@@ -524,6 +538,13 @@ protected internal virtual AbstractRenderer CreateSplitRenderer(int layoutResult
             return splitRenderer;
         }
 
+        /// <summary>Creates an overflow renderer.</summary>
+        /// <param name="layoutResult">the result of content layouting</param>
+        /// <returns>
+        /// a new
+        /// <see cref="AbstractRenderer"/>
+        /// instance
+        /// </returns>
         protected internal virtual AbstractRenderer CreateOverflowRenderer(int layoutResult) {
             AbstractRenderer overflowRenderer = (AbstractRenderer)GetNextRenderer();
             overflowRenderer.parent = parent;
@@ -571,6 +592,10 @@ internal virtual AbstractRenderer[] CreateSplitAndOverflowRenderers(int childPos
             return new AbstractRenderer[] { splitRenderer, overflowRenderer };
         }
 
+        /// <summary>
+        /// This method applies vertical alignment for the occupied area
+        /// of the renderer and its children renderers.
+        /// </summary>
         protected internal virtual void ApplyVerticalAlignment() {
             VerticalAlignment? verticalAlignment = this.GetProperty<VerticalAlignment?>(Property.VERTICAL_ALIGNMENT);
             if (verticalAlignment == null || verticalAlignment == VerticalAlignment.TOP || childRenderers.IsEmpty()) {
@@ -619,6 +644,14 @@ protected internal virtual void ApplyVerticalAlignment() {
             }
         }
 
+        /// <summary>
+        /// This method rotates content of the renderer and
+        /// calculates correct occupied area for the rotated element.
+        /// </summary>
+        /// <param name="layoutBox">
+        /// a
+        /// <see cref="iText.Kernel.Geom.Rectangle"/>
+        /// </param>
         protected internal virtual void ApplyRotationLayout(Rectangle layoutBox) {
             float angle = (float)this.GetPropertyAsFloat(Property.ROTATION_ANGLE);
             float x = occupiedArea.GetBBox().GetX();
@@ -702,6 +735,12 @@ protected internal virtual AffineTransform CreateRotationTransformInsideOccupied
             return rotationTransform;
         }
 
+        /// <summary>This method starts rotation for the renderer if rotation angle property is specified.</summary>
+        /// <param name="canvas">
+        /// the
+        /// <see cref="iText.Kernel.Pdf.Canvas.PdfCanvas"/>
+        /// to draw on
+        /// </param>
         protected internal virtual void BeginRotationIfApplied(PdfCanvas canvas) {
             float? angle = this.GetPropertyAsFloat(Property.ROTATION_ANGLE);
             if (angle != null) {
@@ -717,6 +756,12 @@ protected internal virtual void BeginRotationIfApplied(PdfCanvas canvas) {
             }
         }
 
+        /// <summary>This method ends rotation for the renderer if applied.</summary>
+        /// <param name="canvas">
+        /// the
+        /// <see cref="iText.Kernel.Pdf.Canvas.PdfCanvas"/>
+        /// to draw on
+        /// </param>
         protected internal virtual void EndRotationIfApplied(PdfCanvas canvas) {
             float? angle = this.GetPropertyAsFloat(Property.ROTATION_ANGLE);
             if (angle != null && HasOwnProperty(Property.ROTATION_INITIAL_HEIGHT)) {