public static XGlyphTypeface GetOrCreateFromGdi(GdiFont gdiFont) { // $TODO THHO Lock??? string typefaceKey = ComputeKey(gdiFont); XGlyphTypeface glyphTypeface; if (GlyphTypefaceCache.TryGetGlyphTypeface(typefaceKey, out glyphTypeface)) { // We have the glyph typeface already in cache. return(glyphTypeface); } XFontFamily fontFamily = XFontFamily.GetOrCreateFromGdi(gdiFont); //XFontSource fontSource = XFontSource.GetOrCreateFromGdi(typefaceKey, gdiFont); // Old platform specific stuff XFontSource fontSource = XFontSource.GetOrCreateFromFile(typefaceKey, gdiFont); // Check if styles must be simulated. XStyleSimulations styleSimulations = XStyleSimulations.None; if (gdiFont.Bold && !fontSource.Fontface.os2.IsBold) { styleSimulations |= XStyleSimulations.BoldSimulation; } if (gdiFont.Italic && !fontSource.Fontface.os2.IsItalic) { styleSimulations |= XStyleSimulations.ItalicSimulation; } glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, styleSimulations, gdiFont); GlyphTypefaceCache.AddGlyphTypeface(glyphTypeface); return(glyphTypeface); }
public static XGlyphTypeface GetOrCreateFrom(string familyName, FontResolvingOptions fontResolvingOptions) { // Check cache for requested type face. string typefaceKey = ComputeKey(familyName, fontResolvingOptions); XGlyphTypeface glyphTypeface; try { // Lock around TryGetGlyphTypeface and AddGlyphTypeface. Lock.EnterFontFactory(); if (GlyphTypefaceCache.TryGetGlyphTypeface(typefaceKey, out glyphTypeface)) { // Just return existing one. return(glyphTypeface); } // Resolve typeface by FontFactory. FontResolverInfo fontResolverInfo = FontFactory.ResolveTypeface(familyName, fontResolvingOptions, typefaceKey); if (fontResolverInfo == null) { // No fallback - just stop. throw new InvalidOperationException("No appropriate font found."); } GdiFont gdiFont = null; // Now create the font family at the first. XFontFamily fontFamily; if (fontResolverInfo is PlatformFontResolverInfo platformFontResolverInfo) { // Case: fontResolverInfo was created by platform font resolver // and contains platform specific objects that are reused. // Reuse GDI+ font from platform font resolver. gdiFont = platformFontResolverInfo.GdiFont; fontFamily = XFontFamily.GetOrCreateFromGdi(gdiFont); } else { // Case: fontResolverInfo was created by custom font resolver. // Get or create font family for custom font resolver retrieved font source. fontFamily = XFontFamily.GetOrCreateFontFamily(familyName); } // We have a valid font resolver info. That means we also have an XFontSource object loaded in the cache. XFontSource fontSource = FontFactory.GetFontSourceByFontName(fontResolverInfo.FaceName); Debug.Assert(fontSource != null); // Each font source already contains its OpenTypeFontface. glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations, gdiFont); GlyphTypefaceCache.AddGlyphTypeface(glyphTypeface); } finally { Lock.ExitFontFactory(); } return(glyphTypeface); }
internal static string ComputeKey(GdiFont gdiFont) { string name1 = gdiFont.Name; string name2 = gdiFont.OriginalFontName; string name3 = gdiFont.SystemFontName; string name = name1; GdiFontStyle style = gdiFont.Style; string key = KeyPrefix + name.ToLowerInvariant() + ((style & GdiFontStyle.Italic) == GdiFontStyle.Italic ? "/i" : "/n") + ((style & GdiFontStyle.Bold) == GdiFontStyle.Bold ? "/700" : "/400") + "/5"; // Stretch.Normal return(key); }
const string KeyPrefix = "tk:"; // "typeface key" XGlyphTypeface(string key, XFontFamily fontFamily, XFontSource fontSource, XStyleSimulations styleSimulations, GdiFont gdiFont) { _key = key; _fontFamily = fontFamily; _fontSource = fontSource; _fontface = OpenTypeFontface.GetOrCreateFrom(fontSource); Debug.Assert(ReferenceEquals(_fontSource.Fontface, _fontface)); _gdiFont = gdiFont; _styleSimulations = styleSimulations; Initialize(); }
public static XFontSource GetOrCreateFromFile(string typefaceKey, GdiFont gdiFont) { byte[] bytes; if (gdiFont.Name == GlobalFontSettings.DefaultFontName) { // Load our special 'fall-back' font from resources and load that bytes = LoadFallbackFont(); } else { bytes = PortableFont.ReadFontFileBytes(gdiFont); } XFontSource fontSource = GetOrCreateFrom(typefaceKey, bytes); return(fontSource); }
//internal static XGlyphTypeface TryGetXGlyphTypeface(string familyName, XFontStyle style) //{ // string name = MakeName(familyName, style); // XGlyphTypeface typeface; // _global._typefaces.TryGetValue(name, out typeface); // return typeface; //} #if GDI internal static GdiFont TryCreateFont(string name, double size, GdiFontStyle style, out XFontSource fontSource) { fontSource = null; try { GdiPrivateFontCollection pfc = Singleton._privateFontCollection; if (pfc == null) { return(null); } #if true string key = MakeKey(name, (XFontStyle)style); if (Singleton._fontSources.TryGetValue(key, out fontSource)) { GdiFont font = new GdiFont(name, (float)size, style, GraphicsUnit.World); #if DEBUG_ Debug.Assert(StringComparer.OrdinalIgnoreCase.Compare(name, font.Name) == 0); Debug.Assert(font.Bold == ((style & GdiFontStyle.Bold) != 0)); Debug.Assert(font.Italic == ((style & GdiFontStyle.Italic) != 0)); #endif return(font); } return(null); #else foreach (GdiFontFamily family in pfc.Families) { if (string.Compare(family.Name, name, StringComparison.OrdinalIgnoreCase) == 0) { GdiFont font = new GdiFont(family, (float)size, style, GraphicsUnit.World); if (string.Compare(font.Name, name, StringComparison.OrdinalIgnoreCase) != 0) { // Style simulation is not implemented in GDI+. // Use WPF build. } return(font); } } #endif } catch (Exception ex) { // Ignore exception and return null. Debug.WriteLine(ex.ToString()); } return(null); }
internal static XFontFamily GetOrCreateFromGdi(GdiFont font) { FontFamilyInternal fontFamilyInternal = FontFamilyInternal.GetOrCreateFromGdi(font.FontFamily); return(new XFontFamily(fontFamilyInternal)); }
public PlatformFontResolverInfo(string faceName, bool mustSimulateBold, bool mustSimulateItalic, GdiFont gdiFont) : base(faceName, mustSimulateBold, mustSimulateItalic) { _gdiFont = gdiFont; }
/// <summary> /// Create a GDI+ font and use its handle to retrieve font data using native calls. /// </summary> internal static XFontSource CreateFontSource(string familyName, FontResolvingOptions fontResolvingOptions, out GdiFont font, string typefaceKey) { if (string.IsNullOrEmpty(typefaceKey)) { typefaceKey = XGlyphTypeface.ComputeKey(familyName, fontResolvingOptions); } GdiFontStyle gdiStyle = (GdiFontStyle)(fontResolvingOptions.FontStyle & XFontStyle.BoldItalic); // Create a 10 point GDI+ font as an exemplar. XFontSource fontSource; font = FontHelper.CreateFont(familyName, 10, gdiStyle, out fontSource); if (fontSource != null) { Debug.Assert(font != null); // Case: Font was created by a GDI+ private font collection. #if true #if DEBUG XFontSource existingFontSource; Debug.Assert(FontFactory.TryGetFontSourceByTypefaceKey(typefaceKey, out existingFontSource) && ReferenceEquals(fontSource, existingFontSource)); #endif #else // Win32 API cannot get font data from fonts created by private font collection, // because this is handled internally in GDI+. // Therefore the font source was created when the private font is added to the private font collection. if (!FontFactory.TryGetFontSourceByTypefaceKey(typefaceKey, out fontSource)) { // Simplify styles. // (The code is written for clarity - do not rearrange for optimization) if (font.Bold && font.Italic) { if (FontFactory.TryGetFontSourceByTypefaceKey(XGlyphTypeface.ComputeKey(font.Name, true, false), out fontSource)) { // Use bold font. FontFactory.CacheExistingFontSourceWithNewTypefaceKey(typefaceKey, fontSource); } else if (FontFactory.TryGetFontSourceByTypefaceKey(XGlyphTypeface.ComputeKey(font.Name, false, true), out fontSource)) { // Use italic font. FontFactory.CacheExistingFontSourceWithNewTypefaceKey(typefaceKey, fontSource); } else if (FontFactory.TryGetFontSourceByTypefaceKey(XGlyphTypeface.ComputeKey(font.Name, false, false), out fontSource)) { // Use regular font. FontFactory.CacheExistingFontSourceWithNewTypefaceKey(typefaceKey, fontSource); } } else if (font.Bold || font.Italic) { // Use regular font. if (FontFactory.TryGetFontSourceByTypefaceKey(XGlyphTypeface.ComputeKey(font.Name, false, false), out fontSource)) { FontFactory.CacheExistingFontSourceWithNewTypefaceKey(typefaceKey, fontSource); } } else { if (FontFactory.TryGetFontSourceByTypefaceKey(XGlyphTypeface.ComputeKey(font.Name, false, false), out fontSource)) { // Should never come here... FontFactory.CacheExistingFontSourceWithNewTypefaceKey(typefaceKey, fontSource); } } } #endif } else { // Get or create the font source and cache it under the specified typeface key. fontSource = XFontSource.GetOrCreateFromFile(typefaceKey, font); } return(fontSource); }