/// <summary>
        /// Check if the characters at the boundary between strings is a word boundary
        /// </summary>
        /// <param name="a">The first string</param>
        /// <param name="b">The second string</param>
        /// <returns>True if this is a word boundary</returns>
        public static bool IsWordBoundary(Slice <int> a, Slice <int> b)
        {
            // If either empty, assume it's a boundary
            if (a.Length == 0)
            {
                return(true);
            }
            if (b.Length == 0)
            {
                return(true);
            }

            // Get the last non-ignore character from 'first string
            var aGroup = WordBoundaryClass.Ignore;

            for (int i = a.Length - 1; i >= 0 && aGroup == WordBoundaryClass.Ignore; i--)
            {
                aGroup = UnicodeClasses.BoundaryGroup(a[i]);
            }

            // Get the first non-ignore character from second string
            var bGroup = WordBoundaryClass.Ignore;

            for (int i = 0; i < b.Length && bGroup == WordBoundaryClass.Ignore; i++)
            {
                bGroup = UnicodeClasses.BoundaryGroup(b[i]);
            }

            // Check if boundary
            return(aGroup != bGroup && bGroup != WordBoundaryClass.Space);
        }
        /// <summary>
        /// Locate the start of each "word" in a unicode string.  Used for Ctrl+Left/Right
        /// in editor and different to the line break algorithm.
        /// </summary>
        public static IEnumerable <int> FindWordBoundaries(Slice <int> codePoints)
        {
            // Start is always a word boundary
            yield return(0);

            // Find all boundaries
            bool inWord    = false;
            var  wordGroup = WordBoundaryClass.Ignore;

            for (int i = 0; i < codePoints.Length; i++)
            {
                // Get group
                var bg = UnicodeClasses.BoundaryGroup(codePoints[i]);

                // Ignore?
                if (bg == WordBoundaryClass.Ignore)
                {
                    continue;
                }

                // Ignore spaces before word
                if (!inWord)
                {
                    // Ignore spaces before word
                    if (bg == WordBoundaryClass.Space)
                    {
                        continue;
                    }

                    // Found start of word
                    if (i != 0)
                    {
                        yield return(i);
                    }

                    // We're now in the word
                    inWord    = true;
                    wordGroup = bg;
                    continue;
                }

                // We're in a word group, check for change of kind
                if (wordGroup != bg)
                {
                    if (bg == WordBoundaryClass.Space)
                    {
                        inWord = false;
                    }
                    else
                    {
                        // Switch to a different word kind without a space
                        // just emit a word boundary here
                        yield return(i);
                    }
                }
            }

            if (!inWord && codePoints.Length > 0)
            {
                yield return(codePoints.Length);
            }
        }
Example #3
0
        /// <summary>
        /// Splits a sequence of code points into a series of runs with font fallback applied
        /// </summary>
        /// <param name="codePoints">The code points</param>
        /// <param name="typeface">The preferred typeface</param>
        /// <param name="replacementCharacter">The replacement character to be used for the run</param>
        /// <returns>A sequence of runs with unsupported code points replaced by a selected font fallback</returns>
        public static IEnumerable <Run> GetFontRuns(Slice <int> codePoints, SKTypeface typeface, char replacementCharacter = '\0')
        {
            var font = new SKFont(typeface);

            if (replacementCharacter != '\0')
            {
                var glyph = font.GetGlyph(replacementCharacter);
                if (glyph == 0)
                {
                    var fallbackTypeface = CharacterMatcher.MatchCharacter(typeface.FamilyName, typeface.FontWeight, typeface.FontWidth, typeface.FontSlant, null, replacementCharacter);
                    if (fallbackTypeface != null)
                    {
                        typeface = fallbackTypeface;
                    }
                }

                yield return(new Run()
                {
                    Start = 0,
                    Length = codePoints.Length,
                    Typeface = typeface,
                });

                yield break;
            }

            // Get glyphs using the top-level typeface
            var glyphs = new ushort[codePoints.Length];

            font.GetGlyphs(codePoints.AsSpan(), glyphs);

            // Look for subspans that need font fallback (where glyphs are zero)
            int runStart = 0;

            for (int i = 0; i < codePoints.Length; i++)
            {
                // Do we need fallback for this character?
                if (glyphs[i] == 0)
                {
                    // Check if there's a fallback available, if not, might as well continue with the current top-level typeface
                    var subSpanTypeface = CharacterMatcher.MatchCharacter(typeface.FamilyName, typeface.FontWeight, typeface.FontWidth, typeface.FontSlant, null, codePoints[i]);
                    if (subSpanTypeface == null)
                    {
                        continue;
                    }

                    // Don't fallback for whitespace characters
                    if (UnicodeClasses.BoundaryGroup(codePoints[i]) == WordBoundaryClass.Space)
                    {
                        continue;
                    }

                    // Must be a cluster boundary
                    if (!GraphemeClusterAlgorithm.IsBoundary(codePoints, i))
                    {
                        continue;
                    }

                    // We can do font fallback...

                    // Flush the current top-level run
                    if (i > runStart)
                    {
                        yield return(new Run()
                        {
                            Start = runStart,
                            Length = i - runStart,
                            Typeface = typeface,
                        });
                    }

                    // Count how many unmatched characters
                    var unmatchedStart = i;
                    var unmatchedEnd   = i + 1;
                    while (unmatchedEnd < codePoints.Length &&
                           (glyphs[unmatchedEnd] == 0 || !GraphemeClusterAlgorithm.IsBoundary(codePoints, unmatchedEnd)))
                    {
                        unmatchedEnd++;
                    }
                    var unmatchedLength = unmatchedEnd - unmatchedStart;

                    // Match the missing characters
                    while (unmatchedLength > 0)
                    {
                        // Find the font fallback using the first character
                        subSpanTypeface = CharacterMatcher.MatchCharacter(typeface.FamilyName, typeface.FontWeight, typeface.FontWidth, typeface.FontSlant, null, codePoints[unmatchedStart]);
                        if (subSpanTypeface == null)
                        {
                            unmatchedEnd = unmatchedStart;
                            break;
                        }
                        var subSpanFont = new SKFont(subSpanTypeface);

                        // Get the glyphs over the current unmatched range
                        subSpanFont.GetGlyphs(codePoints.SubSlice(unmatchedStart, unmatchedLength).AsSpan(), new Span <ushort>(glyphs, unmatchedStart, unmatchedLength));

                        // Count how many characters were matched
                        var fallbackStart = unmatchedStart;
                        var fallbackEnd   = unmatchedStart + 1;
                        while (fallbackEnd < unmatchedEnd && glyphs[fallbackEnd] != 0)
                        {
                            fallbackEnd++;
                        }
                        var fallbackLength = fallbackEnd - fallbackStart;

                        // Yield this font fallback run
                        yield return(new Run()
                        {
                            Start = fallbackStart,
                            Length = fallbackLength,
                            Typeface = subSpanTypeface,
                        });

                        // Continue selecting font fallbacks until the entire unmatched ranges has been matched
                        unmatchedStart  += fallbackLength;
                        unmatchedLength -= fallbackLength;
                    }

                    // Move onto the next top level span
                    i        = unmatchedEnd - 1;    // account for i++ on for loop
                    runStart = unmatchedEnd;
                }
            }

            // Flush find run
            if (codePoints.Length > runStart)
            {
                yield return(new Run()
                {
                    Start = runStart,
                    Length = codePoints.Length - runStart,
                    Typeface = typeface,
                });
            }
        }