internal static FontFamilyInternal GetOrCreateFromWpf(WpfFontFamily wpfFontFamily)
{
FontFamilyInternal fontFamily = new FontFamilyInternal(wpfFontFamily);
fontFamily = FontFamilyCache.CacheOrGetFontFamily(fontFamily);
return(fontFamily);
}
//#endif
#if WPF && !SILVERLIGHT
internal static WpfTypeface TryCreateTypeface(string name, XFontStyle style, out WpfFontFamily fontFamily)
{
if (Singleton._fontFamilies.TryGetValue(name, out fontFamily))
{
WpfTypeface typeface = FontHelper.CreateTypeface(fontFamily, style);
return(typeface);
}
return(null);
}
FontFamilyInternal(GdiFontFamily gdiFontFamily)
{
_sourceName = _name = gdiFontFamily.Name;
_gdiFontFamily = gdiFontFamily;
#if WPF
// Hybrid build only.
_wpfFontFamily = new WpfFontFamily(gdiFontFamily.Name);
#endif
}
/// <summary>
/// Create a WPF GlyphTypeface and retrieve font data from it.
/// </summary>
internal static XFontSource CreateFontSource(string familyName, FontResolvingOptions fontResolvingOptions,
out WpfFontFamily wpfFontFamily, out WpfTypeface wpfTypeface, out WpfGlyphTypeface wpfGlyphTypeface, string typefaceKey)
{
if (string.IsNullOrEmpty(typefaceKey))
{
typefaceKey = XGlyphTypeface.ComputeKey(familyName, fontResolvingOptions);
}
XFontStyle style = fontResolvingOptions.FontStyle;
#if DEBUG
if (StringComparer.OrdinalIgnoreCase.Compare(familyName, "Segoe UI Semilight") == 0 &&
(style & XFontStyle.BoldItalic) == XFontStyle.Italic)
{
familyName.GetType();
}
#endif
// Use WPF technique to create font data.
wpfTypeface = XPrivateFontCollection.TryCreateTypeface(familyName, style, out wpfFontFamily);
#if DEBUG__
if (wpfTypeface != null)
{
WpfGlyphTypeface glyphTypeface;
ICollection <WpfTypeface> list = wpfFontFamily.GetTypefaces();
foreach (WpfTypeface tf in list)
{
if (!tf.TryGetGlyphTypeface(out glyphTypeface))
{
Debug - Break.Break();
}
}
//if (!WpfTypeface.TryGetGlyphTypeface(out glyphTypeface))
// throw new InvalidOperationException(PSSR.CannotGetGlyphTypeface(familyName));
}
#endif
if (wpfFontFamily == null)
{
wpfFontFamily = new WpfFontFamily(familyName);
}
if (wpfTypeface == null)
{
wpfTypeface = FontHelper.CreateTypeface(wpfFontFamily, style);
}
// Let WPF choose the right glyph typeface.
if (!wpfTypeface.TryGetGlyphTypeface(out wpfGlyphTypeface))
{
throw new InvalidOperationException(PSSR.CannotGetGlyphTypeface(familyName));
}
// Get or create the font source and cache it unter the specified typeface key.
XFontSource fontSource = XFontSource.GetOrCreateFromWpf(typefaceKey, wpfGlyphTypeface);
return(fontSource);
}
/// <summary>
/// Initializes a new instance of the <see cref="XFont"/> class from a System.Drawing.FontFamily.
/// </summary>
/// <param name="fontFamily">The System.Windows.Media.FontFamily.</param>
/// <param name="emSize">The em size.</param>
/// <param name="style">The font style.</param>
/// <param name="pdfOptions">Additional PDF options.</param>
public XFont(WpfFontFamily fontFamily, double emSize, XFontStyle style, XPdfFontOptions pdfOptions)
{
#if !SILVERLIGHT
_familyName = fontFamily.FamilyNames[XmlLanguage.GetLanguage("en-US")];
#else
// Best we can do in Silverlight.
_familyName = fontFamily.Source;
#endif
_wpfFontFamily = fontFamily;
_emSize = emSize;
_style = style;
_pdfOptions = pdfOptions;
InitializeFromWpf();
}
FontFamilyInternal(WpfFontFamily wpfFontFamily)
{
#if !SILVERLIGHT
_sourceName = wpfFontFamily.Source;
_name = wpfFontFamily.FamilyNames[FontHelper.XmlLanguageEnUs];
_wpfFontFamily = wpfFontFamily;
#else
_sourceName = _name = wpfFontFamily.Source;
_wpfFontFamily = wpfFontFamily;
#endif
#if GDI
// Hybrid build only.
_gdiFontFamily = new GdiFontFamily(_sourceName);
#endif
}
// Implementation Notes
// FontFamilyInternal implements an XFontFamily.
//
// * Each XFontFamily object is just a handle to its FontFamilyInternal singleton.
//
// * A FontFamilyInternal is is uniquely identified by its name. It
// is not possible to use two different fonts that have the same
// family name.
FontFamilyInternal(string familyName, bool createPlatformObjects)
{
_sourceName = _name = familyName;
#if CORE || GDI
if (createPlatformObjects)
{
_gdiFontFamily = new GdiFontFamily(familyName);
_name = _gdiFontFamily.Name;
}
#endif
#if WPF && !SILVERLIGHT
if (createPlatformObjects)
{
_wpfFontFamily = new WpfFontFamily(familyName);
_name = _wpfFontFamily.FamilyNames[FontHelper.XmlLanguageEnUs];
}
#endif
#if SILVERLIGHT
_wpfFontFamily = new WpfFontFamily(_name);
_name = _wpfFontFamily.Source; // Not expected to change _name.
#endif
}
public static XGlyphTypeface GetOrCreateFrom(string familyName, FontResolvingOptions fontResolvingOptions)
{
// Check cache for requested type face.
string typefaceKey = ComputeKey(familyName, fontResolvingOptions);
XGlyphTypeface glyphTypeface;
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.");
}
#if CORE || GDI
GdiFont gdiFont = null;
#endif
#if WPF
WpfFontFamily wpfFontFamily = null;
WpfTypeface wpfTypeface = null;
WpfGlyphTypeface wpfGlyphTypeface = null;
#endif
#if UWP
// Nothing to do.
#endif
// Now create the font family at the first.
XFontFamily fontFamily;
PlatformFontResolverInfo platformFontResolverInfo = fontResolverInfo as PlatformFontResolverInfo;
if (platformFontResolverInfo != null)
{
#if CORE || GDI
// $TODO THHO Lock???
// Reuse GDI+ font from platform font resolver.
gdiFont = platformFontResolverInfo.GdiFont;
fontFamily = XFontFamily.GetOrCreateFromGdi(gdiFont);
#endif
#if WPF
#if !SILVERLIGHT
// Reuse WPF font family created from platform font resolver.
wpfFontFamily = platformFontResolverInfo.WpfFontFamily;
wpfTypeface = platformFontResolverInfo.WpfTypeface;
wpfGlyphTypeface = platformFontResolverInfo.WpfGlyphTypeface;
fontFamily = XFontFamily.GetOrCreateFromWpf(wpfFontFamily);
#else
fontFamily = XFontFamily.GetOrCreateFromWpf(new WpfFontFamily(familyName));
#endif
#endif
#if NETFX_CORE || UWP
fontFamily = null;
#endif
}
else
{
// Create new and exclusively used font family for custom font resolver retrieved font source.
fontFamily = XFontFamily.CreateSolitary(fontResolverInfo.FaceName);
}
// We have a valid font resolver info. That means we also have an XFontSource object loaded in the cache.
////XFontSource fontSource = FontFactory.GetFontSourceByTypefaceKey(fontResolverInfo.FaceName);
XFontSource fontSource = FontFactory.GetFontSourceByFontName(fontResolverInfo.FaceName);
Debug.Assert(fontSource != null);
// Each font source already contains its OpenTypeFontface.
#if CORE || GDI
glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations, gdiFont);
#endif
#if WPF
glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations, wpfTypeface, wpfGlyphTypeface);
#endif
#if NETFX_CORE || UWP
glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations);
#endif
GlyphTypefaceCache.AddGlyphTypeface(glyphTypeface);
return(glyphTypeface);
}
//// Methods
//public Font(Font prototype, FontStyle newStyle);
//public Font(FontFamily family, float emSize);
//public Font(string familyName, float emSize);
//public Font(FontFamily family, float emSize, FontStyle style);
//public Font(FontFamily family, float emSize, GraphicsUnit unit);
//public Font(string familyName, float emSize, FontStyle style);
//public Font(string familyName, float emSize, GraphicsUnit unit);
//public Font(FontFamily family, float emSize, FontStyle style, GraphicsUnit unit);
//public Font(string familyName, float emSize, FontStyle style, GraphicsUnit unit);
////public Font(FontFamily family, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet);
////public Font(string familyName, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet);
////public Font(FontFamily family, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet, bool gdiVerticalFont);
////public Font(string familyName, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet, bool gdiVerticalFont);
//public object Clone();
//private static FontFamily CreateFontFamilyWithFallback(string familyName);
//private void Dispose(bool disposing);
//public override bool Equals(object obj);
//protected override void Finalize();
//public static Font FromHdc(IntPtr hdc);
//public static Font FromHfont(IntPtr hfont);
//public static Font FromLogFont(object lf);
//public static Font FromLogFont(object lf, IntPtr hdc);
//public override int GetHashCode();
/// <summary>
/// Initializes this instance by computing the glyph typeface, font family, font source and TrueType fontface.
/// (PDFsharp currently only deals with TrueType fonts.)
/// </summary>
void Initialize()
{
#if DEBUG
if (_familyName == "Segoe UI Semilight" && (_style & XFontStyle.BoldItalic) == XFontStyle.Italic)
{
GetType();
}
#endif
FontResolvingOptions fontResolvingOptions = OverrideStyleSimulations
? new FontResolvingOptions(_style, StyleSimulations)
: new FontResolvingOptions(_style);
// HACK: 'PlatformDefault' is used in unit test code.
if (StringComparer.OrdinalIgnoreCase.Compare(_familyName, GlobalFontSettings.DefaultFontName) == 0)
{
#if CORE || GDI || WPF
_familyName = "Calibri";
#endif
}
// In principle an XFont is an XGlyphTypeface plus an em-size.
_glyphTypeface = XGlyphTypeface.GetOrCreateFrom(_familyName, fontResolvingOptions);
#if GDI // TODO: In CORE build it is not necessary to create a GDI font at all
// Create font by using font family.
XFontSource fontSource; // Not needed here.
_gdiFont = FontHelper.CreateFont(_familyName, (float)_emSize, (GdiFontStyle)(_style & XFontStyle.BoldItalic), out fontSource);
#endif
#if WPF && !SILVERLIGHT // Pure WPF
_wpfFontFamily = _glyphTypeface.FontFamily.WpfFamily;
_wpfTypeface = _glyphTypeface.WpfTypeface;
if (_wpfFontFamily == null)
{
_wpfFontFamily = new WpfFontFamily(Name);
}
if (_wpfTypeface == null)
{
_wpfTypeface = FontHelper.CreateTypeface(WpfFontFamily, _style);
}
#endif
#if WPF && SILVERLIGHT_ // Pure Silverlight 5
if (GlyphTypeface == null)
{
//Debug.Assert(Typeface == null);
// #P F C
//GlyphTypeface = XPrivateFontCollection.TryGetXGlyphTypeface(Name, _style);
//if (GlyphTypeface == null)
//{
// // HACK: Just make it work...
// GlyphTypeface = GlobalFontSettings.TryGetXGlyphTypeface(Name, _style, out Data);
//}
#if DEBUG
if (GlyphTypeface == null)
{
throw new Exception("No font: " + Name);
}
#endif
_wpfFamily = GlyphTypeface.FontFamily;
}
//if (Family == null)
// Family = new System.Windows.Media.FontFamily(Name);
//if (Typeface == null)
// Typeface = FontHelper.CreateTypeface(Family, _style);
#endif
CreateDescriptorAndInitializeFontMetrics();
}
/// <summary>
/// Initializes a new instance of the <see cref="XFont"/> class from a System.Windows.Media.FontFamily.
/// </summary>
/// <param name="fontFamily">The System.Windows.Media.FontFamily.</param>
/// <param name="emSize">The em size.</param>
/// <param name="style">The font style.</param>
public XFont(WpfFontFamily fontFamily, double emSize, XFontStyle style)
: this(fontFamily, emSize, style, new XPdfFontOptions(GlobalFontSettings.DefaultFontEncoding))
{
}
internal static XFontFamily GetOrCreateFromWpf(WpfFontFamily wpfFontFamily)
{
FontFamilyInternal fontFamilyInternal = FontFamilyInternal.GetOrCreateFromWpf(wpfFontFamily);
return(new XFontFamily(fontFamilyInternal));
}
