Refactor text renderers sequence word wrapping logic

Extract separate TextSequenceWordWrapping class.
For special scripts wrap processing apply EPS to occupied area during relayout.
LineRenderer: merge and rename moveForward mode booleans and methods.
LineRenderer: merge updateSpecialScriptLayoutResults and updateTextRendererLayoutResults to updateTextSequenceLayoutResults.
TextRenderer: set containsPossibleBreak always, not only in case of HTML_MODE rendering mode.
TextRenderer: set containsPossibleBreak in case of width overflow only if forcePartialSplitOnFirstChar.

DEVSIX-1438

Autoported commit.
Original commit hash: [4622b05a63]

Author: yulian-gaponenko

itext.tests/itext.layout.tests/itext/layout/renderer/WordWrapUnitTest.cs

@@ -60,9 +60,9 @@ public class TextLayoutResult : MinMaxWidthLayoutResult {
 
         protected internal bool containsPossibleBreak = false;
 
-        protected internal bool lineStartsWithWhiteSpace = false;
+        protected internal bool startsWithSplitCharacterWhiteSpace = false;
 
-        protected internal bool lineEndsWithSplitCharacterOrWhiteSpace = false;
+        protected internal bool endsWithSplitCharacter = false;
 
         protected internal float leftMinWidth;
 
@@ -209,50 +209,51 @@ public virtual iText.Layout.Layout.TextLayoutResult SetContainsPossibleBreak(boo
 
         /// <summary>
         /// Sets
-        /// <see cref="IsLineStartsWithWhiteSpace()"/>.
+        /// <see cref="IsStartsWithSplitCharacterWhiteSpace()"/>.
         /// </summary>
-        /// <param name="lineStartsWithWhiteSpace">indicates if TextRenderer#line starts with a whitespace.</param>
+        /// <param name="startsWithSplitCharacterWhiteSpace">
+        /// indicates if TextRenderer#line starts with a split character that is
+        /// also a whitespace.
+        /// </param>
         /// <returns>
         /// 
         /// <see cref="TextLayoutResult">this layout result</see>
         /// the setting was applied on.
         /// </returns>
-        /// <seealso cref="IsLineStartsWithWhiteSpace()"/>
-        public virtual iText.Layout.Layout.TextLayoutResult SetLineStartsWithWhiteSpace(bool lineStartsWithWhiteSpace
+        /// <seealso cref="IsStartsWithSplitCharacterWhiteSpace()"/>
+        public virtual iText.Layout.Layout.TextLayoutResult SetStartsWithSplitCharacterWhiteSpace(bool startsWithSplitCharacterWhiteSpace
             ) {
-            this.lineStartsWithWhiteSpace = lineStartsWithWhiteSpace;
+            this.startsWithSplitCharacterWhiteSpace = startsWithSplitCharacterWhiteSpace;
             return this;
         }
 
         /// <summary>Indicates whether TextRenderer#line starts with a whitespace.</summary>
         /// <returns>true if TextRenderer#line starts with a whitespace.</returns>
-        public virtual bool IsLineStartsWithWhiteSpace() {
-            return lineStartsWithWhiteSpace;
+        public virtual bool IsStartsWithSplitCharacterWhiteSpace() {
+            return startsWithSplitCharacterWhiteSpace;
         }
 
         /// <summary>
         /// Sets
-        /// <see cref="IsLineEndsWithSplitCharacterOrWhiteSpace()"/>.
+        /// <see cref="IsEndsWithSplitCharacter()"/>.
         /// </summary>
-        /// <param name="lineEndsWithSplitCharacterOrWhiteSpace">indicates if TextRenderer#line ends with a splitCharacter.
-        ///     </param>
+        /// <param name="endsWithSplitCharacter">indicates if TextRenderer#line ends with a splitCharacter.</param>
         /// <returns>
         /// 
         /// <see cref="TextLayoutResult">this layout result</see>
         /// the setting was applied on.
         /// </returns>
-        /// <seealso cref="IsLineEndsWithSplitCharacterOrWhiteSpace()"/>
-        public virtual iText.Layout.Layout.TextLayoutResult SetLineEndsWithSplitCharacterOrWhiteSpace(bool lineEndsWithSplitCharacterOrWhiteSpace
-            ) {
-            this.lineEndsWithSplitCharacterOrWhiteSpace = lineEndsWithSplitCharacterOrWhiteSpace;
+        /// <seealso cref="IsEndsWithSplitCharacter()"/>
+        public virtual iText.Layout.Layout.TextLayoutResult SetEndsWithSplitCharacter(bool endsWithSplitCharacter) {
+            this.endsWithSplitCharacter = endsWithSplitCharacter;
             return this;
         }
 
         /// <summary>Indicates whether TextRenderer#line ends with a splitCharacter.</summary>
         /// <returns>true if TextRenderer#line ends with a splitCharacter.</returns>
         /// <seealso cref="iText.Layout.Splitting.ISplitCharacters"/>
-        public virtual bool IsLineEndsWithSplitCharacterOrWhiteSpace() {
-            return lineEndsWithSplitCharacterOrWhiteSpace;
+        public virtual bool IsEndsWithSplitCharacter() {
+            return endsWithSplitCharacter;
         }
 
         /// <summary>Sets min width of the leftmost unbreakable part of the TextRenderer#line after layout.</summary>

itext/itext.layout/itext/layout/layout/TextLayoutResult.cs

@@ -90,6 +90,30 @@ public abstract class AbstractRenderer : IRenderer {
         /// <summary>The infinity value which is used while layouting</summary>
         protected internal const float INF = 1e6f;
 
+        /// <summary>
+        /// The common ordering index of top side in arrays of four elements which define top, right, bottom,
+        /// left sides values (e.g. margins, borders, paddings).
+        /// </summary>
+        internal const int TOP_SIDE = 0;
+
+        /// <summary>
+        /// The common ordering index of right side in arrays of four elements which define top, right, bottom,
+        /// left sides values (e.g. margins, borders, paddings).
+        /// </summary>
+        internal const int RIGHT_SIDE = 1;
+
+        /// <summary>
+        /// The common ordering index of bottom side in arrays of four elements which define top, right, bottom,
+        /// left sides values (e.g. margins, borders, paddings).
+        /// </summary>
+        internal const int BOTTOM_SIDE = 2;
+
+        /// <summary>
+        /// The common ordering index of left side in arrays of four elements which define top, right, bottom,
+        /// left sides values (e.g. margins, borders, paddings).
+        /// </summary>
+        internal const int LEFT_SIDE = 3;
+
         // TODO linkedList?
         protected internal IList<IRenderer> childRenderers = new List<IRenderer>();
 
@@ -1653,28 +1677,28 @@ protected internal virtual bool AllowLastYLineRecursiveExtraction() {
         /// of the renderer
         /// </returns>
         protected internal virtual Rectangle ApplyMargins(Rectangle rect, UnitValue[] margins, bool reverse) {
-            if (!margins[0].IsPointValue()) {
+            if (!margins[TOP_SIDE].IsPointValue()) {
                 ILog logger = LogManager.GetLogger(typeof(iText.Layout.Renderer.AbstractRenderer));
                 logger.Error(MessageFormatUtil.Format(iText.IO.LogMessageConstant.PROPERTY_IN_PERCENTS_NOT_SUPPORTED, Property
                     .MARGIN_TOP));
             }
-            if (!margins[1].IsPointValue()) {
+            if (!margins[RIGHT_SIDE].IsPointValue()) {
                 ILog logger = LogManager.GetLogger(typeof(iText.Layout.Renderer.AbstractRenderer));
                 logger.Error(MessageFormatUtil.Format(iText.IO.LogMessageConstant.PROPERTY_IN_PERCENTS_NOT_SUPPORTED, Property
                     .MARGIN_RIGHT));
             }
-            if (!margins[2].IsPointValue()) {
+            if (!margins[BOTTOM_SIDE].IsPointValue()) {
                 ILog logger = LogManager.GetLogger(typeof(iText.Layout.Renderer.AbstractRenderer));
                 logger.Error(MessageFormatUtil.Format(iText.IO.LogMessageConstant.PROPERTY_IN_PERCENTS_NOT_SUPPORTED, Property
                     .MARGIN_BOTTOM));
             }
-            if (!margins[3].IsPointValue()) {
+            if (!margins[LEFT_SIDE].IsPointValue()) {
                 ILog logger = LogManager.GetLogger(typeof(iText.Layout.Renderer.AbstractRenderer));
                 logger.Error(MessageFormatUtil.Format(iText.IO.LogMessageConstant.PROPERTY_IN_PERCENTS_NOT_SUPPORTED, Property
                     .MARGIN_LEFT));
             }
-            return rect.ApplyMargins(margins[0].GetValue(), margins[1].GetValue(), margins[2].GetValue(), margins[3].GetValue
-                (), reverse);
+            return rect.ApplyMargins(margins[TOP_SIDE].GetValue(), margins[RIGHT_SIDE].GetValue(), margins[BOTTOM_SIDE
+                ].GetValue(), margins[LEFT_SIDE].GetValue(), reverse);
         }
 
         /// <summary>Returns margins of the renderer</summary>