public void Render(DrawingContext drawingContext, RenderContext renderContext)
{
Int32 lineCount = _editor.Document.LineCount;
Int32 lineNumberCount = GetLineNumberCount(lineCount);
Typeface typeface = TypefaceGenerator.GetInstance().GenerateTypeface(_editor.GlyphOption.FontFamily, FontStyles.Normal, FontWeights.Normal, FontStretches.Normal);
GlyphTypeface glyphTypeface = TypefaceGenerator.GetInstance().GenerateGlyphTypeface(_editor.GlyphOption.FontFamily, FontStyles.Normal, FontWeights.Normal, FontStretches.Normal);
UInt16 indice = glyphTypeface.CharacterToGlyphMap['0'];
Double characterWidth = glyphTypeface.AdvanceWidths[indice] * _editor.GlyphOption.FontSize;
Double characterHeight = glyphTypeface.AdvanceHeights[indice] * _editor.GlyphOption.FontSize;
Double maxNumberWidth = Math.Max(lineNumberCount * characterWidth, 3 * characterWidth);
Point renderOffset = new Point(renderContext.Offset.X - _editor.HorizontalOffset, _editor._lineRenderer.RenderOffset.Y + _editor.Padding.Top);
var brush = new SolidColorBrush(CommonUtilities.ColorFromHexString("#FF7D7D7D"));
foreach (VisualLine visualLine in _editor._lineRenderer.VisibleLines)
{
var formattedText = new FormattedText(visualLine.Line.LineNumber.ToString(), CultureInfo.CurrentCulture, FlowDirection.LeftToRight, typeface, _editor.GlyphOption.FontSize, brush);
Point actualRenderOffset = renderOffset;
actualRenderOffset.X += maxNumberWidth - formattedText.Width;
actualRenderOffset.Y += (_editor.GlyphOption.LineHeight - characterHeight);
drawingContext.DrawText(formattedText, actualRenderOffset);
renderOffset.Y += _editor.GlyphOption.LineHeight;
}
drawingContext.DrawLine(new Pen(brush, 2.0), new Point(_editor._lineRenderer.RenderOffset.X + maxNumberWidth + 5.0, _editor._lineRenderer.RenderOffset.Y), new Point(_editor._lineRenderer.RenderOffset.X + maxNumberWidth + 5.0, 2000.0));
RenderWidth = maxNumberWidth + 10.0;
renderContext.PushTranslation(RenderWidth, 0.0);
}
public void Add(GlyphTypeface gtf, string path)
{
if (Normal == null)
{
Normal = path;
}
if (gtf.Style == System.Windows.FontStyles.Italic)
{
if (isBoldFont(gtf))
{
BoldItalic = path;
}
else
{
Italic = path;
}
}
else
{
if (isBoldFont(gtf))
{
Bold = path;
}
else
{
Normal = path;
}
}
}
public override bool AllowText(TextRenderInfo renderInfo)
{
DocumentFont font = renderInfo.GetFont();
PdfDictionary fontDict = font.FontDictionary;
PdfName subType = fontDict.GetAsName(PdfName.SUBTYPE);
if (PdfName.TYPE0.Equals(subType))
{
PdfArray descendantFonts = fontDict.GetAsArray(PdfName.DESCENDANTFONTS);
PdfDictionary descendantFont = descendantFonts[0] as PdfDictionary;
PdfDictionary fontDescriptor = descendantFont.GetAsDict(PdfName.FONTDESCRIPTOR);
PdfStream fontStream = fontDescriptor.GetAsStream(PdfName.FONTFILE2);
byte[] fontData = PdfReader.GetStreamBytes((PRStream)fontStream);
MemoryStream dataStream = new MemoryStream(fontData);
dataStream.Position = 0;
MemoryPackage memoryPackage = new MemoryPackage();
Uri uri = memoryPackage.CreatePart(dataStream);
GlyphTypeface glyphTypeface = new GlyphTypeface(uri);
ICollection <string> names = glyphTypeface.FamilyNames.Values;
return(names.Where(name => name.Contains("Arial")).Count() > 0);
}
else
{
// analogous code for other font subtypes
return(false);
}
}
private void btn_setfont_Click(object sender, RoutedEventArgs e)
{
if (cmb_fonts.SelectedIndex == -1)
{
return;
}
// Get fonts names
using (var memoryPackage = new MemoryPackage())
{
using (var fontStream = new MemoryStream(File.ReadAllBytes(AppDomain.CurrentDomain.BaseDirectory.Replace("\\", "/") + cmb_fonts.SelectedItem.ToString())))
{
GlyphTypeface glyphTypeface;
var typefaceSource = memoryPackage.CreatePart(fontStream);
glyphTypeface = new GlyphTypeface(typefaceSource);
fontName = String.Join(" ", glyphTypeface.FamilyNames.Values.ToArray <string>());
lbl_textFont.Text = "Selected Font Name: " + fontName;
memoryPackage.DeletePart(typefaceSource);
}
}
//
lbl_text.FontFamily = new FontFamily("file:///" + AppDomain.CurrentDomain.BaseDirectory + cmb_fonts.SelectedItem.ToString().Substring(1) + "#" + fontName);
lbl_text2.FontFamily = new FontFamily("file:///" + AppDomain.CurrentDomain.BaseDirectory + cmb_fonts.SelectedItem.ToString().Substring(1) + "#" + fontName);
lbl_text3.FontFamily = new FontFamily("file:///" + AppDomain.CurrentDomain.BaseDirectory + cmb_fonts.SelectedItem.ToString().Substring(1) + "#" + fontName);
lbl_textFont2.Text = "Textblock said it's: " + String.Join(" ", lbl_text.FontFamily.FamilyNames.Values.ToArray <string>());
}
public override RSize MeasureString(string str, RFont font)
{
double width = 0;
GlyphTypeface glyphTypeface = ((FontAdapter)font).GlyphTypeface;
if (glyphTypeface != null)
{
for (int i = 0; i < str.Length; i++)
{
if (glyphTypeface.CharacterToGlyphMap.ContainsKey(str[i]))
{
ushort glyph = glyphTypeface.CharacterToGlyphMap[str[i]];
double advanceWidth = glyphTypeface.AdvanceWidths[glyph];
width += advanceWidth;
}
else
{
width = 0;
break;
}
}
}
if (width <= 0)
{
var formattedText = new FormattedText(str, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, ((FontAdapter)font).Font, 96d / 72d * font.Size, Brushes.Red);
return(new RSize(formattedText.WidthIncludingTrailingWhitespace, formattedText.Height));
}
return(new RSize(width * font.Size * 96d / 72d, font.Height));
}
private static sbyte ToPixels(double designSize, double emSize, GlyphTypeface typeface)
{
dynamic typefaceFriend = new AccessPrivateWrapper(typeface);
ushort designEmHeight = typefaceFriend.DesignEmHeight;
return((sbyte)(designSize / designEmHeight * (emSize * 96.0 / 72.0)));
}
/// <summary>
/// Compute unshaped glyph run object from the specified character-based info
/// </summary>
internal sealed override GlyphRun ComputeUnshapedGlyphRun(
Point origin,
char[] characterString,
IList <double> characterAdvances
)
{
bool nullFont;
GlyphTypeface glyphTypeface = GetGlyphTypeface(out nullFont);
Invariant.Assert(glyphTypeface != null);
return(glyphTypeface.ComputeUnshapedGlyphRun(
origin,
new CharacterBufferRange(
characterString,
0, // offsetToFirstChar
characterString.Length
),
characterAdvances,
_emSize,
(float)_properties.PixelsPerDip,
_properties.FontHintingEmSize,
nullFont,
CultureMapper.GetSpecificCulture(_properties.CultureInfo),
(_shapeTypeface == null || _shapeTypeface.DeviceFont == null) ? null : _shapeTypeface.DeviceFont.Name,
_textFormattingMode
));
}
private static bool GetTextBounds(GlyphTypeface glyphTypeface, double fontSize, out double topDistance, out double bottomDistance)
{
string testCharacters = "aA. ÅÄÖÃÂ_[]{}()|ygf";
topDistance = double.MaxValue;
bottomDistance = double.MinValue;
for (int n = 0; n < testCharacters.Length; n++)
{
if (glyphTypeface.CharacterToGlyphMap.TryGetValue(testCharacters[n], out ushort glyphIndex))
{
Geometry outline = glyphTypeface.GetGlyphOutline(glyphIndex, fontSize, 0);
topDistance = Math.Min(topDistance, outline.Bounds.Top);
bottomDistance = Math.Max(bottomDistance, outline.Bounds.Bottom);
}
}
if (bottomDistance == double.MinValue)
{
return(false);
}
topDistance = Math.Abs(topDistance);
return(true);
}
public void Stub01()
{
// <SnippetGlyphTypefaceSnippet1>
// Create a glyph typeface by referencing the Kootenay OpenType font.
GlyphTypeface glyphTypeface = new GlyphTypeface(new Uri("file:///C:\\WINDOWS\\Fonts\\Kooten.ttf"));
// </SnippetGlyphTypefaceSnippet1>
}
/// <summary>
/// Initializes a new instance of the <c>TextStyle</c> class.
/// </summary>
/// <param name="name">Text style name.</param>
/// <param name="font">Text style font file name with full or relative path.</param>
/// <param name="checkName">Specifies if the style name has to be checked.</param>
/// <remarks>If the font file is a true type and is not found in the specified path, the constructor will try to find it in the system font folder.</remarks>
internal TextStyle(string name, string font, bool checkName)
: base(name, DxfObjectCode.TextStyle, checkName)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name), "The text style name should be at least one character long.");
}
if (string.IsNullOrEmpty(font))
{
throw new ArgumentNullException(nameof(font));
}
this.IsReserved = name.Equals(DefaultName, StringComparison.OrdinalIgnoreCase);
this.font = font;
this.bigFont = null;
this.widthFactor = 1.0;
this.obliqueAngle = 0.0;
this.height = 0.0;
this.isVertical = false;
this.isBackward = false;
this.isUpsideDown = false;
this.glyphTypeface = null;
this.fontFamilyName = Path.GetFileNameWithoutExtension(font);
this.TrueTypeFontCheck(font);
}
/// <summary>
/// simple wrapper routine for generating a glyph run
/// </summary>
/// <param name="info"></param>
/// <param name="glyphTypeface"></param>
/// <param name="symbolSize"></param>
/// <param name="pixelsPerDip"></param>
/// <param name="point"></param>
/// <returns></returns>
public static GlyphRun GetGlyphRun(GlyphInfo info, GlyphTypeface glyphTypeface, double symbolSize, float pixelsPerDip, Point point)
{
var run = new GlyphRun(glyphTypeface, 0, false, symbolSize, pixelsPerDip, info.Indexes, point, info.AdvanceWidths,
null, null, null, null, null, null);
return(run);
}
private PDFObject GetWidths(GlyphTypeface glyphTypeface, IIndirectObjectCreator creator,
IDictionary <int, ushort> cmap)
{
PDFArray widths = creator.CreateIndirectArray();
IDictionary <ushort, double> advWidths = glyphTypeface.AdvanceWidths;
for (char ch = (char)firstChar; ch <= lastChar; ch++)
{
int width = 0;
if (subsetCharacters.Contains(ch))
{
ushort gid;
if (cmap.TryGetValue((int)ch, out gid))
{
double widthDouble;
if (advWidths.TryGetValue(gid, out widthDouble))
{
width = (int)(1000 * widthDouble);
}
}
}
widths.Array.Add(new PDFInt(width));
}
return(widths);
}
/// <summary>
/// Calculates / Renders the Main Geometry object
/// </summary>
/// <returns></returns>
private void BuildGeometry()
{
Uri ttfPathUri = new Uri(TtfPath);
GlyphTypeface glyphTypeface = new GlyphTypeface(ttfPathUri);
ushort[] glyphIndexes = new ushort[Text.Length];
double[] advanceWidths = new double[Text.Length];
for (int n = 0; n < Text.Length; n++)
{
ushort glyphIndex = glyphTypeface.CharacterToGlyphMap[Text[n]];
glyphIndexes[n] = glyphIndex;
double width = glyphTypeface.AdvanceWidths[glyphIndex] * HintingEmSize;
advanceWidths[n] = width;
}
GlyphRun wholeString = new GlyphRun(
glyphTypeface, //glyphTypeface
0, //bidiLevel Specifies the bidirectional layout level. Even-numbered and zero values imply left-to-right layout; odd-numbered values imply right-to-left layout.
false, //isSideways
HintingEmSize, //renderingEmSize
glyphIndexes, //glyphIndices (IList<ushort>)
Offset, //Point baselineOrigin
advanceWidths, //IList<double> advancedWiths
null, //IList<Point> glyphOffsets
null, //IList<char> characters
null, //string deviceFontName
null, //IList<ushort> clustermap
null, //IList<bool>caretStops
null //System.Windows.MarkupLanguage
);
TextAsGeometry = wholeString.BuildGeometry();
}
AcquireCacheItem(
GlyphTypeface glyphTypeface
)
{
FEMCacheItem manager = null;
Uri fontUri;
CodeAccessPermission uriDiscoveryPermission = glyphTypeface.CriticalUriDiscoveryPermission;
if (uriDiscoveryPermission != null)
{
uriDiscoveryPermission.Assert();
}
try
{
fontUri = glyphTypeface.FontUri;
}
finally
{
if (uriDiscoveryPermission != null)
{
CodeAccessPermission.RevertAssert();
}
}
if (!_fontEmbeddingManagerCache.TryGetValue(fontUri, out manager))
{
manager = new FEMCacheItem(glyphTypeface, _packagingPolicy);
_fontEmbeddingManagerCache.Add(fontUri, manager);
}
return(manager);
}
public Font(Typeface face, string name, GlyphTypeface gface)
{
Face = face;
FaceName = name;
GlyphTypeface = gface;
_glyphs = new Lazy <List <Glyph> >(LoadGlyphs);
_properties = new Lazy <List <FontProperty> >(LoadProperties);
}
public Font(GlyphTypeface glyph, string familyName, string faceName, FileInfo path)
{
this.glyph = glyph;
this.familyName = familyName;
this.faceName = faceName;
familyFaceName = string.Join(" ", familyName, faceName);
this.path = path;
}
public CharInfo(char character, GlyphTypeface font, double size, int fontId, TexFontMetrics metrics)
{
this.Character = character;
this.Font = font;
this.Size = size;
FontId = fontId;
this.Metrics = metrics;
}
private static GlyphRun CreateGlyphRun(double x, double y, Matrix m, double selfLeft,
GlyphTypeface glyphType, double fontSize, List <ushort> indexes, List <double> widths)
{
//originを物理ピクセルに合わせる。selfLeftはレンダリング時に加算されるので混ぜてはいけない
Point origin = new Point(Math.Ceiling(x * m.M11) / m.M11 - selfLeft, Math.Ceiling(y * m.M22) / m.M22);
return(new GlyphRun(glyphType, 0, false, fontSize, indexes, origin, widths, null, null, null, null, null, null));
}
private IEnumerable <ushort> GetLookupIndicesFromFeatureTable(GlyphTypeface typeface, dynamic featureTable)
{
dynamic fontTable = this.GetFontTable(typeface);
return(this.GetEnumerableFromInternalList(
() => featureTable.LookupCount(fontTable.Wrapped),
p => (ushort)featureTable.LookupIndex(fontTable.Wrapped, p)));
}
public GlyphDescriptor(GlyphTypeface typeface, int character)
{
Typeface = typeface;
Index = Typeface.CharacterToGlyphMap[character];
CharacterName = ((char)character).ToString();
Offset = new Point(0, 0);
Size = 1;
}
internal ShapedBuffer(ReadOnlySlice <char> text, ArraySlice <GlyphInfo> glyphInfos, GlyphTypeface glyphTypeface, double fontRenderingEmSize, sbyte bidiLevel)
{
Text = text;
GlyphInfos = glyphInfos;
GlyphTypeface = glyphTypeface;
FontRenderingEmSize = fontRenderingEmSize;
BidiLevel = bidiLevel;
}
internal GlyphWidths(StringRange range, GlyphTypeface typeFace, double fontSize)
{
_range = range;
_typeFace = typeFace;
_scale = fontSize / _typeFace.DesignEmHeight;
InitGlyphWidths();
}
/// <summary>
/// Initializes a new instance of the <c>TextStyle</c> class.
/// </summary>
/// <param name="name">Text style name.</param>
/// <param name="font">Text style font file name with full or relative path.</param>
/// <param name="checkName">Specifies if the style name has to be checked.</param>
/// <remarks>If the font file is a true type and is not found in the specified path, the constructor will try to find it in the system font folder.</remarks>
internal TextStyle(string name, string font, bool checkName)
: base(name, DxfObjectCode.TextStyle, checkName)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name), "The text style name should be at least one character long.");
}
if (string.IsNullOrEmpty(font))
{
throw new ArgumentNullException(nameof(font));
}
this.IsReserved = name.Equals(DefaultName, StringComparison.OrdinalIgnoreCase);
this.font = font;
this.widthFactor = 1.0;
this.obliqueAngle = 0.0;
this.height = 0.0;
this.isVertical = false;
this.isBackward = false;
this.isUpsideDown = false;
this.glyphTypeface = null;
this.fontFamilyName = Path.GetFileNameWithoutExtension(font);
// the following information is only applied to ttf not shx fonts
if (!Path.GetExtension(font).Equals(".ttf", StringComparison.OrdinalIgnoreCase))
{
return;
}
// try to find the file in the specified directory, if not try it in the fonts system folder
string fontFile;
if (File.Exists(font))
{
fontFile = Path.GetFullPath(font);
}
else
{
string file = Path.GetFileName(font);
fontFile = string.Format("{0}{1}{2}", Environment.GetFolderPath(Environment.SpecialFolder.Fonts), Path.DirectorySeparatorChar, file);
// if the ttf does not even exist in the font system folder
if (!File.Exists(fontFile))
{
return;
}
this.font = file;
}
this.glyphTypeface = new GlyphTypeface(new Uri(fontFile));
this.fontFamilyName = this.glyphTypeface.FamilyNames[CultureInfo.GetCultureInfo(1033)];
if (string.IsNullOrEmpty(this.fontFamilyName))
{
ICollection <string> names = this.glyphTypeface.FamilyNames.Values;
IEnumerator <string> enumerator = names.GetEnumerator();
enumerator.MoveNext();
this.fontFamilyName = enumerator.Current;
}
}
public ShapedBuffer ShapeText(ReadOnlySlice <char> text, GlyphTypeface typeface, double fontRenderingEmSize,
CultureInfo culture, sbyte bidiLevel)
{
using (var buffer = new Buffer())
{
buffer.AddUtf16(text.Buffer.Span, text.Start, text.Length);
MergeBreakPair(buffer);
buffer.GuessSegmentProperties();
buffer.Direction = (bidiLevel & 1) == 0 ? Direction.LeftToRight : Direction.RightToLeft;
buffer.Language = new Language(culture ?? CultureInfo.CurrentCulture);
var font = ((GlyphTypefaceImpl)typeface.PlatformImpl).Font;
font.Shape(buffer);
if (buffer.Direction == Direction.RightToLeft)
{
buffer.Reverse();
}
font.GetScale(out var scaleX, out _);
var textScale = fontRenderingEmSize / scaleX;
var bufferLength = buffer.Length;
var shapedBuffer = new ShapedBuffer(text, bufferLength, typeface, fontRenderingEmSize, bidiLevel);
var glyphInfos = buffer.GetGlyphInfoSpan();
var glyphPositions = buffer.GetGlyphPositionSpan();
for (var i = 0; i < bufferLength; i++)
{
var sourceInfo = glyphInfos[i];
var glyphIndex = (ushort)sourceInfo.Codepoint;
var glyphCluster = (int)sourceInfo.Cluster;
var glyphAdvance = GetGlyphAdvance(glyphPositions, i, textScale);
var glyphOffset = GetGlyphOffset(glyphPositions, i, textScale);
var targetInfo =
new Avalonia.Media.TextFormatting.GlyphInfo(glyphIndex, glyphCluster, glyphAdvance,
glyphOffset);
shapedBuffer[i] = targetInfo;
}
return(shapedBuffer);
}
}
public FpsCounter(GlyphTypeface typeface)
{
for (var c = FirstChar; c <= LastChar; c++)
{
var s = new string((char)c, 1);
var glyph = typeface.GetGlyph((uint)(s[0]));
_runs[c - FirstChar] = new GlyphRun(typeface, 18, new ReadOnlySlice <char>(s.AsMemory()), new ushort[] { glyph });
}
}
private ushort GetGlyphFromCharacter(GlyphTypeface glyphTypeface, char character)
{
ushort glyphIndex;
// TryGetValue will return zero glyph index for missing code points,
// which is the right thing to display per http://www.microsoft.com/typography/otspec/cmap.htm
glyphTypeface.CharacterToGlyphMap.TryGetValue(character, out glyphIndex);
return(glyphIndex);
}
internal ShapeTypeface(
GlyphTypeface glyphTypeface,
IDeviceFont deviceFont
)
{
Invariant.Assert(glyphTypeface != null);
_glyphTypeface = glyphTypeface;
_deviceFont = deviceFont;
}
/// <summary>
/// 创建<see cref="GlyphInfo"/>对象
/// </summary>
/// <param name="typeface"></param>
/// <param name="renderGlyphTypeface"></param>
/// <param name="originGlyphTypeface"></param>
/// <param name="unicodeChar"></param>
/// <param name="glyphIndex"></param>
public GlyphInfo(Typeface typeface, GlyphTypeface renderGlyphTypeface, GlyphTypeface originGlyphTypeface,
char unicodeChar, ushort glyphIndex)
{
Typeface = typeface;
RenderGlyphTypeface = renderGlyphTypeface;
OriginGlyphTypeface = originGlyphTypeface;
UnicodeChar = unicodeChar;
GlyphIndex = glyphIndex;
}
private IEnumerable <ushort> GetOptionalFeatureIndices(GlyphTypeface typeface, Tag script, Tag langSys)
{
dynamic fontTable = this.GetFontTable(typeface);
dynamic langSysTable = this.GetLangSysTable(script, langSys, fontTable);
var optionalFeatureIndices = this.GetEnumerableFromInternalList(
() => langSysTable.FeatureCount(fontTable.Wrapped), p => (ushort)langSysTable.GetFeatureIndex(fontTable.Wrapped, p));
return(optionalFeatureIndices);
}
/*
* PathGeometry pg = m_libCmn.GetFontPathGeometry("あ", 20.0, "HGP白洲太楷書体");
* // "ＭＳ 明朝");
* // "ＤＦ平成ゴシック体W9");
* // "ヒラギノ特太行書");
*/
public ClsFontPathGeometry GetFontPathGeometry(string str, double fontsize, string fontname)
{
char ch;
Uri uri;
ushort glyphIndex;
Typeface typeFace;
GlyphTypeface gt;
Geometry gm;
ClsFontPathGeometry clsFGP;
string name, fontkey;
int max, idx;
ch = Convert.ToChar(str);
m_dFontSize = fontsize;
typeFace = new Typeface(fontname);
RegistryKey regkey =
Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Windows NT\CurrentVersion\Fonts", false);
string[] keys = regkey.GetValueNames();
fontkey = "";
max = keys.Length;
for (idx = 0; idx < max; idx++)
{
if (keys[idx].Contains(fontname) == true)
{
fontkey = keys[idx];
break;
}
}
if (fontkey == "")
{
FontFamily fm = new FontFamily(fontname);
// fm.FamilyNames.TryGetValue(XmlLanguage.GetLanguage("en-us"), out name);
name = fm.FamilyNames.Values.ToList()[0];
for (idx = 0; idx < max; idx++)
{
if (keys[idx].Contains(name) == true)
{
fontkey = keys[idx];
break;
}
}
}
string ttname = (string)regkey.GetValue(fontkey);
uri = new Uri("C:\\Windows\\Fonts\\" + ttname);
//uri = new Uri(fontpath);
gt = new GlyphTypeface(uri);
gt.CharacterToGlyphMap.TryGetValue((int)ch, out glyphIndex);
gm = gt.GetGlyphOutline(glyphIndex, fontsize, fontsize);
clsFGP = new ClsFontPathGeometry();
clsFGP.pg = gm.GetOutlinedPathGeometry();
clsFGP.dMoveY = (gt.Baseline) * fontsize;
return(clsFGP);
}
internal Typeface (GlyphTypeface gtf)
{
typeface = gtf;
}
public bool TryGetGlyphTypeface (out GlyphTypeface glyphTypeface)
{
glyphTypeface = typeface;
return typeface != null;
}
