static (bool success, Typeface typeface) TryGetFromAssets(this string fontName)
{
//First check Alias
var(hasFontAlias, fontPostScriptName) = FontRegistrar.HasFont(fontName);
if (hasFontAlias)
{
return(true, Typeface.CreateFromFile(fontPostScriptName));
}
var isAssetFont = IsAssetFontFamily(fontName);
if (isAssetFont)
{
return(LoadTypefaceFromAsset(fontName));
}
var folders = new[]
{
"",
"Fonts/",
"fonts/",
};
//copied text
var fontFile = FontFile.FromString(fontName);
if (!string.IsNullOrWhiteSpace(fontFile.Extension))
{
var(hasFont, fontPath) = FontRegistrar.HasFont(fontFile.FileNameWithExtension());
if (hasFont)
{
return(true, Typeface.CreateFromFile(fontPath));
}
}
else
{
foreach (var ext in FontFile.Extensions)
{
var formated = fontFile.FileNameWithExtension(ext);
var(hasFont, fontPath) = FontRegistrar.HasFont(formated);
if (hasFont)
{
return(true, Typeface.CreateFromFile(fontPath));
}
foreach (var folder in folders)
{
formated = $"{folder}{fontFile.FileNameWithExtension()}#{fontFile.PostScriptName}";
var result = LoadTypefaceFromAsset(formated);
if (result.success)
{
return(result);
}
}
}
}
return(false, null);
}
private void SetFormattedText()
{
if (Control != null)
{
var text = new NSMutableAttributedString(string.Empty);
foreach (var span in Element.FormattedText.Spans)
{
var range = new NSRange(0, span.Text.Length);
var subText = new NSMutableAttributedString(span.Text, foregroundColor: span.TextColor.ToUIColor());
var font = UIFont.SystemFontOfSize(new nfloat(span.FontSize));
if (string.IsNullOrEmpty(span.FontFamily))
{
switch (label.FontAttributes)
{
case FontAttributes.None:
font = UIFont.SystemFontOfSize(new nfloat(span.FontSize));
break;
case FontAttributes.Bold:
font = UIFont.BoldSystemFontOfSize(new nfloat(span.FontSize));
break;
case FontAttributes.Italic:
font = UIFont.ItalicSystemFontOfSize(new nfloat(span.FontSize));
break;
default:
font = UIFont.BoldSystemFontOfSize(new nfloat(span.FontSize));
break;
}
}
else
{
var exportFonts = FontRegistrar.HasFont(span.FontFamily);
if (exportFonts.hasFont)
{
var pathName = exportFonts.fontPath;
pathName = pathName.Replace(".ttf", string.Empty).Replace(".otf", string.Empty);
font = UIFont.FromName(pathName, new nfloat(span.FontSize));
}
else
{
var fn = GetFontName(span.FontFamily, span.FontAttributes);
font = UIFont.FromName(fn, new nfloat(span.FontSize));
}
}
subText.AddAttribute(UIStringAttributeKey.Font, font, range);
if (span.BackgroundColor != Color.Default)
{
subText.AddAttribute(UIStringAttributeKey.BackgroundColor, span.BackgroundColor.ToUIColor(), range);
}
text.Append(subText);
}
Control.AttributedText = text;
}
}
static string CleanseFontName(string fontName)
{
var fontFile = FontFile.FromString(fontName);
if (!string.IsNullOrWhiteSpace(fontFile.Extension))
{
var(hasFont, _) = FontRegistrar.HasFont(fontFile.FileNameWithExtension());
if (hasFont)
{
return(fontFile.PostScriptName);
}
}
else
{
foreach (var ext in FontFile.Extensions)
{
var formated = fontFile.FileNameWithExtension(ext);
var(hasFont, filePath) = FontRegistrar.HasFont(formated);
if (hasFont)
{
return(fontFile.PostScriptName);
}
}
}
return(fontFile.PostScriptName);
}
private static string CleanseFontName(string fontName)
{
//First check Alias
(bool hasFontAlias, string fontPostScriptName) = FontRegistrar.HasFont(fontName);
if (hasFontAlias)
{
return(fontPostScriptName);
}
FontFile fontFile = FontFile.FromString(fontName);
if (!string.IsNullOrWhiteSpace(fontFile.Extension))
{
(bool hasFont, string filePath) = FontRegistrar.HasFont(fontFile.FileNameWithExtension());
if (hasFont)
{
return(filePath ?? fontFile.PostScriptName);
}
}
else
{
foreach (string ext in FontFile.Extensions)
{
string formated = fontFile.FileNameWithExtension(ext);
(bool hasFont, string filePath) = FontRegistrar.HasFont(formated);
if (hasFont)
{
return(filePath);
}
}
}
return(fontFile.PostScriptName);
}
public void CanLoadFonts(string fontName, string assetName)
{
var fontWeight = FontWeight.Regular;
var registrar = new FontRegistrar(fontLoader: null);
registrar.Register("dokdo_regular.ttf", "myalias");
var manager = new FontManager(registrar);
var actual = manager.GetTypeface(Font.OfSize(fontName, 12, fontWeight));
var expected = Typeface.Create(Typeface.CreateFromAsset(Application.Context.Assets, assetName), (int)fontWeight, italic: false);
Assert.True(expected.Equals(actual));
}
public void CanLoadEmbeddedFont()
{
var fontName = "FooBarFont";
var fontWeight = FontWeight.Regular;
var registrar = new FontRegistrar(new EmbeddedFontLoader());
registrar.Register("dokdo_regular.ttf", fontName, GetType().Assembly);
var manager = new FontManager(registrar);
var actual = manager.GetTypeface(Font.OfSize(fontName, 12, fontWeight));
var defaultFont = Typeface.Create(Typeface.Create(fontName, TypefaceStyle.Normal), (int)fontWeight, italic: false);
Assert.False(defaultFont.Equals(actual));
}
static IEnumerable <string> GetAllFontPossibilities(string fontFamily)
{
const string path = "Assets/Fonts/";
string[] extensions = new[]
{
".ttf",
".otf",
};
var fontFile = FontFile.FromString(fontFamily);
//If the extension is provided, they know what they want!
var hasExtension = !string.IsNullOrWhiteSpace(fontFile.Extension);
if (hasExtension)
{
var(hasFont, filePath) = FontRegistrar.HasFont(fontFile.FileNameWithExtension());
if (hasFont)
{
var formated = $"{filePath}#{fontFile.GetPostScriptNameWithSpaces()}";
yield return(formated);
yield break;
}
else
{
yield return($"{path}{fontFile.FileNameWithExtension()}");
}
}
foreach (var ext in extensions)
{
var(hasFont, filePath) = FontRegistrar.HasFont(fontFile.FileNameWithExtension(ext));
if (hasFont)
{
var formatted = $"{filePath}#{fontFile.GetPostScriptNameWithSpaces()}";
yield return(formatted);
yield break;
}
}
//Always send the base back
yield return(fontFamily);
foreach (var ext in extensions)
{
var formatted = $"{path}{fontFile.FileNameWithExtension(ext)}#{fontFile.GetPostScriptNameWithSpaces()}";
yield return(formatted);
}
}
static (bool success, FontFamily fontFamily) TryGetFromAssets(this string fontName)
{
//First check Alias
var(hasFontAlias, fontPostScriptName) = FontRegistrar.HasFont(fontName);
if (hasFontAlias)
{
return(true, CreateFromFile(fontPostScriptName));
}
var folders = new[]
{
"",
"Fonts/",
"fonts/",
};
//copied text
var fontFile = FontFile.FromString(fontName);
if (!string.IsNullOrWhiteSpace(fontFile.Extension))
{
var(hasFont, fontPath) = FontRegistrar.HasFont(fontFile.FileNameWithExtension());
if (hasFont)
{
return(true, CreateFromFile(fontPath));
}
}
else
{
foreach (var ext in FontFile.Extensions)
{
var formated = fontFile.FileNameWithExtension(ext);
var(hasFont, fontPath) = FontRegistrar.HasFont(formated);
if (hasFont)
{
return(true, CreateFromFile(fontPath));
}
}
}
return(false, null);
}
private void UpdateFormattedText()
{
if (Element?.FormattedText == null)
{
return;
}
var spanList = new List <SpannableString>();
foreach (var span in label.FormattedText.Spans)
{
var ss = new SpannableString(span.Text);
ss.SetSpan(new ForegroundColorSpan(span.TextColor.ToAndroid()), 0, span.Text.Length, SpanTypes.ExclusiveExclusive);
ss.SetSpan(new AbsoluteSizeSpan((int)span.FontSize, true), 0, span.Text.Length, SpanTypes.ExclusiveExclusive);
if (!string.IsNullOrEmpty(span.FontFamily))
{
var exportFonts = FontRegistrar.HasFont(span.FontFamily);
if (exportFonts.hasFont)
{
var tf = Typeface.CreateFromFile(exportFonts.fontPath);
ss.SetSpan(new TypefaceSpan(tf), 0, span.Text.Length, SpanTypes.ExclusiveExclusive);
}
else
{
var tf = GetTypeface();
ss.SetSpan(new TypefaceSpan(span.FontFamily), 0, span.Text.Length, SpanTypes.ExclusiveExclusive);
}
}
else
{
var tf = GetTypeface();
ss.SetSpan(new TypefaceSpan(span.FontFamily), 0, span.Text.Length, SpanTypes.ExclusiveExclusive);
}
spanList.Add(ss);
}
var result = new SpannableString(TextUtils.ConcatFormatted(spanList.ToArray()));
Control.TextFormatted = result;
}
public void CanLoadEmbeddedFont()
{
// skip on older androids for now
// https://github.com/dotnet/maui/issues/5903
if (!OperatingSystem.IsAndroidVersionAtLeast(28))
{
return;
}
var fontName = "FooBarFont";
var fontWeight = FontWeight.Regular;
var fontStyle = TypefaceStyle.Normal;
var fontSlant = false;
var registrar = new FontRegistrar(new EmbeddedFontLoader());
registrar.Register("dokdo_regular.ttf", fontName, GetType().Assembly);
var manager = new FontManager(registrar);
var actual = manager.GetTypeface(Font.OfSize(fontName, 12, fontWeight));
Assert.NotEqual(Typeface.Default, actual);
Typeface expected;
var expectedTypeface = Typeface.Create(fontName, TypefaceStyle.Normal);
if (OperatingSystem.IsAndroidVersionAtLeast(28))
{
expected = Typeface.Create(expectedTypeface, (int)fontWeight, italic: fontSlant);
}
else
{
expected = Typeface.Create(expectedTypeface, fontStyle);
}
Assert.NotEqual(Typeface.Default, expected);
Assert.False(expected.Equals(actual));
}
public MainWindow()
{
InitializeComponent();
var font = ToFontFamily("pack://application:,,,/Fonts/#Font Awesome 5 Free Solid");
var window = new Window()
{
Content = new TextBlock()
{
Text = "\uf007;",
FontFamily = font,
Margin = new System.Windows.Thickness(10, 10, 10, 10)
}
};
window.Show();
FontRegistrar.Register(new ExportFontAttribute("FontAwesome5_Solid.otf"), typeof(MainWindow).Assembly);
Forms.Init();
LoadApplication(new BugReport.App());
}
public void CanLoadFonts(string fontName, string assetName)
{
// skip on older androids for now
// https://github.com/dotnet/maui/issues/5903
if (!OperatingSystem.IsAndroidVersionAtLeast(28))
{
return;
}
var fontWeight = FontWeight.Regular;
var fontStyle = TypefaceStyle.Normal;
var fontSlant = false;
Typeface expected;
var expectedTypeface = Typeface.CreateFromAsset(Application.Context.Assets, assetName);
if (OperatingSystem.IsAndroidVersionAtLeast(28))
{
expected = Typeface.Create(expectedTypeface, (int)fontWeight, fontSlant);
}
else
{
expected = Typeface.Create(expectedTypeface, fontStyle);
}
Assert.NotEqual(Typeface.Default, expected);
var registrar = new FontRegistrar(fontLoader: null);
registrar.Register("dokdo_regular.ttf", "myalias");
var manager = new FontManager(registrar);
var actual = manager.GetTypeface(Font.OfSize(fontName, 12, fontWeight));
Assert.NotEqual(Typeface.Default, actual);
Assert.True(expected.Equals(actual));
}
