LT-22324: add OpenType font feature options

Add word generation font options

Finish up the docx font updates

Partial fixes

LT-22324: preserve OpenType font features

xWorks: preserve OpenType features in Word export

Author: johnml1135

Build/Agent/check-whitespace.ps1

@@ -83,7 +83,7 @@ Get-Content check-results.log | ForEach-Object {
 }
 
 if ($problems.Count -gt 0) {
-	Write-Host "`u26A0`uFE0F Please review the output for further information."
+	Write-Host '[WARN] Please review the output for further information.'
 	Write-Host '### A whitespace issue was found in one or more of the commits.'
 	Write-Host 'This check validates commit history from origin/main..HEAD, not just the current working tree.'
 	Write-Host 'If the report names an older commit, fix the file and then amend, squash, or rebase so that commit no longer appears in the branch history.'

Build/Agent/fix-whitespace.ps1

@@ -38,18 +38,61 @@ function Write-Utf8Text {
 	[System.IO.File]::WriteAllText($Path, $Content, $encoding)
 }
 
+function Get-OriginalLineEnding {
+	param([Parameter(Mandatory)][string]$Content)
+
+	if ($Content.Contains("`r`n")) { return "`r`n" }
+	if ($Content.Contains("`n")) { return "`n" }
+	if ($Content.Contains("`r")) { return "`r" }
+	return [Environment]::NewLine
+}
+
+function Read-Utf8Text {
+	param([Parameter(Mandatory)][string]$Path)
+
+	$stream = [System.IO.File]::OpenRead($Path)
+	try {
+		$encoding = New-Object System.Text.UTF8Encoding($false, $true)
+		$reader = New-Object System.IO.StreamReader($stream, $encoding, $true)
+		try {
+			return $reader.ReadToEnd()
+		}
+		finally {
+			$reader.Dispose()
+		}
+	}
+	finally {
+		$stream.Dispose()
+	}
+}
+
+function Get-TextFilesFromDiff {
+	param([Parameter(Mandatory)][string]$Range)
+
+	$files = New-Object System.Collections.Generic.List[string]
+	foreach ($line in (git diff --numstat $Range)) {
+		$parts = $line -split "`t", 3
+		if ($parts.Length -eq 3 -and $parts[0] -ne '-' -and $parts[1] -ne '-') {
+			$files.Add($parts[2])
+		}
+	}
+
+	return $files.ToArray()
+}
+
 function Format-FileWhitespace {
 	param([Parameter(Mandatory)][string]$Path)
 	if (-not (Test-Path -LiteralPath $Path)) { return }
 	try {
 		$hasUtf8Bom = Test-HasUtf8Bom -Path $Path
-		$raw = Get-Content -LiteralPath $Path -Raw -Encoding utf8
+		$raw = Read-Utf8Text -Path $Path
 	}
  catch {
 		Write-Host "Skipping non-UTF8 or binary file: $Path"
 		return
 	}
 	$orig = $raw
+	$lineEnding = Get-OriginalLineEnding -Content $raw
 	# Normalize newlines to real LF characters for processing
 	$normalized = $raw -replace '\r\n', "`n" -replace '\r', "`n"
 	# Build a mutable list of lines and trim trailing spaces/tabs
@@ -60,7 +103,7 @@ function Format-FileWhitespace {
 	# Remove trailing blank lines
 	while ($lines.Count -gt 0 -and [string]::IsNullOrWhiteSpace($lines[$lines.Count - 1])) { $lines.RemoveAt($lines.Count - 1) }
 	# Join back and ensure exactly one trailing newline
-	$new = ($lines -join "`n") + "`n"
+	$new = ($lines -join $lineEnding) + $lineEnding
 	if ($new -ne $orig) {
 		Write-Utf8Text -Path $Path -Content $new -EmitBom $hasUtf8Bom
 		Write-Host "Fixed whitespace: $Path"
@@ -78,7 +121,8 @@ if (Test-Path -LiteralPath 'check-results.log') {
 if (-not $fixFiles -or $fixFiles.Count -eq 0) {
 	$base = Get-BaseRef
 	Write-Host "Fixing whitespace for files changed since $base..HEAD"
-	$fixFiles = git diff --name-only "$base"..HEAD
+	$range = "$base..HEAD"
+	$fixFiles = Get-TextFilesFromDiff -Range $range
 }
 
 $files = $fixFiles | Where-Object { $_ -and (Test-Path $_) }

Directory.Packages.props

@@ -148,10 +148,15 @@
 		=============================================================
 	-->
 	<ItemGroup Label="Test Infrastructure">
+		<PackageVersion Include="HarfBuzzSharp" Version="7.3.0" />
+		<PackageVersion Include="HarfBuzzSharp.NativeAssets.Win32" Version="7.3.0" />
 		<PackageVersion Include="Moq" Version="4.20.70" />
 		<PackageVersion Include="NUnit" Version="3.14.0" />
 		<PackageVersion Include="NUnit3TestAdapter" Version="4.6.0" />
 		<PackageVersion Include="NUnitForms" Version="1.3.1" />
 		<PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+		<PackageVersion Include="SkiaSharp" Version="2.88.9" />
+		<PackageVersion Include="SkiaSharp.HarfBuzz" Version="2.88.9" />
+		<PackageVersion Include="SkiaSharp.NativeAssets.Win32" Version="2.88.9" />
 	</ItemGroup>
 </Project>

Docs/opentype-font-features.md

@@ -0,0 +1,19 @@
+# OpenType Font Features
+
+FieldWorks stores font options as renderer-neutral feature strings such as `smcp=1`, `kern=0`, and `cv01=2`. The same value is used by writing-system default fonts, style font settings, rendering, and export paths.
+
+In the current WinForms UI, use the Font Options button in font controls to choose the configurable features exposed by the selected font. Graphite remains available for now, but the Font Options UI is no longer limited to Graphite fonts.
+
+Graphite feature IDs are still converted only at the Graphite renderer boundary. OpenType feature tags stay as four-character tags and are passed to the Uniscribe OpenType path when Graphite is not enabled.
+
+For export, CSS output maps these values to `font-feature-settings`, and Notebook export preserves writing-system default font features in `DefaultFontFeatures`.
+
+Word DOCX export preserves the subset of OpenType features that Microsoft WordprocessingML can represent with Office 2010 `w14` typography elements:
+
+- `liga`, `clig`, `hlig`, and `dlig` map to Word ligature settings.
+- `lnum` and `onum` map to lining and old-style number forms.
+- `pnum` and `tnum` map to proportional and tabular number spacing.
+- `calt` maps to contextual alternatives.
+- `ss01` through `ss20` map to Word stylistic sets.
+
+Other tags, including character variants such as `cv01`, small-cap features such as `smcp`, kerning, swashes, and private or vendor tags, do not have a documented arbitrary DOCX feature-tag representation. Word export ignores those unsupported tags while preserving supported tags from the same feature string.

Src/Common/FwUtils/FontFeatureSettings.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace SIL.FieldWorks.Common.FwUtils
+{
+	/// <summary>
+	/// Parses and normalizes renderer-neutral font feature strings of the form tag=value.
+	/// </summary>
+	public static class FontFeatureSettings
+	{
+		/// <summary>
+		/// Parses a comma-separated font feature string into normalized feature settings.
+		/// Invalid entries are ignored so project data cannot crash render/UI paths.
+		/// </summary>
+		public static IReadOnlyList<FontFeatureSetting> Parse(string features)
+		{
+			if (string.IsNullOrWhiteSpace(features))
+				return Array.Empty<FontFeatureSetting>();
+
+			var settingsByTag = new Dictionary<string, FontFeatureSetting>(StringComparer.Ordinal);
+			foreach (var rawPart in features.Split(','))
+			{
+				var part = rawPart.Trim();
+				if (part.Length == 0)
+					continue;
+
+				var equalsIndex = part.IndexOf('=');
+				if (equalsIndex <= 0 || equalsIndex == part.Length - 1)
+					continue;
+
+				var tag = part.Substring(0, equalsIndex).Trim();
+				var valueText = part.Substring(equalsIndex + 1).Trim();
+				if (!IsValidOpenTypeTag(tag))
+					continue;
+
+				int value;
+				if (!int.TryParse(valueText, NumberStyles.Integer, CultureInfo.InvariantCulture, out value) || value < 0)
+					continue;
+
+				settingsByTag[tag] = new FontFeatureSetting(tag, value);
+			}
+
+			return settingsByTag.Values.OrderBy(setting => setting.Tag, StringComparer.Ordinal).ToArray();
+		}
+
+		/// <summary>
+		/// Returns a deterministic string representation of valid feature settings.
+		/// </summary>
+		public static string Normalize(string features)
+		{
+			return string.Join(",", Parse(features).Select(setting => setting.ToString()));
+		}
+
+		/// <summary>
+		/// Returns whether a string is a valid four-character OpenType feature tag.
+		/// </summary>
+		public static bool IsValidOpenTypeTag(string tag)
+		{
+			return tag != null && tag.Length == 4 && tag.All(character => character >= 0x20 && character <= 0x7e);
+		}
+	}
+
+	/// <summary>
+	/// A single renderer-neutral font feature setting.
+	/// </summary>
+	public sealed class FontFeatureSetting
+	{
+		/// <summary>
+		/// Initializes a new instance of the <see cref="FontFeatureSetting"/> class.
+		/// </summary>
+		public FontFeatureSetting(string tag, int value)
+		{
+			if (!FontFeatureSettings.IsValidOpenTypeTag(tag))
+				throw new ArgumentException("OpenType feature tags must contain exactly four printable ASCII characters.", nameof(tag));
+			if (value < 0)
+				throw new ArgumentOutOfRangeException(nameof(value), "Feature values must be non-negative.");
+
+			Tag = tag;
+			Value = value;
+		}
+
+		/// <summary>
+		/// Gets the four-character OpenType feature tag.
+		/// </summary>
+		public string Tag { get; }
+
+		/// <summary>
+		/// Gets the feature value.
+		/// </summary>
+		public int Value { get; }
+
+		/// <inheritdoc />
+		public override string ToString()
+		{
+			return string.Format(CultureInfo.InvariantCulture, "{0}={1}", Tag, Value);
+		}
+	}
+}

Src/Common/FwUtils/FwUtilsTests/FontFeatureSettingsTests.cs

@@ -0,0 +1,42 @@
+using System.Linq;
+using NUnit.Framework;
+
+namespace SIL.FieldWorks.Common.FwUtils
+{
+	[TestFixture]
+	public class FontFeatureSettingsTests
+	{
+		[Test]
+		public void Parse_ReturnsNormalizedTagValueSettings()
+		{
+			var settings = FontFeatureSettings.Parse(" smcp = 1, kern=0,cv01=2 ").ToArray();
+
+			Assert.That(settings.Select(setting => setting.ToString()),
+				Is.EqualTo(new[] { "cv01=2", "kern=0", "smcp=1" }));
+		}
+
+		[Test]
+		public void Parse_LastValueWinsForDuplicateTags()
+		{
+			var settings = FontFeatureSettings.Parse("smcp=1,smcp=0").ToArray();
+
+			Assert.That(settings, Has.Length.EqualTo(1));
+			Assert.That(settings[0].ToString(), Is.EqualTo("smcp=0"));
+		}
+
+		[Test]
+		public void Parse_IgnoresInvalidEntries()
+		{
+			var settings = FontFeatureSettings.Parse("smcp=1,bad=2,cv01=-1,kern=x,liga=0").ToArray();
+
+			Assert.That(settings.Select(setting => setting.ToString()),
+				Is.EqualTo(new[] { "liga=0", "smcp=1" }));
+		}
+
+		[Test]
+		public void Normalize_ReturnsDeterministicRendererNeutralString()
+		{
+			Assert.That(FontFeatureSettings.Normalize(" smcp = 1, kern=0 "), Is.EqualTo("kern=0,smcp=1"));
+		}
+	}
+}

Src/Common/RenderVerification/RenderComparisonTests/HarfBuzzSkiaComparisonTests.cs

@@ -0,0 +1,103 @@
+using System.Linq;
+using System.Runtime.InteropServices;
+using HarfBuzzSharp;
+using NUnit.Framework;
+using SkiaSharp;
+using SkiaSharp.HarfBuzz;
+
+namespace SIL.FieldWorks.Common.RenderVerification.RenderComparisonTests
+{
+	[TestFixture]
+	public class HarfBuzzSkiaComparisonTests
+	{
+		[Test]
+		public void ShapeText_OpenTypeFeatureToggleChangesShapingData()
+		{
+			using (var typeface = SKTypeface.FromFamilyName("Times New Roman"))
+			{
+				if (typeface == null)
+					Assert.Inconclusive("Times New Roman is not installed on this machine.");
+
+				var disabled = ShapeText(typeface, "office affinity AVATAR", "-liga");
+				var enabled = ShapeText(typeface, "office affinity AVATAR", "+liga");
+
+				if (disabled.SequenceEqual(enabled))
+					Assert.Inconclusive("Times New Roman did not expose a deterministic liga shaping delta through HarfBuzzSharp.");
+			}
+		}
+
+		[Test]
+		public void DrawShapedText_ProducesNonBlankComparisonBitmap()
+		{
+			using (var typeface = SKTypeface.FromFamilyName("Times New Roman"))
+			{
+				if (typeface == null)
+					Assert.Inconclusive("Times New Roman is not installed on this machine.");
+
+				using (var bitmap = new SKBitmap(360, 90))
+				using (var canvas = new SKCanvas(bitmap))
+				using (var paint = new SKPaint { Typeface = typeface, TextSize = 40, IsAntialias = true, Color = SKColors.Black })
+				using (var shaper = new SKShaper(typeface))
+				using (var buffer = new Buffer())
+				{
+					canvas.Clear(SKColors.White);
+					buffer.AddUtf8("office affinity AVATAR");
+					buffer.GuessSegmentProperties();
+					var shaped = shaper.Shape(buffer, paint);
+					Assert.That(shaped.Codepoints, Is.Not.Empty);
+
+					canvas.DrawShapedText(shaper, "office affinity AVATAR", 12, 58, paint);
+					Assert.That(CountNonWhitePixels(bitmap), Is.GreaterThan(0));
+				}
+			}
+		}
+
+		private static int CountNonWhitePixels(SKBitmap bitmap)
+		{
+			return Enumerable.Range(0, bitmap.Height)
+				.Sum(y => Enumerable.Range(0, bitmap.Width)
+					.Count(x => bitmap.GetPixel(x, y) != SKColors.White));
+		}
+
+		private static uint[] ShapeText(SKTypeface typeface, string text, string feature)
+		{
+			var fontData = ReadTypefaceData(typeface);
+			var fontDataHandle = GCHandle.Alloc(fontData, GCHandleType.Pinned);
+			try
+			{
+				using (var blob = new Blob(fontDataHandle.AddrOfPinnedObject(), fontData.Length, MemoryMode.Duplicate))
+				using (var face = new Face(blob, 0))
+				using (var font = new HarfBuzzSharp.Font(face))
+				using (var buffer = new Buffer())
+				{
+					font.SetScale(40 * 64, 40 * 64);
+					buffer.AddUtf8(text);
+					buffer.GuessSegmentProperties();
+					font.Shape(buffer, new[] { Feature.Parse(feature) });
+					return buffer.GlyphInfos.Select(info => info.Codepoint).ToArray();
+				}
+			}
+			finally
+			{
+				fontDataHandle.Free();
+			}
+		}
+
+		private static byte[] ReadTypefaceData(SKTypeface typeface)
+		{
+			int faceIndex;
+			using (var stream = typeface.OpenStream(out faceIndex))
+			{
+				if (stream == null || !stream.HasLength)
+					Assert.Inconclusive("The selected typeface does not expose readable font data.");
+
+				var data = new byte[checked((int)stream.Length)];
+				var read = stream.Read(data, data.Length);
+				if (read != data.Length)
+					Assert.Inconclusive("The selected typeface could not be read completely.");
+
+				return data;
+			}
+		}
+	}
+}