public static bool AreFontsEqual(FontFamily lhs, FontFamily rhs, IDocumentContext documentContext) { if (FontEmbedder.GetFontNameFromSource(lhs) == FontEmbedder.GetFontNameFromSource(rhs)) { return(true); } bool flag1 = lhs == null || lhs.Source == null; bool flag2 = rhs == null || rhs.Source == null; if (flag1 && flag2) { return(true); } if (flag1 || flag2) { return(false); } if (lhs.Source == rhs.Source) { return(true); } string fontFamilyPath1 = FontEmbedder.GetFontFamilyPath(lhs.Source); string fontFamilyPath2 = FontEmbedder.GetFontFamilyPath(rhs.Source); bool flag3 = !string.IsNullOrEmpty(fontFamilyPath1); bool flag4 = !string.IsNullOrEmpty(fontFamilyPath2); if (!flag3 && !flag4 || (!flag3 || !flag4)) { return(false); } return(FontEmbedder.GetFontNameFromSource(FontEmbedder.MakeDesignTimeFontFamily(lhs, documentContext)) == FontEmbedder.GetFontNameFromSource(FontEmbedder.MakeDesignTimeFontFamily(rhs, documentContext))); }
private void ChangeFontReference(FontChangeType fontChange, IProjectFont projectFont) { FontFamily oldFontFamily; FontFamily newFontFamily; FontEmbedder.CreateFontFamilyChange(fontChange, projectFont, this.viewModel.Document.DocumentContext, out oldFontFamily, out newFontFamily); if (!(oldFontFamily.Source != newFontFamily.Source)) { return; } SceneElement sceneElement = this.viewModel.RootNode as SceneElement; if (sceneElement == null) { return; } FontFamilyRepairProcessor familyRepairProcessor = new FontFamilyRepairProcessor(this.viewModel.DesignerContext, new FontFamilyChangeModel(oldFontFamily.Source, newFontFamily.Source, fontChange, projectFont, sceneElement.DocumentNode.DocumentRoot, this.viewModel.ProjectContext)); using (SceneEditTransaction editTransaction = this.viewModel.CreateEditTransaction(StringTable.EmbedFontUndoUnit)) { familyRepairProcessor.Begin(); if (familyRepairProcessor.Cancelled) { editTransaction.Cancel(); } else { editTransaction.Commit(); } } }
public FontEmbedOption(SystemFontFamily systemFont, SceneViewModel viewModel, FontEmbeddingDialogModel embeddingModel) { this.systemFont = systemFont; this.viewModel = viewModel; this.embeddingModel = embeddingModel; this.IsFontSubsettingAllowed = FontEmbedder.DoesFontFileSupportSubsetting(Enumerable.FirstOrDefault <string>((IEnumerable <string>)systemFont.FontSources) ?? string.Empty); }
public static IEnumerable <string> GetFontNamesInFile(string fontFile, bool useGdiFontNames) { foreach (FontFamily fontFamily in (IEnumerable <FontFamily>)FontEmbedder.GetFontFamiliesSafe(fontFile)) { yield return(FontEmbedder.GetSerializeFontFamilyName(fontFamily, useGdiFontNames)); } }
public static string GetGdiName(FontFamily family) { string str = string.Empty; Typeface typeface = Enumerable.FirstOrDefault <Typeface>((IEnumerable <Typeface>)family.GetTypefaces()); try { if (typeface != null) { GlyphTypeface glyphTypeface; if (typeface.TryGetGlyphTypeface(out glyphTypeface)) { if (!glyphTypeface.Win32FamilyNames.TryGetValue(CultureInfo.GetCultureInfo("en-US"), out str)) { str = Enumerable.FirstOrDefault <string>((IEnumerable <string>)glyphTypeface.Win32FamilyNames.Values) ?? string.Empty; } } } } catch { str = FontEmbedder.GetWpfName(family); } return(str); }
private static void EnsureSystemFontCache() { if (FontResolver.gdiFontFamilyToFontFileMap != null) { return; } FontResolver.gdiFontFamilyToFontFileMap = new Dictionary <string, List <string> >(); FontResolver.wpfFontFamilyToFontFileMap = new Dictionary <string, List <string> >(); foreach (string str in Directory.GetFiles(FontEmbedder.SystemFontsDirectory)) { foreach (Typeface typeface in (IEnumerable <Typeface>)FontEmbedder.GetTypefacesSafe(str)) { bool useGdiFontNames1 = true; string serializeFontFamilyName1 = FontEmbedder.GetSerializeFontFamilyName(typeface, useGdiFontNames1); bool useGdiFontNames2 = false; string serializeFontFamilyName2 = FontEmbedder.GetSerializeFontFamilyName(typeface, useGdiFontNames2); FontResolver.StoreSystemFont(FontResolver.gdiFontFamilyToFontFileMap, serializeFontFamilyName1, str); FontResolver.StoreSystemFont(FontResolver.wpfFontFamilyToFontFileMap, serializeFontFamilyName2, str); if (serializeFontFamilyName1 != serializeFontFamilyName2) { FontResolver.gdiToWpfSystemFontNameMap[serializeFontFamilyName1] = serializeFontFamilyName2; FontResolver.wpfToGdiSystemFontNameMap[serializeFontFamilyName2] = serializeFontFamilyName1; } } } }
private static void AddFontFileToCache(string fontFile, Dictionary <string, List <KeyValuePair <Typeface, string> > > cache, bool useGdiFontNames, Dictionary <string, string> gdiFontNameMap, Dictionary <string, string> wpfFontNameMap) { foreach (string str in FontEmbedder.GetFontNamesInFile(fontFile, useGdiFontNames)) { string index = FontFamilyHelper.EnsureFamilyName(str); FontFamily fontFamily = new FontFamily(fontFile + "#" + index); List <KeyValuePair <Typeface, string> > list; if (!cache.TryGetValue(str, out list)) { list = new List <KeyValuePair <Typeface, string> >(); cache[index] = list; } foreach (Typeface key in (IEnumerable <Typeface>)FontEmbedder.GetTypefacesSafe(fontFile)) { list.Add(new KeyValuePair <Typeface, string>(key, fontFamily.Source)); } } if (gdiFontNameMap == null) { return; } foreach (Typeface typeface in (IEnumerable <Typeface>)FontEmbedder.GetTypefacesSafe(fontFile)) { bool useGdiFontNames1 = true; string serializeFontFamilyName1 = FontEmbedder.GetSerializeFontFamilyName(typeface, useGdiFontNames1); bool useGdiFontNames2 = false; string serializeFontFamilyName2 = FontEmbedder.GetSerializeFontFamilyName(typeface, useGdiFontNames2); if (serializeFontFamilyName1 != serializeFontFamilyName2 && !string.IsNullOrEmpty(serializeFontFamilyName1) && !string.IsNullOrEmpty(serializeFontFamilyName2)) { gdiFontNameMap[serializeFontFamilyName1] = serializeFontFamilyName2; wpfFontNameMap[serializeFontFamilyName2] = serializeFontFamilyName1; } } }
public static void CreateFontFamilyChange(FontChangeType fontChange, IProjectFont projectFont, IDocumentContext documentContext, out FontFamily oldFontFamily, out FontFamily newFontFamily) { switch (fontChange) { case FontChangeType.SystemToEmbedded: newFontFamily = FontEmbedder.MakeRelativeFontFamily(projectFont, documentContext, true); oldFontFamily = FontEmbedder.MakeSystemFont(newFontFamily); break; case FontChangeType.EmbeddedToSystem: oldFontFamily = FontEmbedder.MakeRelativeFontFamily(projectFont, documentContext, true); newFontFamily = FontEmbedder.MakeSystemFont(oldFontFamily); break; case FontChangeType.ProjectToEmbedded: oldFontFamily = FontEmbedder.MakeRelativeFontFamily(projectFont, documentContext, false); newFontFamily = FontEmbedder.MakeRelativeFontFamily(projectFont, documentContext, true); break; case FontChangeType.EmbeddedToProject: oldFontFamily = FontEmbedder.MakeRelativeFontFamily(projectFont, documentContext, true); newFontFamily = FontEmbedder.MakeRelativeFontFamily(projectFont, documentContext, false); break; default: oldFontFamily = newFontFamily = (FontFamily)null; break; } }
public ProjectFont EmbedSystemFont(SystemFontFamily systemFontFamily) { string fontsDirectory = Path.Combine(this.viewModel.DesignerContext.ActiveProject.ProjectRoot.Path, "Fonts"); if (!Microsoft.Expression.Framework.Documents.PathHelper.DirectoryExists(fontsDirectory)) { Directory.CreateDirectory(fontsDirectory); } foreach (IProjectItem projectItem in this.viewModel.DesignerContext.ActiveProject.AddItems(Enumerable.Select <string, DocumentCreationInfo>((IEnumerable <string>)systemFontFamily.FontSources, (Func <string, DocumentCreationInfo>)(fontSource => new DocumentCreationInfo() { TargetFolder = fontsDirectory, SourcePath = fontSource, CreationOptions = CreationOptions.DoNotSelectCreatedItems })))) { IMSBuildItem msBuildItem = projectItem as IMSBuildItem; if (msBuildItem != null) { projectItem.Properties["BuildAction"] = "BlendEmbeddedFont"; msBuildItem.SetMetadata("IsSystemFont", "True"); msBuildItem.SetMetadata("All", "True"); msBuildItem.SetMetadata("AutoFill", "True"); } } this.EnsureFontSubsettingTask(); foreach (ProjectFont projectFont in (Collection <IProjectFont>) this.viewModel.ProjectContext.ProjectFonts) { if (projectFont.FontFamilyName == FontEmbedder.GetFontNameFromSource(systemFontFamily.FontFamily)) { this.ChangeFontReferenceToEmbeddedFont((IProjectFont)projectFont); return(projectFont); } } return((ProjectFont)null); }
public static IEnumerable <SystemFontFamily> GetSystemFonts(ITypeResolver typeResolver) { if (typeResolver.IsCapabilitySet(PlatformCapability.UsesGdiFontNames)) { return(FontEmbedder.GetGdiFontFamilies()); } return(FontEmbedder.GetWpfFontFamilies()); }
private static IEnumerable <SystemFontFamily> GetGdiFontFamilies() { if (FontEmbedder.gdiFonts == null) { FontEmbedder.CreateSystemFontFamiliesCache(); } return(FontEmbedder.gdiFonts); }
public static FontFamily MakeDesignTimeFontReference(FontFamily fontFamily, IDocumentContext documentContext) { if (fontFamily.Source != null && fontFamily.Source.IndexOf('#') != -1) { return(FontEmbedder.MakeDesignTimeFontFamily(fontFamily, documentContext)); } return(fontFamily); }
public FontEmbedOption(ProjectFont projectFont, IProjectItem projectItem, SceneViewModel viewModel, FontEmbeddingDialogModel embeddingModel) { this.projectFont = projectFont; this.viewModel = viewModel; this.InitializeEmbedOptions(projectItem); this.isEmbedded = this.IsFontItemEmbedded; this.embeddingModel = embeddingModel; this.IsFontSubsettingAllowed = FontEmbedder.DoesFontFileSupportSubsetting(projectFont.FontDocumentPath); }
public string ResolveFont(string fontFamilySource, object fontStretch, object fontStyle, object fontWeight, IDocumentContext documentContext) { string fontFamilyPath = FontEmbedder.GetFontFamilyPath(fontFamilySource); FontFamily fontFamily = FontEmbedder.MakeDesignTimeFontReference(new FontFamily(fontFamilySource), documentContext); Dictionary <string, List <KeyValuePair <Typeface, string> > > dictionary; if (string.IsNullOrEmpty(fontFamilyPath)) { FontResolver.EnsureSystemFontCached(fontFamilySource); dictionary = this.useGdiFontNames ? FontResolver.gdiFontFamilyLookup : FontResolver.wpfFontFamilyLookup; } else { Uri uri = documentContext.MakeDesignTimeUri(new Uri(fontFamilyPath, UriKind.RelativeOrAbsolute)); if (!uri.IsAbsoluteUri) { return(fontFamilySource); } string localPath = uri.LocalPath; if (Microsoft.Expression.Framework.Documents.PathHelper.FileExists(localPath) && !localPath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)) { return(FontEmbedder.MakeSilverlightFontReference(this.GetCachedFont(localPath) + FontEmbedder.GetFontFamilySpecifier(fontFamilySource))); } if (!this.projectFontFamilyLookup.TryGetValue(Path.GetDirectoryName(uri.LocalPath), out dictionary)) { int num = fontFamilySource.IndexOf(";component", StringComparison.OrdinalIgnoreCase); if (num != -1 && fontFamilySource.StartsWith("/", StringComparison.OrdinalIgnoreCase)) { IFontResolver resolverForComponent = this.GetFontResolverForComponent(fontFamilySource.Substring(1, num - 1)); if (resolverForComponent != null && resolverForComponent != this) { return(resolverForComponent.ResolveFont(fontFamilySource, fontStretch, fontStyle, fontWeight, documentContext)); } } return(fontFamilySource); } } string fontNameFromSource = FontEmbedder.GetFontNameFromSource(fontFamily); List <KeyValuePair <Typeface, string> > list; if (dictionary.TryGetValue(fontNameFromSource, out list)) { string path = (string)null; FontResolver.FontMatch fontMatch1 = (FontResolver.FontMatch)null; foreach (KeyValuePair <Typeface, string> keyValuePair in list) { FontResolver.FontMatch fontMatch2 = new FontResolver.FontMatch(keyValuePair.Key, fontStretch, fontStyle, fontWeight); if (fontMatch1 == null || fontMatch2.CompareTo((object)fontMatch1) > 0) { path = keyValuePair.Value; fontMatch1 = fontMatch2; } } fontFamilySource = FontEmbedder.MakeSilverlightFontReference(Path.GetFullPath(path)); } return(fontFamilySource); }
public static string GetSerializeFontFamilyName(FontFamily fontFamily, bool useGdiFontNames) { Typeface typeface = Enumerable.FirstOrDefault <Typeface>((IEnumerable <Typeface>)fontFamily.GetTypefaces()); if (typeface != null) { return(FontEmbedder.GetSerializeFontFamilyName(typeface, useGdiFontNames)); } return(string.Empty); }
public override bool Equals(object obj) { SourcedFontFamilyItem sourcedFontFamilyItem = obj as SourcedFontFamilyItem; if (sourcedFontFamilyItem == null || !(this.FamilyName == sourcedFontFamilyItem.FamilyName)) { return(false); } return(FontEmbedder.AreFontsEqual(this.FontFamilySource, sourcedFontFamilyItem.FontFamilySource, this.DocumentContext)); }
private static FontFamily ConvertToWpfFontFamily(FontFamily fontFamily, IDocumentContext documentContext) { if (string.IsNullOrEmpty(fontFamily.Source)) { return(fontFamily); } string fontNameFromSource = FontEmbedder.GetFontNameFromSource(fontFamily); string fontFamilyPath = FontEmbedder.GetFontFamilyPath(fontFamily.Source); string str = ((IProjectContext)documentContext.TypeResolver).FontResolver.ConvertToWpfFontName(fontNameFromSource); return(new FontFamily(!string.IsNullOrEmpty(fontFamilyPath) ? fontFamilyPath + "#" + str : str)); }
public FontEmbeddingDialogModel(SceneViewModel viewModel) { this.viewModel = viewModel; Dictionary <string, FontEmbedOption> dictionary = new Dictionary <string, FontEmbedOption>(); foreach (ProjectFont projectFont in (Collection <IProjectFont>)viewModel.ProjectContext.ProjectFonts) { IProjectItem projectItem = viewModel.DesignerContext.ActiveProject.FindItem(projectFont.FontDocumentReference); if (projectItem != null) { FontEmbedOption fontEmbedOption = new FontEmbedOption(projectFont, projectItem, viewModel, this); this.fonts.Add(fontEmbedOption); dictionary[projectFont.FontFamilyName] = fontEmbedOption; List <FontEmbedOption> list; if (!this.linkedProjectFonts.TryGetValue(projectFont.FontDocumentReference, out list)) { list = new List <FontEmbedOption>(); this.linkedProjectFonts[projectFont.FontDocumentReference] = list; } list.Add(fontEmbedOption); } } foreach (SystemFontFamily systemFont in FontEmbedder.GetSystemFonts((ITypeResolver)viewModel.ProjectContext)) { FontEmbedOption fontEmbedOption = (FontEmbedOption)null; if (dictionary.TryGetValue(systemFont.FontFamilyName, out fontEmbedOption)) { if (fontEmbedOption.WasSystemFont) { fontEmbedOption.SystemFont = systemFont; } } else if (!systemFont.IsNativeSilverlightFont || !this.viewModel.ProjectContext.IsCapabilitySet(PlatformCapability.DisallowEmbeddingSilverlightFonts)) { this.fonts.Add(new FontEmbedOption(systemFont, viewModel, this)); } } this.fonts.Sort((Comparison <FontEmbedOption>)((lhs, rhs) => { if (lhs.ProjectFont != null && rhs.ProjectFont == null) { return(-1); } if (lhs.ProjectFont == null && rhs.ProjectFont != null) { return(1); } return(lhs.FontFamilyName.CompareTo(rhs.FontFamilyName)); })); this.fontsView = CollectionViewSource.GetDefaultView((object)this.fonts); this.fontsView.CurrentChanged += new EventHandler(this.fontsView_CurrentChanged); }
public object Convert(object o, Type targetType, object parameter, CultureInfo culture) { IDocumentContext documentContext = this.SceneNodeObjectSet.DocumentContext; FontFamily fontFamily1 = this.SceneNodeObjectSet.DesignerContext.PlatformConverter.ConvertToWpf(documentContext, o) as FontFamily; if (fontFamily1 == null) return o; string source = fontFamily1.Source; Uri result; bool flag = !Uri.TryCreate(source, UriKind.RelativeOrAbsolute, out result) ? !Path.IsPathRooted(source) : !result.IsAbsoluteUri; if (string.IsNullOrEmpty(source) || !flag || source.IndexOf('#') == -1) return (object) new UnknownSourceFontFamilyItem(fontFamily1, this.SceneNodeObjectSet); FontFamily fontFamily2 = fontFamily1; return (object) new UnknownSourceFontFamilyItem(FontEmbedder.MakeDesignTimeFontFamily(fontFamily2, documentContext), fontFamily2, this.SceneNodeObjectSet); }
private static FontFamily MakeRelativeFontFamily(IProjectFont projectFont, IDocumentContext documentContext, bool useZipForSilverlight) { string path = documentContext.MakeResourceReference(projectFont.FontDocumentPath); string path1 = (!string.IsNullOrEmpty(path) ? Path.GetDirectoryName(path) : (string)null) ?? string.Empty; string path2 = "#" + projectFont.FontFamilyName; if (!documentContext.TypeResolver.IsCapabilitySet(PlatformCapability.IsWpf)) { path2 = !useZipForSilverlight?Path.GetFileName(projectFont.FontDocumentPath) + path2 : "Fonts.zip" + path2; } else if (string.IsNullOrEmpty(path1)) { path2 = "./" + path2; } return(new FontFamily((Uri)null, FontFamilyHelper.EnsureFamilyName(FontEmbedder.MakeSilverlightFontReference(Path.Combine(path1, path2))))); }
private static void StoreFontLookup(Dictionary <string, List <KeyValuePair <Typeface, string> > > fontFamilyLookup, Dictionary <string, List <string> > fontFamilyToFontFileMap, string fontSource, bool useGdiFontNames) { if (fontFamilyLookup.ContainsKey(fontSource)) { return; } string serializeFontFamilyName = FontEmbedder.GetSerializeFontFamilyName(new FontFamily(fontSource), useGdiFontNames); List <string> list; if (!fontFamilyToFontFileMap.TryGetValue(serializeFontFamilyName, out list)) { return; } foreach (string fontFile in list) { FontResolver.AddFontFileToCache(fontFile, fontFamilyLookup, useGdiFontNames, (Dictionary <string, string>)null, (Dictionary <string, string>)null); } }
public static string GetWpfName(FontFamily fontFamily) { string str = string.Empty; try { if (!fontFamily.FamilyNames.TryGetValue(XmlLanguage.GetLanguage("en-US"), out str)) { str = Enumerable.FirstOrDefault <string>((IEnumerable <string>)fontFamily.FamilyNames.Values) ?? string.Empty; } } catch (ArgumentException ex) { if (!string.IsNullOrEmpty(fontFamily.Source)) { str = FontEmbedder.GetFontNameFromSource(fontFamily); } } return(str); }
private static void StoreSystemFont(string fontFile, Typeface typeface, Dictionary <string, SystemFontFamily> fontFileMap, bool useGdiFontNames) { string serializeFontFamilyName = FontEmbedder.GetSerializeFontFamilyName(typeface, useGdiFontNames); if (string.IsNullOrEmpty(serializeFontFamilyName)) { return; } SystemFontFamily systemFontFamily = (SystemFontFamily)null; if (!fontFileMap.TryGetValue(serializeFontFamilyName, out systemFontFamily)) { systemFontFamily = new SystemFontFamily(new FontFamily(serializeFontFamilyName)); fontFileMap[serializeFontFamilyName] = systemFontFamily; } if (systemFontFamily.FontSources.Contains(fontFile)) { return; } systemFontFamily.FontSources.Add(fontFile); }
private static void RemoveFontFileFromCache(string fontFile, Dictionary <string, List <KeyValuePair <Typeface, string> > > cache, bool useGdiFontNames) { foreach (string familyName in FontEmbedder.GetFontNamesInFile(fontFile, useGdiFontNames)) { string key = FontFamilyHelper.EnsureFamilyName(familyName); List <KeyValuePair <Typeface, string> > list; if (cache.TryGetValue(key, out list)) { using (IEnumerator <Typeface> enumerator = FontEmbedder.GetTypefacesSafe(fontFile).GetEnumerator()) { while (enumerator.MoveNext()) { Typeface typeface = enumerator.Current; list.RemoveAll((Predicate <KeyValuePair <Typeface, string> >)(putativeTypeface => typeface == putativeTypeface.Key)); } } if (list.Count == 0) { cache.Remove(key); } } } }
public static string GetSerializeFontFamilyName(Typeface typeface, bool useGdiFontNames) { string str1 = FontFamilyHelper.EnsureFamilyName(FontEmbedder.GetGdiName(typeface.FontFamily)); string familyName; if (useGdiFontNames) { familyName = str1; } else { string str2 = FontEmbedder.GetFontFamilyPath(typeface.FontFamily.Source); if (string.IsNullOrEmpty(str2)) { str2 = Microsoft.Expression.Framework.Documents.PathHelper.EnsurePathEndsInDirectorySeparator(FontEmbedder.SystemFontsDirectory); } FontFamily fontFamily = new FontFamily(str2 + "#" + str1); string wpfName1 = FontEmbedder.GetWpfName(typeface.FontFamily); string wpfName2 = FontEmbedder.GetWpfName(fontFamily); familyName = !(wpfName1 != wpfName2) ? str1 : wpfName1; } return(FontFamilyHelper.EnsureFamilyName(familyName)); }
public static void CreateSystemFontFamiliesCache() { PerformanceUtility.StartPerformanceSequence(PerformanceEvent.FontCacheInitialization); Dictionary <string, SystemFontFamily> fontFileMap1 = new Dictionary <string, SystemFontFamily>(); Dictionary <string, SystemFontFamily> fontFileMap2 = new Dictionary <string, SystemFontFamily>(); foreach (string str in Directory.GetFiles(FontEmbedder.SystemFontsDirectory)) { foreach (Typeface typeface in (IEnumerable <Typeface>)FontEmbedder.GetTypefacesSafe(str)) { bool useGdiFontNames1 = false; FontEmbedder.StoreSystemFont(str, typeface, fontFileMap1, useGdiFontNames1); bool useGdiFontNames2 = true; FontEmbedder.StoreSystemFont(str, typeface, fontFileMap2, useGdiFontNames2); } } FontEmbedder.wpfFonts = (IEnumerable <SystemFontFamily>)Enumerable.ToList <SystemFontFamily>((IEnumerable <SystemFontFamily>)fontFileMap1.Values); SystemFontFamily systemFontFamily = new SystemFontFamily(new FontFamily("Portable User Interface")); fontFileMap2["Portable User Interface"] = systemFontFamily; FontEmbedder.gdiFonts = (IEnumerable <SystemFontFamily>)Enumerable.ToList <SystemFontFamily>((IEnumerable <SystemFontFamily>)fontFileMap2.Values); PerformanceUtility.EndPerformanceSequence(PerformanceEvent.FontCacheInitialization); }
public static List <SourcedFontFamilyItem> GetFontFamilies(SceneNodeObjectSet sceneNodeObjectSet) { return(FontFamilyValueEditor.GetFontFamilies(FontEmbedder.GetSystemFonts(sceneNodeObjectSet.DocumentContext.TypeResolver), (ICollection <IProjectFont>)sceneNodeObjectSet.ProjectContext.ProjectFonts, sceneNodeObjectSet)); }
public static FontFamily MakeSystemFont(FontFamily fontFamily) { return(new FontFamily(fontFamily.BaseUri, FontEmbedder.GetFontNameFromSource(fontFamily))); }
public void EnsureFontSubsettingTask() { this.viewModel.DesignerContext.ActiveProject.AddImport(FontEmbedder.GetSubsetFontTargetFileName(this.viewModel.ProjectContext.TargetFramework)); }
public static bool IsSubsetFontTargetInstalled(ITypeResolver context) { ProjectXamlContext projectXamlContext = (ProjectXamlContext)context; FrameworkName targetFramework = projectXamlContext.TargetFramework; bool flag; if (!FontEmbedder.isSubsettingTaskInstalledForPlatform.TryGetValue(targetFramework, out flag)) { string buildExtensionsPath = projectXamlContext.MSBuildExtensionsPath; flag = Microsoft.Expression.Framework.Documents.PathHelper.FileExists(FontEmbedder.GetSubsetFontTargetFileName(targetFramework).Replace("$(MSBuildExtensionsPath)", buildExtensionsPath)); FontEmbedder.isSubsettingTaskInstalledForPlatform.Add(targetFramework, flag); } return(flag); }