public void Serialize(XmlElement node)
{
Exceptions.CheckArgumentNull(node, "node").RemoveAll();
if (IsDefault)
{
node.SetBoolean("IsDefault", IsDefault);
return;
}
node.SetString("Family", FontFamily.Source);
node.SetInt32("Weight", FontWeight.ToOpenTypeWeight());
node.SetInt32("Style", (FontStyleConverter)FontStyle);
node.SetInt32("Stretch", FontStretch.ToOpenTypeStretch());
node.SetDouble("Size", FontSize);
if (!TextDecorations.IsNullOrEmpty())
{
XmlElement textDecorationsNode = node.CreateChildElement("TextDecorations");
foreach (TextDecoration decoration in TextDecorations)
{
textDecorationsNode.CreateChildElement("Decoration").SetInt32("Location", (int)decoration.Location);
}
}
}
internal MatchingStyle(
FontStyle style,
FontWeight weight,
FontStretch stretch
)
{
_vector = new Vector(
(stretch.ToOpenTypeStretch() - FontStretches.Normal.ToOpenTypeStretch()) * FontStretchScale,
style.GetStyleForInternalConstruction() * FontStyleScale,
(weight.ToOpenTypeWeight() - FontWeights.Normal.ToOpenTypeWeight()) / 100.0 * FontWeightScale
);
}
public void WriteXml(XmlWriter writer)
{
XmlSerializer ColorSerializer = new XmlSerializer(typeof(Color));
writer.WriteAttributeString("FontWeight", FontWeight.ToOpenTypeWeight().ToString());
writer.WriteAttributeString("FontStyle", FontStyle.ToString());
writer.WriteStartElement("BackgroundColor");
ColorSerializer.Serialize(writer, BackgroundColor);
writer.WriteEndElement();
writer.WriteStartElement("ForeColor");
ColorSerializer.Serialize(writer, ForeColor);
writer.WriteEndElement();
}
/// <summary>
/// TypeConverter method implementation.
/// </summary>
/// <exception cref="NotSupportedException">
/// An NotSupportedException is thrown if the example object is null or is not a FontWeight,
/// or if the destinationType isn't one of the valid destination types.
/// </exception>
/// <param name="context">ITypeDescriptorContext</param>
/// <param name="culture">current culture (see CLR specs)</param>
/// <param name="value">value to convert from</param>
/// <param name="destinationType">Type to convert to</param>
/// <returns>converted value</returns>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType != null && value is FontWeight)
{
if (destinationType == typeof(InstanceDescriptor))
{
MethodInfo mi = typeof(FontWeight).GetMethod("FromOpenTypeWeight", new Type[] { typeof(int) });
FontWeight c = (FontWeight)value;
return(new InstanceDescriptor(mi, new object[] { c.ToOpenTypeWeight() }));
}
else if (destinationType == typeof(string))
{
FontWeight c = (FontWeight)value;
return(((IFormattable)c).ToString(null, culture));
}
}
// Pass unhandled cases to base class (which will throw exceptions for null value or destinationType.)
return(base.ConvertTo(context, culture, value, destinationType));
}
int IComparable.CompareTo(object obj)
{
TypefaceListItem item = obj as TypefaceListItem;
if (item == null)
{
return(-1);
}
// Sort all simulated faces after all non-simulated faces.
if (_simulated != item._simulated)
{
return(_simulated ? 1 : -1);
}
// If weight differs then sort based on weight (lightest first).
int difference = FontWeight.ToOpenTypeWeight() - item.FontWeight.ToOpenTypeWeight();
if (difference != 0)
{
return(difference > 0 ? 1 : -1);
}
// If style differs then sort based on style (Normal, Italic, then Oblique).
FontStyle thisStyle = FontStyle;
FontStyle otherStyle = item.FontStyle;
if (thisStyle != otherStyle)
{
if (thisStyle == FontStyles.Normal)
{
// This item is normal style and should come first.
return(-1);
}
else if (otherStyle == FontStyles.Normal)
{
// The other item is normal style and should come first.
return(1);
}
else
{
// Neither is normal so sort italic before oblique.
return((thisStyle == FontStyles.Italic) ? -1 : 1);
}
}
// If stretch differs then sort based on stretch (Normal first, then numerically).
FontStretch thisStretch = FontStretch;
FontStretch otherStretch = item.FontStretch;
if (thisStretch != otherStretch)
{
if (thisStretch == FontStretches.Normal)
{
// This item is normal stretch and should come first.
return(-1);
}
else if (otherStretch == FontStretches.Normal)
{
// The other item is normal stretch and should come first.
return(1);
}
else
{
// Neither is normal so sort numerically.
return(thisStretch.ToOpenTypeStretch() < otherStretch.ToOpenTypeStretch() ? -1 : 0);
}
}
// They're the same.
return(0);
}
internal GlyphTypeface GetGlyphTypeface(
FontStyle style,
FontWeight weight,
FontStretch stretch
)
{
Text.TextInterface.Font bestMatch = _family.GetFirstMatchingFont((Text.TextInterface.FontWeight)weight.ToOpenTypeWeight(),
(Text.TextInterface.FontStretch)stretch.ToOpenTypeStretch(),
(Text.TextInterface.FontStyle)style.GetStyleForInternalConstruction());
Debug.Assert(bestMatch != null);
return(new GlyphTypeface(bestMatch));
}
private FontWeight GetBoldFont()
{
return(FontWeight.FromOpenTypeWeight(FontWeight.ToOpenTypeWeight() + 300));
}
protected WpfFontFamilyInfo GetTextFontFamilyInfo(SvgTextContentElement element)
{
_actualFontName = null;
string fontFamily = element.GetPropertyValue("font-family");
string[] fontNames = fontFamily.Split(new char[1] {
','
});
FontStyle fontStyle = GetTextFontStyle(element);
FontWeight fontWeight = GetTextFontWeight(element);
FontStretch fontStretch = GetTextFontStretch(element);
var comparer = StringComparison.OrdinalIgnoreCase;
var docElement = element.OwnerDocument;
ISet <string> svgFontFamilies = docElement.SvgFontFamilies;
IDictionary <string, string> styledFontIds = docElement.StyledFontIds;
IList <string> svgFontNames = null;
if (svgFontFamilies != null && svgFontFamilies.Count != 0)
{
svgFontNames = new List <string>();
}
//var systemFontFamilies = Fonts.SystemFontFamilies;
var wpfSettings = _context.Settings;
var fontFamilyNames = wpfSettings.FontFamilyNames;
var privateFontFamilies = wpfSettings.HasFontFamilies;
FontFamily family = null;
// using separate pointer to give less priority to generic font names
FontFamily genericFamily = null;
WpfFontFamilyType familyType = WpfFontFamilyType.None;
foreach (string fn in fontNames)
{
try
{
string fontName = fn.Trim(new char[] { ' ', '\'', '"' });
if (svgFontFamilies != null && svgFontFamilies.Count != 0)
{
if (svgFontFamilies.Contains(fontName))
{
svgFontNames.Add(fontName);
continue;
}
if (styledFontIds.ContainsKey(fontName))
{
string mappedFontName = styledFontIds[fontName];
if (svgFontFamilies.Contains(mappedFontName))
{
svgFontNames.Add(mappedFontName);
continue;
}
}
}
if (string.Equals(fontName, "serif", comparer))
{
genericFamily = WpfDrawingSettings.GenericSerif;
}
else if (string.Equals(fontName, "sans-serif", comparer) ||
string.Equals(fontName, "sans serif", comparer))
{
genericFamily = WpfDrawingSettings.GenericSansSerif;
}
else if (string.Equals(fontName, "monospace", comparer))
{
genericFamily = WpfDrawingSettings.GenericMonospace;
}
else if (styledFontIds.ContainsKey(fontName))
{
string mappedFontName = styledFontIds[fontName];
family = LookupFontFamily(mappedFontName, fontFamilyNames);
if (family != null)
{
_actualFontName = mappedFontName;
familyType = WpfFontFamilyType.System;
}
}
else
{
// Try looking up fonts in the system font registry...
family = LookupFontFamily(fontName, fontFamilyNames);
if (family != null)
{
_actualFontName = fontName;
familyType = WpfFontFamilyType.System;
}
// If not found, look through private fonts if available..
if (family == null && privateFontFamilies)
{
family = wpfSettings.LookupFontFamily(fontName);
if (family != null)
{
_actualFontName = fontName;
familyType = WpfFontFamilyType.Private;
}
}
}
if (family != null)
{
return(new WpfFontFamilyInfo(familyType, _actualFontName, family,
fontWeight, fontStyle, fontStretch));
}
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
}
}
// If set, use the SVG-Font...
if (svgFontNames != null && svgFontNames.Count != 0)
{
FontFamily altFamily = (genericFamily != null) ? genericFamily : WpfDrawingSettings.DefaultFontFamily;
IList <SvgFontElement> svgFonts = docElement.GetFonts(svgFontNames);
if (svgFonts != null && svgFonts.Count != 0)
{
string fontVariant = element.GetPropertyValue("font-variant");
// For a single match...
if (svgFonts.Count == 1)
{
var fontFamilyInfo = new WpfFontFamilyInfo(svgFonts[0].FontFamily, svgFonts[0],
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
// For the defined font style...
if (fontStyle != FontStyles.Normal)
{
// Then it is either oblique or italic
SvgFontElement closeFont = null;
SvgFontElement closestFont = null;
bool isItalic = fontStyle.Equals(FontStyles.Italic);
foreach (var svgFont in svgFonts)
{
var fontFace = svgFont.FontFace;
if (fontFace == null)
{
continue;
}
var typefaceStyle = GetTextFontStyle(fontFace.FontStyle);
if (fontStyle.Equals(typefaceStyle))
{
closeFont = svgFont;
if (closestFont == null)
{
closestFont = svgFont;
}
var typefaceWeight = GetTextFontWeight(fontFace.FontWeight);
if (fontVariant.Equals(fontFace.FontVariant, comparer))
{
closestFont = svgFont;
if (fontWeight.Equals(typefaceWeight))
{
var fontFamilyInfo = new WpfFontFamilyInfo(svgFont.FontFamily, svgFont,
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
}
}
if (closeFont == null)
{
if (isItalic && typefaceStyle == FontStyles.Oblique)
{
closeFont = svgFont;
}
if (!isItalic && typefaceStyle == FontStyles.Italic)
{
closeFont = svgFont;
}
}
}
if (closestFont != null)
{
closeFont = closestFont;
}
if (closeFont != null)
{
var fontFamilyInfo = new WpfFontFamilyInfo(closeFont.FontFamily, closeFont,
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
}
SvgFontElement variantFont = null;
// For multiple matches, we will test the variants...
if (!string.IsNullOrWhiteSpace(fontVariant))
{
foreach (var svgFont in svgFonts)
{
var fontFace = svgFont.FontFace;
if (fontFace == null)
{
continue;
}
if (fontVariant.Equals(fontFace.FontVariant, comparer))
{
variantFont = svgFont;
// Check for more perfect match...
var typefaceWeight = GetTextFontWeight(fontFace.FontWeight);
var typefaceStyle = GetTextFontStyle(fontFace.FontStyle);
if (fontStyle.Equals(typefaceStyle) && fontWeight.Equals(typefaceWeight))
{
var fontFamilyInfo = new WpfFontFamilyInfo(svgFont.FontFamily, svgFont,
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
}
}
//if (variantFont != null)
//{
// // If there was a matching variant but either style or weight not matched...
// var fontFamilyInfo = new WpfFontFamilyInfo(variantFont.FontFamily, variantFont,
// fontWeight, fontStyle, fontStretch);
// fontFamilyInfo.Variant = fontVariant;
// // For rendering that do not support the SVG Fonts...
// fontFamilyInfo.Family = altFamily;
// return fontFamilyInfo;
//}
}
// For the defined font weights...
if (fontWeight != FontWeights.Normal && fontWeight != FontWeights.Regular)
{
int weightValue = fontWeight.ToOpenTypeWeight();
int selectedValue = int.MaxValue;
SvgFontElement sameWeightFont = null;
SvgFontElement closestFont = null;
foreach (var svgFont in svgFonts)
{
var fontFace = svgFont.FontFace;
if (fontFace == null)
{
continue;
}
var typefaceWeight = GetTextFontWeight(fontFace.FontWeight);
if (fontWeight.Equals(typefaceWeight))
{
sameWeightFont = svgFont;
var typefaceStyle = GetTextFontStyle(fontFace.FontStyle);
if (fontStyle.Equals(typefaceStyle))
{
var fontFamilyInfo = new WpfFontFamilyInfo(svgFont.FontFamily, svgFont,
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
}
int weightDiff = Math.Abs(weightValue - typefaceWeight.ToOpenTypeWeight());
if (weightDiff < selectedValue)
{
closestFont = svgFont;
selectedValue = weightDiff;
}
}
// If the weights matched, but not the style
if (sameWeightFont != null)
{
var fontFamilyInfo = new WpfFontFamilyInfo(sameWeightFont.FontFamily, sameWeightFont,
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
if (closestFont != null)
{
var fontFamilyInfo = new WpfFontFamilyInfo(closestFont.FontFamily, closestFont,
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
}
if (variantFont != null)
{
// If there was a matching variant but either style or weight not matched...
var fontFamilyInfo = new WpfFontFamilyInfo(variantFont.FontFamily, variantFont,
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
else // If the variant is not found, return the first match...
{
var fontFamilyInfo = new WpfFontFamilyInfo(svgFonts[0].FontFamily, svgFonts[0],
fontWeight, fontStyle, fontStretch);
fontFamilyInfo.Variant = fontVariant;
// For rendering that do not support the SVG Fonts...
fontFamilyInfo.Family = altFamily;
return(fontFamilyInfo);
}
//// For multiple matches, we will test the variants...
//if (string.IsNullOrWhiteSpace(fontVariant))
//{
// // Not found, return the first match...
// var fontFamilyInfo = new WpfFontFamilyInfo(svgFonts[0].FontFamily, svgFonts[0],
// fontWeight, fontStyle, fontStretch);
// fontFamilyInfo.Variant = fontVariant;
// // For rendering that do not support the SVG Fonts...
// fontFamilyInfo.Family = altFamily;
// return fontFamilyInfo;
//}
}
}
if (genericFamily != null)
{
return(new WpfFontFamilyInfo(WpfFontFamilyType.Generic, _actualFontName, genericFamily,
fontWeight, fontStyle, fontStretch));
}
// No known font-family was found => default to "Arial"
return(new WpfFontFamilyInfo(familyType, _actualFontName,
WpfDrawingSettings.DefaultFontFamily, fontWeight, fontStyle, fontStretch));
}
private FontFamily GetMatchingFontFamily(IList <FontFamily> fontFamilies,
FontWeight weight, FontStyle style, FontStretch stretch)
{
if (fontFamilies == null || fontFamilies.Count == 0)
{
return(null);
}
// For a single match...
if (fontFamilies.Count == 1)
{
return(fontFamilies[0]);
}
// 1. Look for a possibility of all properties matching
foreach (FontFamily fontFamily in fontFamilies)
{
// Return the family typeface collection for the font family.
FamilyTypefaceCollection familyTypefaces = fontFamily.FamilyTypefaces;
// Enumerate the family typefaces in the collection.
foreach (FamilyTypeface typeface in familyTypefaces)
{
FontStyle fontStyle = typeface.Style;
FontWeight fontWeight = typeface.Weight;
FontStretch fontStretch = typeface.Stretch;
if (fontStyle.Equals(style) && fontWeight.Equals(weight) && fontStretch.Equals(stretch))
{
return(fontFamily);
}
}
}
// For the defined font style...
if (style != FontStyles.Normal)
{
// Then it is either oblique or italic
FontFamily closeFamily = null;
FontFamily closestFamily = null;
bool isItalic = style.Equals(FontStyles.Italic);
foreach (FontFamily fontFamily in fontFamilies)
{
// Return the family typeface collection for the font family.
FamilyTypefaceCollection familyTypefaces = fontFamily.FamilyTypefaces;
// Enumerate the family typefaces in the collection.
foreach (FamilyTypeface typeface in familyTypefaces)
{
FontStyle fontStyle = typeface.Style;
FontWeight fontWeight = typeface.Weight;
FontStretch fontStretch = typeface.Stretch;
if (fontStyle.Equals(style))
{
closeFamily = fontFamily;
if (closestFamily == null)
{
closestFamily = fontFamily;
}
if (fontStretch.Equals(stretch))
{
closestFamily = fontFamily;
if (fontWeight.Equals(weight))
{
return(fontFamily);
}
}
}
if (closeFamily == null)
{
if (isItalic && fontStyle == FontStyles.Oblique)
{
closeFamily = fontFamily;
}
if (!isItalic && fontStyle == FontStyles.Italic)
{
closeFamily = fontFamily;
}
}
}
if (closestFamily != null)
{
closeFamily = closestFamily;
}
if (closeFamily != null)
{
return(closeFamily);
}
}
}
// For the defined font weights...
if (weight != FontWeights.Normal && weight != FontWeights.Regular)
{
int weightValue = weight.ToOpenTypeWeight();
int selectedValue = int.MaxValue;
FontFamily sameWeightFamily = null;
FontFamily closestFamily = null;
foreach (FontFamily fontFamily in fontFamilies)
{
// Return the family typeface collection for the font family.
FamilyTypefaceCollection familyTypefaces = fontFamily.FamilyTypefaces;
// Enumerate the family typefaces in the collection.
foreach (FamilyTypeface typeface in familyTypefaces)
{
FontStyle fontStyle = typeface.Style;
FontWeight fontWeight = typeface.Weight;
FontStretch fontStretch = typeface.Stretch;
if (fontWeight.Equals(weight))
{
sameWeightFamily = fontFamily;
if (fontStyle.Equals(style))
{
return(fontFamily);
}
}
int weightDiff = Math.Abs(weightValue - fontWeight.ToOpenTypeWeight());
if (weightDiff < selectedValue)
{
closestFamily = fontFamily;
selectedValue = weightDiff;
}
// If the weights matched, but not the style
if (sameWeightFamily != null)
{
return(sameWeightFamily);
}
if (closestFamily != null)
{
return(closestFamily);
}
}
}
}
return(null);
}
