letter&word spacing

Author: fzhangtj

Runtime/foundation/basic_types.cs

@@ -132,5 +132,22 @@ public static string toStringList<T>(this IList<T> it) {
             }
             return "{ " + string.Join(", ", it.Select(item => item.ToString())) + " }";
         }
+
+        public static void resize<T>(this List<T> list, int size, T value) {
+            int curSize = list.Count;
+            if (size < curSize) {
+                list.RemoveRange(size, curSize - size);
+            } else if(size > curSize) {
+                if (size > list.Capacity) {
+                    list.Capacity = size;
+                }
+                list.AddRange(Enumerable.Repeat(value, size - curSize));
+            }
+            
+            int remains = Math.Min(curSize, size);
+            for (int i = 0; i < remains; ++i) {
+                list[i] = value;
+            }
+        }
     }
 }

Runtime/ui/txt/layout.cs

@@ -1,5 +1,6 @@
+using System;
 using System.Collections.Generic;
-using UnityEngine;
+using Unity.UIWidgets.foundation;
 
 namespace Unity.UIWidgets.ui {
 
@@ -10,15 +11,14 @@ class Layout {
         List<float> _positions = new List<float>();
         float _advance;
         Rect _bounds;
-        string _text;
         TabStops _tabStops;
 
 
-        public static float measureText(float offset, string buf, int start, int count, TextStyle style,
+        public static float measureText(float offset, TextBuff buff, int start, int count, TextStyle style,
             List<float> advances, int advanceOffset, TabStops tabStops) {
             Layout layout = new Layout();
             layout.setTabStops(tabStops);
-            layout.doLayout(offset, buf, start, count, style);
+            layout.doLayout(offset, buff, start, count, style);
             if (advances != null) {
                 var layoutAdv = layout.getAdvances();
                 for (int i = 0; i < count; i++) {
@@ -29,41 +29,79 @@ public static float measureText(float offset, string buf, int start, int count,
             return layout.getAdvance();
         }
 
-        public void doLayout(float offset, string text, int start, int count, TextStyle style) {
-            this._text = text;
-            this._advances.Clear();
-            this._positions.Clear();
+        public void doLayout(float offset, TextBuff buff, int start, int count, TextStyle style) {
+            this._start = start;
             this._count = count;
+            this._advances.resize(count, 0);
+            this._positions.resize(count, 0);
+            this._advance = 0;
+            this._bounds = null;
+            
+            int wordstart = start == buff.size
+                ? start
+                : LayoutUtils.getPrevWordBreakForCache(buff, start + 1);
+            int wordend;
+            for (int iter = start; iter < start + count; iter = wordend) {
+                wordend = LayoutUtils.getNextWordBreakForCache(buff, iter);
+                int wordCount = Math.Min(start + count, wordend) - iter;
+                this.layoutWord(offset, iter - start,  buff.subBuff(wordstart, wordend - wordstart),
+                    iter - wordstart, wordCount, style);
+                wordstart = wordend;
+            }
+            this._count = count;
+            
+        }
+
+        void layoutWord(float offset, int layoutOffset, 
+            TextBuff buff, int start, int wordCount, TextStyle style) {
+            float wordSpacing =
+                wordCount == 1 && LayoutUtils.isWordSpace(buff.charAt(start)) ? style.wordSpacing : 0;
+
             var font = FontManager.instance.getOrCreate(style.fontFamily, style.fontWeight, style.fontStyle).font;
-            font.RequestCharactersInTextureSafe(this._text.Substring(start, count),
+            font.RequestCharactersInTextureSafe(buff.subBuff(start, wordCount).getString(),
                 style.UnityFontSize,
                 style.UnityFontStyle);
+            float x = this._advance;
+            float letterSpace = style.letterSpacing;
+            float letterSpaceHalfLeft = letterSpace * 0.5f;
+            float letterSpaceHalfRight = letterSpace - letterSpaceHalfLeft;
+            
+            for (int i = 0; i < wordCount; i++) {
+                var ch = buff.charAt(start + i);
+                if (i == 0) {
+                    x += letterSpaceHalfLeft + wordSpacing;
+                    this._advances[i + layoutOffset] += letterSpaceHalfLeft + wordSpacing;
+                }
+                else {
+                    this._advances[i - 1 + layoutOffset] += letterSpaceHalfRight;
+                    this._advances[i + layoutOffset] += letterSpaceHalfLeft;
+                    x += letterSpace;
+                }
 
-            this._advance = 0;
-            this._bounds = null;
-            for (int i = 0; i < count; i++) {
-                int charIndex = start + i;
-                var ch = text[charIndex];
                 var glyphInfo = font.getGlyphInfo(ch, style.UnityFontSize, style.UnityFontStyle);
-
                 var rect = glyphInfo.rect;
-                rect = rect.translate(this._advance, 0);
+                rect = rect.translate(x, 0);
                 if (this._bounds == null || this._bounds.isEmpty) {
                     this._bounds = rect;
                 }
                 else {
                     this._bounds = this._bounds.expandToInclude(rect);
                 }
-
-                this._positions.Add(this._advance);
+                
+                this._positions[i + layoutOffset] = x;
                 float advance = glyphInfo.advance;
                 if (ch == '\t') {
                     advance = this._tabStops.nextTab((this._advance + offset)) - this._advance;
                 }
-
-                this._advances.Add(advance);
-                this._advance += advance;
+                x += advance;
+                this._advances[i + layoutOffset] += advance;
+                if (i + 1 == wordCount) {
+                    this._advances[i + layoutOffset] += letterSpaceHalfRight;
+                    x += letterSpaceHalfRight;
+                }
             }
+            
+            this._advance = x;
         }
 
         public void setTabStops(TabStops tabStops) {

Runtime/ui/txt/layout_utils.cs

@@ -1,14 +1,67 @@
 namespace Unity.UIWidgets.ui {
-    public static class LayoutUtils {
+    static class LayoutUtils {
         public const char CHAR_NBSP = '\u00A0';
 
-        public static bool isWordSpace(char ch) {
+        public static bool isWordSpace(ushort ch) {
             return ch == ' ' || ch == CHAR_NBSP;
         }
 
         public static bool isLineEndSpace(char c) {
             return c == '\n' || c == ' ' || c == 0x1680 || (0x2000 <= c && c <= 0x200A && c != 0x2007) ||
                    c == 0x205F || c == 0x3000;
         }
+
+        public static int getPrevWordBreakForCache(TextBuff buff, int offset) {
+            int len = buff.size;
+            if (offset == 0) {
+                return 0;
+            }
+
+            if (offset > len) {
+                offset = len;
+            }
+            if (isWordBreakBefore(buff.charAt(offset - 1))) {
+                return offset - 1;
+            }
+            for (int i = offset - 1; i > 0; i--) {
+                if (isWordBreakBefore(buff.charAt(i)) || isWordBreakAfter(buff.charAt(i - 1))) {
+                    return i;
+                }
+            }
+            return 0;
+        }
+
+        
+        public static int getNextWordBreakForCache(TextBuff buff, int offset) {
+            int len = buff.size;
+            if (offset >= len) {
+                return len;
+            }
+
+            if (isWordBreakAfter(buff.charAt(offset))) {
+                return offset + 1;
+            }
+
+            for (int i = offset + 1; i < len; i++) {
+                if (isWordBreakBefore(buff.charAt(i))) {
+                    return i;
+                }
+            }
+
+            return len;
+        }
+
+        public static bool isWordBreakAfter(ushort c) {
+            if (isWordSpace(c) || (c >= 0x2000 && c <= 0x200a) || c == 0x3000) {
+                // spaces
+                return true;
+            }
+            return false;
+        }
+        
+        public static bool isWordBreakBefore(ushort c) {
+            return isWordBreakAfter(c) || (c >= 0x3400 && c <= 0x9fff);
+        }
+        
     }
 }

Runtime/ui/txt/linebreaker.cs

@@ -71,9 +71,7 @@ class LineBreaker {
         const float ScoreInfty = float.MaxValue;
         const float ScoreDesperate = 1e10f;
 
-        string _textBuf;
-        int _textOffset;
-        int _textLength;
+        TextBuff _textBuf;
         List<float> _charWidths = new List<float>();
         List<int> _breaks = new List<int>();
         List<float> _widths = new List<float>();
@@ -88,7 +86,7 @@ class LineBreaker {
         TabStops _tabStops;
         int mFirstTabIndex;
         List<Candidate> _candidates = new List<Candidate>();
-
+        
         public int computeBreaks() {
             int nCand = this._candidates.Count;
             if (nCand > 0 && (nCand == 1 || this._lastBreak != nCand - 1)) {
@@ -110,10 +108,8 @@ public void resize(int size) {
         }
 
         public void setText(string text, int textOffset, int textLength) {
-            this._textBuf = text;
-            this._textOffset = textOffset;
-            this._textLength = textLength;
-            this._wordBreaker.setText(this._textBuf, textOffset, textLength);
+            this._textBuf = new TextBuff(text, textOffset, textLength);
+            this._wordBreaker.setText(this._textBuf);
             this._wordBreaker.next();
             this._candidates.Clear();
             Candidate can = new Candidate {
@@ -136,7 +132,7 @@ public float addStyleRun(TextStyle style, int start, int end) {
             float width = 0.0f;
             if (style != null) {
                 width = Layout.measureText(this._width - this._preBreak, this._textBuf,
-                    start + this._textOffset, end - start, style,
+                    start, end - start, style,
                     this._charWidths, start, this._tabStops);
             }
 
@@ -149,7 +145,7 @@ public float addStyleRun(TextStyle style, int start, int end) {
             int postSpaceCount = this._spaceCount;
 
             for (int i = start; i < end; i++) {
-                char c = this._textBuf[i + this._textOffset];
+                char c = this._textBuf.charAt(i);
                 if (c == '\t') {
                     this._width = this._preBreak + this._tabStops.nextTab((this._width - this._preBreak));
                     if (this.mFirstTabIndex == int.MaxValue) {

Runtime/ui/txt/paragraph.cs

@@ -358,13 +358,13 @@ public void layout(ParagraphConstraints constraints) {
                     if (!string.IsNullOrEmpty(ellipsis) && !this._width.isInfinite() && !lineRange.hardBreak
                         && i == lineRuns.Count - 1 && (lineNumber == lineLimit - 1 || this._paragraphStyle.maxLines == null)) {
 
-                        float ellipsisWidth = Layout.measureText(runXOffset, ellipsis, 0,
+                        float ellipsisWidth = Layout.measureText(runXOffset, new TextBuff(ellipsis), 0,
                             ellipsis.Length, run.style, null, 0, this._tabStops);
                         List<float> textAdvances = new List<float>(textCount);
                         for (int index = 0; index < textCount;++index) {
                             textAdvances.Add(0);
                         }
-                        float textWidth = Layout.measureText(runXOffset, this._text, textStart, textCount,
+                        float textWidth = Layout.measureText(runXOffset, new TextBuff(text), textStart, textCount,
                             run.style, textAdvances, 0, this._tabStops);
 
                         int truncateCount = 0;
@@ -385,15 +385,15 @@ public void layout(ParagraphConstraints constraints) {
                         }
                     }
 
-                    layout.doLayout(runXOffset, text, textStart, textCount, run.style);
+                    layout.doLayout(runXOffset, new TextBuff(text), textStart, textCount, run.style);
                     if (layout.nGlyphs() == 0) {
                         continue;
                     }
 
                     float wordStartPosition = float.NaN;
-                    // var layoutAdvances = layout.getAdvances();
                     builder.allocRunPos(run.style, text, textStart, textCount);
-                    builder.setBounds(layout.getBounds());
+                    builder.setBounds(layout.getBounds().translate(-layout.getX(0), 0)); // bounds relative to first character
+                    
                     glyphPositions.Clear();
 
                     for (int glyphIndex = 0; glyphIndex < textCount; ++glyphIndex) {

Runtime/ui/txt/text_buff.cs

@@ -0,0 +1,30 @@
+using System;
+using Unity.UIWidgets.foundation;
+
+namespace Unity.UIWidgets.ui {
+    class TextBuff {
+        public readonly string text;
+        public readonly int offset;
+        public readonly int size;
+
+        public TextBuff(string text, int? offset = null, int? size = null) {
+            this.text = text;
+            this.offset = offset ?? 0;
+            this.size = size ?? text.Length - this.offset;
+        }
+
+        public char charAt(int index) {
+            return this.text[this.offset + index];
+        }
+
+        public TextBuff subBuff(int shift, int size) {
+            D.assert(shift >= 0 && shift <= this.size);
+            D.assert(shift + size <= this.size);
+            return new TextBuff(this.text, this.offset + shift, size);
+        }
+
+        public String getString() {
+            return this.text.Substring(this.offset, this.size);
+        }
+    }
+}

Runtime/ui/txt/word_separate.cs

@@ -50,11 +50,15 @@ public Range<int> findWordRange(int index) {
 
 
         internal static characterType classifyChar(string text, int index) {
-            if (char.IsWhiteSpace(text, index)) {
+            return classifyChar(text[index]);
+        }
+        
+        internal static characterType classifyChar(char ch) {
+            if (char.IsWhiteSpace(ch)) {
                 return characterType.WhiteSpace;
             }
 
-            if (char.IsLetterOrDigit(text, index) || text[index] == '\'') {
+            if (char.IsLetterOrDigit(ch) || ch == '\'') {
                 return characterType.LetterLike;
             }