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);
}
