/// <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);
}
}
/// <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,
});
}
}
