internal static async Task ExportFontsAsZipAsync(List <FontVariant> fonts, string name)
{
if (await PickFileAsync(name, "ZIP", new[] { ".zip" }) is StorageFile file)
{
await Task.Run(async() =>
{
ExportNamingScheme scheme = ResourceHelper.AppSettings.ExportNamingScheme;
using var i = await file.OpenStreamForWriteAsync();
i.SetLength(0);
using ZipArchive z = new ZipArchive(i, ZipArchiveMode.Create);
foreach (var font in fonts)
{
if (DirectWrite.IsFontLocal(font.FontFace))
{
string fileName = GetFileName(font, scheme);
ZipArchiveEntry entry = z.CreateEntry(fileName);
using IOutputStream s = entry.Open().AsOutputStream();
await DirectWrite.WriteToStreamAsync(font.FontFace, s);
}
}
});
Messenger.Default.Send(new AppNotificationMessage(true, new ExportFontFileResult(true, file)));
}
}
internal static async Task ExportFontsToFolderAsync(List <FontVariant> fonts)
{
FolderPicker picker = new FolderPicker
{
SuggestedStartLocation = PickerLocationId.DocumentsLibrary
};
picker.FileTypeFilter.Add("*");
if (await picker.PickSingleFolderAsync() is StorageFolder folder)
{
await Task.Run(async() =>
{
ExportNamingScheme scheme = ResourceHelper.AppSettings.ExportNamingScheme;
foreach (var font in fonts)
{
if (DirectWrite.IsFontLocal(font.FontFace))
{
string fileName = GetFileName(font, scheme);
StorageFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
await TryWriteToFileAsync(font, file);
}
}
});
Messenger.Default.Send(new AppNotificationMessage(true, new ExportFontFileResult(folder, true)));
}
}
private static string GetFileName(FontVariant font, ExportNamingScheme scheme)
{
string fileName = null;
string ext = ".ttf";
var src = DirectWrite.GetFileName(font.FontFace);
if (!string.IsNullOrWhiteSpace(src))
{
var strsrc = Path.GetExtension(src);
if (!string.IsNullOrWhiteSpace(strsrc))
{
ext = strsrc;
}
}
if (string.IsNullOrEmpty(ext))
{
if (scheme == ExportNamingScheme.System)
{
fileName = src;
}
}
if (string.IsNullOrWhiteSpace(fileName))
{
fileName = $"{font.FamilyName.Trim()} {font.PreferredName.Trim()}{ext}";
}
return($"{Utils.Humanise(Path.GetFileNameWithoutExtension(fileName), false)}{Path.GetExtension(fileName).ToLower()}");
}
public static async void RequestExportFontFile(FontVariant variant)
{
var scheme = ResourceHelper.AppSettings.ExportNamingScheme;
var interop = Utils.GetInterop();
if (DirectWrite.IsFontLocal(variant.FontFace))
{
string filePath = GetFileName(variant, scheme);
string name = Path.GetFileNameWithoutExtension(filePath);
string ext = Path.GetExtension(filePath);
if (await PickFileAsync(name, Localization.Get("ExportFontFile/Text"), new[] { ext }, PickerLocationId.DocumentsLibrary) is StorageFile file)
{
try
{
bool success = await TryWriteToFileAsync(variant, file);
Messenger.Default.Send(new AppNotificationMessage(true, new ExportFontFileResult(success, file)));
return;
}
catch
{
}
}
}
Messenger.Default.Send(new AppNotificationMessage(true, new ExportFontFileResult(null, false)));
}
public static List <TypographyFeatureInfo> GetSupportedTypographyFeatures(FontVariant variant)
{
var features = DirectWrite.GetSupportedTypography(variant.FontFace).Values.ToList();
var list = features.Select(f => new TypographyFeatureInfo((CanvasTypographyFeatureName)f)).OrderBy(f => f.DisplayName).ToList();
return(list);
}
public static async Task <(StorageFile File, ConversionStatus Result)> TryConvertAsync(
StorageFile file, StorageFolder targetFolder = null)
{
if (file.FileType.ToLower().EndsWith("woff"))
{
StorageFolder folder = targetFolder ?? ApplicationData.Current.TemporaryFolder;
string name = Path.GetFileNameWithoutExtension(file.DisplayName);
if (targetFolder is not null) // Avoid threading errors with multiple converts to the same target folder
{
name += $"-{_random.Next(1000,100000)}";
}
StorageFile newFile = await folder.CreateFileAsync($"{name}.otf", CreationCollisionOption.ReplaceExisting).AsTask().ConfigureAwait(false);
ConversionStatus result = await TryConvertWoffToOtfAsync(file, newFile).ConfigureAwait(false);
if (result == ConversionStatus.OK)
{
if (DirectWrite.HasValidFonts(GetAppUri(newFile)))
{
return(newFile, ConversionStatus.OK);
}
else
{
return(default, ConversionStatus.UnspecifiedError);
private static async Task <bool> TryWriteToFileAsync(FontVariant font, StorageFile file)
{
try
{
using IRandomAccessStream s = await file.OpenAsync(FileAccessMode.ReadWrite);
s.Size = 0;
using IOutputStream o = s.GetOutputStreamAt(0);
await DirectWrite.WriteToStreamAsync(font.FontFace, o);
return(true);
}
catch { }
return(false);
}
public TypographyFeatureInfo(CanvasTypographyFeatureName n)
{
Feature = n;
if (IsNamedFeature(Feature))
{
DisplayName = Feature.Humanize().Transform(To.TitleCase);
}
else
{
//
// For custom font features, we can produce the OpenType feature tag
// using the feature name.
//
uint id = (uint)(Feature);
DisplayName = DirectWrite.GetTagName(id);
}
}
public static async Task <(StorageFile File, ConversionStatus Result)> TryConvertAsync(StorageFile file)
{
if (file.FileType.ToLower().EndsWith("woff"))
{
var folder = ApplicationData.Current.TemporaryFolder;
var newFile = await folder.CreateFileAsync(file.DisplayName + ".otf", CreationCollisionOption.ReplaceExisting).AsTask().ConfigureAwait(false);
ConversionStatus result = await TryConvertWoffToOtfAsync(file, newFile).ConfigureAwait(false);
if (result == ConversionStatus.OK)
{
if (DirectWrite.HasValidFonts(GetAppUri(newFile)))
{
return(newFile, ConversionStatus.OK);
}
else
{
return(default, ConversionStatus.UnspecifiedError);
private static async Task <bool> TryWriteToFileAsync(FontVariant font, StorageFile file)
{
try
{
using IRandomAccessStream s = await file.OpenAsync(FileAccessMode.ReadWrite).AsTask().ConfigureAwait(false);
s.Size = 0;
using IOutputStream o = s.GetOutputStreamAt(0);
await DirectWrite.WriteToStreamAsync(font.FontFace, o).AsTask().ConfigureAwait(false);
await s.FlushAsync(); // using statements force synchronous flushes
return(true);
}
catch { }
return(false);
}
internal static async Task ExportFontsToFolderAsync(List <FontVariant> fonts)
{
if (await PickFolderAsync() is StorageFolder folder)
{
await Task.Run(async() =>
{
ExportNamingScheme scheme = ResourceHelper.AppSettings.ExportNamingScheme;
foreach (var font in fonts)
{
if (DirectWrite.IsFontLocal(font.FontFace))
{
string fileName = GetFileName(font, scheme);
StorageFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting).AsTask().ConfigureAwait(false);
await TryWriteToFileAsync(font, file).ConfigureAwait(false);
}
}
});
WeakReferenceMessenger.Default.Send(new AppNotificationMessage(true, new ExportFontFileResult(folder, true)));
}
}
public TypographyFeatureInfo(CanvasTypographyFeatureName n, string displayName = null)
{
Feature = n;
if (displayName != null)
{
DisplayName = displayName;
}
else if (IsNamedFeature(Feature))
{
DisplayName = Feature.Humanise();
}
else
{
//
// For custom font features, we can produce the OpenType feature tag
// using the feature name.
//
uint id = (uint)(Feature);
DisplayName = DirectWrite.GetTagName(id);
}
}
private static string GetFileName(FontVariant font, ExportNamingScheme scheme)
{
string fileName = null;
string ext = ".ttf";
var src = DirectWrite.GetFileName(font.FontFace);
if (!string.IsNullOrWhiteSpace(src))
{
ext = Path.GetExtension(src);
}
if (scheme == ExportNamingScheme.System)
{
fileName = src;
}
if (string.IsNullOrWhiteSpace(fileName))
{
fileName = $"{font.FamilyName} {font.PreferredName}{ext}";
}
return($"{Humanizer.To.SentenceCase.Transform(Path.GetFileNameWithoutExtension(fileName))}{Path.GetExtension(fileName).ToLower()}");
}
private static IBuffer GetGlyphBuffer(CanvasFontFace fontface, uint unicodeIndex, GlyphImageFormat format)
{
return(DirectWrite.GetImageDataBuffer(fontface, 1024, unicodeIndex, format));
}
/// <unmanaged>HRESULT ID2D1CommandSink::DrawGlyphRun([In] D2D_POINT_2F baselineOrigin,[In] const DWRITE_GLYPH_RUN* glyphRun,[In, Optional] const DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription,[In] ID2D1Brush* foregroundBrush,[In] DWRITE_MEASURING_MODE measuringMode)</unmanaged>
public void DrawGlyphRun(RawVector2 baselineOrigin, DirectWrite.GlyphRun glyphRun, DirectWrite.GlyphRunDescription glyphRunDescription, Brush foregroundBrush, MeasuringMode measuringMode)
{
DrawGlyphRun_(baselineOrigin, glyphRun, glyphRunDescription, foregroundBrush, measuringMode);
}
