|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
//
//
//
// Contents: CharacterMetrics
//
//
using System;
using System.Globalization;
using StringBuilder = System.Text.StringBuilder;
using CompositeFontParser = MS.Internal.FontFace.CompositeFontParser;
using Constants = MS.Internal.TextFormatting.Constants;
using SR = MS.Internal.PresentationCore.SR;
#pragma warning disable 1634, 1691 // suppressing PreSharp warnings
namespace System.Windows.Media
{
/// <summary>
/// Metrics used to lay out a character in a device font.
/// </summary>
public class CharacterMetrics
{
private double _blackBoxWidth;
private double _blackBoxHeight;
private double _baseline;
private double _leftSideBearing;
private double _rightSideBearing;
private double _topSideBearing;
private double _bottomSideBearing;
private enum FieldIndex
{
BlackBoxWidth,
BlackBoxHeight,
Baseline,
LeftSideBearing,
RightSideBearing,
TopSideBearing,
BottomSideBearing
}
private const int NumFields = (int)FieldIndex.BottomSideBearing + 1;
private const int NumRequiredFields = (int)FieldIndex.BlackBoxHeight + 1;
/// <summary>
/// Constructs a CharacterMetrics object with default values.
/// </summary>
public CharacterMetrics()
{
}
/// <summary>
/// Constructs a CharacterMetrics with the specified values.
/// </summary>
/// <param name="metrics">Value of the Metrics property.</param>
public CharacterMetrics(string metrics)
{
ArgumentNullException.ThrowIfNull(metrics);
Metrics = metrics;
}
/// <summary>
/// String specifying the following properties in the following order: BlackBoxWidth, BlackBoxHeight,
/// Baseline, LeftSideBearing, RightSideBearing, TopSideBearing, BottomSideBearing. Property values
/// are delimited by commas, and the first two properties are required. The remaining properties may
/// be omitted and default to zero. For example, "0.75,0.75,,0.1" sets the first, second, and fourth
/// properties to the specified values and the rest to zero.
/// </summary>
public string Metrics
{
get
{
StringBuilder s = new StringBuilder();
// The following fields are required.
s.Append(_blackBoxWidth.ToString(System.Windows.Markup.TypeConverterHelper.InvariantEnglishUS));
s.Append(',');
s.Append(_blackBoxHeight.ToString(System.Windows.Markup.TypeConverterHelper.InvariantEnglishUS));
// Index of the last field we added to the string; this tells us how many commas to
// insert before the next optional field we add.
int lastIndex = (int)FieldIndex.BlackBoxHeight;
// The following fields are optional, but must be in ascending order of field index.
AppendField(_baseline, FieldIndex.Baseline, ref lastIndex, s);
AppendField(_leftSideBearing, FieldIndex.LeftSideBearing, ref lastIndex, s);
AppendField(_rightSideBearing, FieldIndex.RightSideBearing, ref lastIndex, s);
AppendField(_topSideBearing, FieldIndex.TopSideBearing, ref lastIndex, s);
AppendField(_bottomSideBearing, FieldIndex.BottomSideBearing, ref lastIndex, s);
return s.ToString();
}
set
{
double[] metrics = ParseMetrics(value);
// Validate all the values before we assign to any field.
CompositeFontParser.VerifyNonNegativeMultiplierOfEm("BlackBoxWidth", ref metrics[(int)FieldIndex.BlackBoxWidth]);
CompositeFontParser.VerifyNonNegativeMultiplierOfEm("BlackBoxHeight", ref metrics[(int)FieldIndex.BlackBoxHeight]);
CompositeFontParser.VerifyMultiplierOfEm("Baseline", ref metrics[(int)FieldIndex.Baseline]);
CompositeFontParser.VerifyMultiplierOfEm("LeftSideBearing", ref metrics[(int)FieldIndex.LeftSideBearing]);
CompositeFontParser.VerifyMultiplierOfEm("RightSideBearing", ref metrics[(int)FieldIndex.RightSideBearing]);
CompositeFontParser.VerifyMultiplierOfEm("TopSideBearing", ref metrics[(int)FieldIndex.TopSideBearing]);
CompositeFontParser.VerifyMultiplierOfEm("BottomSideBearing", ref metrics[(int)FieldIndex.BottomSideBearing]);
double horizontalAdvance = metrics[(int)FieldIndex.BlackBoxWidth]
+ metrics[(int)FieldIndex.LeftSideBearing]
+ metrics[(int)FieldIndex.RightSideBearing];
if (horizontalAdvance < 0)
throw new ArgumentException(SR.CharacterMetrics_NegativeHorizontalAdvance);
double verticalAdvance = metrics[(int)FieldIndex.BlackBoxHeight]
+ metrics[(int)FieldIndex.TopSideBearing]
+ metrics[(int)FieldIndex.BottomSideBearing];
if (verticalAdvance < 0)
throw new ArgumentException(SR.CharacterMetrics_NegativeVerticalAdvance);
// Set all the properties.
_blackBoxWidth = metrics[(int)FieldIndex.BlackBoxWidth];
_blackBoxHeight = metrics[(int)FieldIndex.BlackBoxHeight];
_baseline = metrics[(int)FieldIndex.Baseline];
_leftSideBearing = metrics[(int)FieldIndex.LeftSideBearing];
_rightSideBearing = metrics[(int)FieldIndex.RightSideBearing];
_topSideBearing = metrics[(int)FieldIndex.TopSideBearing];
_bottomSideBearing = metrics[(int)FieldIndex.BottomSideBearing];
}
}
private static void AppendField(double value, FieldIndex fieldIndex, ref int lastIndex, StringBuilder s)
{
if (value != 0)
{
s.Append(',', (int)fieldIndex - lastIndex);
lastIndex = (int)fieldIndex;
s.Append(value.ToString(System.Windows.Markup.TypeConverterHelper.InvariantEnglishUS));
}
}
private static double[] ParseMetrics(string s)
{
double[] metrics = new double[NumFields];
int i = 0, fieldIndex = 0;
for (; ; )
{
// Let i be first non-whitespace character or end-of-string.
while (i < s.Length && s[i] == ' ')
++i;
// Let j be delimiter or end-of-string.
int j = i;
while (j < s.Length && s[j] != ',')
++j;
// Let k be end-of-field without trailing whitespace.
int k = j;
while (k > i && s[k - 1] == ' ')
--k;
if (k > i)
{
// Non-empty field; convert it to double.
ReadOnlySpan<char> field = s.AsSpan(i, k - i);
if (!double.TryParse(
field,
NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign,
System.Windows.Markup.TypeConverterHelper.InvariantEnglishUS,
out metrics[fieldIndex]
))
{
throw new ArgumentException(SR.Format(SR.CannotConvertStringToType, field.ToString(), "double"));
}
}
else if (fieldIndex < NumRequiredFields)
{
// Empty field; make sure it's an optional one.
throw new ArgumentException(SR.CharacterMetrics_MissingRequiredField);
}
++fieldIndex;
if (j < s.Length)
{
// There's a comma so check if we've exceeded the number of fields.
if (fieldIndex == NumFields)
throw new ArgumentException(SR.CharacterMetrics_TooManyFields);
// Initialize character index for next iteration.
i = j + 1;
}
else
{
// No more fields; check if we have all required fields.
if (fieldIndex < NumRequiredFields)
{
throw new ArgumentException(SR.CharacterMetrics_MissingRequiredField);
}
break;
}
}
return metrics;
}
/// <summary>
/// Width of the black box for the character.
/// </summary>
public double BlackBoxWidth
{
get { return _blackBoxWidth; }
}
/// <summary>
/// Height of the black box for the character.
/// </summary>
public double BlackBoxHeight
{
get { return _blackBoxHeight; }
}
/// <summary>
/// Vertical offset from the bottom of the black box to the baseline. A positive
/// value indicates the baseline is above the bottom of the black box, and a negative
/// value indicates the baseline is below the bottom of the black box.
/// </summary>
public double Baseline
{
get { return _baseline; }
}
/// <summary>
/// Recommended white space to the left of the black box. A negative value results in
/// an overhang. The horizontal advance for the character is LeftSideBearing +
/// BlackBoxWidth + RightSideBearing, and cannot be less than zero.
/// </summary>
public double LeftSideBearing
{
get { return _leftSideBearing; }
}
/// <summary>
/// Recommended white space to the right of the black box. A negative value results in
/// an overhang. The horizontal advance for the character is LeftSideBearing +
/// BlackBoxWidth + RightSideBearing, and cannot be less than zero.
/// </summary>
public double RightSideBearing
{
get { return _rightSideBearing; }
}
/// <summary>
/// Recommended white space above the black box. A negative value results in
/// an overhang. The vertical advance for the character is TopSideBearing +
/// BlackBoxHeight + BottomSideBearing, and cannot be less than zero.
/// </summary>
public double TopSideBearing
{
get { return _topSideBearing; }
}
/// <summary>
/// Recommended white space below the black box. A negative value results in
/// an overhang. The vertical advance for the character is TopSideBearing +
/// BlackBoxHeight + BottomSideBearing, and cannot be less than zero.
/// </summary>
public double BottomSideBearing
{
get { return _bottomSideBearing; }
}
/// <summary>
/// Compares two CharacterMetrics for equality.
/// </summary>
public override bool Equals(object obj)
{
CharacterMetrics other = obj as CharacterMetrics;
// Suppress PRESharp warning that other can be null; apparently PRESharp
// doesn't understand short circuit evaluation of operator &&.
#pragma warning disable 6506
return other != null &&
other._blackBoxWidth == _blackBoxWidth &&
other._blackBoxHeight == _blackBoxHeight &&
other._leftSideBearing == _leftSideBearing &&
other._rightSideBearing == _rightSideBearing &&
other._topSideBearing == _topSideBearing &&
other._bottomSideBearing == _bottomSideBearing;
#pragma warning restore 6506
}
/// <summary>
/// Computes a hash value for a CharacterMetrics.
/// </summary>
public override int GetHashCode()
{
int hash = (int)(_blackBoxWidth * Constants.DefaultRealToIdeal);
hash = (hash * HashMultiplier) + (int)(_blackBoxHeight * Constants.DefaultRealToIdeal);
hash = (hash * HashMultiplier) + (int)(_baseline * Constants.DefaultRealToIdeal);
hash = (hash * HashMultiplier) + (int)(_leftSideBearing * Constants.DefaultRealToIdeal);
hash = (hash * HashMultiplier) + (int)(_rightSideBearing * Constants.DefaultRealToIdeal);
hash = (hash * HashMultiplier) + (int)(_topSideBearing * Constants.DefaultRealToIdeal);
hash = (hash * HashMultiplier) + (int)(_bottomSideBearing * Constants.DefaultRealToIdeal);
return hash;
}
private const int HashMultiplier = 101;
}
}
|